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-cshadow-headers construct "shadowed" C header files for
  47                            g++ [default=no]"
  48 ac_help="$ac_help
  49   --enable-threads        enable thread usage for target GCC.
  50      --enable-threads=LIB    use LIB thread package for target GCC."
  51 ac_help="$ac_help
  52   --enable-cxx-flags=FLAGS      pass compiler FLAGS when building library;
  53                                 [default=none]"
  54 ac_help="$ac_help
  55  --with-gxx-include-dir  the installation directory for include files"
  56 ac_help="$ac_help
  57   --enable-version-specific-runtime-libs    Specify that runtime libraries should be installed in a compiler-specific directory "
  58
  59 # Initialize some variables set by options.
  60 # The variables have the same names as the options, with
  61 # dashes changed to underlines.
  62 build=NONE
  63 cache_file=./config.cache
  64 exec_prefix=NONE
  65 host=NONE
  66 no_create=
  67 nonopt=NONE
  68 no_recursion=
  69 prefix=NONE
  70 program_prefix=NONE
  71 program_suffix=NONE
  72 program_transform_name=s,x,x,
  73 silent=
  74 site=
  75 srcdir=
  76 target=NONE
  77 verbose=
  78 x_includes=NONE
  79 x_libraries=NONE
  80 bindir='${exec_prefix}/bin'
  81 sbindir='${exec_prefix}/sbin'
  82 libexecdir='${exec_prefix}/libexec'
  83 datadir='${prefix}/share'
  84 sysconfdir='${prefix}/etc'
  85 sharedstatedir='${prefix}/com'
  86 localstatedir='${prefix}/var'
  87 libdir='${exec_prefix}/lib'
  88 includedir='${prefix}/include'
  89 oldincludedir='/usr/include'
  90 infodir='${prefix}/info'
  91 mandir='${prefix}/man'
  92
  93 # Initialize some other variables.
  94 subdirs=
  95 MFLAGS= MAKEFLAGS=
  96 SHELL=${CONFIG_SHELL-/bin/sh}
  97 # Maximum number of lines to put in a shell here document.
  98 ac_max_here_lines=12
  99
 100 ac_prev=
 101 for ac_option
 102 do
 103
 104   # If the previous option needs an argument, assign it.
 105   if test -n "$ac_prev"; then
 106     eval "$ac_prev=\$ac_option"
 107     ac_prev=
 108     continue
 109   fi
 110
 111   case "$ac_option" in
 112   -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
 113   *) ac_optarg= ;;
 114   esac
 115
 116   # Accept the important Cygnus configure options, so we can diagnose typos.
 117
 118   case "$ac_option" in
 119
 120   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 121     ac_prev=bindir ;;
 122   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 123     bindir="$ac_optarg" ;;
 124
 125   -build | --build | --buil | --bui | --bu)
 126     ac_prev=build ;;
 127   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 128     build="$ac_optarg" ;;
 129
 130   -cache-file | --cache-file | --cache-fil | --cache-fi \
 131   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 132     ac_prev=cache_file ;;
 133   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 134   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 135     cache_file="$ac_optarg" ;;
 136
 137   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 138     ac_prev=datadir ;;
 139   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 140   | --da=*)
 141     datadir="$ac_optarg" ;;
 142
 143   -disable-* | --disable-*)
 144     ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
 145     # Reject names that are not valid shell variable names.
 146     if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
 147       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 148     fi
 149     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 150     eval "enable_${ac_feature}=no" ;;
 151
 152   -enable-* | --enable-*)
 153     ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
 154     # Reject names that are not valid shell variable names.
 155     if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
 156       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 157     fi
 158     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 159     case "$ac_option" in
 160       *=*) ;;
 161       *) ac_optarg=yes ;;
 162     esac
 163     eval "enable_${ac_feature}='$ac_optarg'" ;;
 164
 165   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 166   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 167   | --exec | --exe | --ex)
 168     ac_prev=exec_prefix ;;
 169   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 170   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 171   | --exec=* | --exe=* | --ex=*)
 172     exec_prefix="$ac_optarg" ;;
 173
 174   -gas | --gas | --ga | --g)
 175     # Obsolete; use --with-gas.
 176     with_gas=yes ;;
 177
 178   -help | --help | --hel | --he)
 179     # Omit some internal or obsolete options to make the list less imposing.
 180     # This message is too long to be a string in the A/UX 3.1 sh.
 181     cat << EOF
 182 Usage: configure [options] [host]
 183 Options: [defaults in brackets after descriptions]
 184 Configuration:
 185   --cache-file=FILE       cache test results in FILE
 186   --help                  print this message
 187   --no-create             do not create output files
 188   --quiet, --silent       do not print \`checking...' messages
 189   --version               print the version of autoconf that created configure
 190 Directory and file names:
 191   --prefix=PREFIX         install architecture-independent files in PREFIX
 192                           [$ac_default_prefix]
 193   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 194                           [same as prefix]
 195   --bindir=DIR            user executables in DIR [EPREFIX/bin]
 196   --sbindir=DIR           system admin executables in DIR [EPREFIX/sbin]
 197   --libexecdir=DIR        program executables in DIR [EPREFIX/libexec]
 198   --datadir=DIR           read-only architecture-independent data in DIR
 199                           [PREFIX/share]
 200   --sysconfdir=DIR        read-only single-machine data in DIR [PREFIX/etc]
 201   --sharedstatedir=DIR    modifiable architecture-independent data in DIR
 202                           [PREFIX/com]
 203   --localstatedir=DIR     modifiable single-machine data in DIR [PREFIX/var]
 204   --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
 205   --includedir=DIR        C header files in DIR [PREFIX/include]
 206   --oldincludedir=DIR     C header files for non-gcc in DIR [/usr/include]
 207   --infodir=DIR           info documentation in DIR [PREFIX/info]
 208   --mandir=DIR            man documentation in DIR [PREFIX/man]
 209   --srcdir=DIR            find the sources in DIR [configure dir or ..]
 210   --program-prefix=PREFIX prepend PREFIX to installed program names
 211   --program-suffix=SUFFIX append SUFFIX to installed program names
 212   --program-transform-name=PROGRAM
 213                           run sed PROGRAM on installed program names
 214 EOF
 215     cat << EOF
 216 Host type:
 217   --build=BUILD           configure for building on BUILD [BUILD=HOST]
 218   --host=HOST             configure for HOST [guessed]
 219   --target=TARGET         configure for TARGET [TARGET=HOST]
 220 Features and packages:
 221   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 222   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 223   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 224   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 225   --x-includes=DIR        X include files are in DIR
 226   --x-libraries=DIR       X library files are in DIR
 227 EOF
 228     if test -n "$ac_help"; then
 229       echo "--enable and --with options recognized:$ac_help"
 230     fi
 231     exit 0 ;;
 232
 233   -host | --host | --hos | --ho)
 234     ac_prev=host ;;
 235   -host=* | --host=* | --hos=* | --ho=*)
 236     host="$ac_optarg" ;;
 237
 238   -includedir | --includedir | --includedi | --included | --include \
 239   | --includ | --inclu | --incl | --inc)
 240     ac_prev=includedir ;;
 241   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 242   | --includ=* | --inclu=* | --incl=* | --inc=*)
 243     includedir="$ac_optarg" ;;
 244
 245   -infodir | --infodir | --infodi | --infod | --info | --inf)
 246     ac_prev=infodir ;;
 247   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 248     infodir="$ac_optarg" ;;
 249
 250   -libdir | --libdir | --libdi | --libd)
 251     ac_prev=libdir ;;
 252   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 253     libdir="$ac_optarg" ;;
 254
 255   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 256   | --libexe | --libex | --libe)
 257     ac_prev=libexecdir ;;
 258   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 259   | --libexe=* | --libex=* | --libe=*)
 260     libexecdir="$ac_optarg" ;;
 261
 262   -localstatedir | --localstatedir | --localstatedi | --localstated \
 263   | --localstate | --localstat | --localsta | --localst \
 264   | --locals | --local | --loca | --loc | --lo)
 265     ac_prev=localstatedir ;;
 266   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 267   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 268   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 269     localstatedir="$ac_optarg" ;;
 270
 271   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 272     ac_prev=mandir ;;
 273   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 274     mandir="$ac_optarg" ;;
 275
 276   -nfp | --nfp | --nf)
 277     # Obsolete; use --without-fp.
 278     with_fp=no ;;
 279
 280   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 281   | --no-cr | --no-c)
 282     no_create=yes ;;
 283
 284   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 285   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 286     no_recursion=yes ;;
 287
 288   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 289   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 290   | --oldin | --oldi | --old | --ol | --o)
 291     ac_prev=oldincludedir ;;
 292   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 293   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 294   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 295     oldincludedir="$ac_optarg" ;;
 296
 297   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 298     ac_prev=prefix ;;
 299   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 300     prefix="$ac_optarg" ;;
 301
 302   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 303   | --program-pre | --program-pr | --program-p)
 304     ac_prev=program_prefix ;;
 305   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 306   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 307     program_prefix="$ac_optarg" ;;
 308
 309   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 310   | --program-suf | --program-su | --program-s)
 311     ac_prev=program_suffix ;;
 312   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 313   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 314     program_suffix="$ac_optarg" ;;
 315
 316   -program-transform-name | --program-transform-name \
 317   | --program-transform-nam | --program-transform-na \
 318   | --program-transform-n | --program-transform- \
 319   | --program-transform | --program-transfor \
 320   | --program-transfo | --program-transf \
 321   | --program-trans | --program-tran \
 322   | --progr-tra | --program-tr | --program-t)
 323     ac_prev=program_transform_name ;;
 324   -program-transform-name=* | --program-transform-name=* \
 325   | --program-transform-nam=* | --program-transform-na=* \
 326   | --program-transform-n=* | --program-transform-=* \
 327   | --program-transform=* | --program-transfor=* \
 328   | --program-transfo=* | --program-transf=* \
 329   | --program-trans=* | --program-tran=* \
 330   | --progr-tra=* | --program-tr=* | --program-t=*)
 331     program_transform_name="$ac_optarg" ;;
 332
 333   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 334   | -silent | --silent | --silen | --sile | --sil)
 335     silent=yes ;;
 336
 337   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 338     ac_prev=sbindir ;;
 339   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 340   | --sbi=* | --sb=*)
 341     sbindir="$ac_optarg" ;;
 342
 343   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 344   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 345   | --sharedst | --shareds | --shared | --share | --shar \
 346   | --sha | --sh)
 347     ac_prev=sharedstatedir ;;
 348   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 349   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 350   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 351   | --sha=* | --sh=*)
 352     sharedstatedir="$ac_optarg" ;;
 353
 354   -site | --site | --sit)
 355     ac_prev=site ;;
 356   -site=* | --site=* | --sit=*)
 357     site="$ac_optarg" ;;
 358
 359   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 360     ac_prev=srcdir ;;
 361   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 362     srcdir="$ac_optarg" ;;
 363
 364   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 365   | --syscon | --sysco | --sysc | --sys | --sy)
 366     ac_prev=sysconfdir ;;
 367   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 368   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 369     sysconfdir="$ac_optarg" ;;
 370
 371   -target | --target | --targe | --targ | --tar | --ta | --t)
 372     ac_prev=target ;;
 373   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 374     target="$ac_optarg" ;;
 375
 376   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 377     verbose=yes ;;
 378
 379   -version | --version | --versio | --versi | --vers)
 380     echo "configure generated by autoconf version 2.13"
 381     exit 0 ;;
 382
 383   -with-* | --with-*)
 384     ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
 385     # Reject names that are not valid shell variable names.
 386     if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
 387       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 388     fi
 389     ac_package=`echo $ac_package| sed 's/-/_/g'`
 390     case "$ac_option" in
 391       *=*) ;;
 392       *) ac_optarg=yes ;;
 393     esac
 394     eval "with_${ac_package}='$ac_optarg'" ;;
 395
 396   -without-* | --without-*)
 397     ac_package=`echo $ac_option|sed -e 's/-*without-//'`
 398     # Reject names that are not valid shell variable names.
 399     if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
 400       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 401     fi
 402     ac_package=`echo $ac_package| sed 's/-/_/g'`
 403     eval "with_${ac_package}=no" ;;
 404
 405   --x)
 406     # Obsolete; use --with-x.
 407     with_x=yes ;;
 408
 409   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 410   | --x-incl | --x-inc | --x-in | --x-i)
 411     ac_prev=x_includes ;;
 412   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 413   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 414     x_includes="$ac_optarg" ;;
 415
 416   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 417   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 418     ac_prev=x_libraries ;;
 419   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 420   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 421     x_libraries="$ac_optarg" ;;
 422
 423   -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; }
 424     ;;
 425
 426   *)
 427     if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
 428       echo "configure: warning: $ac_option: invalid host type" 1>&2
 429     fi
 430     if test "x$nonopt" != xNONE; then
 431       { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; }
 432     fi
 433     nonopt="$ac_option"
 434     ;;
 435
 436   esac
 437 done
 438
 439 if test -n "$ac_prev"; then
 440   { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; }
 441 fi
 442
 443 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
 444
 445 # File descriptor usage:
 446 # 0 standard input
 447 # 1 file creation
 448 # 2 errors and warnings
 449 # 3 some systems may open it to /dev/tty
 450 # 4 used on the Kubota Titan
 451 # 6 checking for... messages and results
 452 # 5 compiler messages saved in config.log
 453 if test "$silent" = yes; then
 454   exec 6>/dev/null
 455 else
 456   exec 6>&1
 457 fi
 458 exec 5>./config.log
 459
 460 echo "\
 461 This file contains any messages produced by compilers while
 462 running configure, to aid debugging if configure makes a mistake.
 463 " 1>&5
 464
 465 # Strip out --no-create and --no-recursion so they do not pile up.
 466 # Also quote any args containing shell metacharacters.
 467 ac_configure_args=
 468 for ac_arg
 469 do
 470   case "$ac_arg" in
 471   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 472   | --no-cr | --no-c) ;;
 473   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 474   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
 475   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
 476   ac_configure_args="$ac_configure_args '$ac_arg'" ;;
 477   *) ac_configure_args="$ac_configure_args $ac_arg" ;;
 478   esac
 479 done
 480
 481 # NLS nuisances.
 482 # Only set these to C if already set.  These must not be set unconditionally
 483 # because not all systems understand e.g. LANG=C (notably SCO).
 484 # Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
 485 # Non-C LC_CTYPE values break the ctype check.
 486 if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
 487 if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
 488 if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
 489 if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi
 490
 491 # confdefs.h avoids OS command line length limits that DEFS can exceed.
 492 rm -rf conftest* confdefs.h
 493 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
 494 echo > confdefs.h
 495
 496 # A filename unique to this package, relative to the directory that
 497 # configure is in, which we can look for to find out if srcdir is correct.
 498 ac_unique_file=src/complex.cc
 499
 500 # Find the source files, if location was not specified.
 501 if test -z "$srcdir"; then
 502   ac_srcdir_defaulted=yes
 503   # Try the directory containing this script, then its parent.
 504   ac_prog=$0
 505   ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
 506   test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
 507   srcdir=$ac_confdir
 508   if test ! -r $srcdir/$ac_unique_file; then
 509     srcdir=..
 510   fi
 511 else
 512   ac_srcdir_defaulted=no
 513 fi
 514 if test ! -r $srcdir/$ac_unique_file; then
 515   if test "$ac_srcdir_defaulted" = yes; then
 516     { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; }
 517   else
 518     { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; }
 519   fi
 520 fi
 521 srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
 522
 523 # Prefer explicitly selected file to automatically selected ones.
 524 if test -z "$CONFIG_SITE"; then
 525   if test "x$prefix" != xNONE; then
 526     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
 527   else
 528     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
 529   fi
 530 fi
 531 for ac_site_file in $CONFIG_SITE; do
 532   if test -r "$ac_site_file"; then
 533     echo "loading site script $ac_site_file"
 534     . "$ac_site_file"
 535   fi
 536 done
 537
 538 if test -r "$cache_file"; then
 539   echo "loading cache $cache_file"
 540   . $cache_file
 541 else
 542   echo "creating cache $cache_file"
 543   > $cache_file
 544 fi
 545
 546 ac_ext=c
 547 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
 548 ac_cpp='$CPP $CPPFLAGS'
 549 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
 550 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
 551 cross_compiling=$ac_cv_prog_cc_cross
 552
 553 ac_exeext=
 554 ac_objext=o
 555 if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
 556   # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
 557   if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
 558     ac_n= ac_c='
 559 ' ac_t='        '
 560   else
 561     ac_n=-n ac_c= ac_t=
 562   fi
 563 else
 564   ac_n= ac_c='\c' ac_t=
 565 fi
 566
 567
 568 ac_aux_dir=
 569 for ac_dir in .. $srcdir/..; do
 570   if test -f $ac_dir/install-sh; then
 571     ac_aux_dir=$ac_dir
 572     ac_install_sh="$ac_aux_dir/install-sh -c"
 573     break
 574   elif test -f $ac_dir/install.sh; then
 575     ac_aux_dir=$ac_dir
 576     ac_install_sh="$ac_aux_dir/install.sh -c"
 577     break
 578   fi
 579 done
 580 if test -z "$ac_aux_dir"; then
 581   { echo "configure: error: can not find install-sh or install.sh in .. $srcdir/.." 1>&2; exit 1; }
 582 fi
 583 ac_config_guess=$ac_aux_dir/config.guess
 584 ac_config_sub=$ac_aux_dir/config.sub
 585 ac_configure=$ac_aux_dir/configure # This should be Cygnus configure.
 586
 587
 588 # Gets and sets build, host, target, *_vendor, *_cpu, *_os, etc.
 589
 590 # Do some error checking and defaulting for the host and target type.
 591 # The inputs are:
 592 #    configure --host=HOST --target=TARGET --build=BUILD NONOPT
 593 #
 594 # The rules are:
 595 # 1. You are not allowed to specify --host, --target, and nonopt at the
 596 #    same time.
 597 # 2. Host defaults to nonopt.
 598 # 3. If nonopt is not specified, then host defaults to the current host,
 599 #    as determined by config.guess.
 600 # 4. Target and build default to nonopt.
 601 # 5. If nonopt is not specified, then target and build default to host.
 602
 603 # The aliases save the names the user supplied, while $host etc.
 604 # will get canonicalized.
 605 case $host---$target---$nonopt in
 606 NONE---*---* | *---NONE---* | *---*---NONE) ;;
 607 *) { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; } ;;
 608 esac
 609
 610
 611 # Make sure we can run config.sub.
 612 if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then :
 613 else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 614 fi
 615
 616 echo $ac_n "checking host system type""... $ac_c" 1>&6
 617 echo "configure:618: checking host system type" >&5
 618
 619 host_alias=$host
 620 case "$host_alias" in
 621 NONE)
 622   case $nonopt in
 623   NONE)
 624     if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then :
 625     else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
 626     fi ;;
 627   *) host_alias=$nonopt ;;
 628   esac ;;
 629 esac
 630
 631 host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias`
 632 host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 633 host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 634 host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 635 echo "$ac_t""$host" 1>&6
 636
 637 echo $ac_n "checking target system type""... $ac_c" 1>&6
 638 echo "configure:639: checking target system type" >&5
 639
 640 target_alias=$target
 641 case "$target_alias" in
 642 NONE)
 643   case $nonopt in
 644   NONE) target_alias=$host_alias ;;
 645   *) target_alias=$nonopt ;;
 646   esac ;;
 647 esac
 648
 649 target=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $target_alias`
 650 target_cpu=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 651 target_vendor=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 652 target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 653 echo "$ac_t""$target" 1>&6
 654
 655 echo $ac_n "checking build system type""... $ac_c" 1>&6
 656 echo "configure:657: checking build system type" >&5
 657
 658 build_alias=$build
 659 case "$build_alias" in
 660 NONE)
 661   case $nonopt in
 662   NONE) build_alias=$host_alias ;;
 663   *) build_alias=$nonopt ;;
 664   esac ;;
 665 esac
 666
 667 build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias`
 668 build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 669 build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 670 build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 671 echo "$ac_t""$build" 1>&6
 672
 673 test "$host_alias" != "$target_alias" &&
 674   test "$program_prefix$program_suffix$program_transform_name" = \
 675     NONENONEs,x,x, &&
 676   program_prefix=${target_alias}-
 677
 678
 679 # We use these options to decide which functions to include.
 680 # Check whether --with-target-subdir or --without-target-subdir was given.
 681 if test "${with_target_subdir+set}" = set; then
 682   withval="$with_target_subdir"
 683   :
 684 fi
 685
 686 # Check whether --with-cross-host or --without-cross-host was given.
 687 if test "${with_cross_host+set}" = set; then
 688   withval="$with_cross_host"
 689   :
 690 fi
 691
 692
 693 # Runs configure.host and configure.target. Have to run this before
 694 # the GLIBCPP_ENABLE_* macros below.
 695 # Find a good install program.  We prefer a C program (faster),
 696 # so one script is as good as another.  But avoid the broken or
 697 # incompatible versions:
 698 # SysV /etc/install, /usr/sbin/install
 699 # SunOS /usr/etc/install
 700 # IRIX /sbin/install
 701 # AIX /bin/install
 702 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
 703 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
 704 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 705 # ./install, which can be erroneously created by make from ./install.sh.
 706 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
 707 echo "configure:708: checking for a BSD compatible install" >&5
 708 if test -z "$INSTALL"; then
 709 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
 710   echo $ac_n "(cached) $ac_c" 1>&6
 711 else
 712     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
 713   for ac_dir in $PATH; do
 714     # Account for people who put trailing slashes in PATH elements.
 715     case "$ac_dir/" in
 716     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
 717     *)
 718       # OSF1 and SCO ODT 3.0 have their own names for install.
 719       # Don't use installbsd from OSF since it installs stuff as root
 720       # by default.
 721       for ac_prog in ginstall scoinst install; do
 722         if test -f $ac_dir/$ac_prog; then
 723           if test $ac_prog = install &&
 724             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
 725             # AIX install.  It has an incompatible calling convention.
 726             :
 727           else
 728             ac_cv_path_install="$ac_dir/$ac_prog -c"
 729             break 2
 730           fi
 731         fi
 732       done
 733       ;;
 734     esac
 735   done
 736   IFS="$ac_save_IFS"
 737
 738 fi
 739   if test "${ac_cv_path_install+set}" = set; then
 740     INSTALL="$ac_cv_path_install"
 741   else
 742     # As a last resort, use the slow shell script.  We don't cache a
 743     # path for INSTALL within a source directory, because that will
 744     # break other packages using the cache if that directory is
 745     # removed, or if the path is relative.
 746     INSTALL="$ac_install_sh"
 747   fi
 748 fi
 749 echo "$ac_t""$INSTALL" 1>&6
 750
 751 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
 752 # It thinks the first close brace ends the variable substitution.
 753 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 754
 755 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
 756
 757 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 758
 759 echo $ac_n "checking whether build environment is sane""... $ac_c" 1>&6
 760 echo "configure:761: checking whether build environment is sane" >&5
 761 # Just in case
 762 sleep 1
 763 echo timestamp > conftestfile
 764 # Do `set' in a subshell so we don't clobber the current shell's
 765 # arguments.  Must try -L first in case configure is actually a
 766 # symlink; some systems play weird games with the mod time of symlinks
 767 # (eg FreeBSD returns the mod time of the symlink's containing
 768 # directory).
 769 if (
 770    set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`
 771    if test "$*" = "X"; then
 772       # -L didn't work.
 773       set X `ls -t $srcdir/configure conftestfile`
 774    fi
 775    if test "$*" != "X $srcdir/configure conftestfile" \
 776       && test "$*" != "X conftestfile $srcdir/configure"; then
 777
 778       # If neither matched, then we have a broken ls.  This can happen
 779       # if, for instance, CONFIG_SHELL is bash and it inherits a
 780       # broken ls alias from the environment.  This has actually
 781       # happened.  Such a system could not be considered "sane".
 782       { echo "configure: error: ls -t appears to fail.  Make sure there is not a broken
 783 alias in your environment" 1>&2; exit 1; }
 784    fi
 785
 786    test "$2" = conftestfile
 787    )
 788 then
 789    # Ok.
 790    :
 791 else
 792    { echo "configure: error: newly created file is older than distributed files!
 793 Check your system clock" 1>&2; exit 1; }
 794 fi
 795 rm -f conftest*
 796 echo "$ac_t""yes" 1>&6
 797 if test "$program_transform_name" = s,x,x,; then
 798   program_transform_name=
 799 else
 800   # Double any \ or $.  echo might interpret backslashes.
 801   cat <<\EOF_SED > conftestsed
 802 s,\\,\\\\,g; s,\$,$$,g
 803 EOF_SED
 804   program_transform_name="`echo $program_transform_name|sed -f conftestsed`"
 805   rm -f conftestsed
 806 fi
 807 test "$program_prefix" != NONE &&
 808   program_transform_name="s,^,${program_prefix},; $program_transform_name"
 809 # Use a double $ so make ignores it.
 810 test "$program_suffix" != NONE &&
 811   program_transform_name="s,\$\$,${program_suffix},; $program_transform_name"
 812
 813 # sed with no file args requires a program.
 814 test "$program_transform_name" = "" && program_transform_name="s,x,x,"
 815
 816 echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6
 817 echo "configure:818: checking whether ${MAKE-make} sets \${MAKE}" >&5
 818 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'`
 819 if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then
 820   echo $ac_n "(cached) $ac_c" 1>&6
 821 else
 822   cat > conftestmake <<\EOF
 823 all:
 824         @echo 'ac_maketemp="${MAKE}"'
 825 EOF
 826 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
 827 eval `${MAKE-make} -f conftestmake 2>/dev/null | grep temp=`
 828 if test -n "$ac_maketemp"; then
 829   eval ac_cv_prog_make_${ac_make}_set=yes
 830 else
 831   eval ac_cv_prog_make_${ac_make}_set=no
 832 fi
 833 rm -f conftestmake
 834 fi
 835 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
 836   echo "$ac_t""yes" 1>&6
 837   SET_MAKE=
 838 else
 839   echo "$ac_t""no" 1>&6
 840   SET_MAKE="MAKE=${MAKE-make}"
 841 fi
 842
 843 if test $host != $build; then
 844   ac_tool_prefix=${host_alias}-
 845 else
 846   ac_tool_prefix=
 847 fi
 848
 849 echo $ac_n "checking for Cygwin environment""... $ac_c" 1>&6
 850 echo "configure:851: checking for Cygwin environment" >&5
 851 if eval "test \"`echo '$''{'ac_cv_cygwin'+set}'`\" = set"; then
 852   echo $ac_n "(cached) $ac_c" 1>&6
 853 else
 854   cat > conftest.$ac_ext <<EOF
 855 #line 856 "configure"
 856 #include "confdefs.h"
 857
 858 int main() {
 859
 860 #ifndef __CYGWIN__
 861 #define __CYGWIN__ __CYGWIN32__
 862 #endif
 863 return __CYGWIN__;
 864 ; return 0; }
 865 EOF
 866 if { (eval echo configure:867: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 867   rm -rf conftest*
 868   ac_cv_cygwin=yes
 869 else
 870   echo "configure: failed program was:" >&5
 871   cat conftest.$ac_ext >&5
 872   rm -rf conftest*
 873   ac_cv_cygwin=no
 874 fi
 875 rm -f conftest*
 876 rm -f conftest*
 877 fi
 878
 879 echo "$ac_t""$ac_cv_cygwin" 1>&6
 880 CYGWIN=
 881 test "$ac_cv_cygwin" = yes && CYGWIN=yes
 882 echo $ac_n "checking for mingw32 environment""... $ac_c" 1>&6
 883 echo "configure:884: checking for mingw32 environment" >&5
 884 if eval "test \"`echo '$''{'ac_cv_mingw32'+set}'`\" = set"; then
 885   echo $ac_n "(cached) $ac_c" 1>&6
 886 else
 887   cat > conftest.$ac_ext <<EOF
 888 #line 889 "configure"
 889 #include "confdefs.h"
 890
 891 int main() {
 892 return __MINGW32__;
 893 ; return 0; }
 894 EOF
 895 if { (eval echo configure:896: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
 896   rm -rf conftest*
 897   ac_cv_mingw32=yes
 898 else
 899   echo "configure: failed program was:" >&5
 900   cat conftest.$ac_ext >&5
 901   rm -rf conftest*
 902   ac_cv_mingw32=no
 903 fi
 904 rm -f conftest*
 905 rm -f conftest*
 906 fi
 907
 908 echo "$ac_t""$ac_cv_mingw32" 1>&6
 909 MINGW32=
 910 test "$ac_cv_mingw32" = yes && MINGW32=yes
 911
 912     # Check whether --enable-multilib or --disable-multilib was given.
 913 if test "${enable_multilib+set}" = set; then
 914   enableval="$enable_multilib"
 915   case "${enableval}" in
 916     yes) multilib=yes ;;
 917     no)  multilib=no ;;
 918     *)   { echo "configure: error: bad value ${enableval} for multilib option" 1>&2; exit 1; } ;;
 919    esac
 920 else
 921   multilib=yes
 922 fi
 923
 924       if test "${srcdir}" = "."; then
 925     if test "${with_target_subdir}" != "."; then
 926       glibcpp_basedir="${srcdir}/${with_multisrctop}../."
 927     else
 928       glibcpp_basedir="${srcdir}/${with_multisrctop}."
 929     fi
 930   else
 931     glibcpp_basedir="${srcdir}/."
 932   fi
 933
 934
 935
 936 PACKAGE=libstdc++
 937
 938 VERSION=2.90.8
 939
 940 if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then
 941   { echo "configure: error: source directory already configured; run "make distclean" there first" 1>&2; exit 1; }
 942 fi
 943 cat >> confdefs.h <<EOF
 944 #define PACKAGE "$PACKAGE"
 945 EOF
 946
 947 cat >> confdefs.h <<EOF
 948 #define VERSION "$VERSION"
 949 EOF
 950
 951
 952
 953 missing_dir=`cd $ac_aux_dir && pwd`
 954 echo $ac_n "checking for working aclocal""... $ac_c" 1>&6
 955 echo "configure:956: checking for working aclocal" >&5
 956 # Run test in a subshell; some versions of sh will print an error if
 957 # an executable is not found, even if stderr is redirected.
 958 # Redirect stdin to placate older versions of autoconf.  Sigh.
 959 if (aclocal --version) < /dev/null > /dev/null 2>&1; then
 960    ACLOCAL=aclocal
 961    echo "$ac_t""found" 1>&6
 962 else
 963    ACLOCAL="$missing_dir/missing aclocal"
 964    echo "$ac_t""missing" 1>&6
 965 fi
 966
 967 echo $ac_n "checking for working autoconf""... $ac_c" 1>&6
 968 echo "configure:969: checking for working autoconf" >&5
 969 # Run test in a subshell; some versions of sh will print an error if
 970 # an executable is not found, even if stderr is redirected.
 971 # Redirect stdin to placate older versions of autoconf.  Sigh.
 972 if (autoconf --version) < /dev/null > /dev/null 2>&1; then
 973    AUTOCONF=autoconf
 974    echo "$ac_t""found" 1>&6
 975 else
 976    AUTOCONF="$missing_dir/missing autoconf"
 977    echo "$ac_t""missing" 1>&6
 978 fi
 979
 980 echo $ac_n "checking for working automake""... $ac_c" 1>&6
 981 echo "configure:982: checking for working automake" >&5
 982 # Run test in a subshell; some versions of sh will print an error if
 983 # an executable is not found, even if stderr is redirected.
 984 # Redirect stdin to placate older versions of autoconf.  Sigh.
 985 if (automake --version) < /dev/null > /dev/null 2>&1; then
 986    AUTOMAKE=automake
 987    echo "$ac_t""found" 1>&6
 988 else
 989    AUTOMAKE="$missing_dir/missing automake"
 990    echo "$ac_t""missing" 1>&6
 991 fi
 992
 993 echo $ac_n "checking for working autoheader""... $ac_c" 1>&6
 994 echo "configure:995: checking for working autoheader" >&5
 995 # Run test in a subshell; some versions of sh will print an error if
 996 # an executable is not found, even if stderr is redirected.
 997 # Redirect stdin to placate older versions of autoconf.  Sigh.
 998 if (autoheader --version) < /dev/null > /dev/null 2>&1; then
 999    AUTOHEADER=autoheader
1000    echo "$ac_t""found" 1>&6
1001 else
1002    AUTOHEADER="$missing_dir/missing autoheader"
1003    echo "$ac_t""missing" 1>&6
1004 fi
1005
1006 echo $ac_n "checking for working makeinfo""... $ac_c" 1>&6
1007 echo "configure:1008: checking for working makeinfo" >&5
1008 # Run test in a subshell; some versions of sh will print an error if
1009 # an executable is not found, even if stderr is redirected.
1010 # Redirect stdin to placate older versions of autoconf.  Sigh.
1011 if (makeinfo --version) < /dev/null > /dev/null 2>&1; then
1012    MAKEINFO=makeinfo
1013    echo "$ac_t""found" 1>&6
1014 else
1015    MAKEINFO="$missing_dir/missing makeinfo"
1016    echo "$ac_t""missing" 1>&6
1017 fi
1018
1019
1020
1021   # Never versions of autoconf add an underscore to these functions.
1022   # Prevent future problems ...
1023
1024
1025
1026
1027
1028 #  AC_PROG_CC
1029
1030 # FIXME: We temporarily define our own version of AC_PROG_CC.  This is
1031 # copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS.  We
1032 # are probably using a cross compiler, which will not be able to fully
1033 # link an executable.  This should really be fixed in autoconf
1034 # itself.
1035
1036
1037
1038
1039 # Extract the first word of "gcc", so it can be a program name with args.
1040 set dummy gcc; ac_word=$2
1041 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1042 echo "configure:1043: checking for $ac_word" >&5
1043 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1044   echo $ac_n "(cached) $ac_c" 1>&6
1045 else
1046   if test -n "$CC"; then
1047   ac_cv_prog_CC="$CC" # Let the user override the test.
1048 else
1049   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1050   ac_dummy="$PATH"
1051   for ac_dir in $ac_dummy; do
1052     test -z "$ac_dir" && ac_dir=.
1053     if test -f $ac_dir/$ac_word; then
1054       ac_cv_prog_CC="gcc"
1055       break
1056     fi
1057   done
1058   IFS="$ac_save_ifs"
1059 fi
1060 fi
1061 CC="$ac_cv_prog_CC"
1062 if test -n "$CC"; then
1063   echo "$ac_t""$CC" 1>&6
1064 else
1065   echo "$ac_t""no" 1>&6
1066 fi
1067
1068 if test -z "$CC"; then
1069   # Extract the first word of "cc", so it can be a program name with args.
1070 set dummy cc; ac_word=$2
1071 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1072 echo "configure:1073: checking for $ac_word" >&5
1073 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1074   echo $ac_n "(cached) $ac_c" 1>&6
1075 else
1076   if test -n "$CC"; then
1077   ac_cv_prog_CC="$CC" # Let the user override the test.
1078 else
1079   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1080   ac_prog_rejected=no
1081   ac_dummy="$PATH"
1082   for ac_dir in $ac_dummy; do
1083     test -z "$ac_dir" && ac_dir=.
1084     if test -f $ac_dir/$ac_word; then
1085       if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
1086         ac_prog_rejected=yes
1087         continue
1088       fi
1089       ac_cv_prog_CC="cc"
1090       break
1091     fi
1092   done
1093   IFS="$ac_save_ifs"
1094 if test $ac_prog_rejected = yes; then
1095   # We found a bogon in the path, so make sure we never use it.
1096   set dummy $ac_cv_prog_CC
1097   shift
1098   if test $# -gt 0; then
1099     # We chose a different compiler from the bogus one.
1100     # However, it has the same basename, so the bogon will be chosen
1101     # first if we set CC to just the basename; use the full file name.
1102     shift
1103     set dummy "$ac_dir/$ac_word" "$@"
1104     shift
1105     ac_cv_prog_CC="$@"
1106   fi
1107 fi
1108 fi
1109 fi
1110 CC="$ac_cv_prog_CC"
1111 if test -n "$CC"; then
1112   echo "$ac_t""$CC" 1>&6
1113 else
1114   echo "$ac_t""no" 1>&6
1115 fi
1116
1117   test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
1118 fi
1119
1120 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
1121 echo "configure:1122: checking whether we are using GNU C" >&5
1122 if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
1123   echo $ac_n "(cached) $ac_c" 1>&6
1124 else
1125   cat > conftest.c <<EOF
1126 #ifdef __GNUC__
1127   yes;
1128 #endif
1129 EOF
1130 if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1131: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1131   ac_cv_prog_gcc=yes
1132 else
1133   ac_cv_prog_gcc=no
1134 fi
1135 fi
1136
1137 echo "$ac_t""$ac_cv_prog_gcc" 1>&6
1138
1139 if test $ac_cv_prog_gcc = yes; then
1140   GCC=yes
1141   ac_test_CFLAGS="${CFLAGS+set}"
1142   ac_save_CFLAGS="$CFLAGS"
1143   CFLAGS=
1144   echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
1145 echo "configure:1146: checking whether ${CC-cc} accepts -g" >&5
1146 if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
1147   echo $ac_n "(cached) $ac_c" 1>&6
1148 else
1149   echo 'void f(){}' > conftest.c
1150 if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
1151   ac_cv_prog_cc_g=yes
1152 else
1153   ac_cv_prog_cc_g=no
1154 fi
1155 rm -f conftest*
1156
1157 fi
1158
1159 echo "$ac_t""$ac_cv_prog_cc_g" 1>&6
1160   if test "$ac_test_CFLAGS" = set; then
1161     CFLAGS="$ac_save_CFLAGS"
1162   elif test $ac_cv_prog_cc_g = yes; then
1163     CFLAGS="-g -O2"
1164   else
1165     CFLAGS="-O2"
1166   fi
1167 else
1168   GCC=
1169   test "${CFLAGS+set}" = set || CFLAGS="-g"
1170 fi
1171
1172
1173 # Can't just call these here as g++ requires libstc++ to be built....
1174 #  AC_PROG_CXX
1175
1176 # Likewise for AC_PROG_CXX.
1177
1178
1179
1180 # Use CXX_libstdcxx so that we do not cause CXX to be cached with the
1181 # flags that come in CXX while configuring libstdc++.  They're different
1182 # from those used for all other target libraries.  If CXX is set in
1183 # the environment, respect that here.
1184 CXX_libstdcxx=$CXX
1185 for ac_prog in $CCC c++ g++ gcc CC cxx cc++
1186 do
1187 # Extract the first word of "$ac_prog", so it can be a program name with args.
1188 set dummy $ac_prog; ac_word=$2
1189 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1190 echo "configure:1191: checking for $ac_word" >&5
1191 if eval "test \"`echo '$''{'ac_cv_prog_CXX_libstdcxx'+set}'`\" = set"; then
1192   echo $ac_n "(cached) $ac_c" 1>&6
1193 else
1194   if test -n "$CXX_libstdcxx"; then
1195   ac_cv_prog_CXX_libstdcxx="$CXX_libstdcxx" # Let the user override the test.
1196 else
1197   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1198   ac_dummy="$PATH"
1199   for ac_dir in $ac_dummy; do
1200     test -z "$ac_dir" && ac_dir=.
1201     if test -f $ac_dir/$ac_word; then
1202       ac_cv_prog_CXX_libstdcxx="$ac_prog"
1203       break
1204     fi
1205   done
1206   IFS="$ac_save_ifs"
1207 fi
1208 fi
1209 CXX_libstdcxx="$ac_cv_prog_CXX_libstdcxx"
1210 if test -n "$CXX_libstdcxx"; then
1211   echo "$ac_t""$CXX_libstdcxx" 1>&6
1212 else
1213   echo "$ac_t""no" 1>&6
1214 fi
1215
1216 test -n "$CXX_libstdcxx" && break
1217 done
1218 test -n "$CXX_libstdcxx" || CXX_libstdcxx="gcc"
1219
1220 CXX=$CXX_libstdcxx
1221
1222 test -z "$CXX" && { echo "configure: error: no acceptable c++ found in \$PATH" 1>&2; exit 1; }
1223
1224 echo $ac_n "checking whether we are using GNU C++""... $ac_c" 1>&6
1225 echo "configure:1226: checking whether we are using GNU C++" >&5
1226 if eval "test \"`echo '$''{'ac_cv_prog_gxx'+set}'`\" = set"; then
1227   echo $ac_n "(cached) $ac_c" 1>&6
1228 else
1229   cat > conftest.C <<EOF
1230 #ifdef __GNUC__
1231   yes;
1232 #endif
1233 EOF
1234 if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:1235: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
1235   ac_cv_prog_gxx=yes
1236 else
1237   ac_cv_prog_gxx=no
1238 fi
1239 fi
1240
1241 echo "$ac_t""$ac_cv_prog_gxx" 1>&6
1242
1243 if test $ac_cv_prog_gxx = yes; then
1244   GXX=yes
1245   ac_test_CXXFLAGS="${CXXFLAGS+set}"
1246   ac_save_CXXFLAGS="$CXXFLAGS"
1247   CXXFLAGS=
1248   echo $ac_n "checking whether ${CXX-g++} accepts -g""... $ac_c" 1>&6
1249 echo "configure:1250: checking whether ${CXX-g++} accepts -g" >&5
1250 if eval "test \"`echo '$''{'ac_cv_prog_cxx_g'+set}'`\" = set"; then
1251   echo $ac_n "(cached) $ac_c" 1>&6
1252 else
1253   echo 'void f(){}' > conftest.cc
1254 if test -z "`${CXX-g++} -g -c conftest.cc 2>&1`"; then
1255   ac_cv_prog_cxx_g=yes
1256 else
1257   ac_cv_prog_cxx_g=no
1258 fi
1259 rm -f conftest*
1260
1261 fi
1262
1263 echo "$ac_t""$ac_cv_prog_cxx_g" 1>&6
1264   if test "$ac_test_CXXFLAGS" = set; then
1265     CXXFLAGS="$ac_save_CXXFLAGS"
1266   elif test $ac_cv_prog_cxx_g = yes; then
1267     CXXFLAGS="-g -O2"
1268   else
1269     CXXFLAGS="-O2"
1270   fi
1271 else
1272   GXX=
1273   test "${CXXFLAGS+set}" = set || CXXFLAGS="-g"
1274 fi
1275
1276
1277   # Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
1278 set dummy ${ac_tool_prefix}as; ac_word=$2
1279 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1280 echo "configure:1281: checking for $ac_word" >&5
1281 if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
1282   echo $ac_n "(cached) $ac_c" 1>&6
1283 else
1284   if test -n "$AS"; then
1285   ac_cv_prog_AS="$AS" # Let the user override the test.
1286 else
1287   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1288   ac_dummy="$PATH"
1289   for ac_dir in $ac_dummy; do
1290     test -z "$ac_dir" && ac_dir=.
1291     if test -f $ac_dir/$ac_word; then
1292       ac_cv_prog_AS="${ac_tool_prefix}as"
1293       break
1294     fi
1295   done
1296   IFS="$ac_save_ifs"
1297   test -z "$ac_cv_prog_AS" && ac_cv_prog_AS="as"
1298 fi
1299 fi
1300 AS="$ac_cv_prog_AS"
1301 if test -n "$AS"; then
1302   echo "$ac_t""$AS" 1>&6
1303 else
1304   echo "$ac_t""no" 1>&6
1305 fi
1306
1307
1308
1309   # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
1310 set dummy ${ac_tool_prefix}ar; ac_word=$2
1311 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1312 echo "configure:1313: checking for $ac_word" >&5
1313 if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
1314   echo $ac_n "(cached) $ac_c" 1>&6
1315 else
1316   if test -n "$AR"; then
1317   ac_cv_prog_AR="$AR" # Let the user override the test.
1318 else
1319   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1320   ac_dummy="$PATH"
1321   for ac_dir in $ac_dummy; do
1322     test -z "$ac_dir" && ac_dir=.
1323     if test -f $ac_dir/$ac_word; then
1324       ac_cv_prog_AR="${ac_tool_prefix}ar"
1325       break
1326     fi
1327   done
1328   IFS="$ac_save_ifs"
1329   test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="ar"
1330 fi
1331 fi
1332 AR="$ac_cv_prog_AR"
1333 if test -n "$AR"; then
1334   echo "$ac_t""$AR" 1>&6
1335 else
1336   echo "$ac_t""no" 1>&6
1337 fi
1338
1339
1340
1341   # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
1342 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
1343 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1344 echo "configure:1345: checking for $ac_word" >&5
1345 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1346   echo $ac_n "(cached) $ac_c" 1>&6
1347 else
1348   if test -n "$RANLIB"; then
1349   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1350 else
1351   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1352   ac_dummy="$PATH"
1353   for ac_dir in $ac_dummy; do
1354     test -z "$ac_dir" && ac_dir=.
1355     if test -f $ac_dir/$ac_word; then
1356       ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
1357       break
1358     fi
1359   done
1360   IFS="$ac_save_ifs"
1361 fi
1362 fi
1363 RANLIB="$ac_cv_prog_RANLIB"
1364 if test -n "$RANLIB"; then
1365   echo "$ac_t""$RANLIB" 1>&6
1366 else
1367   echo "$ac_t""no" 1>&6
1368 fi
1369
1370
1371 if test -z "$ac_cv_prog_RANLIB"; then
1372 if test -n "$ac_tool_prefix"; then
1373   # Extract the first word of "ranlib", so it can be a program name with args.
1374 set dummy ranlib; ac_word=$2
1375 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1376 echo "configure:1377: checking for $ac_word" >&5
1377 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
1378   echo $ac_n "(cached) $ac_c" 1>&6
1379 else
1380   if test -n "$RANLIB"; then
1381   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
1382 else
1383   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1384   ac_dummy="$PATH"
1385   for ac_dir in $ac_dummy; do
1386     test -z "$ac_dir" && ac_dir=.
1387     if test -f $ac_dir/$ac_word; then
1388       ac_cv_prog_RANLIB="ranlib"
1389       break
1390     fi
1391   done
1392   IFS="$ac_save_ifs"
1393   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
1394 fi
1395 fi
1396 RANLIB="$ac_cv_prog_RANLIB"
1397 if test -n "$RANLIB"; then
1398   echo "$ac_t""$RANLIB" 1>&6
1399 else
1400   echo "$ac_t""no" 1>&6
1401 fi
1402
1403 else
1404   RANLIB=":"
1405 fi
1406 fi
1407
1408
1409   # Find a good install program.  We prefer a C program (faster),
1410 # so one script is as good as another.  But avoid the broken or
1411 # incompatible versions:
1412 # SysV /etc/install, /usr/sbin/install
1413 # SunOS /usr/etc/install
1414 # IRIX /sbin/install
1415 # AIX /bin/install
1416 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1417 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1418 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1419 # ./install, which can be erroneously created by make from ./install.sh.
1420 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
1421 echo "configure:1422: checking for a BSD compatible install" >&5
1422 if test -z "$INSTALL"; then
1423 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
1424   echo $ac_n "(cached) $ac_c" 1>&6
1425 else
1426     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
1427   for ac_dir in $PATH; do
1428     # Account for people who put trailing slashes in PATH elements.
1429     case "$ac_dir/" in
1430     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
1431     *)
1432       # OSF1 and SCO ODT 3.0 have their own names for install.
1433       # Don't use installbsd from OSF since it installs stuff as root
1434       # by default.
1435       for ac_prog in ginstall scoinst install; do
1436         if test -f $ac_dir/$ac_prog; then
1437           if test $ac_prog = install &&
1438             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
1439             # AIX install.  It has an incompatible calling convention.
1440             :
1441           else
1442             ac_cv_path_install="$ac_dir/$ac_prog -c"
1443             break 2
1444           fi
1445         fi
1446       done
1447       ;;
1448     esac
1449   done
1450   IFS="$ac_save_IFS"
1451
1452 fi
1453   if test "${ac_cv_path_install+set}" = set; then
1454     INSTALL="$ac_cv_path_install"
1455   else
1456     # As a last resort, use the slow shell script.  We don't cache a
1457     # path for INSTALL within a source directory, because that will
1458     # break other packages using the cache if that directory is
1459     # removed, or if the path is relative.
1460     INSTALL="$ac_install_sh"
1461   fi
1462 fi
1463 echo "$ac_t""$INSTALL" 1>&6
1464
1465 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1466 # It thinks the first close brace ends the variable substitution.
1467 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1468
1469 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
1470
1471 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1472
1473
1474   echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6
1475 echo "configure:1476: checking whether to enable maintainer-specific portions of Makefiles" >&5
1476     # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
1477 if test "${enable_maintainer_mode+set}" = set; then
1478   enableval="$enable_maintainer_mode"
1479   USE_MAINTAINER_MODE=$enableval
1480 else
1481   USE_MAINTAINER_MODE=no
1482 fi
1483
1484   echo "$ac_t""$USE_MAINTAINER_MODE" 1>&6
1485
1486
1487 if test $USE_MAINTAINER_MODE = yes; then
1488   MAINTAINER_MODE_TRUE=
1489   MAINTAINER_MODE_FALSE='#'
1490 else
1491   MAINTAINER_MODE_TRUE='#'
1492   MAINTAINER_MODE_FALSE=
1493 fi
1494   MAINT=$MAINTAINER_MODE_TRUE
1495
1496
1497
1498   # We need AC_EXEEXT to keep automake happy in cygnus mode.  However,
1499   # at least currently, we never actually build a program, so we never
1500   # need to use $(EXEEXT).  Moreover, the test for EXEEXT normally
1501   # fails, because we are probably configuring with a cross compiler
1502   # which cant create executables.  So we include AC_EXEEXT to keep
1503   # automake happy, but we dont execute it, since we dont care about
1504   # the result.
1505   if false; then
1506
1507
1508 echo $ac_n "checking for executable suffix""... $ac_c" 1>&6
1509 echo "configure:1510: checking for executable suffix" >&5
1510 if eval "test \"`echo '$''{'ac_cv_exeext'+set}'`\" = set"; then
1511   echo $ac_n "(cached) $ac_c" 1>&6
1512 else
1513   if test "$CYGWIN" = yes || test "$MINGW32" = yes; then
1514   ac_cv_exeext=.exe
1515 else
1516   rm -f conftest*
1517   echo 'int main () { return 0; }' > conftest.$ac_ext
1518   ac_cv_exeext=
1519   if { (eval echo configure:1520: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
1520     for file in conftest.*; do
1521       case $file in
1522       *.c | *.o | *.obj) ;;
1523       *) ac_cv_exeext=`echo $file | sed -e s/conftest//` ;;
1524       esac
1525     done
1526   else
1527     { echo "configure: error: installation or configuration problem: compiler cannot create executables." 1>&2; exit 1; }
1528   fi
1529   rm -f conftest*
1530   test x"${ac_cv_exeext}" = x && ac_cv_exeext=no
1531 fi
1532 fi
1533
1534 EXEEXT=""
1535 test x"${ac_cv_exeext}" != xno && EXEEXT=${ac_cv_exeext}
1536 echo "$ac_t""${ac_cv_exeext}" 1>&6
1537 ac_exeext=$EXEEXT
1538
1539   fi
1540
1541   # configure.host sets the following important variables
1542   #        glibcpp_cflags    - host specific C compiler flags
1543   #        glibcpp_cxxflags  - host specific C++ compiler flags
1544   glibcpp_cflags=
1545   glibcpp_cxxflags=
1546
1547   . ${glibcpp_basedir}/configure.host
1548
1549   case ${glibcpp_basedir} in
1550     /* | A-Za-z:/\\*) libgcj_flagbasedir=${glibcpp_basedir} ;;
1551     *) glibcpp_flagbasedir='$(top_builddir)/'${glibcpp_basedir} ;;
1552   esac
1553
1554   # This does for the target what configure.host does for the host.  In
1555   # addition to modifying the same flags, it also sets up symlinks.
1556
1557     . ${glibcpp_basedir}/configure.target
1558     echo "$ac_t""CPU config directory is $cpu_include_dir" 1>&6
1559     echo "$ac_t""OS config directory is $os_include_dir" 1>&6
1560
1561
1562
1563   GLIBCPP_CFLAGS="${glibcpp_cflags}"
1564   GLIBCPP_CXXFLAGS="${glibcpp_cxxflags}"
1565
1566
1567
1568
1569
1570 # Check whether --enable-shared or --disable-shared was given.
1571 if test "${enable_shared+set}" = set; then
1572   enableval="$enable_shared"
1573   p=${PACKAGE-default}
1574 case "$enableval" in
1575 yes) enable_shared=yes ;;
1576 no) enable_shared=no ;;
1577 *)
1578   enable_shared=no
1579   # Look at the argument we got.  We use all the common list separators.
1580   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1581   for pkg in $enableval; do
1582     if test "X$pkg" = "X$p"; then
1583       enable_shared=yes
1584     fi
1585   done
1586   IFS="$ac_save_ifs"
1587   ;;
1588 esac
1589 else
1590   enable_shared=yes
1591 fi
1592
1593 # Check whether --enable-static or --disable-static was given.
1594 if test "${enable_static+set}" = set; then
1595   enableval="$enable_static"
1596   p=${PACKAGE-default}
1597 case "$enableval" in
1598 yes) enable_static=yes ;;
1599 no) enable_static=no ;;
1600 *)
1601   enable_static=no
1602   # Look at the argument we got.  We use all the common list separators.
1603   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1604   for pkg in $enableval; do
1605     if test "X$pkg" = "X$p"; then
1606       enable_static=yes
1607     fi
1608   done
1609   IFS="$ac_save_ifs"
1610   ;;
1611 esac
1612 else
1613   enable_static=yes
1614 fi
1615
1616 # Check whether --enable-fast-install or --disable-fast-install was given.
1617 if test "${enable_fast_install+set}" = set; then
1618   enableval="$enable_fast_install"
1619   p=${PACKAGE-default}
1620 case "$enableval" in
1621 yes) enable_fast_install=yes ;;
1622 no) enable_fast_install=no ;;
1623 *)
1624   enable_fast_install=no
1625   # Look at the argument we got.  We use all the common list separators.
1626   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
1627   for pkg in $enableval; do
1628     if test "X$pkg" = "X$p"; then
1629       enable_fast_install=yes
1630     fi
1631   done
1632   IFS="$ac_save_ifs"
1633   ;;
1634 esac
1635 else
1636   enable_fast_install=yes
1637 fi
1638
1639 # Check whether --with-gnu-ld or --without-gnu-ld was given.
1640 if test "${with_gnu_ld+set}" = set; then
1641   withval="$with_gnu_ld"
1642   test "$withval" = no || with_gnu_ld=yes
1643 else
1644   with_gnu_ld=no
1645 fi
1646
1647 ac_prog=ld
1648 if test "$ac_cv_prog_gcc" = yes; then
1649   # Check if gcc -print-prog-name=ld gives a path.
1650   echo $ac_n "checking for ld used by GCC""... $ac_c" 1>&6
1651 echo "configure:1652: checking for ld used by GCC" >&5
1652   case $host in
1653   *-*-mingw*)
1654     # gcc leaves a trailing carriage return which upsets mingw
1655     ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
1656   *)
1657     ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
1658   esac
1659   case "$ac_prog" in
1660     # Accept absolute paths.
1661     [\\/]* | [A-Za-z]:[\\/]*)
1662       re_direlt='/[^/][^/]*/\.\./'
1663       # Canonicalize the path of ld
1664       ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
1665       while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
1666         ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
1667       done
1668       test -z "$LD" && LD="$ac_prog"
1669       ;;
1670   "")
1671     # If it fails, then pretend we aren't using GCC.
1672     ac_prog=ld
1673     ;;
1674   *)
1675     # If it is relative, then search for the first ld in PATH.
1676     with_gnu_ld=unknown
1677     ;;
1678   esac
1679 elif test "$with_gnu_ld" = yes; then
1680   echo $ac_n "checking for GNU ld""... $ac_c" 1>&6
1681 echo "configure:1682: checking for GNU ld" >&5
1682 else
1683   echo $ac_n "checking for non-GNU ld""... $ac_c" 1>&6
1684 echo "configure:1685: checking for non-GNU ld" >&5
1685 fi
1686 if eval "test \"`echo '$''{'ac_cv_path_LD'+set}'`\" = set"; then
1687   echo $ac_n "(cached) $ac_c" 1>&6
1688 else
1689   if test -z "$LD"; then
1690   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1691   for ac_dir in $PATH; do
1692     test -z "$ac_dir" && ac_dir=.
1693     if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
1694       ac_cv_path_LD="$ac_dir/$ac_prog"
1695       # Check to see if the program is GNU ld.  I'd rather use --version,
1696       # but apparently some GNU ld's only accept -v.
1697       # Break only if it was the GNU/non-GNU ld that we prefer.
1698       if "$ac_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
1699         test "$with_gnu_ld" != no && break
1700       else
1701         test "$with_gnu_ld" != yes && break
1702       fi
1703     fi
1704   done
1705   IFS="$ac_save_ifs"
1706 else
1707   ac_cv_path_LD="$LD" # Let the user override the test with a path.
1708 fi
1709 fi
1710
1711 LD="$ac_cv_path_LD"
1712 if test -n "$LD"; then
1713   echo "$ac_t""$LD" 1>&6
1714 else
1715   echo "$ac_t""no" 1>&6
1716 fi
1717 test -z "$LD" && { echo "configure: error: no acceptable ld found in \$PATH" 1>&2; exit 1; }
1718 echo $ac_n "checking if the linker ($LD) is GNU ld""... $ac_c" 1>&6
1719 echo "configure:1720: checking if the linker ($LD) is GNU ld" >&5
1720 if eval "test \"`echo '$''{'ac_cv_prog_gnu_ld'+set}'`\" = set"; then
1721   echo $ac_n "(cached) $ac_c" 1>&6
1722 else
1723   # I'd rather use --version here, but apparently some GNU ld's only accept -v.
1724 if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
1725   ac_cv_prog_gnu_ld=yes
1726 else
1727   ac_cv_prog_gnu_ld=no
1728 fi
1729 fi
1730
1731 echo "$ac_t""$ac_cv_prog_gnu_ld" 1>&6
1732 with_gnu_ld=$ac_cv_prog_gnu_ld
1733
1734
1735 echo $ac_n "checking for $LD option to reload object files""... $ac_c" 1>&6
1736 echo "configure:1737: checking for $LD option to reload object files" >&5
1737 if eval "test \"`echo '$''{'lt_cv_ld_reload_flag'+set}'`\" = set"; then
1738   echo $ac_n "(cached) $ac_c" 1>&6
1739 else
1740   lt_cv_ld_reload_flag='-r'
1741 fi
1742
1743 echo "$ac_t""$lt_cv_ld_reload_flag" 1>&6
1744 reload_flag=$lt_cv_ld_reload_flag
1745 test -n "$reload_flag" && reload_flag=" $reload_flag"
1746
1747 echo $ac_n "checking for BSD-compatible nm""... $ac_c" 1>&6
1748 echo "configure:1749: checking for BSD-compatible nm" >&5
1749 if eval "test \"`echo '$''{'ac_cv_path_NM'+set}'`\" = set"; then
1750   echo $ac_n "(cached) $ac_c" 1>&6
1751 else
1752   if test -n "$NM"; then
1753   # Let the user override the test.
1754   ac_cv_path_NM="$NM"
1755 else
1756   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
1757   for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
1758     test -z "$ac_dir" && ac_dir=.
1759     tmp_nm=$ac_dir/${ac_tool_prefix}nm
1760     if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then
1761       # Check to see if the nm accepts a BSD-compat flag.
1762       # Adding the `sed 1q' prevents false positives on HP-UX, which says:
1763       #   nm: unknown option "B" ignored
1764       # Tru64's nm complains that /dev/null is an invalid object file
1765       if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then
1766         ac_cv_path_NM="$tmp_nm -B"
1767         break
1768       elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
1769         ac_cv_path_NM="$tmp_nm -p"
1770         break
1771       else
1772         ac_cv_path_NM=${ac_cv_path_NM="$tmp_nm"} # keep the first match, but
1773         continue # so that we can try to find one that supports BSD flags
1774       fi
1775     fi
1776   done
1777   IFS="$ac_save_ifs"
1778   test -z "$ac_cv_path_NM" && ac_cv_path_NM=nm
1779 fi
1780 fi
1781
1782 NM="$ac_cv_path_NM"
1783 echo "$ac_t""$NM" 1>&6
1784
1785 echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6
1786 echo "configure:1787: checking whether ln -s works" >&5
1787 if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then
1788   echo $ac_n "(cached) $ac_c" 1>&6
1789 else
1790   rm -f conftestdata
1791 if ln -s X conftestdata 2>/dev/null
1792 then
1793   rm -f conftestdata
1794   ac_cv_prog_LN_S="ln -s"
1795 else
1796   ac_cv_prog_LN_S=ln
1797 fi
1798 fi
1799 LN_S="$ac_cv_prog_LN_S"
1800 if test "$ac_cv_prog_LN_S" = "ln -s"; then
1801   echo "$ac_t""yes" 1>&6
1802 else
1803   echo "$ac_t""no" 1>&6
1804 fi
1805
1806 echo $ac_n "checking how to recognise dependant libraries""... $ac_c" 1>&6
1807 echo "configure:1808: checking how to recognise dependant libraries" >&5
1808 if eval "test \"`echo '$''{'lt_cv_deplibs_check_method'+set}'`\" = set"; then
1809   echo $ac_n "(cached) $ac_c" 1>&6
1810 else
1811   lt_cv_file_magic_cmd='$MAGIC_CMD'
1812 lt_cv_file_magic_test_file=
1813 lt_cv_deplibs_check_method='unknown'
1814 # Need to set the preceding variable on all platforms that support
1815 # interlibrary dependencies.
1816 # 'none' -- dependencies not supported.
1817 # `unknown' -- same as none, but documents that we really don't know.
1818 # 'pass_all' -- all dependencies passed with no checks.
1819 # 'test_compile' -- check by making test program.
1820 # 'file_magic [regex]' -- check by looking for files in library path
1821 # which responds to the $file_magic_cmd with a given egrep regex.
1822 # If you have `file' or equivalent on your system and you're not sure
1823 # whether `pass_all' will *always* work, you probably want this one.
1824
1825 case "$host_os" in
1826 aix4*)
1827   lt_cv_deplibs_check_method=pass_all
1828   ;;
1829
1830 beos*)
1831   lt_cv_deplibs_check_method=pass_all
1832   ;;
1833
1834 bsdi4*)
1835     lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
1836     lt_cv_file_magic_cmd='/usr/bin/file -L'
1837   lt_cv_file_magic_test_file=/shlib/libc.so
1838   ;;
1839
1840 cygwin* | mingw* |pw32*)
1841   lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
1842   lt_cv_file_magic_cmd='$OBJDUMP -f'
1843   ;;
1844
1845 freebsd* )
1846   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
1847     case "$host_cpu" in
1848     i*86 )
1849       # Not sure whether the presence of OpenBSD here was a mistake.
1850       # Let's accept both of them until this is cleared up.
1851             lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library'
1852             lt_cv_file_magic_cmd=/usr/bin/file
1853       lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
1854       ;;
1855     esac
1856   else
1857     lt_cv_deplibs_check_method=pass_all
1858   fi
1859   ;;
1860
1861 gnu*)
1862   lt_cv_deplibs_check_method=pass_all
1863   ;;
1864
1865 hpux10.20*)
1866   # TODO:  Does this work for hpux-11 too?
1867   lt_cv_deplibs_check_method='file_magic (s0-90-90-9|PA-RISC0-9.0-9) shared library'
1868   lt_cv_file_magic_cmd=/usr/bin/file
1869   lt_cv_file_magic_test_file=/usr/lib/libc.sl
1870   ;;
1871
1872 irix5* | irix6*)
1873   case "$host_os" in
1874   irix5*)
1875     # this will be overridden with pass_all, but let us keep it just in case
1876     lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
1877     ;;
1878   *)
1879     case "$LD" in
1880     *-32|*"-32 ") libmagic=32-bit;;
1881     *-n32|*"-n32 ") libmagic=N32;;
1882     *-64|*"-64 ") libmagic=64-bit;;
1883     *) libmagic=never-match;;
1884     esac
1885     # this will be overridden with pass_all, but let us keep it just in case
1886         lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1"
1887         ;;
1888   esac
1889   lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
1890   lt_cv_deplibs_check_method=pass_all
1891   ;;
1892
1893 # This must be Linux ELF.
1894 linux-gnu*)
1895   case "$host_cpu" in
1896   alpha* | i*86 | powerpc* | sparc* | ia64* )
1897     lt_cv_deplibs_check_method=pass_all ;;
1898   *)
1899     # glibc up to 2.1.1 does not perform some relocations on ARM
1900         lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )' ;;
1901       esac
1902   lt_cv_file_magic_test_file=`echo /lib/libc.so* /lib/libc-*.so`
1903   ;;
1904
1905 netbsd*)
1906   if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then :
1907   else
1908         lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB shared object'
1909         lt_cv_file_magic_cmd='/usr/bin/file -L'
1910     lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
1911   fi
1912   ;;
1913
1914 osf3* | osf4* | osf5*)
1915   # this will be overridden with pass_all, but let us keep it just in case
1916   lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
1917   lt_cv_file_magic_test_file=/shlib/libc.so
1918   lt_cv_deplibs_check_method=pass_all
1919   ;;
1920
1921 sco3.2v5*)
1922   lt_cv_deplibs_check_method=pass_all
1923   ;;
1924
1925 solaris*)
1926   lt_cv_deplibs_check_method=pass_all
1927   lt_cv_file_magic_test_file=/lib/libc.so
1928   ;;
1929
1930 sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
1931   case "$host_vendor" in
1932   ncr)
1933     lt_cv_deplibs_check_method=pass_all
1934     ;;
1935   motorola)
1936         lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
1937         lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
1938     ;;
1939   esac
1940   ;;
1941 esac
1942
1943 fi
1944
1945 echo "$ac_t""$lt_cv_deplibs_check_method" 1>&6
1946 file_magic_cmd=$lt_cv_file_magic_cmd
1947 deplibs_check_method=$lt_cv_deplibs_check_method
1948
1949 echo $ac_n "checking for object suffix""... $ac_c" 1>&6
1950 echo "configure:1951: checking for object suffix" >&5
1951 if eval "test \"`echo '$''{'ac_cv_objext'+set}'`\" = set"; then
1952   echo $ac_n "(cached) $ac_c" 1>&6
1953 else
1954   rm -f conftest*
1955 echo 'int i = 1;' > conftest.$ac_ext
1956 if { (eval echo configure:1957: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
1957   for ac_file in conftest.*; do
1958     case $ac_file in
1959     *.c) ;;
1960     *) ac_cv_objext=`echo $ac_file | sed -e s/conftest.//` ;;
1961     esac
1962   done
1963 else
1964   { echo "configure: error: installation or configuration problem; compiler does not work" 1>&2; exit 1; }
1965 fi
1966 rm -f conftest*
1967 fi
1968
1969 echo "$ac_t""$ac_cv_objext" 1>&6
1970 OBJEXT=$ac_cv_objext
1971 ac_objext=$ac_cv_objext
1972
1973 # Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
1974
1975 # Only perform the check for file, if the check method requires it
1976 case "$deplibs_check_method" in
1977 file_magic*)
1978   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
1979     echo $ac_n "checking for ${ac_tool_prefix}file""... $ac_c" 1>&6
1980 echo "configure:1981: checking for ${ac_tool_prefix}file" >&5
1981 if eval "test \"`echo '$''{'lt_cv_path_MAGIC_CMD'+set}'`\" = set"; then
1982   echo $ac_n "(cached) $ac_c" 1>&6
1983 else
1984   case "$MAGIC_CMD" in
1985   /*)
1986   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
1987   ;;
1988   ?:/*)
1989   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
1990   ;;
1991   *)
1992   ac_save_MAGIC_CMD="$MAGIC_CMD"
1993   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1994   ac_dummy="/usr/bin:$PATH"
1995   for ac_dir in $ac_dummy; do
1996     test -z "$ac_dir" && ac_dir=.
1997     if test -f $ac_dir/${ac_tool_prefix}file; then
1998       lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
1999       if test -n "$file_magic_test_file"; then
2000         case "$deplibs_check_method" in
2001         "file_magic "*)
2002           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
2003           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2004           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
2005             egrep "$file_magic_regex" > /dev/null; then
2006             :
2007           else
2008             cat <<EOF 1>&2
2009
2010 *** Warning: the command libtool uses to detect shared libraries,
2011 *** $file_magic_cmd, produces output that libtool cannot recognize.
2012 *** The result is that libtool may fail to recognize shared libraries
2013 *** as such.  This will affect the creation of libtool libraries that
2014 *** depend on shared libraries, but programs linked with such libtool
2015 *** libraries will work regardless of this problem.  Nevertheless, you
2016 *** may want to report the problem to your system manager and/or to
2017 *** bug-libtool@gnu.org
2018
2019 EOF
2020           fi ;;
2021         esac
2022       fi
2023       break
2024     fi
2025   done
2026   IFS="$ac_save_ifs"
2027   MAGIC_CMD="$ac_save_MAGIC_CMD"
2028   ;;
2029 esac
2030 fi
2031
2032 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2033 if test -n "$MAGIC_CMD"; then
2034   echo "$ac_t""$MAGIC_CMD" 1>&6
2035 else
2036   echo "$ac_t""no" 1>&6
2037 fi
2038
2039 if test -z "$lt_cv_path_MAGIC_CMD"; then
2040   if test -n "$ac_tool_prefix"; then
2041     echo $ac_n "checking for file""... $ac_c" 1>&6
2042 echo "configure:2043: checking for file" >&5
2043 if eval "test \"`echo '$''{'lt_cv_path_MAGIC_CMD'+set}'`\" = set"; then
2044   echo $ac_n "(cached) $ac_c" 1>&6
2045 else
2046   case "$MAGIC_CMD" in
2047   /*)
2048   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
2049   ;;
2050   ?:/*)
2051   lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
2052   ;;
2053   *)
2054   ac_save_MAGIC_CMD="$MAGIC_CMD"
2055   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2056   ac_dummy="/usr/bin:$PATH"
2057   for ac_dir in $ac_dummy; do
2058     test -z "$ac_dir" && ac_dir=.
2059     if test -f $ac_dir/file; then
2060       lt_cv_path_MAGIC_CMD="$ac_dir/file"
2061       if test -n "$file_magic_test_file"; then
2062         case "$deplibs_check_method" in
2063         "file_magic "*)
2064           file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
2065           MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2066           if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
2067             egrep "$file_magic_regex" > /dev/null; then
2068             :
2069           else
2070             cat <<EOF 1>&2
2071
2072 *** Warning: the command libtool uses to detect shared libraries,
2073 *** $file_magic_cmd, produces output that libtool cannot recognize.
2074 *** The result is that libtool may fail to recognize shared libraries
2075 *** as such.  This will affect the creation of libtool libraries that
2076 *** depend on shared libraries, but programs linked with such libtool
2077 *** libraries will work regardless of this problem.  Nevertheless, you
2078 *** may want to report the problem to your system manager and/or to
2079 *** bug-libtool@gnu.org
2080
2081 EOF
2082           fi ;;
2083         esac
2084       fi
2085       break
2086     fi
2087   done
2088   IFS="$ac_save_ifs"
2089   MAGIC_CMD="$ac_save_MAGIC_CMD"
2090   ;;
2091 esac
2092 fi
2093
2094 MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2095 if test -n "$MAGIC_CMD"; then
2096   echo "$ac_t""$MAGIC_CMD" 1>&6
2097 else
2098   echo "$ac_t""no" 1>&6
2099 fi
2100
2101   else
2102     MAGIC_CMD=:
2103   fi
2104 fi
2105
2106   fi
2107   ;;
2108 esac
2109
2110 # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
2111 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
2112 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2113 echo "configure:2114: checking for $ac_word" >&5
2114 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
2115   echo $ac_n "(cached) $ac_c" 1>&6
2116 else
2117   if test -n "$RANLIB"; then
2118   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
2119 else
2120   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2121   ac_dummy="$PATH"
2122   for ac_dir in $ac_dummy; do
2123     test -z "$ac_dir" && ac_dir=.
2124     if test -f $ac_dir/$ac_word; then
2125       ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
2126       break
2127     fi
2128   done
2129   IFS="$ac_save_ifs"
2130 fi
2131 fi
2132 RANLIB="$ac_cv_prog_RANLIB"
2133 if test -n "$RANLIB"; then
2134   echo "$ac_t""$RANLIB" 1>&6
2135 else
2136   echo "$ac_t""no" 1>&6
2137 fi
2138
2139
2140 if test -z "$ac_cv_prog_RANLIB"; then
2141 if test -n "$ac_tool_prefix"; then
2142   # Extract the first word of "ranlib", so it can be a program name with args.
2143 set dummy ranlib; ac_word=$2
2144 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2145 echo "configure:2146: checking for $ac_word" >&5
2146 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
2147   echo $ac_n "(cached) $ac_c" 1>&6
2148 else
2149   if test -n "$RANLIB"; then
2150   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
2151 else
2152   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2153   ac_dummy="$PATH"
2154   for ac_dir in $ac_dummy; do
2155     test -z "$ac_dir" && ac_dir=.
2156     if test -f $ac_dir/$ac_word; then
2157       ac_cv_prog_RANLIB="ranlib"
2158       break
2159     fi
2160   done
2161   IFS="$ac_save_ifs"
2162   test -z "$ac_cv_prog_RANLIB" && ac_cv_prog_RANLIB=":"
2163 fi
2164 fi
2165 RANLIB="$ac_cv_prog_RANLIB"
2166 if test -n "$RANLIB"; then
2167   echo "$ac_t""$RANLIB" 1>&6
2168 else
2169   echo "$ac_t""no" 1>&6
2170 fi
2171
2172 else
2173   RANLIB=":"
2174 fi
2175 fi
2176
2177 # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
2178 set dummy ${ac_tool_prefix}strip; ac_word=$2
2179 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2180 echo "configure:2181: checking for $ac_word" >&5
2181 if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
2182   echo $ac_n "(cached) $ac_c" 1>&6
2183 else
2184   if test -n "$STRIP"; then
2185   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
2186 else
2187   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2188   ac_dummy="$PATH"
2189   for ac_dir in $ac_dummy; do
2190     test -z "$ac_dir" && ac_dir=.
2191     if test -f $ac_dir/$ac_word; then
2192       ac_cv_prog_STRIP="${ac_tool_prefix}strip"
2193       break
2194     fi
2195   done
2196   IFS="$ac_save_ifs"
2197 fi
2198 fi
2199 STRIP="$ac_cv_prog_STRIP"
2200 if test -n "$STRIP"; then
2201   echo "$ac_t""$STRIP" 1>&6
2202 else
2203   echo "$ac_t""no" 1>&6
2204 fi
2205
2206
2207 if test -z "$ac_cv_prog_STRIP"; then
2208 if test -n "$ac_tool_prefix"; then
2209   # Extract the first word of "strip", so it can be a program name with args.
2210 set dummy strip; ac_word=$2
2211 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2212 echo "configure:2213: checking for $ac_word" >&5
2213 if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
2214   echo $ac_n "(cached) $ac_c" 1>&6
2215 else
2216   if test -n "$STRIP"; then
2217   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
2218 else
2219   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2220   ac_dummy="$PATH"
2221   for ac_dir in $ac_dummy; do
2222     test -z "$ac_dir" && ac_dir=.
2223     if test -f $ac_dir/$ac_word; then
2224       ac_cv_prog_STRIP="strip"
2225       break
2226     fi
2227   done
2228   IFS="$ac_save_ifs"
2229   test -z "$ac_cv_prog_STRIP" && ac_cv_prog_STRIP=":"
2230 fi
2231 fi
2232 STRIP="$ac_cv_prog_STRIP"
2233 if test -n "$STRIP"; then
2234   echo "$ac_t""$STRIP" 1>&6
2235 else
2236   echo "$ac_t""no" 1>&6
2237 fi
2238
2239 else
2240   STRIP=":"
2241 fi
2242 fi
2243
2244
2245 # Check for any special flags to pass to ltconfig.
2246 libtool_flags="--cache-file=$cache_file"
2247 test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
2248 test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
2249 test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
2250 test "$ac_cv_prog_gcc" = yes && libtool_flags="$libtool_flags --with-gcc"
2251 test "$ac_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
2252 libtool_flags="$libtool_flags --enable-dlopen"
2253
2254 # Check whether --enable-libtool-lock or --disable-libtool-lock was given.
2255 if test "${enable_libtool_lock+set}" = set; then
2256   enableval="$enable_libtool_lock"
2257   :
2258 fi
2259
2260 test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
2261 test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
2262
2263 # Check whether --with-pic or --without-pic was given.
2264 if test "${with_pic+set}" = set; then
2265   withval="$with_pic"
2266   pic_mode="$withval"
2267 else
2268   pic_mode=default
2269 fi
2270
2271 test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
2272 test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
2273
2274 # Some flags need to be propagated to the compiler or linker for good
2275 # libtool support.
2276 case "$host" in
2277 *-*-irix6*)
2278   # Find out which ABI we are using.
2279   echo '#line 2280 "configure"' > conftest.$ac_ext
2280   if { (eval echo configure:2281: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2281     case "`/usr/bin/file conftest.o`" in
2282     *32-bit*)
2283       LD="${LD-ld} -32"
2284       ;;
2285     *N32*)
2286       LD="${LD-ld} -n32"
2287       ;;
2288     *64-bit*)
2289       LD="${LD-ld} -64"
2290       ;;
2291     esac
2292   fi
2293   rm -rf conftest*
2294   ;;
2295
2296 *-*-sco3.2v5*)
2297   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
2298   SAVE_CFLAGS="$CFLAGS"
2299   CFLAGS="$CFLAGS -belf"
2300   echo $ac_n "checking whether the C compiler needs -belf""... $ac_c" 1>&6
2301 echo "configure:2302: checking whether the C compiler needs -belf" >&5
2302 if eval "test \"`echo '$''{'lt_cv_cc_needs_belf'+set}'`\" = set"; then
2303   echo $ac_n "(cached) $ac_c" 1>&6
2304 else
2305
2306      ac_ext=c
2307 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2308 ac_cpp='$CPP $CPPFLAGS'
2309 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2310 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2311 cross_compiling=$ac_cv_prog_cc_cross
2312
2313      cat > conftest.$ac_ext <<EOF
2314 #line 2315 "configure"
2315 #include "confdefs.h"
2316
2317 int main() {
2318
2319 ; return 0; }
2320 EOF
2321 if { (eval echo configure:2322: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2322   rm -rf conftest*
2323   lt_cv_cc_needs_belf=yes
2324 else
2325   echo "configure: failed program was:" >&5
2326   cat conftest.$ac_ext >&5
2327   rm -rf conftest*
2328   lt_cv_cc_needs_belf=no
2329 fi
2330 rm -f conftest*
2331      ac_ext=c
2332 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2333 ac_cpp='$CPP $CPPFLAGS'
2334 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2335 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2336 cross_compiling=$ac_cv_prog_cc_cross
2337
2338 fi
2339
2340 echo "$ac_t""$lt_cv_cc_needs_belf" 1>&6
2341   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
2342     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
2343     CFLAGS="$SAVE_CFLAGS"
2344   fi
2345   ;;
2346
2347
2348 esac
2349
2350 echo $ac_n "checking how to run the C++ preprocessor""... $ac_c" 1>&6
2351 echo "configure:2352: checking how to run the C++ preprocessor" >&5
2352 if test -z "$CXXCPP"; then
2353 if eval "test \"`echo '$''{'ac_cv_prog_CXXCPP'+set}'`\" = set"; then
2354   echo $ac_n "(cached) $ac_c" 1>&6
2355 else
2356   ac_ext=C
2357 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2358 ac_cpp='$CXXCPP $CPPFLAGS'
2359 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2360 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2361 cross_compiling=$ac_cv_prog_cxx_cross
2362   CXXCPP="${CXX-g++} -E"
2363   cat > conftest.$ac_ext <<EOF
2364 #line 2365 "configure"
2365 #include "confdefs.h"
2366 #include <stdlib.h>
2367 EOF
2368 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2369 { (eval echo configure:2370: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2370 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2371 if test -z "$ac_err"; then
2372   :
2373 else
2374   echo "$ac_err" >&5
2375   echo "configure: failed program was:" >&5
2376   cat conftest.$ac_ext >&5
2377   rm -rf conftest*
2378   CXXCPP=/lib/cpp
2379 fi
2380 rm -f conftest*
2381   ac_cv_prog_CXXCPP="$CXXCPP"
2382 ac_ext=c
2383 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2384 ac_cpp='$CPP $CPPFLAGS'
2385 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2386 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2387 cross_compiling=$ac_cv_prog_cc_cross
2388 fi
2389 fi
2390 CXXCPP="$ac_cv_prog_CXXCPP"
2391 echo "$ac_t""$CXXCPP" 1>&6
2392
2393
2394 # Save cache, so that ltconfig can load it
2395 cat > confcache <<\EOF
2396 # This file is a shell script that caches the results of configure
2397 # tests run on this system so they can be shared between configure
2398 # scripts and configure runs.  It is not useful on other systems.
2399 # If it contains results you don't want to keep, you may remove or edit it.
2400 #
2401 # By default, configure uses ./config.cache as the cache file,
2402 # creating it if it does not exist already.  You can give configure
2403 # the --cache-file=FILE option to use a different cache file; that is
2404 # what configure does when it calls configure scripts in
2405 # subdirectories, so they share the cache.
2406 # Giving --cache-file=/dev/null disables caching, for debugging configure.
2407 # config.status only pays attention to the cache file if you give it the
2408 # --recheck option to rerun configure.
2409 #
2410 EOF
2411 # The following way of writing the cache mishandles newlines in values,
2412 # but we know of no workaround that is simple, portable, and efficient.
2413 # So, don't put newlines in cache variables' values.
2414 # Ultrix sh set writes to stderr and can't be redirected directly,
2415 # and sets the high bit in the cache file unless we assign to the vars.
2416 (set) 2>&1 |
2417   case `(ac_space=' '; set | grep ac_space) 2>&1` in
2418   *ac_space=\ *)
2419     # `set' does not quote correctly, so add quotes (double-quote substitution
2420     # turns \\\\ into \\, and sed turns \\ into \).
2421     sed -n \
2422       -e "s/'/'\\\\''/g" \
2423       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
2424     ;;
2425   *)
2426     # `set' quotes correctly as required by POSIX, so do not add quotes.
2427     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
2428     ;;
2429   esac >> confcache
2430 if cmp -s $cache_file confcache; then
2431   :
2432 else
2433   if test -w $cache_file; then
2434     echo "updating cache $cache_file"
2435     cat confcache > $cache_file
2436   else
2437     echo "not updating unwritable cache $cache_file"
2438   fi
2439 fi
2440 rm -f confcache
2441
2442
2443 # Actually configure libtool.  ac_aux_dir is where install-sh is found.
2444 AR="$AR" LTCC="$CC" CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
2445 MAGIC_CMD="$MAGIC_CMD" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
2446 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
2447 AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
2448 objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
2449 deplibs_check_method="$deplibs_check_method" file_magic_cmd="$file_magic_cmd" \
2450 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
2451 $libtool_flags --no-verify --build="$build" $ac_aux_dir/ltmain.sh $host \
2452 || { echo "configure: error: libtool configure failed" 1>&2; exit 1; }
2453
2454 # Reload cache, that may have been modified by ltconfig
2455 if test -r "$cache_file"; then
2456   echo "loading cache $cache_file"
2457   . $cache_file
2458 else
2459   echo "creating cache $cache_file"
2460   > $cache_file
2461 fi
2462
2463
2464 # This can be used to rebuild libtool when needed
2465 LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh $ac_aux_dir/ltcf-c.sh"
2466
2467 # Always use our own libtool.
2468 LIBTOOL='$(SHELL) $(top_builddir)/libtool'
2469
2470 # Redirect the config.log output again, so that the ltconfig log is not
2471 # clobbered by the next message.
2472 exec 5>>./config.log
2473
2474
2475
2476
2477 LIBTOOL_DEPS=$LIBTOOL_DEPS" $ac_aux_dir/ltcf-cxx.sh"
2478 lt_save_CC="$CC"
2479 lt_save_CFLAGS="$CFLAGS"
2480 AR="$AR" LTCC="$CC" CC="$CXX" CXX="$CXX" CFLAGS="$CXXFLAGS" CPPFLAGS="$CPPFLAGS" \
2481 MAGIC_CMD="$MAGIC_CMD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
2482 LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
2483 AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
2484 objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
2485 deplibs_check_method="$deplibs_check_method" \
2486 file_magic_cmd="$file_magic_cmd" \
2487 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig -o libtool $libtool_flags \
2488 --build="$build" --add-tag=CXX $ac_aux_dir/ltcf-cxx.sh $host \
2489 || { echo "configure: error: libtool tag configuration failed" 1>&2; exit 1; }
2490 CC="$lt_save_CC"
2491 CFLAGS="$lt_save_CFLAGS"
2492
2493 # Redirect the config.log output again, so that the ltconfig log is not
2494 # clobbered by the next message.
2495 exec 5>>./config.log
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505 echo $ac_n "checking for GNU make""... $ac_c" 1>&6
2506 echo "configure:2507: checking for GNU make" >&5
2507 if eval "test \"`echo '$''{'_cv_gnu_make_command'+set}'`\" = set"; then
2508   echo $ac_n "(cached) $ac_c" 1>&6
2509 else
2510   _cv_gnu_make_command='' ;
2511           for a in "${MAKE:-make}" make gmake gnumake ; do
2512                   if ( $a --version 2> /dev/null | grep -c GNU > /dev/null )
2513                   then
2514                           _cv_gnu_make_command=$a ;
2515                           break;
2516                   fi
2517           done ;
2518
2519 fi
2520
2521 echo "$ac_t""$_cv_gnu_make_command" 1>&6 ;
2522   if test  "x$_cv_gnu_make_command" != "x"  ; then
2523           ifGNUmake='' ;
2524   else
2525           ifGNUmake='#' ;
2526   fi
2527
2528
2529   if test "x$_cv_gnu_make_command" = "x"; then
2530     { echo "configure: error: GNU make not found. Please install it or correct your path." 1>&2; exit 1; }
2531   fi
2532
2533
2534
2535
2536 # Check for c++ or library specific bits that don't require linking.
2537
2538 if test ! -f stamp-sanity-compiler; then
2539   echo $ac_n "checking for g++ that will successfully compile libstdc++-v3""... $ac_c" 1>&6
2540 echo "configure:2541: checking for g++ that will successfully compile libstdc++-v3" >&5
2541
2542   ac_ext=C
2543 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2544 ac_cpp='$CXXCPP $CPPFLAGS'
2545 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2546 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2547 cross_compiling=$ac_cv_prog_cxx_cross
2548
2549   cat > conftest.$ac_ext <<EOF
2550 #line 2551 "configure"
2551 #include "confdefs.h"
2552
2553   #if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
2554     ok
2555   #endif
2556
2557 EOF
2558 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2559   egrep "ok" >/dev/null 2>&1; then
2560   rm -rf conftest*
2561   gpp_satisfactory=yes
2562 else
2563   rm -rf conftest*
2564   { echo "configure: error: please upgrade to gcc-2.95 or above" 1>&2; exit 1; }
2565 fi
2566 rm -f conftest*
2567
2568   ac_ext=c
2569 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
2570 ac_cpp='$CPP $CPPFLAGS'
2571 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
2572 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
2573 cross_compiling=$ac_cv_prog_cc_cross
2574
2575   echo "$ac_t""$gpp_satisfactory" 1>&6
2576   touch stamp-sanity-compiler
2577 fi
2578
2579
2580 # Enable all the crazy c++ stuff.  C_MBCHAR must come early.
2581 # Check whether --enable-debug or --disable-debug was given.
2582 if test "${enable_debug+set}" = set; then
2583   enableval="$enable_debug"
2584   case "${enableval}" in
2585  yes) enable_debug=yes ;;
2586  no)  enable_debug=no ;;
2587  *)   { echo "configure: error: Unknown argument to enable/disable extra debugging" 1>&2; exit 1; } ;;
2588  esac
2589 else
2590   enable_debug=no
2591 fi
2592
2593 case "${enable_debug}" in
2594     yes)
2595         DEBUG_FLAGS='-O0 -ggdb3'
2596         ;;
2597     no)
2598         DEBUG_FLAGS='-g'
2599         ;;
2600 esac
2601
2602
2603 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
2604 echo "configure:2605: checking how to run the C preprocessor" >&5
2605 # On Suns, sometimes $CPP names a directory.
2606 if test -n "$CPP" && test -d "$CPP"; then
2607   CPP=
2608 fi
2609 if test -z "$CPP"; then
2610 if eval "test \"`echo '$''{'ac_cv_prog_CPP'+set}'`\" = set"; then
2611   echo $ac_n "(cached) $ac_c" 1>&6
2612 else
2613     # This must be in double quotes, not single quotes, because CPP may get
2614   # substituted into the Makefile and "${CC-cc}" will confuse make.
2615   CPP="${CC-cc} -E"
2616   # On the NeXT, cc -E runs the code through the compiler's parser,
2617   # not just through cpp.
2618   cat > conftest.$ac_ext <<EOF
2619 #line 2620 "configure"
2620 #include "confdefs.h"
2621 #include <assert.h>
2622 Syntax Error
2623 EOF
2624 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2625 { (eval echo configure:2626: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2626 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2627 if test -z "$ac_err"; then
2628   :
2629 else
2630   echo "$ac_err" >&5
2631   echo "configure: failed program was:" >&5
2632   cat conftest.$ac_ext >&5
2633   rm -rf conftest*
2634   CPP="${CC-cc} -E -traditional-cpp"
2635   cat > conftest.$ac_ext <<EOF
2636 #line 2637 "configure"
2637 #include "confdefs.h"
2638 #include <assert.h>
2639 Syntax Error
2640 EOF
2641 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2642 { (eval echo configure:2643: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2643 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2644 if test -z "$ac_err"; then
2645   :
2646 else
2647   echo "$ac_err" >&5
2648   echo "configure: failed program was:" >&5
2649   cat conftest.$ac_ext >&5
2650   rm -rf conftest*
2651   CPP="${CC-cc} -nologo -E"
2652   cat > conftest.$ac_ext <<EOF
2653 #line 2654 "configure"
2654 #include "confdefs.h"
2655 #include <assert.h>
2656 Syntax Error
2657 EOF
2658 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2659 { (eval echo configure:2660: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2660 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2661 if test -z "$ac_err"; then
2662   :
2663 else
2664   echo "$ac_err" >&5
2665   echo "configure: failed program was:" >&5
2666   cat conftest.$ac_ext >&5
2667   rm -rf conftest*
2668   CPP=/lib/cpp
2669 fi
2670 rm -f conftest*
2671 fi
2672 rm -f conftest*
2673 fi
2674 rm -f conftest*
2675   ac_cv_prog_CPP="$CPP"
2676 fi
2677   CPP="$ac_cv_prog_CPP"
2678 else
2679   ac_cv_prog_CPP="$CPP"
2680 fi
2681 echo "$ac_t""$CPP" 1>&6
2682
2683
2684   echo $ac_n "checking for cstdio to use""... $ac_c" 1>&6
2685 echo "configure:2686: checking for cstdio to use" >&5
2686   # Check whether --enable-cstdio or --disable-cstdio was given.
2687 if test "${enable_cstdio+set}" = set; then
2688   enableval="$enable_cstdio"
2689   if test x$enable_cstdio = xno; then
2690      enable_cstdio=stdio
2691   fi
2692 else
2693   enable_cstdio=stdio
2694 fi
2695
2696
2697   enable_cstdio_flag=$enable_cstdio
2698
2699     case x${enable_cstdio_flag} in
2700     xlibio)
2701       CSTDIO_H=config/c_io_libio.h
2702       CSTDIO_CC=config/c_io_libio.cc
2703       echo "$ac_t""libio" 1>&6
2704
2705       # see if we are on a system with libio native (ie, linux)
2706       ac_safe=`echo "libio.h" | sed 'y%./+-%__p_%'`
2707 echo $ac_n "checking for libio.h""... $ac_c" 1>&6
2708 echo "configure:2709: checking for libio.h" >&5
2709 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
2710   echo $ac_n "(cached) $ac_c" 1>&6
2711 else
2712   cat > conftest.$ac_ext <<EOF
2713 #line 2714 "configure"
2714 #include "confdefs.h"
2715 #include <libio.h>
2716 EOF
2717 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
2718 { (eval echo configure:2719: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
2719 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
2720 if test -z "$ac_err"; then
2721   rm -rf conftest*
2722   eval "ac_cv_header_$ac_safe=yes"
2723 else
2724   echo "$ac_err" >&5
2725   echo "configure: failed program was:" >&5
2726   cat conftest.$ac_ext >&5
2727   rm -rf conftest*
2728   eval "ac_cv_header_$ac_safe=no"
2729 fi
2730 rm -f conftest*
2731 fi
2732 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
2733   echo "$ac_t""yes" 1>&6
2734   has_libio=yes
2735 else
2736   echo "$ac_t""no" 1>&6
2737 has_libio=no
2738 fi
2739
2740
2741       # Need to check and see what version of glibc is being used. If
2742       # it's not glibc-2.2 or higher, then we'll need to go ahead and
2743       # compile most of libio for linux systems.
2744       if test x$has_libio = x"yes"; then
2745         case "$target" in
2746           *-*-linux*)
2747               echo $ac_n "checking for glibc version >= 2.2""... $ac_c" 1>&6
2748 echo "configure:2749: checking for glibc version >= 2.2" >&5
2749               cat > conftest.$ac_ext <<EOF
2750 #line 2751 "configure"
2751 #include "confdefs.h"
2752
2753             #include <features.h>
2754               #if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2)
2755                     ok
2756               #endif
2757
2758 EOF
2759 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
2760   egrep "ok" >/dev/null 2>&1; then
2761   rm -rf conftest*
2762   glibc_satisfactory=yes
2763 else
2764   rm -rf conftest*
2765   glibc_satisfactory=no
2766 fi
2767 rm -f conftest*
2768
2769               echo "$ac_t""$glibc_satisfactory" 1>&6
2770             ;;
2771         esac
2772
2773         # XXX at the moment, admit defeat and force the recompilation
2774         # XXX of glibc even on glibc-2.2 systems, because libio is not synched.
2775         glibc_satisfactory=no
2776
2777         if test x$glibc_satisfactory = x"yes"; then
2778            need_libio=no
2779            need_wlibio=no
2780         else
2781            need_libio=yes
2782            # bkoz XXX need to add checks to enable this
2783            # pme XXX here's a first pass at such a check
2784            if test x$enable_c_mbchar != xno; then
2785               need_wlibio=yes
2786            else
2787               need_wlibio=no
2788            fi
2789         fi
2790
2791       else
2792          # Using libio, but <libio.h> doesn't exist on the target system. . .
2793          need_libio=yes
2794          # bkoz XXX need to add checks to enable this
2795          # pme XXX here's a first pass at such a check
2796          if test x$enable_c_mbchar != xno; then
2797              need_wlibio=yes
2798          else
2799              need_wlibio=no
2800          fi
2801       fi
2802       ;;
2803     xstdio | x | xno | xnone | xyes)
2804       # default
2805       CSTDIO_H=config/c_io_stdio.h
2806       CSTDIO_CC=config/c_io_stdio.cc
2807       echo "$ac_t""stdio" 1>&6
2808
2809       # We're not using stdio.
2810       need_libio=no
2811       need_wlibio=no
2812       # Wide characters are not supported with this package.
2813       enable_c_mbchar=no
2814       ;;
2815     *)
2816       echo "$enable_cstdio is an unknown io package" 1>&2
2817       exit 1
2818       ;;
2819   esac
2820
2821
2822
2823   # 2000-08-04 bkoz hack
2824   CCODECVT_C=config/c_io_libio_codecvt.c
2825
2826   # 2000-08-04 bkoz hack
2827
2828
2829
2830 if test "$need_libio" = yes || test "$need_wlibio" = yes; then
2831   GLIBCPP_BUILD_LIBIO_TRUE=
2832   GLIBCPP_BUILD_LIBIO_FALSE='#'
2833 else
2834   GLIBCPP_BUILD_LIBIO_TRUE='#'
2835   GLIBCPP_BUILD_LIBIO_FALSE=
2836 fi
2837
2838
2839 if test "$need_libio" = yes; then
2840   GLIBCPP_NEED_LIBIO_TRUE=
2841   GLIBCPP_NEED_LIBIO_FALSE='#'
2842 else
2843   GLIBCPP_NEED_LIBIO_TRUE='#'
2844   GLIBCPP_NEED_LIBIO_FALSE=
2845 fi
2846
2847
2848 if test "$need_wlibio" = yes; then
2849   GLIBCPP_NEED_WLIBIO_TRUE=
2850   GLIBCPP_NEED_WLIBIO_FALSE='#'
2851 else
2852   GLIBCPP_NEED_WLIBIO_TRUE='#'
2853   GLIBCPP_NEED_WLIBIO_FALSE=
2854 fi
2855   if test "$need_libio" = yes || test "$need_wlibio" = yes; then
2856         libio_la=../libio/libio.la
2857   else
2858         libio_la=
2859   fi
2860
2861
2862 # Check whether --enable-c-mbchar or --disable-c-mbchar was given.
2863 if test "${enable_c_mbchar+set}" = set; then
2864   enableval="$enable_c_mbchar"
2865   case "$enableval" in
2866  yes) enable_c_mbchar=yes ;;
2867  no)  enable_c_mbchar=no ;;
2868  *)   { echo "configure: error: Unknown argument to enable/disable c-mbchar" 1>&2; exit 1; } ;;
2869  esac
2870 else
2871   enable_c_mbchar=yes
2872 fi
2873
2874
2875   # Check whether --enable-long-long or --disable-long-long was given.
2876 if test "${enable_long_long+set}" = set; then
2877   enableval="$enable_long_long"
2878     case "$enableval" in
2879    yes) enable_long_long=yes ;;
2880    no)  enable_long_long=no ;;
2881    *)   { echo "configure: error: Unknown argument to enable/disable long long" 1>&2; exit 1; } ;;
2882    esac
2883 else
2884   enable_long_long=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 enabled cshadow headers""... $ac_c" 1>&6
3050 echo "configure:3051: checking for enabled cshadow headers" >&5
3051 # Check whether --enable-cshadow-headers or --disable-cshadow-headers was given.
3052 if test "${enable_cshadow_headers+set}" = set; then
3053   enableval="$enable_cshadow_headers"
3054
3055   case "$enableval" in
3056    yes) enable_cshadow_headers=yes
3057         ;;
3058    no)  enable_cshadow_headers=no
3059         ;;
3060    *)   { echo "configure: error: Unknown argument to enable/disable shadowed C headers" 1>&2; exit 1; }
3061         ;;
3062   esac
3063 else
3064   enable_cshadow_headers=no
3065 fi
3066
3067   echo "$ac_t""$enable_cshadow_headers" 1>&6
3068
3069       case "$enable_cshadow_headers" in
3070     yes)
3071         CSHADOW_FLAGS="-fno-builtin"
3072         C_INCLUDE_DIR='${top_srcdir}/include/c_std'
3073         cat >> confdefs.h <<\EOF
3074 #define _GLIBCPP_USE_SHADOW_HEADERS 1
3075 EOF
3076
3077         ;;
3078     no)
3079         CSHADOW_FLAGS=""
3080         C_INCLUDE_DIR='${top_srcdir}/include/c'
3081         ;;
3082   esac
3083
3084
3085
3086
3087
3088 if test "$enable_cshadow_headers" = yes; then
3089   GLIBCPP_USE_CSHADOW_TRUE=
3090   GLIBCPP_USE_CSHADOW_FALSE='#'
3091 else
3092   GLIBCPP_USE_CSHADOW_TRUE='#'
3093   GLIBCPP_USE_CSHADOW_FALSE=
3094 fi
3095
3096
3097       echo $ac_n "checking for threads package to use""... $ac_c" 1>&6
3098 echo "configure:3099: checking for threads package to use" >&5
3099   # Check whether --enable-threads or --disable-threads was given.
3100 if test "${enable_threads+set}" = set; then
3101   enableval="$enable_threads"
3102   if test x$enable_threads = xno; then
3103     enable_threads=''
3104   fi
3105 else
3106   enable_threads=''
3107 fi
3108
3109
3110   enable_threads_flag=$enable_threads
3111
3112     case x${enable_threads_flag} in
3113         x | xno | xnone)
3114                 # No threads
3115                 target_thread_file='single'
3116                 ;;
3117         xyes)
3118                 # default
3119                 target_thread_file='posix'
3120                 ;;
3121         xdecosf1 | xirix | xmach | xos2 | xposix | xpthreads | xsingle | \
3122         xsolaris | xwin32 | xdce | xvxworks)
3123                 target_thread_file=$enable_threads_flag
3124                 ;;
3125         *)
3126                 echo "$enable_threads is an unknown thread package" 1>&2
3127                 exit 1
3128                 ;;
3129   esac
3130
3131     THREADH=
3132   case "$target_thread_file" in
3133     no | none | single)
3134       THREADH=threads-no.h
3135       ;;
3136     posix | pthreads)
3137       THREADH=threads-posix.h
3138       ;;
3139     decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks)
3140       { echo "configure: error: thread package $THREADS not yet supported" 1>&2; exit 1; }
3141       ;;
3142     *)
3143       { echo "configure: error: $THREADS is an unsupported/unknown thread package" 1>&2; exit 1; }
3144       ;;
3145   esac
3146   echo "$ac_t""$THREADH" 1>&6
3147
3148
3149   if test $THREADH != threads-no.h; then
3150     cat >> confdefs.h <<\EOF
3151 #define _GLIBCPP_USE_THREADS 1
3152 EOF
3153
3154   fi
3155
3156
3157     echo $ac_n "checking for atomicity.h""... $ac_c" 1>&6
3158 echo "configure:3159: checking for atomicity.h" >&5
3159     # We have ATOMICITY already from GLIBCPP_CONFIGURE
3160     if test "$ATOMICITYH" = "config/cpu/generic"; then
3161       echo "configure: warning: No ATOMICITY settings found, using generic atomic ops." 1>&2
3162     fi
3163     echo "$ac_t""$ATOMICITYH/bits/atomicity.h" 1>&6
3164
3165
3166 # Check whether --enable-cxx-flags or --disable-cxx-flags was given.
3167 if test "${enable_cxx_flags+set}" = set; then
3168   enableval="$enable_cxx_flags"
3169   case "x$enableval" in
3170  xyes)
3171         { echo "configure: error: --enable-cxx-flags needs compiler flags as arguments" 1>&2; exit 1; } ;;
3172  xno|x)
3173         enable_cxx_flags='' ;;
3174  *)
3175         enable_cxx_flags="$enableval" ;;
3176  esac
3177 else
3178   enable_cxx_flags='none'
3179 fi
3180
3181
3182 if test "$enable_cxx_flags" = "none"; then
3183   enable_cxx_flags='';
3184 fi
3185
3186 if test -n "$enable_cxx_flags"; then
3187     for f in $enable_cxx_flags; do
3188         case "$f" in
3189             -fhonor-std)  ;;
3190             -*)  ;;
3191             *)   # and we're trying to pass /what/ exactly?
3192                  { echo "configure: error: compiler flags start with a -" 1>&2; exit 1; } ;;
3193         esac
3194     done
3195 fi
3196 EXTRA_CXX_FLAGS="$enable_cxx_flags"
3197
3198
3199
3200 if test -n "$with_cross_host"; then
3201
3202   # We are being configured with a cross compiler.  AC_REPLACE_FUNCS
3203   # may not work correctly, because the compiler may not be able to
3204   # link executables.
3205   xcompiling=1
3206   NATIVE=no
3207
3208   # If Canadian cross, then don't pick up tools from the build
3209   # directory.
3210   if test x"$build" != x"$with_cross_host" && x"$build" != x"$target"; then
3211     CANADIAN=yes
3212     NULL_TARGET=yes
3213   else
3214     CANADIAN=no
3215     NULL_TARGET=no
3216   fi
3217
3218   case "$target_alias" in
3219     *-linux-*)
3220         # Construct linux crosses by hand, eliminating bits that need ld...
3221         # Check for available headers.
3222         for ac_hdr in nan.h ieeefp.h endian.h sys/isa_defs.h \
3223         machine/endian.h machine/param.h sys/machine.h fp.h locale.h \
3224         float.h inttypes.h
3225 do
3226 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
3227 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
3228 echo "configure:3229: checking for $ac_hdr" >&5
3229 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
3230   echo $ac_n "(cached) $ac_c" 1>&6
3231 else
3232   cat > conftest.$ac_ext <<EOF
3233 #line 3234 "configure"
3234 #include "confdefs.h"
3235 #include <$ac_hdr>
3236 EOF
3237 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
3238 { (eval echo configure:3239: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
3239 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
3240 if test -z "$ac_err"; then
3241   rm -rf conftest*
3242   eval "ac_cv_header_$ac_safe=yes"
3243 else
3244   echo "$ac_err" >&5
3245   echo "configure: failed program was:" >&5
3246   cat conftest.$ac_ext >&5
3247   rm -rf conftest*
3248   eval "ac_cv_header_$ac_safe=no"
3249 fi
3250 rm -f conftest*
3251 fi
3252 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
3253   echo "$ac_t""yes" 1>&6
3254     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
3255   cat >> confdefs.h <<EOF
3256 #define $ac_tr_hdr 1
3257 EOF
3258
3259 else
3260   echo "$ac_t""no" 1>&6
3261 fi
3262 done
3263
3264
3265         # GLIBCPP_CHECK_COMPILER_FEATURES
3266         WFMT_FLAGS='-fdiagnostics-show-location=once'
3267         SECTION_FLAGS='-ffunction-sections -fdata-sections'
3268
3269
3270
3271   # If we're not using GNU ld, then there's no point in even trying these
3272   # tests.  Check for that first.  We should have already tested for gld
3273   # by now (in libtool), but require it now just to be safe...
3274   SECTION_LDFLAGS=''
3275   OPT_LDFLAGS=''
3276
3277
3278   # Set --gc-sections.
3279   if test "$ac_cv_prog_gnu_ld" = "notbroken"; then
3280     # GNU ld it is!  Joy and bunny rabbits!
3281
3282     # All these tests are for C++; save the language and the compiler flags.
3283     # Need to do this so that g++ won't try to link in libstdc++
3284     ac_test_CFLAGS="${CFLAGS+set}"
3285     ac_save_CFLAGS="$CFLAGS"
3286     CFLAGS='-x c++  -Wl,--gc-sections'
3287
3288     # Check for -Wl,--gc-sections
3289     # XXX This test is broken at the moment, as symbols required for
3290     # linking are now in libsupc++ (not built yet.....). In addition,
3291     # this test has cored on solaris in the past. In addition,
3292     # --gc-sections doesn't really work at the moment (keeps on discarding
3293     # used sections, first .eh_frame and now some of the glibc sections for
3294     # iconv). Bzzzzt. Thanks for playing, maybe next time.
3295     echo $ac_n "checking for ld that supports -Wl,--gc-sections""... $ac_c" 1>&6
3296 echo "configure:3297: checking for ld that supports -Wl,--gc-sections" >&5
3297     if test "$cross_compiling" = yes; then
3298   ac_sectionLDflags=yes
3299 else
3300   cat > conftest.$ac_ext <<EOF
3301 #line 3302 "configure"
3302 #include "confdefs.h"
3303
3304      int main(void)
3305      {
3306        try { throw 1; }
3307        catch (...) { };
3308        return 0;
3309      }
3310
3311 EOF
3312 if { (eval echo configure:3313: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
3313 then
3314   ac_sectionLDflags=yes
3315 else
3316   echo "configure: failed program was:" >&5
3317   cat conftest.$ac_ext >&5
3318   rm -fr conftest*
3319   ac_sectionLFflags=no
3320 fi
3321 rm -fr conftest*
3322 fi
3323
3324     if test "$ac_test_CFLAGS" = set; then
3325       CFLAGS="$ac_save_CFLAGS"
3326     else
3327       # this is the suspicious part
3328       CFLAGS=''
3329     fi
3330     if test "$ac_sectionLDflags" = "yes"; then
3331       SECTION_LDFLAGS='-Wl,--gc-sections'
3332     fi
3333     echo "$ac_t""$ac_sectionLDflags" 1>&6
3334   fi
3335
3336   # Set linker optimization flags.
3337   if test "$ac_cv_prog_gnu_ld" = "yes"; then
3338     OPT_LDFLAGS='-Wl,-O1'
3339   fi
3340
3341
3342
3343
3344         # GLIBCPP_CHECK_BUILTIN_MATH_SUPPORT
3345         # GLIBCPP_CHECK_MATH_SUPPORT
3346         cat >> confdefs.h <<\EOF
3347 #define HAVE_ACOSF 1
3348 EOF
3349
3350         cat >> confdefs.h <<\EOF
3351 #define HAVE_ASINF 1
3352 EOF
3353
3354         cat >> confdefs.h <<\EOF
3355 #define HAVE_ATAN2F 1
3356 EOF
3357
3358         cat >> confdefs.h <<\EOF
3359 #define HAVE_ATANF 1
3360 EOF
3361
3362         cat >> confdefs.h <<\EOF
3363 #define HAVE_CEILF 1
3364 EOF
3365
3366         cat >> confdefs.h <<\EOF
3367 #define HAVE_COPYSIGN 1
3368 EOF
3369
3370         cat >> confdefs.h <<\EOF
3371 #define HAVE_COPYSIGNF 1
3372 EOF
3373
3374         cat >> confdefs.h <<\EOF
3375 #define HAVE_COSF 1
3376 EOF
3377
3378         cat >> confdefs.h <<\EOF
3379 #define HAVE_COSHF 1
3380 EOF
3381
3382         cat >> confdefs.h <<\EOF
3383 #define HAVE_EXPF 1
3384 EOF
3385
3386         cat >> confdefs.h <<\EOF
3387 #define HAVE_FABSF 1
3388 EOF
3389
3390         cat >> confdefs.h <<\EOF
3391 #define HAVE_FINITE 1
3392 EOF
3393
3394         cat >> confdefs.h <<\EOF
3395 #define HAVE_FINITEF 1
3396 EOF
3397
3398         cat >> confdefs.h <<\EOF
3399 #define HAVE_FLOORF 1
3400 EOF
3401
3402         cat >> confdefs.h <<\EOF
3403 #define HAVE_FMODF 1
3404 EOF
3405
3406         cat >> confdefs.h <<\EOF
3407 #define HAVE_FREXPF 1
3408 EOF
3409
3410         cat >> confdefs.h <<\EOF
3411 #define HAVE_ISINF 1
3412 EOF
3413
3414         cat >> confdefs.h <<\EOF
3415 #define HAVE_ISINFF 1
3416 EOF
3417
3418         cat >> confdefs.h <<\EOF
3419 #define HAVE_ISNAN 1
3420 EOF
3421
3422         cat >> confdefs.h <<\EOF
3423 #define HAVE_ISNANF 1
3424 EOF
3425
3426         cat >> confdefs.h <<\EOF
3427 #define HAVE_LDEXPF 1
3428 EOF
3429
3430         cat >> confdefs.h <<\EOF
3431 #define HAVE_LOG10F 1
3432 EOF
3433
3434         cat >> confdefs.h <<\EOF
3435 #define HAVE_LOGF 1
3436 EOF
3437
3438         cat >> confdefs.h <<\EOF
3439 #define HAVE_MODFF 1
3440 EOF
3441
3442         cat >> confdefs.h <<\EOF
3443 #define HAVE_POWF 1
3444 EOF
3445
3446         cat >> confdefs.h <<\EOF
3447 #define HAVE_SINCOS 1
3448 EOF
3449
3450         cat >> confdefs.h <<\EOF
3451 #define HAVE_SINCOSF 1
3452 EOF
3453
3454         cat >> confdefs.h <<\EOF
3455 #define HAVE_SINF 1
3456 EOF
3457
3458         cat >> confdefs.h <<\EOF
3459 #define HAVE_SINHF 1
3460 EOF
3461
3462         cat >> confdefs.h <<\EOF
3463 #define HAVE_SQRTF 1
3464 EOF
3465
3466         cat >> confdefs.h <<\EOF
3467 #define HAVE_TANF 1
3468 EOF
3469
3470         cat >> confdefs.h <<\EOF
3471 #define HAVE_TANHF 1
3472 EOF
3473
3474
3475         # At some point, we should differentiate between architectures
3476         # like x86, which have long double versions, and alpha/powerpc/etc.,
3477         # which don't. For the time being, punt.
3478         if test x"long_double_math_on_this_cpu" = x"yes"; then
3479           cat >> confdefs.h <<\EOF
3480 #define HAVE_ACOSL 1
3481 EOF
3482
3483           cat >> confdefs.h <<\EOF
3484 #define HAVE_ASINL 1
3485 EOF
3486
3487           cat >> confdefs.h <<\EOF
3488 #define HAVE_ATAN2L 1
3489 EOF
3490
3491           cat >> confdefs.h <<\EOF
3492 #define HAVE_ATANL 1
3493 EOF
3494
3495           cat >> confdefs.h <<\EOF
3496 #define HAVE_CEILL 1
3497 EOF
3498
3499           cat >> confdefs.h <<\EOF
3500 #define HAVE_COPYSIGNL 1
3501 EOF
3502
3503           cat >> confdefs.h <<\EOF
3504 #define HAVE_COSL 1
3505 EOF
3506
3507           cat >> confdefs.h <<\EOF
3508 #define HAVE_COSHL 1
3509 EOF
3510
3511           cat >> confdefs.h <<\EOF
3512 #define HAVE_EXPL 1
3513 EOF
3514
3515           cat >> confdefs.h <<\EOF
3516 #define HAVE_FABSL 1
3517 EOF
3518
3519           cat >> confdefs.h <<\EOF
3520 #define HAVE_FINITEL 1
3521 EOF
3522
3523           cat >> confdefs.h <<\EOF
3524 #define HAVE_FLOORL 1
3525 EOF
3526
3527           cat >> confdefs.h <<\EOF
3528 #define HAVE_FMODL 1
3529 EOF
3530
3531           cat >> confdefs.h <<\EOF
3532 #define HAVE_FREXPL 1
3533 EOF
3534
3535           cat >> confdefs.h <<\EOF
3536 #define HAVE_ISINFL 1
3537 EOF
3538
3539           cat >> confdefs.h <<\EOF
3540 #define HAVE_ISNANL 1
3541 EOF
3542
3543           cat >> confdefs.h <<\EOF
3544 #define HAVE_LDEXPL 1
3545 EOF
3546
3547           cat >> confdefs.h <<\EOF
3548 #define HAVE_LOG10L 1
3549 EOF
3550
3551           cat >> confdefs.h <<\EOF
3552 #define HAVE_LOGL 1
3553 EOF
3554
3555           cat >> confdefs.h <<\EOF
3556 #define HAVE_MODFL 1
3557 EOF
3558
3559           cat >> confdefs.h <<\EOF
3560 #define HAVE_POWL 1
3561 EOF
3562
3563           cat >> confdefs.h <<\EOF
3564 #define HAVE_SINCOSL 1
3565 EOF
3566
3567           cat >> confdefs.h <<\EOF
3568 #define HAVE_SINL 1
3569 EOF
3570
3571           cat >> confdefs.h <<\EOF
3572 #define HAVE_SINHL 1
3573 EOF
3574
3575           cat >> confdefs.h <<\EOF
3576 #define HAVE_SQRTL 1
3577 EOF
3578
3579           cat >> confdefs.h <<\EOF
3580 #define HAVE_TANL 1
3581 EOF
3582
3583           cat >> confdefs.h <<\EOF
3584 #define HAVE_TANHL 1
3585 EOF
3586
3587         fi
3588
3589     for ac_hdr in complex.h
3590 do
3591 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
3592 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
3593 echo "configure:3594: checking for $ac_hdr" >&5
3594 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
3595   echo $ac_n "(cached) $ac_c" 1>&6
3596 else
3597   cat > conftest.$ac_ext <<EOF
3598 #line 3599 "configure"
3599 #include "confdefs.h"
3600 #include <$ac_hdr>
3601 EOF
3602 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
3603 { (eval echo configure:3604: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
3604 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
3605 if test -z "$ac_err"; then
3606   rm -rf conftest*
3607   eval "ac_cv_header_$ac_safe=yes"
3608 else
3609   echo "$ac_err" >&5
3610   echo "configure: failed program was:" >&5
3611   cat conftest.$ac_ext >&5
3612   rm -rf conftest*
3613   eval "ac_cv_header_$ac_safe=no"
3614 fi
3615 rm -f conftest*
3616 fi
3617 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
3618   echo "$ac_t""yes" 1>&6
3619     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
3620   cat >> confdefs.h <<EOF
3621 #define $ac_tr_hdr 1
3622 EOF
3623
3624 else
3625   echo "$ac_t""no" 1>&6
3626 fi
3627 done
3628
3629   echo $ac_n "checking for main in -lm""... $ac_c" 1>&6
3630 echo "configure:3631: checking for main in -lm" >&5
3631 ac_lib_var=`echo m'_'main | sed 'y%./+-%__p_%'`
3632 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
3633   echo $ac_n "(cached) $ac_c" 1>&6
3634 else
3635   ac_save_LIBS="$LIBS"
3636 LIBS="-lm  $LIBS"
3637 cat > conftest.$ac_ext <<EOF
3638 #line 3639 "configure"
3639 #include "confdefs.h"
3640
3641 int main() {
3642 main()
3643 ; return 0; }
3644 EOF
3645 if { (eval echo configure:3646: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3646   rm -rf conftest*
3647   eval "ac_cv_lib_$ac_lib_var=yes"
3648 else
3649   echo "configure: failed program was:" >&5
3650   cat conftest.$ac_ext >&5
3651   rm -rf conftest*
3652   eval "ac_cv_lib_$ac_lib_var=no"
3653 fi
3654 rm -f conftest*
3655 LIBS="$ac_save_LIBS"
3656
3657 fi
3658 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
3659   echo "$ac_t""yes" 1>&6
3660     ac_tr_lib=HAVE_LIB`echo m | sed -e 's/[^a-zA-Z0-9_]/_/g' \
3661     -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
3662   cat >> confdefs.h <<EOF
3663 #define $ac_tr_lib 1
3664 EOF
3665
3666   LIBS="-lm $LIBS"
3667
3668 else
3669   echo "$ac_t""no" 1>&6
3670 fi
3671
3672   for ac_func in csqrt csqrtf nan hypot hypotf atan2f expf copysignf
3673 do
3674 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
3675 echo "configure:3676: checking for $ac_func" >&5
3676 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
3677   echo $ac_n "(cached) $ac_c" 1>&6
3678 else
3679   cat > conftest.$ac_ext <<EOF
3680 #line 3681 "configure"
3681 #include "confdefs.h"
3682 /* System header to define __stub macros and hopefully few prototypes,
3683     which can conflict with char $ac_func(); below.  */
3684 #include <assert.h>
3685 /* Override any gcc2 internal prototype to avoid an error.  */
3686 /* We use char because int might match the return type of a gcc2
3687     builtin and then its argument prototype would still apply.  */
3688 char $ac_func();
3689
3690 int main() {
3691
3692 /* The GNU C library defines this for functions which it implements
3693     to always fail with ENOSYS.  Some functions are actually named
3694     something starting with __ and the normal name is an alias.  */
3695 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
3696 choke me
3697 #else
3698 $ac_func();
3699 #endif
3700
3701 ; return 0; }
3702 EOF
3703 if { (eval echo configure:3704: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3704   rm -rf conftest*
3705   eval "ac_cv_func_$ac_func=yes"
3706 else
3707   echo "configure: failed program was:" >&5
3708   cat conftest.$ac_ext >&5
3709   rm -rf conftest*
3710   eval "ac_cv_func_$ac_func=no"
3711 fi
3712 rm -f conftest*
3713 fi
3714
3715 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
3716   echo "$ac_t""yes" 1>&6
3717     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3718   cat >> confdefs.h <<EOF
3719 #define $ac_tr_func 1
3720 EOF
3721
3722 else
3723   echo "$ac_t""no" 1>&6
3724 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
3725 fi
3726 done
3727
3728
3729
3730           USE_COMPLEX_LONG_DOUBLE=no
3731   if test x$ac_cv_func_atan2l = x"yes" \
3732      && test x$ac_cv_func_copysignl = x"yes"; then
3733     USE_COMPLEX_LONG_DOUBLE=yes
3734     for ac_func in csqrtl hypotl signbitl
3735 do
3736 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
3737 echo "configure:3738: checking for $ac_func" >&5
3738 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
3739   echo $ac_n "(cached) $ac_c" 1>&6
3740 else
3741   cat > conftest.$ac_ext <<EOF
3742 #line 3743 "configure"
3743 #include "confdefs.h"
3744 /* System header to define __stub macros and hopefully few prototypes,
3745     which can conflict with char $ac_func(); below.  */
3746 #include <assert.h>
3747 /* Override any gcc2 internal prototype to avoid an error.  */
3748 /* We use char because int might match the return type of a gcc2
3749     builtin and then its argument prototype would still apply.  */
3750 char $ac_func();
3751
3752 int main() {
3753
3754 /* The GNU C library defines this for functions which it implements
3755     to always fail with ENOSYS.  Some functions are actually named
3756     something starting with __ and the normal name is an alias.  */
3757 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
3758 choke me
3759 #else
3760 $ac_func();
3761 #endif
3762
3763 ; return 0; }
3764 EOF
3765 if { (eval echo configure:3766: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
3766   rm -rf conftest*
3767   eval "ac_cv_func_$ac_func=yes"
3768 else
3769   echo "configure: failed program was:" >&5
3770   cat conftest.$ac_ext >&5
3771   rm -rf conftest*
3772   eval "ac_cv_func_$ac_func=no"
3773 fi
3774 rm -f conftest*
3775 fi
3776
3777 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
3778   echo "$ac_t""yes" 1>&6
3779     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
3780   cat >> confdefs.h <<EOF
3781 #define $ac_tr_func 1
3782 EOF
3783
3784 else
3785   echo "$ac_t""no" 1>&6
3786 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
3787 fi
3788 done
3789
3790
3791   fi
3792
3793
3794
3795
3796
3797
3798   echo $ac_n "checking for GNU C++ __complex__ support""... $ac_c" 1>&6
3799 echo "configure:3800: checking for GNU C++ __complex__ support" >&5
3800   if eval "test \"`echo '$''{'glibcpp_cv_complex'+set}'`\" = set"; then
3801   echo $ac_n "(cached) $ac_c" 1>&6
3802 else
3803
3804
3805     ac_ext=C
3806 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3807 ac_cpp='$CXXCPP $CPPFLAGS'
3808 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3809 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3810 cross_compiling=$ac_cv_prog_cxx_cross
3811
3812     cat > conftest.$ac_ext <<EOF
3813 #line 3814 "configure"
3814 #include "confdefs.h"
3815 struct dcomplex { __complex__ double x; }; \
3816                     dcomplex f(const dcomplex& x) { return dcomplex(x); }
3817 int main() {
3818 \
3819                      dcomplex x; f(x);
3820 ; return 0; }
3821 EOF
3822 if { (eval echo configure:3823: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3823   rm -rf conftest*
3824   glibcpp_cv_complex=ok
3825 else
3826   echo "configure: failed program was:" >&5
3827   cat conftest.$ac_ext >&5
3828   rm -rf conftest*
3829   glibcpp_cv_complex=buggy
3830
3831 fi
3832 rm -f conftest*
3833     ac_ext=c
3834 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3835 ac_cpp='$CPP $CPPFLAGS'
3836 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3837 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3838 cross_compiling=$ac_cv_prog_cc_cross
3839
3840
3841 fi
3842
3843   echo "$ac_t""$glibcpp_cv_complex" 1>&6
3844   if test $glibcpp_cv_complex = buggy; then
3845     cat >> confdefs.h <<\EOF
3846 #define _GLIBCPP_BUGGY_COMPLEX 1
3847 EOF
3848
3849   fi
3850
3851   echo $ac_n "checking for GNU C++ __complex__ float support""... $ac_c" 1>&6
3852 echo "configure:3853: checking for GNU C++ __complex__ float support" >&5
3853   if eval "test \"`echo '$''{'glibcpp_cv_float_complex'+set}'`\" = set"; then
3854   echo $ac_n "(cached) $ac_c" 1>&6
3855 else
3856
3857
3858     ac_ext=C
3859 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3860 ac_cpp='$CXXCPP $CPPFLAGS'
3861 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3862 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3863 cross_compiling=$ac_cv_prog_cxx_cross
3864
3865     rm -f conftest.h
3866     cat > conftest.h <<EOB
3867       //
3868       // Check for buggy __complex__ that causes ICE in most versions of egcs
3869       // and gcc-2.95.x on certain platforms (eg., x86-win32).
3870       //
3871       // See http://gcc.gnu.org/ml/gcc-bugs/1999-07n/msg00845.html for
3872       // more info on the bug itself.
3873       //
3874       struct
3875       float_complex
3876       {
3877        __complex__ float m_value;
3878        float_complex (float = 0.0f, float = 0.0f);
3879        float_complex (__complex__ float val) : m_value (val) {}
3880        float_complex foo (const float_complex &val)
3881          { return float_complex (~val.m_value); }
3882       };
3883 EOB
3884     cat > conftest.$ac_ext <<EOF
3885 #line 3886 "configure"
3886 #include "confdefs.h"
3887 #include "conftest.h"
3888 int main() {
3889
3890 ; return 0; }
3891 EOF
3892 if { (eval echo configure:3893: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
3893   rm -rf conftest*
3894   glibcpp_cv_float_complex=ok
3895 else
3896   echo "configure: failed program was:" >&5
3897   cat conftest.$ac_ext >&5
3898   rm -rf conftest*
3899   glibcpp_cv_float_complex=buggy
3900
3901 fi
3902 rm -f conftest*
3903     ac_ext=c
3904 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
3905 ac_cpp='$CPP $CPPFLAGS'
3906 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
3907 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
3908 cross_compiling=$ac_cv_prog_cc_cross
3909
3910
3911 fi
3912
3913   echo "$ac_t""$glibcpp_cv_float_complex" 1>&6
3914   if test $glibcpp_cv_float_complex = buggy; then
3915     cat >> confdefs.h <<\EOF
3916 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
3917 EOF
3918
3919   fi
3920
3921
3922   if test x$enable_c_mbchar != xno; then
3923
3924         ac_safe=`echo "wchar.h" | sed 'y%./+-%__p_%'`
3925 echo $ac_n "checking for wchar.h""... $ac_c" 1>&6
3926 echo "configure:3927: checking for wchar.h" >&5
3927 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
3928   echo $ac_n "(cached) $ac_c" 1>&6
3929 else
3930   cat > conftest.$ac_ext <<EOF
3931 #line 3932 "configure"
3932 #include "confdefs.h"
3933 #include <wchar.h>
3934 EOF
3935 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
3936 { (eval echo configure:3937: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
3937 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
3938 if test -z "$ac_err"; then
3939   rm -rf conftest*
3940   eval "ac_cv_header_$ac_safe=yes"
3941 else
3942   echo "$ac_err" >&5
3943   echo "configure: failed program was:" >&5
3944   cat conftest.$ac_ext >&5
3945   rm -rf conftest*
3946   eval "ac_cv_header_$ac_safe=no"
3947 fi
3948 rm -f conftest*
3949 fi
3950 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
3951   echo "$ac_t""yes" 1>&6
3952   ac_has_wchar_h=yes
3953 else
3954   echo "$ac_t""no" 1>&6
3955 ac_has_wchar_h=no
3956 fi
3957
3958     ac_safe=`echo "wctype.h" | sed 'y%./+-%__p_%'`
3959 echo $ac_n "checking for wctype.h""... $ac_c" 1>&6
3960 echo "configure:3961: checking for wctype.h" >&5
3961 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
3962   echo $ac_n "(cached) $ac_c" 1>&6
3963 else
3964   cat > conftest.$ac_ext <<EOF
3965 #line 3966 "configure"
3966 #include "confdefs.h"
3967 #include <wctype.h>
3968 EOF
3969 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
3970 { (eval echo configure:3971: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
3971 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
3972 if test -z "$ac_err"; then
3973   rm -rf conftest*
3974   eval "ac_cv_header_$ac_safe=yes"
3975 else
3976   echo "$ac_err" >&5
3977   echo "configure: failed program was:" >&5
3978   cat conftest.$ac_ext >&5
3979   rm -rf conftest*
3980   eval "ac_cv_header_$ac_safe=no"
3981 fi
3982 rm -f conftest*
3983 fi
3984 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
3985   echo "$ac_t""yes" 1>&6
3986   ac_has_wctype_h=yes
3987 else
3988   echo "$ac_t""no" 1>&6
3989 ac_has_wctype_h=no
3990 fi
3991
3992
3993         if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes; then
3994
3995                   echo $ac_n "checking for mbstate_t""... $ac_c" 1>&6
3996 echo "configure:3997: checking for mbstate_t" >&5
3997       cat > conftest.$ac_ext <<EOF
3998 #line 3999 "configure"
3999 #include "confdefs.h"
4000 #include <wchar.h>
4001 int main() {
4002 mbstate_t teststate;
4003 ; return 0; }
4004 EOF
4005 if { (eval echo configure:4006: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4006   rm -rf conftest*
4007   use_native_mbstatet=yes
4008 else
4009   echo "configure: failed program was:" >&5
4010   cat conftest.$ac_ext >&5
4011   rm -rf conftest*
4012   use_native_mbstatet=no
4013 fi
4014 rm -f conftest*
4015       echo "$ac_t""$use_native_mbstatet" 1>&6
4016
4017                   echo $ac_n "checking for WCHAR_MIN and WCHAR_MAX""... $ac_c" 1>&6
4018 echo "configure:4019: checking for WCHAR_MIN and WCHAR_MAX" >&5
4019       cat > conftest.$ac_ext <<EOF
4020 #line 4021 "configure"
4021 #include "confdefs.h"
4022 #include <wchar.h>
4023 int main() {
4024 int i = WCHAR_MIN; int j = WCHAR_MAX;
4025 ; return 0; }
4026 EOF
4027 if { (eval echo configure:4028: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4028   rm -rf conftest*
4029   has_wchar_minmax=yes
4030 else
4031   echo "configure: failed program was:" >&5
4032   cat conftest.$ac_ext >&5
4033   rm -rf conftest*
4034   has_wchar_minmax=no
4035 fi
4036 rm -f conftest*
4037       echo "$ac_t""$has_wchar_minmax" 1>&6
4038
4039                   echo $ac_n "checking for WEOF""... $ac_c" 1>&6
4040 echo "configure:4041: checking for WEOF" >&5
4041       cat > conftest.$ac_ext <<EOF
4042 #line 4043 "configure"
4043 #include "confdefs.h"
4044
4045         #include <wchar.h>
4046         #include <stddef.h>
4047 int main() {
4048 wint_t i = WEOF;
4049 ; return 0; }
4050 EOF
4051 if { (eval echo configure:4052: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4052   rm -rf conftest*
4053   has_weof=yes
4054 else
4055   echo "configure: failed program was:" >&5
4056   cat conftest.$ac_ext >&5
4057   rm -rf conftest*
4058   has_weof=no
4059 fi
4060 rm -f conftest*
4061       echo "$ac_t""$has_weof" 1>&6
4062
4063             for ac_func in wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset \
4064       wcsrtombs mbsrtowcs
4065 do
4066 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4067 echo "configure:4068: checking for $ac_func" >&5
4068 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4069   echo $ac_n "(cached) $ac_c" 1>&6
4070 else
4071   cat > conftest.$ac_ext <<EOF
4072 #line 4073 "configure"
4073 #include "confdefs.h"
4074 /* System header to define __stub macros and hopefully few prototypes,
4075     which can conflict with char $ac_func(); below.  */
4076 #include <assert.h>
4077 /* Override any gcc2 internal prototype to avoid an error.  */
4078 /* We use char because int might match the return type of a gcc2
4079     builtin and then its argument prototype would still apply.  */
4080 char $ac_func();
4081
4082 int main() {
4083
4084 /* The GNU C library defines this for functions which it implements
4085     to always fail with ENOSYS.  Some functions are actually named
4086     something starting with __ and the normal name is an alias.  */
4087 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4088 choke me
4089 #else
4090 $ac_func();
4091 #endif
4092
4093 ; return 0; }
4094 EOF
4095 if { (eval echo configure:4096: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4096   rm -rf conftest*
4097   eval "ac_cv_func_$ac_func=yes"
4098 else
4099   echo "configure: failed program was:" >&5
4100   cat conftest.$ac_ext >&5
4101   rm -rf conftest*
4102   eval "ac_cv_func_$ac_func=no"
4103 fi
4104 rm -f conftest*
4105 fi
4106
4107 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4108   echo "$ac_t""yes" 1>&6
4109     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4110   cat >> confdefs.h <<EOF
4111 #define $ac_tr_func 1
4112 EOF
4113  ac_wfuncs=yes
4114 else
4115   echo "$ac_t""no" 1>&6
4116 ac_wfuncs=no
4117 fi
4118 done
4119
4120
4121       echo $ac_n "checking for ISO C99 wchar_t support""... $ac_c" 1>&6
4122 echo "configure:4123: checking for ISO C99 wchar_t support" >&5
4123       if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes \
4124          && test x"$ac_wfuncs" = xyes; then
4125         ac_isoC99_wchar_t=yes
4126       else
4127         ac_isoC99_wchar_t=no
4128       fi
4129       echo "$ac_t""$ac_isoC99_wchar_t" 1>&6
4130
4131                   ac_safe=`echo "iconv.h" | sed 'y%./+-%__p_%'`
4132 echo $ac_n "checking for iconv.h""... $ac_c" 1>&6
4133 echo "configure:4134: checking for iconv.h" >&5
4134 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
4135   echo $ac_n "(cached) $ac_c" 1>&6
4136 else
4137   cat > conftest.$ac_ext <<EOF
4138 #line 4139 "configure"
4139 #include "confdefs.h"
4140 #include <iconv.h>
4141 EOF
4142 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
4143 { (eval echo configure:4144: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
4144 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
4145 if test -z "$ac_err"; then
4146   rm -rf conftest*
4147   eval "ac_cv_header_$ac_safe=yes"
4148 else
4149   echo "$ac_err" >&5
4150   echo "configure: failed program was:" >&5
4151   cat conftest.$ac_ext >&5
4152   rm -rf conftest*
4153   eval "ac_cv_header_$ac_safe=no"
4154 fi
4155 rm -f conftest*
4156 fi
4157 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
4158   echo "$ac_t""yes" 1>&6
4159   ac_has_iconv_h=yes
4160 else
4161   echo "$ac_t""no" 1>&6
4162 ac_has_iconv_h=no
4163 fi
4164
4165       ac_safe=`echo "langinfo.h" | sed 'y%./+-%__p_%'`
4166 echo $ac_n "checking for langinfo.h""... $ac_c" 1>&6
4167 echo "configure:4168: checking for langinfo.h" >&5
4168 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
4169   echo $ac_n "(cached) $ac_c" 1>&6
4170 else
4171   cat > conftest.$ac_ext <<EOF
4172 #line 4173 "configure"
4173 #include "confdefs.h"
4174 #include <langinfo.h>
4175 EOF
4176 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
4177 { (eval echo configure:4178: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
4178 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
4179 if test -z "$ac_err"; then
4180   rm -rf conftest*
4181   eval "ac_cv_header_$ac_safe=yes"
4182 else
4183   echo "$ac_err" >&5
4184   echo "configure: failed program was:" >&5
4185   cat conftest.$ac_ext >&5
4186   rm -rf conftest*
4187   eval "ac_cv_header_$ac_safe=no"
4188 fi
4189 rm -f conftest*
4190 fi
4191 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
4192   echo "$ac_t""yes" 1>&6
4193   ac_has_langinfo_h=yes
4194 else
4195   echo "$ac_t""no" 1>&6
4196 ac_has_langinfo_h=no
4197 fi
4198
4199
4200             echo $ac_n "checking for iconv in -liconv""... $ac_c" 1>&6
4201 echo "configure:4202: checking for iconv in -liconv" >&5
4202 ac_lib_var=`echo iconv'_'iconv | sed 'y%./+-%__p_%'`
4203 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
4204   echo $ac_n "(cached) $ac_c" 1>&6
4205 else
4206   ac_save_LIBS="$LIBS"
4207 LIBS="-liconv  $LIBS"
4208 cat > conftest.$ac_ext <<EOF
4209 #line 4210 "configure"
4210 #include "confdefs.h"
4211 /* Override any gcc2 internal prototype to avoid an error.  */
4212 /* We use char because int might match the return type of a gcc2
4213     builtin and then its argument prototype would still apply.  */
4214 char iconv();
4215
4216 int main() {
4217 iconv()
4218 ; return 0; }
4219 EOF
4220 if { (eval echo configure:4221: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4221   rm -rf conftest*
4222   eval "ac_cv_lib_$ac_lib_var=yes"
4223 else
4224   echo "configure: failed program was:" >&5
4225   cat conftest.$ac_ext >&5
4226   rm -rf conftest*
4227   eval "ac_cv_lib_$ac_lib_var=no"
4228 fi
4229 rm -f conftest*
4230 LIBS="$ac_save_LIBS"
4231
4232 fi
4233 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
4234   echo "$ac_t""yes" 1>&6
4235   libiconv="-liconv"
4236 else
4237   echo "$ac_t""no" 1>&6
4238 fi
4239
4240       ac_save_LIBS="$LIBS"
4241       LIBS="$LIBS $libiconv"
4242
4243       for ac_func in iconv_open iconv_close iconv nl_langinfo
4244 do
4245 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
4246 echo "configure:4247: checking for $ac_func" >&5
4247 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
4248   echo $ac_n "(cached) $ac_c" 1>&6
4249 else
4250   cat > conftest.$ac_ext <<EOF
4251 #line 4252 "configure"
4252 #include "confdefs.h"
4253 /* System header to define __stub macros and hopefully few prototypes,
4254     which can conflict with char $ac_func(); below.  */
4255 #include <assert.h>
4256 /* Override any gcc2 internal prototype to avoid an error.  */
4257 /* We use char because int might match the return type of a gcc2
4258     builtin and then its argument prototype would still apply.  */
4259 char $ac_func();
4260
4261 int main() {
4262
4263 /* The GNU C library defines this for functions which it implements
4264     to always fail with ENOSYS.  Some functions are actually named
4265     something starting with __ and the normal name is an alias.  */
4266 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4267 choke me
4268 #else
4269 $ac_func();
4270 #endif
4271
4272 ; return 0; }
4273 EOF
4274 if { (eval echo configure:4275: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4275   rm -rf conftest*
4276   eval "ac_cv_func_$ac_func=yes"
4277 else
4278   echo "configure: failed program was:" >&5
4279   cat conftest.$ac_ext >&5
4280   rm -rf conftest*
4281   eval "ac_cv_func_$ac_func=no"
4282 fi
4283 rm -f conftest*
4284 fi
4285
4286 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
4287   echo "$ac_t""yes" 1>&6
4288     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4289   cat >> confdefs.h <<EOF
4290 #define $ac_tr_func 1
4291 EOF
4292  \
4293       ac_XPG2funcs=yes
4294 else
4295   echo "$ac_t""no" 1>&6
4296 ac_XPG2funcs=no
4297 fi
4298 done
4299
4300
4301       LIBS="$ac_save_LIBS"
4302
4303       echo $ac_n "checking for XPG2 wchar_t support""... $ac_c" 1>&6
4304 echo "configure:4305: checking for XPG2 wchar_t support" >&5
4305       if test x"$ac_has_iconv_h" = xyes && test x"$ac_has_langinfo_h" = xyes \
4306          && test x"$ac_XPG2funcs" = xyes; then
4307         ac_XPG2_wchar_t=yes
4308       else
4309         ac_XPG2_wchar_t=no
4310       fi
4311       echo "$ac_t""$ac_XPG2_wchar_t" 1>&6
4312
4313                   echo $ac_n "checking for enabled wchar_t specializations""... $ac_c" 1>&6
4314 echo "configure:4315: checking for enabled wchar_t specializations" >&5
4315       if test x"$ac_isoC99_wchar_t" = xyes \
4316          && test x"$ac_XPG2_wchar_t" = xyes; then
4317         libinst_wstring_la="libinst-wstring.la"
4318         cat >> confdefs.h <<\EOF
4319 #define _GLIBCPP_USE_WCHAR_T 1
4320 EOF
4321
4322         echo "$ac_t"""yes"" 1>&6
4323       else
4324         libinst_wstring_la=""
4325         echo "$ac_t"""no"" 1>&6
4326       fi
4327
4328
4329     else
4330       echo "configure: warning: <wchar.h> not found" 1>&2
4331     fi
4332
4333   else
4334         :
4335   fi
4336
4337         # GLIBCPP_CHECK_CTYPE_SUPPORT
4338         ctype_include_dir="config/os/gnu-linux"
4339         # GLIBCPP_CHECK_STDLIB_SUPPORT
4340         cat >> confdefs.h <<\EOF
4341 #define HAVE_STRTOF 1
4342 EOF
4343
4344         cat >> confdefs.h <<\EOF
4345 #define HAVE_STRTOLD 1
4346 EOF
4347
4348         # AC_FUNC_MMAP
4349         cat >> confdefs.h <<\EOF
4350 #define HAVE_MMAP 1
4351 EOF
4352
4353         ;;
4354     *)
4355         # We assume newlib.  This lets us hard-code the functions we know
4356         # we'll have.
4357         cat >> confdefs.h <<\EOF
4358 #define HAVE_FINITE 1
4359 EOF
4360
4361         cat >> confdefs.h <<\EOF
4362 #define HAVE_ISNAN 1
4363 EOF
4364
4365         cat >> confdefs.h <<\EOF
4366 #define HAVE_ISNANF 1
4367 EOF
4368
4369         cat >> confdefs.h <<\EOF
4370 #define HAVE_ISINF 1
4371 EOF
4372
4373         cat >> confdefs.h <<\EOF
4374 #define HAVE_ISINFF 1
4375 EOF
4376
4377
4378         ctype_include_dir="config/os/newlib"
4379         os_include_dir="config/os/newlib"
4380
4381         cat >> confdefs.h <<\EOF
4382 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
4383 EOF
4384
4385         cat >> confdefs.h <<\EOF
4386 #define _GLIBCPP_BUGGY_COMPLEX 1
4387 EOF
4388
4389         # need to check for faster f versions of math functions, ie sinf?
4390         ;;
4391   esac
4392 else
4393
4394   # We are being configured natively. We can do more elaborate tests
4395   # that include AC_TRY_COMPILE now, as the linker is assumed to be
4396   # working.
4397   xcompiling=0
4398   NATIVE=yes
4399   CANADIAN=no
4400   NULL_TARGET=no
4401
4402   # Check for available headers.
4403   for ac_hdr in nan.h ieeefp.h endian.h sys/isa_defs.h machine/endian.h \
4404   machine/param.h sys/machine.h fp.h locale.h float.h inttypes.h gconv.h
4405 do
4406 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
4407 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
4408 echo "configure:4409: checking for $ac_hdr" >&5
4409 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
4410   echo $ac_n "(cached) $ac_c" 1>&6
4411 else
4412   cat > conftest.$ac_ext <<EOF
4413 #line 4414 "configure"
4414 #include "confdefs.h"
4415 #include <$ac_hdr>
4416 EOF
4417 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
4418 { (eval echo configure:4419: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
4419 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
4420 if test -z "$ac_err"; then
4421   rm -rf conftest*
4422   eval "ac_cv_header_$ac_safe=yes"
4423 else
4424   echo "$ac_err" >&5
4425   echo "configure: failed program was:" >&5
4426   cat conftest.$ac_ext >&5
4427   rm -rf conftest*
4428   eval "ac_cv_header_$ac_safe=no"
4429 fi
4430 rm -f conftest*
4431 fi
4432 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
4433   echo "$ac_t""yes" 1>&6
4434     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
4435   cat >> confdefs.h <<EOF
4436 #define $ac_tr_hdr 1
4437 EOF
4438
4439 else
4440   echo "$ac_t""no" 1>&6
4441 fi
4442 done
4443
4444
4445
4446   # All these tests are for C++; save the language and the compiler flags.
4447   # The CXXFLAGS thing is suspicious, but based on similar bits
4448   # found in GLIBCPP_CONFIGURE.
4449
4450   ac_ext=C
4451 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4452 ac_cpp='$CXXCPP $CPPFLAGS'
4453 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4454 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4455 cross_compiling=$ac_cv_prog_cxx_cross
4456
4457   ac_test_CXXFLAGS="${CXXFLAGS+set}"
4458   ac_save_CXXFLAGS="$CXXFLAGS"
4459
4460   # Check for maintainer-mode bits.
4461   if test x"$USE_MAINTAINER_MODE" = xno; then
4462     WERROR=''
4463   else
4464     WERROR='-Werror'
4465   fi
4466
4467   # Check for more sophisticated diagnostic control.
4468   echo $ac_n "checking for g++ that supports -fdiagnostics-show-location=once""... $ac_c" 1>&6
4469 echo "configure:4470: checking for g++ that supports -fdiagnostics-show-location=once" >&5
4470   CXXFLAGS='-Werror -fdiagnostics-show-location=once'
4471   cat > conftest.$ac_ext <<EOF
4472 #line 4473 "configure"
4473 #include "confdefs.h"
4474
4475 int main() {
4476 int foo;
4477
4478 ; return 0; }
4479 EOF
4480 if { (eval echo configure:4481: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4481   rm -rf conftest*
4482   ac_gabydiags=yes
4483 else
4484   echo "configure: failed program was:" >&5
4485   cat conftest.$ac_ext >&5
4486   rm -rf conftest*
4487   ac_gabydiags=no
4488 fi
4489 rm -f conftest*
4490   if test "$ac_test_CXXFLAGS" = set; then
4491     CXXFLAGS="$ac_save_CXXFLAGS"
4492   else
4493     # this is the suspicious part
4494     CXXFLAGS=''
4495   fi
4496   if test "$ac_gabydiags" = "yes"; then
4497     WFMT_FLAGS='-fdiagnostics-show-location=once'
4498   fi
4499   echo "$ac_t""$ac_gabydiags" 1>&6
4500
4501   # Check for -ffunction-sections -fdata-sections
4502   echo $ac_n "checking for g++ that supports -ffunction-sections -fdata-sections""... $ac_c" 1>&6
4503 echo "configure:4504: checking for g++ that supports -ffunction-sections -fdata-sections" >&5
4504   CXXFLAGS='-Werror -ffunction-sections -fdata-sections'
4505   cat > conftest.$ac_ext <<EOF
4506 #line 4507 "configure"
4507 #include "confdefs.h"
4508
4509 int main() {
4510 int foo;
4511
4512 ; return 0; }
4513 EOF
4514 if { (eval echo configure:4515: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4515   rm -rf conftest*
4516   ac_fdsections=yes
4517 else
4518   echo "configure: failed program was:" >&5
4519   cat conftest.$ac_ext >&5
4520   rm -rf conftest*
4521   ac_fdsections=no
4522 fi
4523 rm -f conftest*
4524   if test "$ac_test_CXXFLAGS" = set; then
4525     CXXFLAGS="$ac_save_CXXFLAGS"
4526   else
4527     # this is the suspicious part
4528     CXXFLAGS=''
4529   fi
4530   if test "$ac_fdsections" = "yes"; then
4531     SECTION_FLAGS='-ffunction-sections -fdata-sections'
4532   fi
4533   echo "$ac_t""$ac_fdsections" 1>&6
4534
4535   ac_ext=c
4536 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4537 ac_cpp='$CPP $CPPFLAGS'
4538 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4539 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4540 cross_compiling=$ac_cv_prog_cc_cross
4541
4542
4543
4544
4545
4546
4547   # If we're not using GNU ld, then there's no point in even trying these
4548   # tests.  Check for that first.  We should have already tested for gld
4549   # by now (in libtool), but require it now just to be safe...
4550   SECTION_LDFLAGS=''
4551   OPT_LDFLAGS=''
4552
4553
4554   # Set --gc-sections.
4555   if test "$ac_cv_prog_gnu_ld" = "notbroken"; then
4556     # GNU ld it is!  Joy and bunny rabbits!
4557
4558     # All these tests are for C++; save the language and the compiler flags.
4559     # Need to do this so that g++ won't try to link in libstdc++
4560     ac_test_CFLAGS="${CFLAGS+set}"
4561     ac_save_CFLAGS="$CFLAGS"
4562     CFLAGS='-x c++  -Wl,--gc-sections'
4563
4564     # Check for -Wl,--gc-sections
4565     # XXX This test is broken at the moment, as symbols required for
4566     # linking are now in libsupc++ (not built yet.....). In addition,
4567     # this test has cored on solaris in the past. In addition,
4568     # --gc-sections doesn't really work at the moment (keeps on discarding
4569     # used sections, first .eh_frame and now some of the glibc sections for
4570     # iconv). Bzzzzt. Thanks for playing, maybe next time.
4571     echo $ac_n "checking for ld that supports -Wl,--gc-sections""... $ac_c" 1>&6
4572 echo "configure:4573: checking for ld that supports -Wl,--gc-sections" >&5
4573     if test "$cross_compiling" = yes; then
4574   ac_sectionLDflags=yes
4575 else
4576   cat > conftest.$ac_ext <<EOF
4577 #line 4578 "configure"
4578 #include "confdefs.h"
4579
4580      int main(void)
4581      {
4582        try { throw 1; }
4583        catch (...) { };
4584        return 0;
4585      }
4586
4587 EOF
4588 if { (eval echo configure:4589: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
4589 then
4590   ac_sectionLDflags=yes
4591 else
4592   echo "configure: failed program was:" >&5
4593   cat conftest.$ac_ext >&5
4594   rm -fr conftest*
4595   ac_sectionLFflags=no
4596 fi
4597 rm -fr conftest*
4598 fi
4599
4600     if test "$ac_test_CFLAGS" = set; then
4601       CFLAGS="$ac_save_CFLAGS"
4602     else
4603       # this is the suspicious part
4604       CFLAGS=''
4605     fi
4606     if test "$ac_sectionLDflags" = "yes"; then
4607       SECTION_LDFLAGS='-Wl,--gc-sections'
4608     fi
4609     echo "$ac_t""$ac_sectionLDflags" 1>&6
4610   fi
4611
4612   # Set linker optimization flags.
4613   if test "$ac_cv_prog_gnu_ld" = "yes"; then
4614     OPT_LDFLAGS='-Wl,-O1'
4615   fi
4616
4617
4618
4619
4620
4621
4622   echo $ac_n "checking for __builtin_abs declaration""... $ac_c" 1>&6
4623 echo "configure:4624: checking for __builtin_abs declaration" >&5
4624   if test x${glibcpp_cv_func___builtin_abs_use+set} != xset; then
4625     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_abs_use'+set}'`\" = set"; then
4626   echo $ac_n "(cached) $ac_c" 1>&6
4627 else
4628
4629
4630       ac_ext=C
4631 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4632 ac_cpp='$CXXCPP $CPPFLAGS'
4633 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4634 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4635 cross_compiling=$ac_cv_prog_cxx_cross
4636
4637       cat > conftest.$ac_ext <<EOF
4638 #line 4639 "configure"
4639 #include "confdefs.h"
4640 #include <math.h>
4641 int main() {
4642  __builtin_abs(0);
4643 ; return 0; }
4644 EOF
4645 if { (eval echo configure:4646: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4646   rm -rf conftest*
4647   glibcpp_cv_func___builtin_abs_use=yes
4648 else
4649   echo "configure: failed program was:" >&5
4650   cat conftest.$ac_ext >&5
4651   rm -rf conftest*
4652   glibcpp_cv_func___builtin_abs_use=no
4653 fi
4654 rm -f conftest*
4655       ac_ext=c
4656 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4657 ac_cpp='$CPP $CPPFLAGS'
4658 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4659 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4660 cross_compiling=$ac_cv_prog_cc_cross
4661
4662
4663 fi
4664
4665   fi
4666   echo "$ac_t""$glibcpp_cv_func___builtin_abs_use" 1>&6
4667   if test x$glibcpp_cv_func___builtin_abs_use = x"yes"; then
4668     echo $ac_n "checking for __builtin_abs linkage""... $ac_c" 1>&6
4669 echo "configure:4670: checking for __builtin_abs linkage" >&5
4670     if test x${glibcpp_cv_func___builtin_abs_link+set} != xset; then
4671       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_abs_link'+set}'`\" = set"; then
4672   echo $ac_n "(cached) $ac_c" 1>&6
4673 else
4674
4675         cat > conftest.$ac_ext <<EOF
4676 #line 4677 "configure"
4677 #include "confdefs.h"
4678 #include <math.h>
4679 int main() {
4680  __builtin_abs(0);
4681 ; return 0; }
4682 EOF
4683 if { (eval echo configure:4684: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4684   rm -rf conftest*
4685   glibcpp_cv_func___builtin_abs_link=yes
4686 else
4687   echo "configure: failed program was:" >&5
4688   cat conftest.$ac_ext >&5
4689   rm -rf conftest*
4690   glibcpp_cv_func___builtin_abs_link=no
4691 fi
4692 rm -f conftest*
4693
4694 fi
4695
4696     fi
4697     echo "$ac_t""$glibcpp_cv_func___builtin_abs_link" 1>&6
4698     if test x$glibcpp_cv_func___builtin_abs_link = x"yes"; then
4699       ac_tr_func=HAVE_`echo __builtin_abs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4700       cat >> confdefs.h <<EOF
4701 #define ${ac_tr_func} 1
4702 EOF
4703
4704     fi
4705   fi
4706
4707
4708   echo $ac_n "checking for __builtin_fabsf declaration""... $ac_c" 1>&6
4709 echo "configure:4710: checking for __builtin_fabsf declaration" >&5
4710   if test x${glibcpp_cv_func___builtin_fabsf_use+set} != xset; then
4711     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsf_use'+set}'`\" = set"; then
4712   echo $ac_n "(cached) $ac_c" 1>&6
4713 else
4714
4715
4716       ac_ext=C
4717 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4718 ac_cpp='$CXXCPP $CPPFLAGS'
4719 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4720 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4721 cross_compiling=$ac_cv_prog_cxx_cross
4722
4723       cat > conftest.$ac_ext <<EOF
4724 #line 4725 "configure"
4725 #include "confdefs.h"
4726 #include <math.h>
4727 int main() {
4728  __builtin_fabsf(0);
4729 ; return 0; }
4730 EOF
4731 if { (eval echo configure:4732: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4732   rm -rf conftest*
4733   glibcpp_cv_func___builtin_fabsf_use=yes
4734 else
4735   echo "configure: failed program was:" >&5
4736   cat conftest.$ac_ext >&5
4737   rm -rf conftest*
4738   glibcpp_cv_func___builtin_fabsf_use=no
4739 fi
4740 rm -f conftest*
4741       ac_ext=c
4742 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4743 ac_cpp='$CPP $CPPFLAGS'
4744 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4745 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4746 cross_compiling=$ac_cv_prog_cc_cross
4747
4748
4749 fi
4750
4751   fi
4752   echo "$ac_t""$glibcpp_cv_func___builtin_fabsf_use" 1>&6
4753   if test x$glibcpp_cv_func___builtin_fabsf_use = x"yes"; then
4754     echo $ac_n "checking for __builtin_fabsf linkage""... $ac_c" 1>&6
4755 echo "configure:4756: checking for __builtin_fabsf linkage" >&5
4756     if test x${glibcpp_cv_func___builtin_fabsf_link+set} != xset; then
4757       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsf_link'+set}'`\" = set"; then
4758   echo $ac_n "(cached) $ac_c" 1>&6
4759 else
4760
4761         cat > conftest.$ac_ext <<EOF
4762 #line 4763 "configure"
4763 #include "confdefs.h"
4764 #include <math.h>
4765 int main() {
4766  __builtin_fabsf(0);
4767 ; return 0; }
4768 EOF
4769 if { (eval echo configure:4770: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4770   rm -rf conftest*
4771   glibcpp_cv_func___builtin_fabsf_link=yes
4772 else
4773   echo "configure: failed program was:" >&5
4774   cat conftest.$ac_ext >&5
4775   rm -rf conftest*
4776   glibcpp_cv_func___builtin_fabsf_link=no
4777 fi
4778 rm -f conftest*
4779
4780 fi
4781
4782     fi
4783     echo "$ac_t""$glibcpp_cv_func___builtin_fabsf_link" 1>&6
4784     if test x$glibcpp_cv_func___builtin_fabsf_link = x"yes"; then
4785       ac_tr_func=HAVE_`echo __builtin_fabsf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4786       cat >> confdefs.h <<EOF
4787 #define ${ac_tr_func} 1
4788 EOF
4789
4790     fi
4791   fi
4792
4793
4794   echo $ac_n "checking for __builtin_fabs declaration""... $ac_c" 1>&6
4795 echo "configure:4796: checking for __builtin_fabs declaration" >&5
4796   if test x${glibcpp_cv_func___builtin_fabs_use+set} != xset; then
4797     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabs_use'+set}'`\" = set"; then
4798   echo $ac_n "(cached) $ac_c" 1>&6
4799 else
4800
4801
4802       ac_ext=C
4803 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4804 ac_cpp='$CXXCPP $CPPFLAGS'
4805 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4806 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4807 cross_compiling=$ac_cv_prog_cxx_cross
4808
4809       cat > conftest.$ac_ext <<EOF
4810 #line 4811 "configure"
4811 #include "confdefs.h"
4812 #include <math.h>
4813 int main() {
4814  __builtin_fabs(0);
4815 ; return 0; }
4816 EOF
4817 if { (eval echo configure:4818: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4818   rm -rf conftest*
4819   glibcpp_cv_func___builtin_fabs_use=yes
4820 else
4821   echo "configure: failed program was:" >&5
4822   cat conftest.$ac_ext >&5
4823   rm -rf conftest*
4824   glibcpp_cv_func___builtin_fabs_use=no
4825 fi
4826 rm -f conftest*
4827       ac_ext=c
4828 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4829 ac_cpp='$CPP $CPPFLAGS'
4830 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4831 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4832 cross_compiling=$ac_cv_prog_cc_cross
4833
4834
4835 fi
4836
4837   fi
4838   echo "$ac_t""$glibcpp_cv_func___builtin_fabs_use" 1>&6
4839   if test x$glibcpp_cv_func___builtin_fabs_use = x"yes"; then
4840     echo $ac_n "checking for __builtin_fabs linkage""... $ac_c" 1>&6
4841 echo "configure:4842: checking for __builtin_fabs linkage" >&5
4842     if test x${glibcpp_cv_func___builtin_fabs_link+set} != xset; then
4843       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabs_link'+set}'`\" = set"; then
4844   echo $ac_n "(cached) $ac_c" 1>&6
4845 else
4846
4847         cat > conftest.$ac_ext <<EOF
4848 #line 4849 "configure"
4849 #include "confdefs.h"
4850 #include <math.h>
4851 int main() {
4852  __builtin_fabs(0);
4853 ; return 0; }
4854 EOF
4855 if { (eval echo configure:4856: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4856   rm -rf conftest*
4857   glibcpp_cv_func___builtin_fabs_link=yes
4858 else
4859   echo "configure: failed program was:" >&5
4860   cat conftest.$ac_ext >&5
4861   rm -rf conftest*
4862   glibcpp_cv_func___builtin_fabs_link=no
4863 fi
4864 rm -f conftest*
4865
4866 fi
4867
4868     fi
4869     echo "$ac_t""$glibcpp_cv_func___builtin_fabs_link" 1>&6
4870     if test x$glibcpp_cv_func___builtin_fabs_link = x"yes"; then
4871       ac_tr_func=HAVE_`echo __builtin_fabs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4872       cat >> confdefs.h <<EOF
4873 #define ${ac_tr_func} 1
4874 EOF
4875
4876     fi
4877   fi
4878
4879
4880   echo $ac_n "checking for __builtin_fabsl declaration""... $ac_c" 1>&6
4881 echo "configure:4882: checking for __builtin_fabsl declaration" >&5
4882   if test x${glibcpp_cv_func___builtin_fabsl_use+set} != xset; then
4883     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsl_use'+set}'`\" = set"; then
4884   echo $ac_n "(cached) $ac_c" 1>&6
4885 else
4886
4887
4888       ac_ext=C
4889 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4890 ac_cpp='$CXXCPP $CPPFLAGS'
4891 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4892 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4893 cross_compiling=$ac_cv_prog_cxx_cross
4894
4895       cat > conftest.$ac_ext <<EOF
4896 #line 4897 "configure"
4897 #include "confdefs.h"
4898 #include <math.h>
4899 int main() {
4900  __builtin_fabsl(0);
4901 ; return 0; }
4902 EOF
4903 if { (eval echo configure:4904: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4904   rm -rf conftest*
4905   glibcpp_cv_func___builtin_fabsl_use=yes
4906 else
4907   echo "configure: failed program was:" >&5
4908   cat conftest.$ac_ext >&5
4909   rm -rf conftest*
4910   glibcpp_cv_func___builtin_fabsl_use=no
4911 fi
4912 rm -f conftest*
4913       ac_ext=c
4914 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4915 ac_cpp='$CPP $CPPFLAGS'
4916 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4917 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4918 cross_compiling=$ac_cv_prog_cc_cross
4919
4920
4921 fi
4922
4923   fi
4924   echo "$ac_t""$glibcpp_cv_func___builtin_fabsl_use" 1>&6
4925   if test x$glibcpp_cv_func___builtin_fabsl_use = x"yes"; then
4926     echo $ac_n "checking for __builtin_fabsl linkage""... $ac_c" 1>&6
4927 echo "configure:4928: checking for __builtin_fabsl linkage" >&5
4928     if test x${glibcpp_cv_func___builtin_fabsl_link+set} != xset; then
4929       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fabsl_link'+set}'`\" = set"; then
4930   echo $ac_n "(cached) $ac_c" 1>&6
4931 else
4932
4933         cat > conftest.$ac_ext <<EOF
4934 #line 4935 "configure"
4935 #include "confdefs.h"
4936 #include <math.h>
4937 int main() {
4938  __builtin_fabsl(0);
4939 ; return 0; }
4940 EOF
4941 if { (eval echo configure:4942: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
4942   rm -rf conftest*
4943   glibcpp_cv_func___builtin_fabsl_link=yes
4944 else
4945   echo "configure: failed program was:" >&5
4946   cat conftest.$ac_ext >&5
4947   rm -rf conftest*
4948   glibcpp_cv_func___builtin_fabsl_link=no
4949 fi
4950 rm -f conftest*
4951
4952 fi
4953
4954     fi
4955     echo "$ac_t""$glibcpp_cv_func___builtin_fabsl_link" 1>&6
4956     if test x$glibcpp_cv_func___builtin_fabsl_link = x"yes"; then
4957       ac_tr_func=HAVE_`echo __builtin_fabsl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
4958       cat >> confdefs.h <<EOF
4959 #define ${ac_tr_func} 1
4960 EOF
4961
4962     fi
4963   fi
4964
4965
4966   echo $ac_n "checking for __builtin_labs declaration""... $ac_c" 1>&6
4967 echo "configure:4968: checking for __builtin_labs declaration" >&5
4968   if test x${glibcpp_cv_func___builtin_labs_use+set} != xset; then
4969     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_labs_use'+set}'`\" = set"; then
4970   echo $ac_n "(cached) $ac_c" 1>&6
4971 else
4972
4973
4974       ac_ext=C
4975 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
4976 ac_cpp='$CXXCPP $CPPFLAGS'
4977 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
4978 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
4979 cross_compiling=$ac_cv_prog_cxx_cross
4980
4981       cat > conftest.$ac_ext <<EOF
4982 #line 4983 "configure"
4983 #include "confdefs.h"
4984 #include <math.h>
4985 int main() {
4986  __builtin_labs(0);
4987 ; return 0; }
4988 EOF
4989 if { (eval echo configure:4990: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
4990   rm -rf conftest*
4991   glibcpp_cv_func___builtin_labs_use=yes
4992 else
4993   echo "configure: failed program was:" >&5
4994   cat conftest.$ac_ext >&5
4995   rm -rf conftest*
4996   glibcpp_cv_func___builtin_labs_use=no
4997 fi
4998 rm -f conftest*
4999       ac_ext=c
5000 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5001 ac_cpp='$CPP $CPPFLAGS'
5002 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5003 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5004 cross_compiling=$ac_cv_prog_cc_cross
5005
5006
5007 fi
5008
5009   fi
5010   echo "$ac_t""$glibcpp_cv_func___builtin_labs_use" 1>&6
5011   if test x$glibcpp_cv_func___builtin_labs_use = x"yes"; then
5012     echo $ac_n "checking for __builtin_labs linkage""... $ac_c" 1>&6
5013 echo "configure:5014: checking for __builtin_labs linkage" >&5
5014     if test x${glibcpp_cv_func___builtin_labs_link+set} != xset; then
5015       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_labs_link'+set}'`\" = set"; then
5016   echo $ac_n "(cached) $ac_c" 1>&6
5017 else
5018
5019         cat > conftest.$ac_ext <<EOF
5020 #line 5021 "configure"
5021 #include "confdefs.h"
5022 #include <math.h>
5023 int main() {
5024  __builtin_labs(0);
5025 ; return 0; }
5026 EOF
5027 if { (eval echo configure:5028: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5028   rm -rf conftest*
5029   glibcpp_cv_func___builtin_labs_link=yes
5030 else
5031   echo "configure: failed program was:" >&5
5032   cat conftest.$ac_ext >&5
5033   rm -rf conftest*
5034   glibcpp_cv_func___builtin_labs_link=no
5035 fi
5036 rm -f conftest*
5037
5038 fi
5039
5040     fi
5041     echo "$ac_t""$glibcpp_cv_func___builtin_labs_link" 1>&6
5042     if test x$glibcpp_cv_func___builtin_labs_link = x"yes"; then
5043       ac_tr_func=HAVE_`echo __builtin_labs | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5044       cat >> confdefs.h <<EOF
5045 #define ${ac_tr_func} 1
5046 EOF
5047
5048     fi
5049   fi
5050
5051
5052
5053   echo $ac_n "checking for __builtin_sqrtf declaration""... $ac_c" 1>&6
5054 echo "configure:5055: checking for __builtin_sqrtf declaration" >&5
5055   if test x${glibcpp_cv_func___builtin_sqrtf_use+set} != xset; then
5056     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtf_use'+set}'`\" = set"; then
5057   echo $ac_n "(cached) $ac_c" 1>&6
5058 else
5059
5060
5061       ac_ext=C
5062 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5063 ac_cpp='$CXXCPP $CPPFLAGS'
5064 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5065 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5066 cross_compiling=$ac_cv_prog_cxx_cross
5067
5068       cat > conftest.$ac_ext <<EOF
5069 #line 5070 "configure"
5070 #include "confdefs.h"
5071 #include <math.h>
5072 int main() {
5073  __builtin_sqrtf(0);
5074 ; return 0; }
5075 EOF
5076 if { (eval echo configure:5077: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5077   rm -rf conftest*
5078   glibcpp_cv_func___builtin_sqrtf_use=yes
5079 else
5080   echo "configure: failed program was:" >&5
5081   cat conftest.$ac_ext >&5
5082   rm -rf conftest*
5083   glibcpp_cv_func___builtin_sqrtf_use=no
5084 fi
5085 rm -f conftest*
5086       ac_ext=c
5087 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5088 ac_cpp='$CPP $CPPFLAGS'
5089 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5090 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5091 cross_compiling=$ac_cv_prog_cc_cross
5092
5093
5094 fi
5095
5096   fi
5097   echo "$ac_t""$glibcpp_cv_func___builtin_sqrtf_use" 1>&6
5098   if test x$glibcpp_cv_func___builtin_sqrtf_use = x"yes"; then
5099     echo $ac_n "checking for __builtin_sqrtf linkage""... $ac_c" 1>&6
5100 echo "configure:5101: checking for __builtin_sqrtf linkage" >&5
5101     if test x${glibcpp_cv_func___builtin_sqrtf_link+set} != xset; then
5102       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtf_link'+set}'`\" = set"; then
5103   echo $ac_n "(cached) $ac_c" 1>&6
5104 else
5105
5106         cat > conftest.$ac_ext <<EOF
5107 #line 5108 "configure"
5108 #include "confdefs.h"
5109 #include <math.h>
5110 int main() {
5111  __builtin_sqrtf(0);
5112 ; return 0; }
5113 EOF
5114 if { (eval echo configure:5115: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5115   rm -rf conftest*
5116   glibcpp_cv_func___builtin_sqrtf_link=yes
5117 else
5118   echo "configure: failed program was:" >&5
5119   cat conftest.$ac_ext >&5
5120   rm -rf conftest*
5121   glibcpp_cv_func___builtin_sqrtf_link=no
5122 fi
5123 rm -f conftest*
5124
5125 fi
5126
5127     fi
5128     echo "$ac_t""$glibcpp_cv_func___builtin_sqrtf_link" 1>&6
5129     if test x$glibcpp_cv_func___builtin_sqrtf_link = x"yes"; then
5130       ac_tr_func=HAVE_`echo __builtin_sqrtf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5131       cat >> confdefs.h <<EOF
5132 #define ${ac_tr_func} 1
5133 EOF
5134
5135     fi
5136   fi
5137
5138
5139   echo $ac_n "checking for __builtin_fsqrt declaration""... $ac_c" 1>&6
5140 echo "configure:5141: checking for __builtin_fsqrt declaration" >&5
5141   if test x${glibcpp_cv_func___builtin_fsqrt_use+set} != xset; then
5142     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fsqrt_use'+set}'`\" = set"; then
5143   echo $ac_n "(cached) $ac_c" 1>&6
5144 else
5145
5146
5147       ac_ext=C
5148 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5149 ac_cpp='$CXXCPP $CPPFLAGS'
5150 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5151 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5152 cross_compiling=$ac_cv_prog_cxx_cross
5153
5154       cat > conftest.$ac_ext <<EOF
5155 #line 5156 "configure"
5156 #include "confdefs.h"
5157 #include <math.h>
5158 int main() {
5159  __builtin_fsqrt(0);
5160 ; return 0; }
5161 EOF
5162 if { (eval echo configure:5163: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5163   rm -rf conftest*
5164   glibcpp_cv_func___builtin_fsqrt_use=yes
5165 else
5166   echo "configure: failed program was:" >&5
5167   cat conftest.$ac_ext >&5
5168   rm -rf conftest*
5169   glibcpp_cv_func___builtin_fsqrt_use=no
5170 fi
5171 rm -f conftest*
5172       ac_ext=c
5173 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5174 ac_cpp='$CPP $CPPFLAGS'
5175 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5176 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5177 cross_compiling=$ac_cv_prog_cc_cross
5178
5179
5180 fi
5181
5182   fi
5183   echo "$ac_t""$glibcpp_cv_func___builtin_fsqrt_use" 1>&6
5184   if test x$glibcpp_cv_func___builtin_fsqrt_use = x"yes"; then
5185     echo $ac_n "checking for __builtin_fsqrt linkage""... $ac_c" 1>&6
5186 echo "configure:5187: checking for __builtin_fsqrt linkage" >&5
5187     if test x${glibcpp_cv_func___builtin_fsqrt_link+set} != xset; then
5188       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_fsqrt_link'+set}'`\" = set"; then
5189   echo $ac_n "(cached) $ac_c" 1>&6
5190 else
5191
5192         cat > conftest.$ac_ext <<EOF
5193 #line 5194 "configure"
5194 #include "confdefs.h"
5195 #include <math.h>
5196 int main() {
5197  __builtin_fsqrt(0);
5198 ; return 0; }
5199 EOF
5200 if { (eval echo configure:5201: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5201   rm -rf conftest*
5202   glibcpp_cv_func___builtin_fsqrt_link=yes
5203 else
5204   echo "configure: failed program was:" >&5
5205   cat conftest.$ac_ext >&5
5206   rm -rf conftest*
5207   glibcpp_cv_func___builtin_fsqrt_link=no
5208 fi
5209 rm -f conftest*
5210
5211 fi
5212
5213     fi
5214     echo "$ac_t""$glibcpp_cv_func___builtin_fsqrt_link" 1>&6
5215     if test x$glibcpp_cv_func___builtin_fsqrt_link = x"yes"; then
5216       ac_tr_func=HAVE_`echo __builtin_fsqrt | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5217       cat >> confdefs.h <<EOF
5218 #define ${ac_tr_func} 1
5219 EOF
5220
5221     fi
5222   fi
5223
5224
5225   echo $ac_n "checking for __builtin_sqrtl declaration""... $ac_c" 1>&6
5226 echo "configure:5227: checking for __builtin_sqrtl declaration" >&5
5227   if test x${glibcpp_cv_func___builtin_sqrtl_use+set} != xset; then
5228     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtl_use'+set}'`\" = set"; then
5229   echo $ac_n "(cached) $ac_c" 1>&6
5230 else
5231
5232
5233       ac_ext=C
5234 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5235 ac_cpp='$CXXCPP $CPPFLAGS'
5236 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5237 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5238 cross_compiling=$ac_cv_prog_cxx_cross
5239
5240       cat > conftest.$ac_ext <<EOF
5241 #line 5242 "configure"
5242 #include "confdefs.h"
5243 #include <math.h>
5244 int main() {
5245  __builtin_sqrtl(0);
5246 ; return 0; }
5247 EOF
5248 if { (eval echo configure:5249: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5249   rm -rf conftest*
5250   glibcpp_cv_func___builtin_sqrtl_use=yes
5251 else
5252   echo "configure: failed program was:" >&5
5253   cat conftest.$ac_ext >&5
5254   rm -rf conftest*
5255   glibcpp_cv_func___builtin_sqrtl_use=no
5256 fi
5257 rm -f conftest*
5258       ac_ext=c
5259 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5260 ac_cpp='$CPP $CPPFLAGS'
5261 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5262 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5263 cross_compiling=$ac_cv_prog_cc_cross
5264
5265
5266 fi
5267
5268   fi
5269   echo "$ac_t""$glibcpp_cv_func___builtin_sqrtl_use" 1>&6
5270   if test x$glibcpp_cv_func___builtin_sqrtl_use = x"yes"; then
5271     echo $ac_n "checking for __builtin_sqrtl linkage""... $ac_c" 1>&6
5272 echo "configure:5273: checking for __builtin_sqrtl linkage" >&5
5273     if test x${glibcpp_cv_func___builtin_sqrtl_link+set} != xset; then
5274       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sqrtl_link'+set}'`\" = set"; then
5275   echo $ac_n "(cached) $ac_c" 1>&6
5276 else
5277
5278         cat > conftest.$ac_ext <<EOF
5279 #line 5280 "configure"
5280 #include "confdefs.h"
5281 #include <math.h>
5282 int main() {
5283  __builtin_sqrtl(0);
5284 ; return 0; }
5285 EOF
5286 if { (eval echo configure:5287: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5287   rm -rf conftest*
5288   glibcpp_cv_func___builtin_sqrtl_link=yes
5289 else
5290   echo "configure: failed program was:" >&5
5291   cat conftest.$ac_ext >&5
5292   rm -rf conftest*
5293   glibcpp_cv_func___builtin_sqrtl_link=no
5294 fi
5295 rm -f conftest*
5296
5297 fi
5298
5299     fi
5300     echo "$ac_t""$glibcpp_cv_func___builtin_sqrtl_link" 1>&6
5301     if test x$glibcpp_cv_func___builtin_sqrtl_link = x"yes"; then
5302       ac_tr_func=HAVE_`echo __builtin_sqrtl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5303       cat >> confdefs.h <<EOF
5304 #define ${ac_tr_func} 1
5305 EOF
5306
5307     fi
5308   fi
5309
5310
5311
5312   echo $ac_n "checking for __builtin_sinf declaration""... $ac_c" 1>&6
5313 echo "configure:5314: checking for __builtin_sinf declaration" >&5
5314   if test x${glibcpp_cv_func___builtin_sinf_use+set} != xset; then
5315     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinf_use'+set}'`\" = set"; then
5316   echo $ac_n "(cached) $ac_c" 1>&6
5317 else
5318
5319
5320       ac_ext=C
5321 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5322 ac_cpp='$CXXCPP $CPPFLAGS'
5323 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5324 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5325 cross_compiling=$ac_cv_prog_cxx_cross
5326
5327       cat > conftest.$ac_ext <<EOF
5328 #line 5329 "configure"
5329 #include "confdefs.h"
5330 #include <math.h>
5331 int main() {
5332  __builtin_sinf(0);
5333 ; return 0; }
5334 EOF
5335 if { (eval echo configure:5336: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5336   rm -rf conftest*
5337   glibcpp_cv_func___builtin_sinf_use=yes
5338 else
5339   echo "configure: failed program was:" >&5
5340   cat conftest.$ac_ext >&5
5341   rm -rf conftest*
5342   glibcpp_cv_func___builtin_sinf_use=no
5343 fi
5344 rm -f conftest*
5345       ac_ext=c
5346 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5347 ac_cpp='$CPP $CPPFLAGS'
5348 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5349 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5350 cross_compiling=$ac_cv_prog_cc_cross
5351
5352
5353 fi
5354
5355   fi
5356   echo "$ac_t""$glibcpp_cv_func___builtin_sinf_use" 1>&6
5357   if test x$glibcpp_cv_func___builtin_sinf_use = x"yes"; then
5358     echo $ac_n "checking for __builtin_sinf linkage""... $ac_c" 1>&6
5359 echo "configure:5360: checking for __builtin_sinf linkage" >&5
5360     if test x${glibcpp_cv_func___builtin_sinf_link+set} != xset; then
5361       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinf_link'+set}'`\" = set"; then
5362   echo $ac_n "(cached) $ac_c" 1>&6
5363 else
5364
5365         cat > conftest.$ac_ext <<EOF
5366 #line 5367 "configure"
5367 #include "confdefs.h"
5368 #include <math.h>
5369 int main() {
5370  __builtin_sinf(0);
5371 ; return 0; }
5372 EOF
5373 if { (eval echo configure:5374: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5374   rm -rf conftest*
5375   glibcpp_cv_func___builtin_sinf_link=yes
5376 else
5377   echo "configure: failed program was:" >&5
5378   cat conftest.$ac_ext >&5
5379   rm -rf conftest*
5380   glibcpp_cv_func___builtin_sinf_link=no
5381 fi
5382 rm -f conftest*
5383
5384 fi
5385
5386     fi
5387     echo "$ac_t""$glibcpp_cv_func___builtin_sinf_link" 1>&6
5388     if test x$glibcpp_cv_func___builtin_sinf_link = x"yes"; then
5389       ac_tr_func=HAVE_`echo __builtin_sinf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5390       cat >> confdefs.h <<EOF
5391 #define ${ac_tr_func} 1
5392 EOF
5393
5394     fi
5395   fi
5396
5397
5398   echo $ac_n "checking for __builtin_sin declaration""... $ac_c" 1>&6
5399 echo "configure:5400: checking for __builtin_sin declaration" >&5
5400   if test x${glibcpp_cv_func___builtin_sin_use+set} != xset; then
5401     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sin_use'+set}'`\" = set"; then
5402   echo $ac_n "(cached) $ac_c" 1>&6
5403 else
5404
5405
5406       ac_ext=C
5407 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5408 ac_cpp='$CXXCPP $CPPFLAGS'
5409 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5410 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5411 cross_compiling=$ac_cv_prog_cxx_cross
5412
5413       cat > conftest.$ac_ext <<EOF
5414 #line 5415 "configure"
5415 #include "confdefs.h"
5416 #include <math.h>
5417 int main() {
5418  __builtin_sin(0);
5419 ; return 0; }
5420 EOF
5421 if { (eval echo configure:5422: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5422   rm -rf conftest*
5423   glibcpp_cv_func___builtin_sin_use=yes
5424 else
5425   echo "configure: failed program was:" >&5
5426   cat conftest.$ac_ext >&5
5427   rm -rf conftest*
5428   glibcpp_cv_func___builtin_sin_use=no
5429 fi
5430 rm -f conftest*
5431       ac_ext=c
5432 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5433 ac_cpp='$CPP $CPPFLAGS'
5434 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5435 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5436 cross_compiling=$ac_cv_prog_cc_cross
5437
5438
5439 fi
5440
5441   fi
5442   echo "$ac_t""$glibcpp_cv_func___builtin_sin_use" 1>&6
5443   if test x$glibcpp_cv_func___builtin_sin_use = x"yes"; then
5444     echo $ac_n "checking for __builtin_sin linkage""... $ac_c" 1>&6
5445 echo "configure:5446: checking for __builtin_sin linkage" >&5
5446     if test x${glibcpp_cv_func___builtin_sin_link+set} != xset; then
5447       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sin_link'+set}'`\" = set"; then
5448   echo $ac_n "(cached) $ac_c" 1>&6
5449 else
5450
5451         cat > conftest.$ac_ext <<EOF
5452 #line 5453 "configure"
5453 #include "confdefs.h"
5454 #include <math.h>
5455 int main() {
5456  __builtin_sin(0);
5457 ; return 0; }
5458 EOF
5459 if { (eval echo configure:5460: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5460   rm -rf conftest*
5461   glibcpp_cv_func___builtin_sin_link=yes
5462 else
5463   echo "configure: failed program was:" >&5
5464   cat conftest.$ac_ext >&5
5465   rm -rf conftest*
5466   glibcpp_cv_func___builtin_sin_link=no
5467 fi
5468 rm -f conftest*
5469
5470 fi
5471
5472     fi
5473     echo "$ac_t""$glibcpp_cv_func___builtin_sin_link" 1>&6
5474     if test x$glibcpp_cv_func___builtin_sin_link = x"yes"; then
5475       ac_tr_func=HAVE_`echo __builtin_sin | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5476       cat >> confdefs.h <<EOF
5477 #define ${ac_tr_func} 1
5478 EOF
5479
5480     fi
5481   fi
5482
5483
5484   echo $ac_n "checking for __builtin_sinl declaration""... $ac_c" 1>&6
5485 echo "configure:5486: checking for __builtin_sinl declaration" >&5
5486   if test x${glibcpp_cv_func___builtin_sinl_use+set} != xset; then
5487     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinl_use'+set}'`\" = set"; then
5488   echo $ac_n "(cached) $ac_c" 1>&6
5489 else
5490
5491
5492       ac_ext=C
5493 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5494 ac_cpp='$CXXCPP $CPPFLAGS'
5495 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5496 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5497 cross_compiling=$ac_cv_prog_cxx_cross
5498
5499       cat > conftest.$ac_ext <<EOF
5500 #line 5501 "configure"
5501 #include "confdefs.h"
5502 #include <math.h>
5503 int main() {
5504  __builtin_sinl(0);
5505 ; return 0; }
5506 EOF
5507 if { (eval echo configure:5508: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5508   rm -rf conftest*
5509   glibcpp_cv_func___builtin_sinl_use=yes
5510 else
5511   echo "configure: failed program was:" >&5
5512   cat conftest.$ac_ext >&5
5513   rm -rf conftest*
5514   glibcpp_cv_func___builtin_sinl_use=no
5515 fi
5516 rm -f conftest*
5517       ac_ext=c
5518 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5519 ac_cpp='$CPP $CPPFLAGS'
5520 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5521 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5522 cross_compiling=$ac_cv_prog_cc_cross
5523
5524
5525 fi
5526
5527   fi
5528   echo "$ac_t""$glibcpp_cv_func___builtin_sinl_use" 1>&6
5529   if test x$glibcpp_cv_func___builtin_sinl_use = x"yes"; then
5530     echo $ac_n "checking for __builtin_sinl linkage""... $ac_c" 1>&6
5531 echo "configure:5532: checking for __builtin_sinl linkage" >&5
5532     if test x${glibcpp_cv_func___builtin_sinl_link+set} != xset; then
5533       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_sinl_link'+set}'`\" = set"; then
5534   echo $ac_n "(cached) $ac_c" 1>&6
5535 else
5536
5537         cat > conftest.$ac_ext <<EOF
5538 #line 5539 "configure"
5539 #include "confdefs.h"
5540 #include <math.h>
5541 int main() {
5542  __builtin_sinl(0);
5543 ; return 0; }
5544 EOF
5545 if { (eval echo configure:5546: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5546   rm -rf conftest*
5547   glibcpp_cv_func___builtin_sinl_link=yes
5548 else
5549   echo "configure: failed program was:" >&5
5550   cat conftest.$ac_ext >&5
5551   rm -rf conftest*
5552   glibcpp_cv_func___builtin_sinl_link=no
5553 fi
5554 rm -f conftest*
5555
5556 fi
5557
5558     fi
5559     echo "$ac_t""$glibcpp_cv_func___builtin_sinl_link" 1>&6
5560     if test x$glibcpp_cv_func___builtin_sinl_link = x"yes"; then
5561       ac_tr_func=HAVE_`echo __builtin_sinl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5562       cat >> confdefs.h <<EOF
5563 #define ${ac_tr_func} 1
5564 EOF
5565
5566     fi
5567   fi
5568
5569
5570
5571   echo $ac_n "checking for __builtin_cosf declaration""... $ac_c" 1>&6
5572 echo "configure:5573: checking for __builtin_cosf declaration" >&5
5573   if test x${glibcpp_cv_func___builtin_cosf_use+set} != xset; then
5574     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosf_use'+set}'`\" = set"; then
5575   echo $ac_n "(cached) $ac_c" 1>&6
5576 else
5577
5578
5579       ac_ext=C
5580 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5581 ac_cpp='$CXXCPP $CPPFLAGS'
5582 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5583 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5584 cross_compiling=$ac_cv_prog_cxx_cross
5585
5586       cat > conftest.$ac_ext <<EOF
5587 #line 5588 "configure"
5588 #include "confdefs.h"
5589 #include <math.h>
5590 int main() {
5591  __builtin_cosf(0);
5592 ; return 0; }
5593 EOF
5594 if { (eval echo configure:5595: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5595   rm -rf conftest*
5596   glibcpp_cv_func___builtin_cosf_use=yes
5597 else
5598   echo "configure: failed program was:" >&5
5599   cat conftest.$ac_ext >&5
5600   rm -rf conftest*
5601   glibcpp_cv_func___builtin_cosf_use=no
5602 fi
5603 rm -f conftest*
5604       ac_ext=c
5605 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5606 ac_cpp='$CPP $CPPFLAGS'
5607 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5608 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5609 cross_compiling=$ac_cv_prog_cc_cross
5610
5611
5612 fi
5613
5614   fi
5615   echo "$ac_t""$glibcpp_cv_func___builtin_cosf_use" 1>&6
5616   if test x$glibcpp_cv_func___builtin_cosf_use = x"yes"; then
5617     echo $ac_n "checking for __builtin_cosf linkage""... $ac_c" 1>&6
5618 echo "configure:5619: checking for __builtin_cosf linkage" >&5
5619     if test x${glibcpp_cv_func___builtin_cosf_link+set} != xset; then
5620       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosf_link'+set}'`\" = set"; then
5621   echo $ac_n "(cached) $ac_c" 1>&6
5622 else
5623
5624         cat > conftest.$ac_ext <<EOF
5625 #line 5626 "configure"
5626 #include "confdefs.h"
5627 #include <math.h>
5628 int main() {
5629  __builtin_cosf(0);
5630 ; return 0; }
5631 EOF
5632 if { (eval echo configure:5633: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5633   rm -rf conftest*
5634   glibcpp_cv_func___builtin_cosf_link=yes
5635 else
5636   echo "configure: failed program was:" >&5
5637   cat conftest.$ac_ext >&5
5638   rm -rf conftest*
5639   glibcpp_cv_func___builtin_cosf_link=no
5640 fi
5641 rm -f conftest*
5642
5643 fi
5644
5645     fi
5646     echo "$ac_t""$glibcpp_cv_func___builtin_cosf_link" 1>&6
5647     if test x$glibcpp_cv_func___builtin_cosf_link = x"yes"; then
5648       ac_tr_func=HAVE_`echo __builtin_cosf | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5649       cat >> confdefs.h <<EOF
5650 #define ${ac_tr_func} 1
5651 EOF
5652
5653     fi
5654   fi
5655
5656
5657   echo $ac_n "checking for __builtin_cos declaration""... $ac_c" 1>&6
5658 echo "configure:5659: checking for __builtin_cos declaration" >&5
5659   if test x${glibcpp_cv_func___builtin_cos_use+set} != xset; then
5660     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cos_use'+set}'`\" = set"; then
5661   echo $ac_n "(cached) $ac_c" 1>&6
5662 else
5663
5664
5665       ac_ext=C
5666 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5667 ac_cpp='$CXXCPP $CPPFLAGS'
5668 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5669 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5670 cross_compiling=$ac_cv_prog_cxx_cross
5671
5672       cat > conftest.$ac_ext <<EOF
5673 #line 5674 "configure"
5674 #include "confdefs.h"
5675 #include <math.h>
5676 int main() {
5677  __builtin_cos(0);
5678 ; return 0; }
5679 EOF
5680 if { (eval echo configure:5681: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5681   rm -rf conftest*
5682   glibcpp_cv_func___builtin_cos_use=yes
5683 else
5684   echo "configure: failed program was:" >&5
5685   cat conftest.$ac_ext >&5
5686   rm -rf conftest*
5687   glibcpp_cv_func___builtin_cos_use=no
5688 fi
5689 rm -f conftest*
5690       ac_ext=c
5691 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5692 ac_cpp='$CPP $CPPFLAGS'
5693 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5694 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5695 cross_compiling=$ac_cv_prog_cc_cross
5696
5697
5698 fi
5699
5700   fi
5701   echo "$ac_t""$glibcpp_cv_func___builtin_cos_use" 1>&6
5702   if test x$glibcpp_cv_func___builtin_cos_use = x"yes"; then
5703     echo $ac_n "checking for __builtin_cos linkage""... $ac_c" 1>&6
5704 echo "configure:5705: checking for __builtin_cos linkage" >&5
5705     if test x${glibcpp_cv_func___builtin_cos_link+set} != xset; then
5706       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cos_link'+set}'`\" = set"; then
5707   echo $ac_n "(cached) $ac_c" 1>&6
5708 else
5709
5710         cat > conftest.$ac_ext <<EOF
5711 #line 5712 "configure"
5712 #include "confdefs.h"
5713 #include <math.h>
5714 int main() {
5715  __builtin_cos(0);
5716 ; return 0; }
5717 EOF
5718 if { (eval echo configure:5719: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5719   rm -rf conftest*
5720   glibcpp_cv_func___builtin_cos_link=yes
5721 else
5722   echo "configure: failed program was:" >&5
5723   cat conftest.$ac_ext >&5
5724   rm -rf conftest*
5725   glibcpp_cv_func___builtin_cos_link=no
5726 fi
5727 rm -f conftest*
5728
5729 fi
5730
5731     fi
5732     echo "$ac_t""$glibcpp_cv_func___builtin_cos_link" 1>&6
5733     if test x$glibcpp_cv_func___builtin_cos_link = x"yes"; then
5734       ac_tr_func=HAVE_`echo __builtin_cos | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5735       cat >> confdefs.h <<EOF
5736 #define ${ac_tr_func} 1
5737 EOF
5738
5739     fi
5740   fi
5741
5742
5743   echo $ac_n "checking for __builtin_cosl declaration""... $ac_c" 1>&6
5744 echo "configure:5745: checking for __builtin_cosl declaration" >&5
5745   if test x${glibcpp_cv_func___builtin_cosl_use+set} != xset; then
5746     if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosl_use'+set}'`\" = set"; then
5747   echo $ac_n "(cached) $ac_c" 1>&6
5748 else
5749
5750
5751       ac_ext=C
5752 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5753 ac_cpp='$CXXCPP $CPPFLAGS'
5754 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5755 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5756 cross_compiling=$ac_cv_prog_cxx_cross
5757
5758       cat > conftest.$ac_ext <<EOF
5759 #line 5760 "configure"
5760 #include "confdefs.h"
5761 #include <math.h>
5762 int main() {
5763  __builtin_cosl(0);
5764 ; return 0; }
5765 EOF
5766 if { (eval echo configure:5767: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5767   rm -rf conftest*
5768   glibcpp_cv_func___builtin_cosl_use=yes
5769 else
5770   echo "configure: failed program was:" >&5
5771   cat conftest.$ac_ext >&5
5772   rm -rf conftest*
5773   glibcpp_cv_func___builtin_cosl_use=no
5774 fi
5775 rm -f conftest*
5776       ac_ext=c
5777 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5778 ac_cpp='$CPP $CPPFLAGS'
5779 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5780 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5781 cross_compiling=$ac_cv_prog_cc_cross
5782
5783
5784 fi
5785
5786   fi
5787   echo "$ac_t""$glibcpp_cv_func___builtin_cosl_use" 1>&6
5788   if test x$glibcpp_cv_func___builtin_cosl_use = x"yes"; then
5789     echo $ac_n "checking for __builtin_cosl linkage""... $ac_c" 1>&6
5790 echo "configure:5791: checking for __builtin_cosl linkage" >&5
5791     if test x${glibcpp_cv_func___builtin_cosl_link+set} != xset; then
5792       if eval "test \"`echo '$''{'glibcpp_cv_func___builtin_cosl_link'+set}'`\" = set"; then
5793   echo $ac_n "(cached) $ac_c" 1>&6
5794 else
5795
5796         cat > conftest.$ac_ext <<EOF
5797 #line 5798 "configure"
5798 #include "confdefs.h"
5799 #include <math.h>
5800 int main() {
5801  __builtin_cosl(0);
5802 ; return 0; }
5803 EOF
5804 if { (eval echo configure:5805: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5805   rm -rf conftest*
5806   glibcpp_cv_func___builtin_cosl_link=yes
5807 else
5808   echo "configure: failed program was:" >&5
5809   cat conftest.$ac_ext >&5
5810   rm -rf conftest*
5811   glibcpp_cv_func___builtin_cosl_link=no
5812 fi
5813 rm -f conftest*
5814
5815 fi
5816
5817     fi
5818     echo "$ac_t""$glibcpp_cv_func___builtin_cosl_link" 1>&6
5819     if test x$glibcpp_cv_func___builtin_cosl_link = x"yes"; then
5820       ac_tr_func=HAVE_`echo __builtin_cosl | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
5821       cat >> confdefs.h <<EOF
5822 #define ${ac_tr_func} 1
5823 EOF
5824
5825     fi
5826   fi
5827
5828
5829               dummyvar=no
5830   if test x$dummyvar = x"yes"; then
5831     cat >> confdefs.h <<\EOF
5832 #define HAVE___BUILTIN_ABS 1
5833 EOF
5834
5835     cat >> confdefs.h <<\EOF
5836 #define HAVE___BUILTIN_LABS 1
5837 EOF
5838
5839     cat >> confdefs.h <<\EOF
5840 #define HAVE___BUILTIN_COS 1
5841 EOF
5842
5843     cat >> confdefs.h <<\EOF
5844 #define HAVE___BUILTIN_COSF 1
5845 EOF
5846
5847     cat >> confdefs.h <<\EOF
5848 #define HAVE___BUILTIN_COSL 1
5849 EOF
5850
5851     cat >> confdefs.h <<\EOF
5852 #define HAVE___BUILTIN_FABS 1
5853 EOF
5854
5855     cat >> confdefs.h <<\EOF
5856 #define HAVE___BUILTIN_FABSF 1
5857 EOF
5858
5859     cat >> confdefs.h <<\EOF
5860 #define HAVE___BUILTIN_FABSL 1
5861 EOF
5862
5863     cat >> confdefs.h <<\EOF
5864 #define HAVE___BUILTIN_SIN 1
5865 EOF
5866
5867     cat >> confdefs.h <<\EOF
5868 #define HAVE___BUILTIN_SINF 1
5869 EOF
5870
5871     cat >> confdefs.h <<\EOF
5872 #define HAVE___BUILTIN_SINL 1
5873 EOF
5874
5875     cat >> confdefs.h <<\EOF
5876 #define HAVE___BUILTIN_FSQRT 1
5877 EOF
5878
5879     cat >> confdefs.h <<\EOF
5880 #define HAVE___BUILTIN_SQRTF 1
5881 EOF
5882
5883     cat >> confdefs.h <<\EOF
5884 #define HAVE___BUILTIN_SQRTL 1
5885 EOF
5886
5887   fi
5888
5889
5890   ac_test_CXXFLAGS="${CXXFLAGS+set}"
5891   ac_save_CXXFLAGS="$CXXFLAGS"
5892   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
5893
5894     echo $ac_n "checking for sin in -lm""... $ac_c" 1>&6
5895 echo "configure:5896: checking for sin in -lm" >&5
5896 ac_lib_var=`echo m'_'sin | sed 'y%./+-%__p_%'`
5897 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
5898   echo $ac_n "(cached) $ac_c" 1>&6
5899 else
5900   ac_save_LIBS="$LIBS"
5901 LIBS="-lm  $LIBS"
5902 cat > conftest.$ac_ext <<EOF
5903 #line 5904 "configure"
5904 #include "confdefs.h"
5905 /* Override any gcc2 internal prototype to avoid an error.  */
5906 /* We use char because int might match the return type of a gcc2
5907     builtin and then its argument prototype would still apply.  */
5908 char sin();
5909
5910 int main() {
5911 sin()
5912 ; return 0; }
5913 EOF
5914 if { (eval echo configure:5915: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
5915   rm -rf conftest*
5916   eval "ac_cv_lib_$ac_lib_var=yes"
5917 else
5918   echo "configure: failed program was:" >&5
5919   cat conftest.$ac_ext >&5
5920   rm -rf conftest*
5921   eval "ac_cv_lib_$ac_lib_var=no"
5922 fi
5923 rm -f conftest*
5924 LIBS="$ac_save_LIBS"
5925
5926 fi
5927 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
5928   echo "$ac_t""yes" 1>&6
5929   libm="-lm"
5930 else
5931   echo "$ac_t""no" 1>&6
5932 fi
5933
5934   ac_save_LIBS="$LIBS"
5935   LIBS="$LIBS $libm"
5936
5937
5938   echo $ac_n "checking for isinf declaration""... $ac_c" 1>&6
5939 echo "configure:5940: checking for isinf declaration" >&5
5940   if test x${glibcpp_cv_func_isinf_use+set} != xset; then
5941     if eval "test \"`echo '$''{'glibcpp_cv_func_isinf_use'+set}'`\" = set"; then
5942   echo $ac_n "(cached) $ac_c" 1>&6
5943 else
5944
5945
5946       ac_ext=C
5947 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5948 ac_cpp='$CXXCPP $CPPFLAGS'
5949 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5950 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5951 cross_compiling=$ac_cv_prog_cxx_cross
5952
5953       cat > conftest.$ac_ext <<EOF
5954 #line 5955 "configure"
5955 #include "confdefs.h"
5956 #include <math.h>
5957 int main() {
5958  isinf(0);
5959 ; return 0; }
5960 EOF
5961 if { (eval echo configure:5962: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
5962   rm -rf conftest*
5963   glibcpp_cv_func_isinf_use=yes
5964 else
5965   echo "configure: failed program was:" >&5
5966   cat conftest.$ac_ext >&5
5967   rm -rf conftest*
5968   glibcpp_cv_func_isinf_use=no
5969 fi
5970 rm -f conftest*
5971       ac_ext=c
5972 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
5973 ac_cpp='$CPP $CPPFLAGS'
5974 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
5975 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
5976 cross_compiling=$ac_cv_prog_cc_cross
5977
5978
5979 fi
5980
5981   fi
5982   echo "$ac_t""$glibcpp_cv_func_isinf_use" 1>&6
5983   if test x$glibcpp_cv_func_isinf_use = x"yes"; then
5984     for ac_func in isinf
5985 do
5986 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
5987 echo "configure:5988: checking for $ac_func" >&5
5988 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
5989   echo $ac_n "(cached) $ac_c" 1>&6
5990 else
5991   cat > conftest.$ac_ext <<EOF
5992 #line 5993 "configure"
5993 #include "confdefs.h"
5994 /* System header to define __stub macros and hopefully few prototypes,
5995     which can conflict with char $ac_func(); below.  */
5996 #include <assert.h>
5997 /* Override any gcc2 internal prototype to avoid an error.  */
5998 /* We use char because int might match the return type of a gcc2
5999     builtin and then its argument prototype would still apply.  */
6000 char $ac_func();
6001
6002 int main() {
6003
6004 /* The GNU C library defines this for functions which it implements
6005     to always fail with ENOSYS.  Some functions are actually named
6006     something starting with __ and the normal name is an alias.  */
6007 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6008 choke me
6009 #else
6010 $ac_func();
6011 #endif
6012
6013 ; return 0; }
6014 EOF
6015 if { (eval echo configure:6016: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6016   rm -rf conftest*
6017   eval "ac_cv_func_$ac_func=yes"
6018 else
6019   echo "configure: failed program was:" >&5
6020   cat conftest.$ac_ext >&5
6021   rm -rf conftest*
6022   eval "ac_cv_func_$ac_func=no"
6023 fi
6024 rm -f conftest*
6025 fi
6026
6027 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6028   echo "$ac_t""yes" 1>&6
6029     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6030   cat >> confdefs.h <<EOF
6031 #define $ac_tr_func 1
6032 EOF
6033
6034 else
6035   echo "$ac_t""no" 1>&6
6036 fi
6037 done
6038
6039   fi
6040
6041
6042   echo $ac_n "checking for isnan declaration""... $ac_c" 1>&6
6043 echo "configure:6044: checking for isnan declaration" >&5
6044   if test x${glibcpp_cv_func_isnan_use+set} != xset; then
6045     if eval "test \"`echo '$''{'glibcpp_cv_func_isnan_use'+set}'`\" = set"; then
6046   echo $ac_n "(cached) $ac_c" 1>&6
6047 else
6048
6049
6050       ac_ext=C
6051 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6052 ac_cpp='$CXXCPP $CPPFLAGS'
6053 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6054 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6055 cross_compiling=$ac_cv_prog_cxx_cross
6056
6057       cat > conftest.$ac_ext <<EOF
6058 #line 6059 "configure"
6059 #include "confdefs.h"
6060 #include <math.h>
6061 int main() {
6062  isnan(0);
6063 ; return 0; }
6064 EOF
6065 if { (eval echo configure:6066: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6066   rm -rf conftest*
6067   glibcpp_cv_func_isnan_use=yes
6068 else
6069   echo "configure: failed program was:" >&5
6070   cat conftest.$ac_ext >&5
6071   rm -rf conftest*
6072   glibcpp_cv_func_isnan_use=no
6073 fi
6074 rm -f conftest*
6075       ac_ext=c
6076 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6077 ac_cpp='$CPP $CPPFLAGS'
6078 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6079 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6080 cross_compiling=$ac_cv_prog_cc_cross
6081
6082
6083 fi
6084
6085   fi
6086   echo "$ac_t""$glibcpp_cv_func_isnan_use" 1>&6
6087   if test x$glibcpp_cv_func_isnan_use = x"yes"; then
6088     for ac_func in isnan
6089 do
6090 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6091 echo "configure:6092: checking for $ac_func" >&5
6092 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6093   echo $ac_n "(cached) $ac_c" 1>&6
6094 else
6095   cat > conftest.$ac_ext <<EOF
6096 #line 6097 "configure"
6097 #include "confdefs.h"
6098 /* System header to define __stub macros and hopefully few prototypes,
6099     which can conflict with char $ac_func(); below.  */
6100 #include <assert.h>
6101 /* Override any gcc2 internal prototype to avoid an error.  */
6102 /* We use char because int might match the return type of a gcc2
6103     builtin and then its argument prototype would still apply.  */
6104 char $ac_func();
6105
6106 int main() {
6107
6108 /* The GNU C library defines this for functions which it implements
6109     to always fail with ENOSYS.  Some functions are actually named
6110     something starting with __ and the normal name is an alias.  */
6111 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6112 choke me
6113 #else
6114 $ac_func();
6115 #endif
6116
6117 ; return 0; }
6118 EOF
6119 if { (eval echo configure:6120: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6120   rm -rf conftest*
6121   eval "ac_cv_func_$ac_func=yes"
6122 else
6123   echo "configure: failed program was:" >&5
6124   cat conftest.$ac_ext >&5
6125   rm -rf conftest*
6126   eval "ac_cv_func_$ac_func=no"
6127 fi
6128 rm -f conftest*
6129 fi
6130
6131 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6132   echo "$ac_t""yes" 1>&6
6133     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6134   cat >> confdefs.h <<EOF
6135 #define $ac_tr_func 1
6136 EOF
6137
6138 else
6139   echo "$ac_t""no" 1>&6
6140 fi
6141 done
6142
6143   fi
6144
6145
6146   echo $ac_n "checking for finite declaration""... $ac_c" 1>&6
6147 echo "configure:6148: checking for finite declaration" >&5
6148   if test x${glibcpp_cv_func_finite_use+set} != xset; then
6149     if eval "test \"`echo '$''{'glibcpp_cv_func_finite_use'+set}'`\" = set"; then
6150   echo $ac_n "(cached) $ac_c" 1>&6
6151 else
6152
6153
6154       ac_ext=C
6155 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6156 ac_cpp='$CXXCPP $CPPFLAGS'
6157 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6158 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6159 cross_compiling=$ac_cv_prog_cxx_cross
6160
6161       cat > conftest.$ac_ext <<EOF
6162 #line 6163 "configure"
6163 #include "confdefs.h"
6164 #include <math.h>
6165 int main() {
6166  finite(0);
6167 ; return 0; }
6168 EOF
6169 if { (eval echo configure:6170: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6170   rm -rf conftest*
6171   glibcpp_cv_func_finite_use=yes
6172 else
6173   echo "configure: failed program was:" >&5
6174   cat conftest.$ac_ext >&5
6175   rm -rf conftest*
6176   glibcpp_cv_func_finite_use=no
6177 fi
6178 rm -f conftest*
6179       ac_ext=c
6180 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6181 ac_cpp='$CPP $CPPFLAGS'
6182 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6183 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6184 cross_compiling=$ac_cv_prog_cc_cross
6185
6186
6187 fi
6188
6189   fi
6190   echo "$ac_t""$glibcpp_cv_func_finite_use" 1>&6
6191   if test x$glibcpp_cv_func_finite_use = x"yes"; then
6192     for ac_func in finite
6193 do
6194 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6195 echo "configure:6196: checking for $ac_func" >&5
6196 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6197   echo $ac_n "(cached) $ac_c" 1>&6
6198 else
6199   cat > conftest.$ac_ext <<EOF
6200 #line 6201 "configure"
6201 #include "confdefs.h"
6202 /* System header to define __stub macros and hopefully few prototypes,
6203     which can conflict with char $ac_func(); below.  */
6204 #include <assert.h>
6205 /* Override any gcc2 internal prototype to avoid an error.  */
6206 /* We use char because int might match the return type of a gcc2
6207     builtin and then its argument prototype would still apply.  */
6208 char $ac_func();
6209
6210 int main() {
6211
6212 /* The GNU C library defines this for functions which it implements
6213     to always fail with ENOSYS.  Some functions are actually named
6214     something starting with __ and the normal name is an alias.  */
6215 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6216 choke me
6217 #else
6218 $ac_func();
6219 #endif
6220
6221 ; return 0; }
6222 EOF
6223 if { (eval echo configure:6224: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6224   rm -rf conftest*
6225   eval "ac_cv_func_$ac_func=yes"
6226 else
6227   echo "configure: failed program was:" >&5
6228   cat conftest.$ac_ext >&5
6229   rm -rf conftest*
6230   eval "ac_cv_func_$ac_func=no"
6231 fi
6232 rm -f conftest*
6233 fi
6234
6235 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6236   echo "$ac_t""yes" 1>&6
6237     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6238   cat >> confdefs.h <<EOF
6239 #define $ac_tr_func 1
6240 EOF
6241
6242 else
6243   echo "$ac_t""no" 1>&6
6244 fi
6245 done
6246
6247   fi
6248
6249
6250   echo $ac_n "checking for copysign declaration""... $ac_c" 1>&6
6251 echo "configure:6252: checking for copysign declaration" >&5
6252   if test x${glibcpp_cv_func_copysign_use+set} != xset; then
6253     if eval "test \"`echo '$''{'glibcpp_cv_func_copysign_use'+set}'`\" = set"; then
6254   echo $ac_n "(cached) $ac_c" 1>&6
6255 else
6256
6257
6258       ac_ext=C
6259 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6260 ac_cpp='$CXXCPP $CPPFLAGS'
6261 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6262 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6263 cross_compiling=$ac_cv_prog_cxx_cross
6264
6265       cat > conftest.$ac_ext <<EOF
6266 #line 6267 "configure"
6267 #include "confdefs.h"
6268 #include <math.h>
6269 int main() {
6270  copysign(0, 0);
6271 ; return 0; }
6272 EOF
6273 if { (eval echo configure:6274: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6274   rm -rf conftest*
6275   glibcpp_cv_func_copysign_use=yes
6276 else
6277   echo "configure: failed program was:" >&5
6278   cat conftest.$ac_ext >&5
6279   rm -rf conftest*
6280   glibcpp_cv_func_copysign_use=no
6281 fi
6282 rm -f conftest*
6283       ac_ext=c
6284 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6285 ac_cpp='$CPP $CPPFLAGS'
6286 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6287 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6288 cross_compiling=$ac_cv_prog_cc_cross
6289
6290
6291 fi
6292
6293   fi
6294   echo "$ac_t""$glibcpp_cv_func_copysign_use" 1>&6
6295   if test x$glibcpp_cv_func_copysign_use = x"yes"; then
6296     for ac_func in copysign
6297 do
6298 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6299 echo "configure:6300: checking for $ac_func" >&5
6300 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6301   echo $ac_n "(cached) $ac_c" 1>&6
6302 else
6303   cat > conftest.$ac_ext <<EOF
6304 #line 6305 "configure"
6305 #include "confdefs.h"
6306 /* System header to define __stub macros and hopefully few prototypes,
6307     which can conflict with char $ac_func(); below.  */
6308 #include <assert.h>
6309 /* Override any gcc2 internal prototype to avoid an error.  */
6310 /* We use char because int might match the return type of a gcc2
6311     builtin and then its argument prototype would still apply.  */
6312 char $ac_func();
6313
6314 int main() {
6315
6316 /* The GNU C library defines this for functions which it implements
6317     to always fail with ENOSYS.  Some functions are actually named
6318     something starting with __ and the normal name is an alias.  */
6319 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6320 choke me
6321 #else
6322 $ac_func();
6323 #endif
6324
6325 ; return 0; }
6326 EOF
6327 if { (eval echo configure:6328: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6328   rm -rf conftest*
6329   eval "ac_cv_func_$ac_func=yes"
6330 else
6331   echo "configure: failed program was:" >&5
6332   cat conftest.$ac_ext >&5
6333   rm -rf conftest*
6334   eval "ac_cv_func_$ac_func=no"
6335 fi
6336 rm -f conftest*
6337 fi
6338
6339 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6340   echo "$ac_t""yes" 1>&6
6341     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6342   cat >> confdefs.h <<EOF
6343 #define $ac_tr_func 1
6344 EOF
6345
6346 else
6347   echo "$ac_t""no" 1>&6
6348 fi
6349 done
6350
6351   fi
6352
6353
6354   echo $ac_n "checking for sincos declaration""... $ac_c" 1>&6
6355 echo "configure:6356: checking for sincos declaration" >&5
6356   if test x${glibcpp_cv_func_sincos_use+set} != xset; then
6357     if eval "test \"`echo '$''{'glibcpp_cv_func_sincos_use'+set}'`\" = set"; then
6358   echo $ac_n "(cached) $ac_c" 1>&6
6359 else
6360
6361
6362       ac_ext=C
6363 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6364 ac_cpp='$CXXCPP $CPPFLAGS'
6365 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6366 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6367 cross_compiling=$ac_cv_prog_cxx_cross
6368
6369       cat > conftest.$ac_ext <<EOF
6370 #line 6371 "configure"
6371 #include "confdefs.h"
6372 #include <math.h>
6373 int main() {
6374  sincos(0, 0, 0);
6375 ; return 0; }
6376 EOF
6377 if { (eval echo configure:6378: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6378   rm -rf conftest*
6379   glibcpp_cv_func_sincos_use=yes
6380 else
6381   echo "configure: failed program was:" >&5
6382   cat conftest.$ac_ext >&5
6383   rm -rf conftest*
6384   glibcpp_cv_func_sincos_use=no
6385 fi
6386 rm -f conftest*
6387       ac_ext=c
6388 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6389 ac_cpp='$CPP $CPPFLAGS'
6390 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6391 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6392 cross_compiling=$ac_cv_prog_cc_cross
6393
6394
6395 fi
6396
6397   fi
6398   echo "$ac_t""$glibcpp_cv_func_sincos_use" 1>&6
6399   if test x$glibcpp_cv_func_sincos_use = x"yes"; then
6400     for ac_func in sincos
6401 do
6402 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6403 echo "configure:6404: checking for $ac_func" >&5
6404 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6405   echo $ac_n "(cached) $ac_c" 1>&6
6406 else
6407   cat > conftest.$ac_ext <<EOF
6408 #line 6409 "configure"
6409 #include "confdefs.h"
6410 /* System header to define __stub macros and hopefully few prototypes,
6411     which can conflict with char $ac_func(); below.  */
6412 #include <assert.h>
6413 /* Override any gcc2 internal prototype to avoid an error.  */
6414 /* We use char because int might match the return type of a gcc2
6415     builtin and then its argument prototype would still apply.  */
6416 char $ac_func();
6417
6418 int main() {
6419
6420 /* The GNU C library defines this for functions which it implements
6421     to always fail with ENOSYS.  Some functions are actually named
6422     something starting with __ and the normal name is an alias.  */
6423 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6424 choke me
6425 #else
6426 $ac_func();
6427 #endif
6428
6429 ; return 0; }
6430 EOF
6431 if { (eval echo configure:6432: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6432   rm -rf conftest*
6433   eval "ac_cv_func_$ac_func=yes"
6434 else
6435   echo "configure: failed program was:" >&5
6436   cat conftest.$ac_ext >&5
6437   rm -rf conftest*
6438   eval "ac_cv_func_$ac_func=no"
6439 fi
6440 rm -f conftest*
6441 fi
6442
6443 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6444   echo "$ac_t""yes" 1>&6
6445     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6446   cat >> confdefs.h <<EOF
6447 #define $ac_tr_func 1
6448 EOF
6449
6450 else
6451   echo "$ac_t""no" 1>&6
6452 fi
6453 done
6454
6455   fi
6456
6457
6458   echo $ac_n "checking for fpclass declaration""... $ac_c" 1>&6
6459 echo "configure:6460: checking for fpclass declaration" >&5
6460   if test x${glibcpp_cv_func_fpclass_use+set} != xset; then
6461     if eval "test \"`echo '$''{'glibcpp_cv_func_fpclass_use'+set}'`\" = set"; then
6462   echo $ac_n "(cached) $ac_c" 1>&6
6463 else
6464
6465
6466       ac_ext=C
6467 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6468 ac_cpp='$CXXCPP $CPPFLAGS'
6469 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6470 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6471 cross_compiling=$ac_cv_prog_cxx_cross
6472
6473       cat > conftest.$ac_ext <<EOF
6474 #line 6475 "configure"
6475 #include "confdefs.h"
6476 #include <math.h>
6477 int main() {
6478  fpclass(0);
6479 ; return 0; }
6480 EOF
6481 if { (eval echo configure:6482: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6482   rm -rf conftest*
6483   glibcpp_cv_func_fpclass_use=yes
6484 else
6485   echo "configure: failed program was:" >&5
6486   cat conftest.$ac_ext >&5
6487   rm -rf conftest*
6488   glibcpp_cv_func_fpclass_use=no
6489 fi
6490 rm -f conftest*
6491       ac_ext=c
6492 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6493 ac_cpp='$CPP $CPPFLAGS'
6494 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6495 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6496 cross_compiling=$ac_cv_prog_cc_cross
6497
6498
6499 fi
6500
6501   fi
6502   echo "$ac_t""$glibcpp_cv_func_fpclass_use" 1>&6
6503   if test x$glibcpp_cv_func_fpclass_use = x"yes"; then
6504     for ac_func in fpclass
6505 do
6506 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6507 echo "configure:6508: checking for $ac_func" >&5
6508 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6509   echo $ac_n "(cached) $ac_c" 1>&6
6510 else
6511   cat > conftest.$ac_ext <<EOF
6512 #line 6513 "configure"
6513 #include "confdefs.h"
6514 /* System header to define __stub macros and hopefully few prototypes,
6515     which can conflict with char $ac_func(); below.  */
6516 #include <assert.h>
6517 /* Override any gcc2 internal prototype to avoid an error.  */
6518 /* We use char because int might match the return type of a gcc2
6519     builtin and then its argument prototype would still apply.  */
6520 char $ac_func();
6521
6522 int main() {
6523
6524 /* The GNU C library defines this for functions which it implements
6525     to always fail with ENOSYS.  Some functions are actually named
6526     something starting with __ and the normal name is an alias.  */
6527 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6528 choke me
6529 #else
6530 $ac_func();
6531 #endif
6532
6533 ; return 0; }
6534 EOF
6535 if { (eval echo configure:6536: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6536   rm -rf conftest*
6537   eval "ac_cv_func_$ac_func=yes"
6538 else
6539   echo "configure: failed program was:" >&5
6540   cat conftest.$ac_ext >&5
6541   rm -rf conftest*
6542   eval "ac_cv_func_$ac_func=no"
6543 fi
6544 rm -f conftest*
6545 fi
6546
6547 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6548   echo "$ac_t""yes" 1>&6
6549     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6550   cat >> confdefs.h <<EOF
6551 #define $ac_tr_func 1
6552 EOF
6553
6554 else
6555   echo "$ac_t""no" 1>&6
6556 fi
6557 done
6558
6559   fi
6560
6561
6562   echo $ac_n "checking for qfpclass declaration""... $ac_c" 1>&6
6563 echo "configure:6564: checking for qfpclass declaration" >&5
6564   if test x${glibcpp_cv_func_qfpclass_use+set} != xset; then
6565     if eval "test \"`echo '$''{'glibcpp_cv_func_qfpclass_use'+set}'`\" = set"; then
6566   echo $ac_n "(cached) $ac_c" 1>&6
6567 else
6568
6569
6570       ac_ext=C
6571 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6572 ac_cpp='$CXXCPP $CPPFLAGS'
6573 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6574 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6575 cross_compiling=$ac_cv_prog_cxx_cross
6576
6577       cat > conftest.$ac_ext <<EOF
6578 #line 6579 "configure"
6579 #include "confdefs.h"
6580 #include <math.h>
6581 int main() {
6582  qfpclass(0);
6583 ; return 0; }
6584 EOF
6585 if { (eval echo configure:6586: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6586   rm -rf conftest*
6587   glibcpp_cv_func_qfpclass_use=yes
6588 else
6589   echo "configure: failed program was:" >&5
6590   cat conftest.$ac_ext >&5
6591   rm -rf conftest*
6592   glibcpp_cv_func_qfpclass_use=no
6593 fi
6594 rm -f conftest*
6595       ac_ext=c
6596 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6597 ac_cpp='$CPP $CPPFLAGS'
6598 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6599 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6600 cross_compiling=$ac_cv_prog_cc_cross
6601
6602
6603 fi
6604
6605   fi
6606   echo "$ac_t""$glibcpp_cv_func_qfpclass_use" 1>&6
6607   if test x$glibcpp_cv_func_qfpclass_use = x"yes"; then
6608     for ac_func in qfpclass
6609 do
6610 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6611 echo "configure:6612: checking for $ac_func" >&5
6612 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6613   echo $ac_n "(cached) $ac_c" 1>&6
6614 else
6615   cat > conftest.$ac_ext <<EOF
6616 #line 6617 "configure"
6617 #include "confdefs.h"
6618 /* System header to define __stub macros and hopefully few prototypes,
6619     which can conflict with char $ac_func(); below.  */
6620 #include <assert.h>
6621 /* Override any gcc2 internal prototype to avoid an error.  */
6622 /* We use char because int might match the return type of a gcc2
6623     builtin and then its argument prototype would still apply.  */
6624 char $ac_func();
6625
6626 int main() {
6627
6628 /* The GNU C library defines this for functions which it implements
6629     to always fail with ENOSYS.  Some functions are actually named
6630     something starting with __ and the normal name is an alias.  */
6631 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6632 choke me
6633 #else
6634 $ac_func();
6635 #endif
6636
6637 ; return 0; }
6638 EOF
6639 if { (eval echo configure:6640: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6640   rm -rf conftest*
6641   eval "ac_cv_func_$ac_func=yes"
6642 else
6643   echo "configure: failed program was:" >&5
6644   cat conftest.$ac_ext >&5
6645   rm -rf conftest*
6646   eval "ac_cv_func_$ac_func=no"
6647 fi
6648 rm -f conftest*
6649 fi
6650
6651 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6652   echo "$ac_t""yes" 1>&6
6653     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6654   cat >> confdefs.h <<EOF
6655 #define $ac_tr_func 1
6656 EOF
6657
6658 else
6659   echo "$ac_t""no" 1>&6
6660 fi
6661 done
6662
6663   fi
6664
6665
6666
6667   echo $ac_n "checking for isnanf declaration""... $ac_c" 1>&6
6668 echo "configure:6669: checking for isnanf declaration" >&5
6669   if test x${glibcpp_cv_func_isnanf_use+set} != xset; then
6670     if eval "test \"`echo '$''{'glibcpp_cv_func_isnanf_use'+set}'`\" = set"; then
6671   echo $ac_n "(cached) $ac_c" 1>&6
6672 else
6673
6674
6675       ac_ext=C
6676 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6677 ac_cpp='$CXXCPP $CPPFLAGS'
6678 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6679 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6680 cross_compiling=$ac_cv_prog_cxx_cross
6681
6682       cat > conftest.$ac_ext <<EOF
6683 #line 6684 "configure"
6684 #include "confdefs.h"
6685 #include <math.h>
6686 int main() {
6687  isnanf(0);
6688 ; return 0; }
6689 EOF
6690 if { (eval echo configure:6691: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6691   rm -rf conftest*
6692   glibcpp_cv_func_isnanf_use=yes
6693 else
6694   echo "configure: failed program was:" >&5
6695   cat conftest.$ac_ext >&5
6696   rm -rf conftest*
6697   glibcpp_cv_func_isnanf_use=no
6698 fi
6699 rm -f conftest*
6700       ac_ext=c
6701 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6702 ac_cpp='$CPP $CPPFLAGS'
6703 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6704 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6705 cross_compiling=$ac_cv_prog_cc_cross
6706
6707
6708 fi
6709
6710   fi
6711   echo "$ac_t""$glibcpp_cv_func_isnanf_use" 1>&6
6712   if test x$glibcpp_cv_func_isnanf_use = x"yes"; then
6713     for ac_func in isnanf
6714 do
6715 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6716 echo "configure:6717: checking for $ac_func" >&5
6717 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6718   echo $ac_n "(cached) $ac_c" 1>&6
6719 else
6720   cat > conftest.$ac_ext <<EOF
6721 #line 6722 "configure"
6722 #include "confdefs.h"
6723 /* System header to define __stub macros and hopefully few prototypes,
6724     which can conflict with char $ac_func(); below.  */
6725 #include <assert.h>
6726 /* Override any gcc2 internal prototype to avoid an error.  */
6727 /* We use char because int might match the return type of a gcc2
6728     builtin and then its argument prototype would still apply.  */
6729 char $ac_func();
6730
6731 int main() {
6732
6733 /* The GNU C library defines this for functions which it implements
6734     to always fail with ENOSYS.  Some functions are actually named
6735     something starting with __ and the normal name is an alias.  */
6736 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6737 choke me
6738 #else
6739 $ac_func();
6740 #endif
6741
6742 ; return 0; }
6743 EOF
6744 if { (eval echo configure:6745: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6745   rm -rf conftest*
6746   eval "ac_cv_func_$ac_func=yes"
6747 else
6748   echo "configure: failed program was:" >&5
6749   cat conftest.$ac_ext >&5
6750   rm -rf conftest*
6751   eval "ac_cv_func_$ac_func=no"
6752 fi
6753 rm -f conftest*
6754 fi
6755
6756 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6757   echo "$ac_t""yes" 1>&6
6758     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6759   cat >> confdefs.h <<EOF
6760 #define $ac_tr_func 1
6761 EOF
6762
6763 else
6764   echo "$ac_t""no" 1>&6
6765 fi
6766 done
6767
6768   fi
6769
6770
6771   echo $ac_n "checking for isinff declaration""... $ac_c" 1>&6
6772 echo "configure:6773: checking for isinff declaration" >&5
6773   if test x${glibcpp_cv_func_isinff_use+set} != xset; then
6774     if eval "test \"`echo '$''{'glibcpp_cv_func_isinff_use'+set}'`\" = set"; then
6775   echo $ac_n "(cached) $ac_c" 1>&6
6776 else
6777
6778
6779       ac_ext=C
6780 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6781 ac_cpp='$CXXCPP $CPPFLAGS'
6782 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6783 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6784 cross_compiling=$ac_cv_prog_cxx_cross
6785
6786       cat > conftest.$ac_ext <<EOF
6787 #line 6788 "configure"
6788 #include "confdefs.h"
6789 #include <math.h>
6790 int main() {
6791  isinff(0);
6792 ; return 0; }
6793 EOF
6794 if { (eval echo configure:6795: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6795   rm -rf conftest*
6796   glibcpp_cv_func_isinff_use=yes
6797 else
6798   echo "configure: failed program was:" >&5
6799   cat conftest.$ac_ext >&5
6800   rm -rf conftest*
6801   glibcpp_cv_func_isinff_use=no
6802 fi
6803 rm -f conftest*
6804       ac_ext=c
6805 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6806 ac_cpp='$CPP $CPPFLAGS'
6807 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6808 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6809 cross_compiling=$ac_cv_prog_cc_cross
6810
6811
6812 fi
6813
6814   fi
6815   echo "$ac_t""$glibcpp_cv_func_isinff_use" 1>&6
6816   if test x$glibcpp_cv_func_isinff_use = x"yes"; then
6817     for ac_func in isinff
6818 do
6819 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6820 echo "configure:6821: checking for $ac_func" >&5
6821 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6822   echo $ac_n "(cached) $ac_c" 1>&6
6823 else
6824   cat > conftest.$ac_ext <<EOF
6825 #line 6826 "configure"
6826 #include "confdefs.h"
6827 /* System header to define __stub macros and hopefully few prototypes,
6828     which can conflict with char $ac_func(); below.  */
6829 #include <assert.h>
6830 /* Override any gcc2 internal prototype to avoid an error.  */
6831 /* We use char because int might match the return type of a gcc2
6832     builtin and then its argument prototype would still apply.  */
6833 char $ac_func();
6834
6835 int main() {
6836
6837 /* The GNU C library defines this for functions which it implements
6838     to always fail with ENOSYS.  Some functions are actually named
6839     something starting with __ and the normal name is an alias.  */
6840 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6841 choke me
6842 #else
6843 $ac_func();
6844 #endif
6845
6846 ; return 0; }
6847 EOF
6848 if { (eval echo configure:6849: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6849   rm -rf conftest*
6850   eval "ac_cv_func_$ac_func=yes"
6851 else
6852   echo "configure: failed program was:" >&5
6853   cat conftest.$ac_ext >&5
6854   rm -rf conftest*
6855   eval "ac_cv_func_$ac_func=no"
6856 fi
6857 rm -f conftest*
6858 fi
6859
6860 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6861   echo "$ac_t""yes" 1>&6
6862     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6863   cat >> confdefs.h <<EOF
6864 #define $ac_tr_func 1
6865 EOF
6866
6867 else
6868   echo "$ac_t""no" 1>&6
6869 fi
6870 done
6871
6872   fi
6873
6874
6875   echo $ac_n "checking for acosf declaration""... $ac_c" 1>&6
6876 echo "configure:6877: checking for acosf declaration" >&5
6877   if test x${glibcpp_cv_func_acosf_use+set} != xset; then
6878     if eval "test \"`echo '$''{'glibcpp_cv_func_acosf_use'+set}'`\" = set"; then
6879   echo $ac_n "(cached) $ac_c" 1>&6
6880 else
6881
6882
6883       ac_ext=C
6884 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6885 ac_cpp='$CXXCPP $CPPFLAGS'
6886 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6887 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6888 cross_compiling=$ac_cv_prog_cxx_cross
6889
6890       cat > conftest.$ac_ext <<EOF
6891 #line 6892 "configure"
6892 #include "confdefs.h"
6893 #include <math.h>
6894 int main() {
6895  acosf(0);
6896 ; return 0; }
6897 EOF
6898 if { (eval echo configure:6899: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
6899   rm -rf conftest*
6900   glibcpp_cv_func_acosf_use=yes
6901 else
6902   echo "configure: failed program was:" >&5
6903   cat conftest.$ac_ext >&5
6904   rm -rf conftest*
6905   glibcpp_cv_func_acosf_use=no
6906 fi
6907 rm -f conftest*
6908       ac_ext=c
6909 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6910 ac_cpp='$CPP $CPPFLAGS'
6911 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6912 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6913 cross_compiling=$ac_cv_prog_cc_cross
6914
6915
6916 fi
6917
6918   fi
6919   echo "$ac_t""$glibcpp_cv_func_acosf_use" 1>&6
6920   if test x$glibcpp_cv_func_acosf_use = x"yes"; then
6921     for ac_func in acosf
6922 do
6923 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
6924 echo "configure:6925: checking for $ac_func" >&5
6925 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
6926   echo $ac_n "(cached) $ac_c" 1>&6
6927 else
6928   cat > conftest.$ac_ext <<EOF
6929 #line 6930 "configure"
6930 #include "confdefs.h"
6931 /* System header to define __stub macros and hopefully few prototypes,
6932     which can conflict with char $ac_func(); below.  */
6933 #include <assert.h>
6934 /* Override any gcc2 internal prototype to avoid an error.  */
6935 /* We use char because int might match the return type of a gcc2
6936     builtin and then its argument prototype would still apply.  */
6937 char $ac_func();
6938
6939 int main() {
6940
6941 /* The GNU C library defines this for functions which it implements
6942     to always fail with ENOSYS.  Some functions are actually named
6943     something starting with __ and the normal name is an alias.  */
6944 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6945 choke me
6946 #else
6947 $ac_func();
6948 #endif
6949
6950 ; return 0; }
6951 EOF
6952 if { (eval echo configure:6953: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
6953   rm -rf conftest*
6954   eval "ac_cv_func_$ac_func=yes"
6955 else
6956   echo "configure: failed program was:" >&5
6957   cat conftest.$ac_ext >&5
6958   rm -rf conftest*
6959   eval "ac_cv_func_$ac_func=no"
6960 fi
6961 rm -f conftest*
6962 fi
6963
6964 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
6965   echo "$ac_t""yes" 1>&6
6966     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
6967   cat >> confdefs.h <<EOF
6968 #define $ac_tr_func 1
6969 EOF
6970
6971 else
6972   echo "$ac_t""no" 1>&6
6973 fi
6974 done
6975
6976   fi
6977
6978
6979   echo $ac_n "checking for asinf declaration""... $ac_c" 1>&6
6980 echo "configure:6981: checking for asinf declaration" >&5
6981   if test x${glibcpp_cv_func_asinf_use+set} != xset; then
6982     if eval "test \"`echo '$''{'glibcpp_cv_func_asinf_use'+set}'`\" = set"; then
6983   echo $ac_n "(cached) $ac_c" 1>&6
6984 else
6985
6986
6987       ac_ext=C
6988 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
6989 ac_cpp='$CXXCPP $CPPFLAGS'
6990 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
6991 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
6992 cross_compiling=$ac_cv_prog_cxx_cross
6993
6994       cat > conftest.$ac_ext <<EOF
6995 #line 6996 "configure"
6996 #include "confdefs.h"
6997 #include <math.h>
6998 int main() {
6999  asinf(0);
7000 ; return 0; }
7001 EOF
7002 if { (eval echo configure:7003: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7003   rm -rf conftest*
7004   glibcpp_cv_func_asinf_use=yes
7005 else
7006   echo "configure: failed program was:" >&5
7007   cat conftest.$ac_ext >&5
7008   rm -rf conftest*
7009   glibcpp_cv_func_asinf_use=no
7010 fi
7011 rm -f conftest*
7012       ac_ext=c
7013 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7014 ac_cpp='$CPP $CPPFLAGS'
7015 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7016 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7017 cross_compiling=$ac_cv_prog_cc_cross
7018
7019
7020 fi
7021
7022   fi
7023   echo "$ac_t""$glibcpp_cv_func_asinf_use" 1>&6
7024   if test x$glibcpp_cv_func_asinf_use = x"yes"; then
7025     for ac_func in asinf
7026 do
7027 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7028 echo "configure:7029: checking for $ac_func" >&5
7029 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7030   echo $ac_n "(cached) $ac_c" 1>&6
7031 else
7032   cat > conftest.$ac_ext <<EOF
7033 #line 7034 "configure"
7034 #include "confdefs.h"
7035 /* System header to define __stub macros and hopefully few prototypes,
7036     which can conflict with char $ac_func(); below.  */
7037 #include <assert.h>
7038 /* Override any gcc2 internal prototype to avoid an error.  */
7039 /* We use char because int might match the return type of a gcc2
7040     builtin and then its argument prototype would still apply.  */
7041 char $ac_func();
7042
7043 int main() {
7044
7045 /* The GNU C library defines this for functions which it implements
7046     to always fail with ENOSYS.  Some functions are actually named
7047     something starting with __ and the normal name is an alias.  */
7048 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7049 choke me
7050 #else
7051 $ac_func();
7052 #endif
7053
7054 ; return 0; }
7055 EOF
7056 if { (eval echo configure:7057: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7057   rm -rf conftest*
7058   eval "ac_cv_func_$ac_func=yes"
7059 else
7060   echo "configure: failed program was:" >&5
7061   cat conftest.$ac_ext >&5
7062   rm -rf conftest*
7063   eval "ac_cv_func_$ac_func=no"
7064 fi
7065 rm -f conftest*
7066 fi
7067
7068 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7069   echo "$ac_t""yes" 1>&6
7070     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7071   cat >> confdefs.h <<EOF
7072 #define $ac_tr_func 1
7073 EOF
7074
7075 else
7076   echo "$ac_t""no" 1>&6
7077 fi
7078 done
7079
7080   fi
7081
7082
7083   echo $ac_n "checking for atanf declaration""... $ac_c" 1>&6
7084 echo "configure:7085: checking for atanf declaration" >&5
7085   if test x${glibcpp_cv_func_atanf_use+set} != xset; then
7086     if eval "test \"`echo '$''{'glibcpp_cv_func_atanf_use'+set}'`\" = set"; then
7087   echo $ac_n "(cached) $ac_c" 1>&6
7088 else
7089
7090
7091       ac_ext=C
7092 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7093 ac_cpp='$CXXCPP $CPPFLAGS'
7094 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7095 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7096 cross_compiling=$ac_cv_prog_cxx_cross
7097
7098       cat > conftest.$ac_ext <<EOF
7099 #line 7100 "configure"
7100 #include "confdefs.h"
7101 #include <math.h>
7102 int main() {
7103  atanf(0);
7104 ; return 0; }
7105 EOF
7106 if { (eval echo configure:7107: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7107   rm -rf conftest*
7108   glibcpp_cv_func_atanf_use=yes
7109 else
7110   echo "configure: failed program was:" >&5
7111   cat conftest.$ac_ext >&5
7112   rm -rf conftest*
7113   glibcpp_cv_func_atanf_use=no
7114 fi
7115 rm -f conftest*
7116       ac_ext=c
7117 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7118 ac_cpp='$CPP $CPPFLAGS'
7119 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7120 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7121 cross_compiling=$ac_cv_prog_cc_cross
7122
7123
7124 fi
7125
7126   fi
7127   echo "$ac_t""$glibcpp_cv_func_atanf_use" 1>&6
7128   if test x$glibcpp_cv_func_atanf_use = x"yes"; then
7129     for ac_func in atanf
7130 do
7131 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7132 echo "configure:7133: checking for $ac_func" >&5
7133 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7134   echo $ac_n "(cached) $ac_c" 1>&6
7135 else
7136   cat > conftest.$ac_ext <<EOF
7137 #line 7138 "configure"
7138 #include "confdefs.h"
7139 /* System header to define __stub macros and hopefully few prototypes,
7140     which can conflict with char $ac_func(); below.  */
7141 #include <assert.h>
7142 /* Override any gcc2 internal prototype to avoid an error.  */
7143 /* We use char because int might match the return type of a gcc2
7144     builtin and then its argument prototype would still apply.  */
7145 char $ac_func();
7146
7147 int main() {
7148
7149 /* The GNU C library defines this for functions which it implements
7150     to always fail with ENOSYS.  Some functions are actually named
7151     something starting with __ and the normal name is an alias.  */
7152 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7153 choke me
7154 #else
7155 $ac_func();
7156 #endif
7157
7158 ; return 0; }
7159 EOF
7160 if { (eval echo configure:7161: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7161   rm -rf conftest*
7162   eval "ac_cv_func_$ac_func=yes"
7163 else
7164   echo "configure: failed program was:" >&5
7165   cat conftest.$ac_ext >&5
7166   rm -rf conftest*
7167   eval "ac_cv_func_$ac_func=no"
7168 fi
7169 rm -f conftest*
7170 fi
7171
7172 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7173   echo "$ac_t""yes" 1>&6
7174     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7175   cat >> confdefs.h <<EOF
7176 #define $ac_tr_func 1
7177 EOF
7178
7179 else
7180   echo "$ac_t""no" 1>&6
7181 fi
7182 done
7183
7184   fi
7185
7186
7187   echo $ac_n "checking for ceilf declaration""... $ac_c" 1>&6
7188 echo "configure:7189: checking for ceilf declaration" >&5
7189   if test x${glibcpp_cv_func_ceilf_use+set} != xset; then
7190     if eval "test \"`echo '$''{'glibcpp_cv_func_ceilf_use'+set}'`\" = set"; then
7191   echo $ac_n "(cached) $ac_c" 1>&6
7192 else
7193
7194
7195       ac_ext=C
7196 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7197 ac_cpp='$CXXCPP $CPPFLAGS'
7198 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7199 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7200 cross_compiling=$ac_cv_prog_cxx_cross
7201
7202       cat > conftest.$ac_ext <<EOF
7203 #line 7204 "configure"
7204 #include "confdefs.h"
7205 #include <math.h>
7206 int main() {
7207  ceilf(0);
7208 ; return 0; }
7209 EOF
7210 if { (eval echo configure:7211: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7211   rm -rf conftest*
7212   glibcpp_cv_func_ceilf_use=yes
7213 else
7214   echo "configure: failed program was:" >&5
7215   cat conftest.$ac_ext >&5
7216   rm -rf conftest*
7217   glibcpp_cv_func_ceilf_use=no
7218 fi
7219 rm -f conftest*
7220       ac_ext=c
7221 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7222 ac_cpp='$CPP $CPPFLAGS'
7223 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7224 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7225 cross_compiling=$ac_cv_prog_cc_cross
7226
7227
7228 fi
7229
7230   fi
7231   echo "$ac_t""$glibcpp_cv_func_ceilf_use" 1>&6
7232   if test x$glibcpp_cv_func_ceilf_use = x"yes"; then
7233     for ac_func in ceilf
7234 do
7235 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7236 echo "configure:7237: checking for $ac_func" >&5
7237 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7238   echo $ac_n "(cached) $ac_c" 1>&6
7239 else
7240   cat > conftest.$ac_ext <<EOF
7241 #line 7242 "configure"
7242 #include "confdefs.h"
7243 /* System header to define __stub macros and hopefully few prototypes,
7244     which can conflict with char $ac_func(); below.  */
7245 #include <assert.h>
7246 /* Override any gcc2 internal prototype to avoid an error.  */
7247 /* We use char because int might match the return type of a gcc2
7248     builtin and then its argument prototype would still apply.  */
7249 char $ac_func();
7250
7251 int main() {
7252
7253 /* The GNU C library defines this for functions which it implements
7254     to always fail with ENOSYS.  Some functions are actually named
7255     something starting with __ and the normal name is an alias.  */
7256 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7257 choke me
7258 #else
7259 $ac_func();
7260 #endif
7261
7262 ; return 0; }
7263 EOF
7264 if { (eval echo configure:7265: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7265   rm -rf conftest*
7266   eval "ac_cv_func_$ac_func=yes"
7267 else
7268   echo "configure: failed program was:" >&5
7269   cat conftest.$ac_ext >&5
7270   rm -rf conftest*
7271   eval "ac_cv_func_$ac_func=no"
7272 fi
7273 rm -f conftest*
7274 fi
7275
7276 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7277   echo "$ac_t""yes" 1>&6
7278     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7279   cat >> confdefs.h <<EOF
7280 #define $ac_tr_func 1
7281 EOF
7282
7283 else
7284   echo "$ac_t""no" 1>&6
7285 fi
7286 done
7287
7288   fi
7289
7290
7291   echo $ac_n "checking for cosf declaration""... $ac_c" 1>&6
7292 echo "configure:7293: checking for cosf declaration" >&5
7293   if test x${glibcpp_cv_func_cosf_use+set} != xset; then
7294     if eval "test \"`echo '$''{'glibcpp_cv_func_cosf_use'+set}'`\" = set"; then
7295   echo $ac_n "(cached) $ac_c" 1>&6
7296 else
7297
7298
7299       ac_ext=C
7300 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7301 ac_cpp='$CXXCPP $CPPFLAGS'
7302 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7303 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7304 cross_compiling=$ac_cv_prog_cxx_cross
7305
7306       cat > conftest.$ac_ext <<EOF
7307 #line 7308 "configure"
7308 #include "confdefs.h"
7309 #include <math.h>
7310 int main() {
7311  cosf(0);
7312 ; return 0; }
7313 EOF
7314 if { (eval echo configure:7315: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7315   rm -rf conftest*
7316   glibcpp_cv_func_cosf_use=yes
7317 else
7318   echo "configure: failed program was:" >&5
7319   cat conftest.$ac_ext >&5
7320   rm -rf conftest*
7321   glibcpp_cv_func_cosf_use=no
7322 fi
7323 rm -f conftest*
7324       ac_ext=c
7325 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7326 ac_cpp='$CPP $CPPFLAGS'
7327 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7328 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7329 cross_compiling=$ac_cv_prog_cc_cross
7330
7331
7332 fi
7333
7334   fi
7335   echo "$ac_t""$glibcpp_cv_func_cosf_use" 1>&6
7336   if test x$glibcpp_cv_func_cosf_use = x"yes"; then
7337     for ac_func in cosf
7338 do
7339 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7340 echo "configure:7341: checking for $ac_func" >&5
7341 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7342   echo $ac_n "(cached) $ac_c" 1>&6
7343 else
7344   cat > conftest.$ac_ext <<EOF
7345 #line 7346 "configure"
7346 #include "confdefs.h"
7347 /* System header to define __stub macros and hopefully few prototypes,
7348     which can conflict with char $ac_func(); below.  */
7349 #include <assert.h>
7350 /* Override any gcc2 internal prototype to avoid an error.  */
7351 /* We use char because int might match the return type of a gcc2
7352     builtin and then its argument prototype would still apply.  */
7353 char $ac_func();
7354
7355 int main() {
7356
7357 /* The GNU C library defines this for functions which it implements
7358     to always fail with ENOSYS.  Some functions are actually named
7359     something starting with __ and the normal name is an alias.  */
7360 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7361 choke me
7362 #else
7363 $ac_func();
7364 #endif
7365
7366 ; return 0; }
7367 EOF
7368 if { (eval echo configure:7369: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7369   rm -rf conftest*
7370   eval "ac_cv_func_$ac_func=yes"
7371 else
7372   echo "configure: failed program was:" >&5
7373   cat conftest.$ac_ext >&5
7374   rm -rf conftest*
7375   eval "ac_cv_func_$ac_func=no"
7376 fi
7377 rm -f conftest*
7378 fi
7379
7380 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7381   echo "$ac_t""yes" 1>&6
7382     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7383   cat >> confdefs.h <<EOF
7384 #define $ac_tr_func 1
7385 EOF
7386
7387 else
7388   echo "$ac_t""no" 1>&6
7389 fi
7390 done
7391
7392   fi
7393
7394
7395   echo $ac_n "checking for coshf declaration""... $ac_c" 1>&6
7396 echo "configure:7397: checking for coshf declaration" >&5
7397   if test x${glibcpp_cv_func_coshf_use+set} != xset; then
7398     if eval "test \"`echo '$''{'glibcpp_cv_func_coshf_use'+set}'`\" = set"; then
7399   echo $ac_n "(cached) $ac_c" 1>&6
7400 else
7401
7402
7403       ac_ext=C
7404 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7405 ac_cpp='$CXXCPP $CPPFLAGS'
7406 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7407 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7408 cross_compiling=$ac_cv_prog_cxx_cross
7409
7410       cat > conftest.$ac_ext <<EOF
7411 #line 7412 "configure"
7412 #include "confdefs.h"
7413 #include <math.h>
7414 int main() {
7415  coshf(0);
7416 ; return 0; }
7417 EOF
7418 if { (eval echo configure:7419: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7419   rm -rf conftest*
7420   glibcpp_cv_func_coshf_use=yes
7421 else
7422   echo "configure: failed program was:" >&5
7423   cat conftest.$ac_ext >&5
7424   rm -rf conftest*
7425   glibcpp_cv_func_coshf_use=no
7426 fi
7427 rm -f conftest*
7428       ac_ext=c
7429 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7430 ac_cpp='$CPP $CPPFLAGS'
7431 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7432 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7433 cross_compiling=$ac_cv_prog_cc_cross
7434
7435
7436 fi
7437
7438   fi
7439   echo "$ac_t""$glibcpp_cv_func_coshf_use" 1>&6
7440   if test x$glibcpp_cv_func_coshf_use = x"yes"; then
7441     for ac_func in coshf
7442 do
7443 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7444 echo "configure:7445: checking for $ac_func" >&5
7445 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7446   echo $ac_n "(cached) $ac_c" 1>&6
7447 else
7448   cat > conftest.$ac_ext <<EOF
7449 #line 7450 "configure"
7450 #include "confdefs.h"
7451 /* System header to define __stub macros and hopefully few prototypes,
7452     which can conflict with char $ac_func(); below.  */
7453 #include <assert.h>
7454 /* Override any gcc2 internal prototype to avoid an error.  */
7455 /* We use char because int might match the return type of a gcc2
7456     builtin and then its argument prototype would still apply.  */
7457 char $ac_func();
7458
7459 int main() {
7460
7461 /* The GNU C library defines this for functions which it implements
7462     to always fail with ENOSYS.  Some functions are actually named
7463     something starting with __ and the normal name is an alias.  */
7464 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7465 choke me
7466 #else
7467 $ac_func();
7468 #endif
7469
7470 ; return 0; }
7471 EOF
7472 if { (eval echo configure:7473: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7473   rm -rf conftest*
7474   eval "ac_cv_func_$ac_func=yes"
7475 else
7476   echo "configure: failed program was:" >&5
7477   cat conftest.$ac_ext >&5
7478   rm -rf conftest*
7479   eval "ac_cv_func_$ac_func=no"
7480 fi
7481 rm -f conftest*
7482 fi
7483
7484 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7485   echo "$ac_t""yes" 1>&6
7486     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7487   cat >> confdefs.h <<EOF
7488 #define $ac_tr_func 1
7489 EOF
7490
7491 else
7492   echo "$ac_t""no" 1>&6
7493 fi
7494 done
7495
7496   fi
7497
7498
7499   echo $ac_n "checking for fabsf declaration""... $ac_c" 1>&6
7500 echo "configure:7501: checking for fabsf declaration" >&5
7501   if test x${glibcpp_cv_func_fabsf_use+set} != xset; then
7502     if eval "test \"`echo '$''{'glibcpp_cv_func_fabsf_use'+set}'`\" = set"; then
7503   echo $ac_n "(cached) $ac_c" 1>&6
7504 else
7505
7506
7507       ac_ext=C
7508 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7509 ac_cpp='$CXXCPP $CPPFLAGS'
7510 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7511 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7512 cross_compiling=$ac_cv_prog_cxx_cross
7513
7514       cat > conftest.$ac_ext <<EOF
7515 #line 7516 "configure"
7516 #include "confdefs.h"
7517 #include <math.h>
7518 int main() {
7519  fabsf(0);
7520 ; return 0; }
7521 EOF
7522 if { (eval echo configure:7523: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7523   rm -rf conftest*
7524   glibcpp_cv_func_fabsf_use=yes
7525 else
7526   echo "configure: failed program was:" >&5
7527   cat conftest.$ac_ext >&5
7528   rm -rf conftest*
7529   glibcpp_cv_func_fabsf_use=no
7530 fi
7531 rm -f conftest*
7532       ac_ext=c
7533 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7534 ac_cpp='$CPP $CPPFLAGS'
7535 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7536 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7537 cross_compiling=$ac_cv_prog_cc_cross
7538
7539
7540 fi
7541
7542   fi
7543   echo "$ac_t""$glibcpp_cv_func_fabsf_use" 1>&6
7544   if test x$glibcpp_cv_func_fabsf_use = x"yes"; then
7545     for ac_func in fabsf
7546 do
7547 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7548 echo "configure:7549: checking for $ac_func" >&5
7549 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7550   echo $ac_n "(cached) $ac_c" 1>&6
7551 else
7552   cat > conftest.$ac_ext <<EOF
7553 #line 7554 "configure"
7554 #include "confdefs.h"
7555 /* System header to define __stub macros and hopefully few prototypes,
7556     which can conflict with char $ac_func(); below.  */
7557 #include <assert.h>
7558 /* Override any gcc2 internal prototype to avoid an error.  */
7559 /* We use char because int might match the return type of a gcc2
7560     builtin and then its argument prototype would still apply.  */
7561 char $ac_func();
7562
7563 int main() {
7564
7565 /* The GNU C library defines this for functions which it implements
7566     to always fail with ENOSYS.  Some functions are actually named
7567     something starting with __ and the normal name is an alias.  */
7568 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7569 choke me
7570 #else
7571 $ac_func();
7572 #endif
7573
7574 ; return 0; }
7575 EOF
7576 if { (eval echo configure:7577: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7577   rm -rf conftest*
7578   eval "ac_cv_func_$ac_func=yes"
7579 else
7580   echo "configure: failed program was:" >&5
7581   cat conftest.$ac_ext >&5
7582   rm -rf conftest*
7583   eval "ac_cv_func_$ac_func=no"
7584 fi
7585 rm -f conftest*
7586 fi
7587
7588 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7589   echo "$ac_t""yes" 1>&6
7590     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7591   cat >> confdefs.h <<EOF
7592 #define $ac_tr_func 1
7593 EOF
7594
7595 else
7596   echo "$ac_t""no" 1>&6
7597 fi
7598 done
7599
7600   fi
7601
7602
7603   echo $ac_n "checking for floorf declaration""... $ac_c" 1>&6
7604 echo "configure:7605: checking for floorf declaration" >&5
7605   if test x${glibcpp_cv_func_floorf_use+set} != xset; then
7606     if eval "test \"`echo '$''{'glibcpp_cv_func_floorf_use'+set}'`\" = set"; then
7607   echo $ac_n "(cached) $ac_c" 1>&6
7608 else
7609
7610
7611       ac_ext=C
7612 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7613 ac_cpp='$CXXCPP $CPPFLAGS'
7614 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7615 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7616 cross_compiling=$ac_cv_prog_cxx_cross
7617
7618       cat > conftest.$ac_ext <<EOF
7619 #line 7620 "configure"
7620 #include "confdefs.h"
7621 #include <math.h>
7622 int main() {
7623  floorf(0);
7624 ; return 0; }
7625 EOF
7626 if { (eval echo configure:7627: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7627   rm -rf conftest*
7628   glibcpp_cv_func_floorf_use=yes
7629 else
7630   echo "configure: failed program was:" >&5
7631   cat conftest.$ac_ext >&5
7632   rm -rf conftest*
7633   glibcpp_cv_func_floorf_use=no
7634 fi
7635 rm -f conftest*
7636       ac_ext=c
7637 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7638 ac_cpp='$CPP $CPPFLAGS'
7639 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7640 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7641 cross_compiling=$ac_cv_prog_cc_cross
7642
7643
7644 fi
7645
7646   fi
7647   echo "$ac_t""$glibcpp_cv_func_floorf_use" 1>&6
7648   if test x$glibcpp_cv_func_floorf_use = x"yes"; then
7649     for ac_func in floorf
7650 do
7651 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7652 echo "configure:7653: checking for $ac_func" >&5
7653 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7654   echo $ac_n "(cached) $ac_c" 1>&6
7655 else
7656   cat > conftest.$ac_ext <<EOF
7657 #line 7658 "configure"
7658 #include "confdefs.h"
7659 /* System header to define __stub macros and hopefully few prototypes,
7660     which can conflict with char $ac_func(); below.  */
7661 #include <assert.h>
7662 /* Override any gcc2 internal prototype to avoid an error.  */
7663 /* We use char because int might match the return type of a gcc2
7664     builtin and then its argument prototype would still apply.  */
7665 char $ac_func();
7666
7667 int main() {
7668
7669 /* The GNU C library defines this for functions which it implements
7670     to always fail with ENOSYS.  Some functions are actually named
7671     something starting with __ and the normal name is an alias.  */
7672 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7673 choke me
7674 #else
7675 $ac_func();
7676 #endif
7677
7678 ; return 0; }
7679 EOF
7680 if { (eval echo configure:7681: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7681   rm -rf conftest*
7682   eval "ac_cv_func_$ac_func=yes"
7683 else
7684   echo "configure: failed program was:" >&5
7685   cat conftest.$ac_ext >&5
7686   rm -rf conftest*
7687   eval "ac_cv_func_$ac_func=no"
7688 fi
7689 rm -f conftest*
7690 fi
7691
7692 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7693   echo "$ac_t""yes" 1>&6
7694     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7695   cat >> confdefs.h <<EOF
7696 #define $ac_tr_func 1
7697 EOF
7698
7699 else
7700   echo "$ac_t""no" 1>&6
7701 fi
7702 done
7703
7704   fi
7705
7706
7707   echo $ac_n "checking for fmodf declaration""... $ac_c" 1>&6
7708 echo "configure:7709: checking for fmodf declaration" >&5
7709   if test x${glibcpp_cv_func_fmodf_use+set} != xset; then
7710     if eval "test \"`echo '$''{'glibcpp_cv_func_fmodf_use'+set}'`\" = set"; then
7711   echo $ac_n "(cached) $ac_c" 1>&6
7712 else
7713
7714
7715       ac_ext=C
7716 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7717 ac_cpp='$CXXCPP $CPPFLAGS'
7718 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7719 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7720 cross_compiling=$ac_cv_prog_cxx_cross
7721
7722       cat > conftest.$ac_ext <<EOF
7723 #line 7724 "configure"
7724 #include "confdefs.h"
7725 #include <math.h>
7726 int main() {
7727  fmodf(0, 0);
7728 ; return 0; }
7729 EOF
7730 if { (eval echo configure:7731: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7731   rm -rf conftest*
7732   glibcpp_cv_func_fmodf_use=yes
7733 else
7734   echo "configure: failed program was:" >&5
7735   cat conftest.$ac_ext >&5
7736   rm -rf conftest*
7737   glibcpp_cv_func_fmodf_use=no
7738 fi
7739 rm -f conftest*
7740       ac_ext=c
7741 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7742 ac_cpp='$CPP $CPPFLAGS'
7743 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7744 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7745 cross_compiling=$ac_cv_prog_cc_cross
7746
7747
7748 fi
7749
7750   fi
7751   echo "$ac_t""$glibcpp_cv_func_fmodf_use" 1>&6
7752   if test x$glibcpp_cv_func_fmodf_use = x"yes"; then
7753     for ac_func in fmodf
7754 do
7755 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7756 echo "configure:7757: checking for $ac_func" >&5
7757 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7758   echo $ac_n "(cached) $ac_c" 1>&6
7759 else
7760   cat > conftest.$ac_ext <<EOF
7761 #line 7762 "configure"
7762 #include "confdefs.h"
7763 /* System header to define __stub macros and hopefully few prototypes,
7764     which can conflict with char $ac_func(); below.  */
7765 #include <assert.h>
7766 /* Override any gcc2 internal prototype to avoid an error.  */
7767 /* We use char because int might match the return type of a gcc2
7768     builtin and then its argument prototype would still apply.  */
7769 char $ac_func();
7770
7771 int main() {
7772
7773 /* The GNU C library defines this for functions which it implements
7774     to always fail with ENOSYS.  Some functions are actually named
7775     something starting with __ and the normal name is an alias.  */
7776 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7777 choke me
7778 #else
7779 $ac_func();
7780 #endif
7781
7782 ; return 0; }
7783 EOF
7784 if { (eval echo configure:7785: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7785   rm -rf conftest*
7786   eval "ac_cv_func_$ac_func=yes"
7787 else
7788   echo "configure: failed program was:" >&5
7789   cat conftest.$ac_ext >&5
7790   rm -rf conftest*
7791   eval "ac_cv_func_$ac_func=no"
7792 fi
7793 rm -f conftest*
7794 fi
7795
7796 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7797   echo "$ac_t""yes" 1>&6
7798     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7799   cat >> confdefs.h <<EOF
7800 #define $ac_tr_func 1
7801 EOF
7802
7803 else
7804   echo "$ac_t""no" 1>&6
7805 fi
7806 done
7807
7808   fi
7809
7810
7811   echo $ac_n "checking for frexpf declaration""... $ac_c" 1>&6
7812 echo "configure:7813: checking for frexpf declaration" >&5
7813   if test x${glibcpp_cv_func_frexpf_use+set} != xset; then
7814     if eval "test \"`echo '$''{'glibcpp_cv_func_frexpf_use'+set}'`\" = set"; then
7815   echo $ac_n "(cached) $ac_c" 1>&6
7816 else
7817
7818
7819       ac_ext=C
7820 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7821 ac_cpp='$CXXCPP $CPPFLAGS'
7822 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7823 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7824 cross_compiling=$ac_cv_prog_cxx_cross
7825
7826       cat > conftest.$ac_ext <<EOF
7827 #line 7828 "configure"
7828 #include "confdefs.h"
7829 #include <math.h>
7830 int main() {
7831  frexpf(0, 0);
7832 ; return 0; }
7833 EOF
7834 if { (eval echo configure:7835: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7835   rm -rf conftest*
7836   glibcpp_cv_func_frexpf_use=yes
7837 else
7838   echo "configure: failed program was:" >&5
7839   cat conftest.$ac_ext >&5
7840   rm -rf conftest*
7841   glibcpp_cv_func_frexpf_use=no
7842 fi
7843 rm -f conftest*
7844       ac_ext=c
7845 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7846 ac_cpp='$CPP $CPPFLAGS'
7847 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7848 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7849 cross_compiling=$ac_cv_prog_cc_cross
7850
7851
7852 fi
7853
7854   fi
7855   echo "$ac_t""$glibcpp_cv_func_frexpf_use" 1>&6
7856   if test x$glibcpp_cv_func_frexpf_use = x"yes"; then
7857     for ac_func in frexpf
7858 do
7859 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7860 echo "configure:7861: checking for $ac_func" >&5
7861 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7862   echo $ac_n "(cached) $ac_c" 1>&6
7863 else
7864   cat > conftest.$ac_ext <<EOF
7865 #line 7866 "configure"
7866 #include "confdefs.h"
7867 /* System header to define __stub macros and hopefully few prototypes,
7868     which can conflict with char $ac_func(); below.  */
7869 #include <assert.h>
7870 /* Override any gcc2 internal prototype to avoid an error.  */
7871 /* We use char because int might match the return type of a gcc2
7872     builtin and then its argument prototype would still apply.  */
7873 char $ac_func();
7874
7875 int main() {
7876
7877 /* The GNU C library defines this for functions which it implements
7878     to always fail with ENOSYS.  Some functions are actually named
7879     something starting with __ and the normal name is an alias.  */
7880 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7881 choke me
7882 #else
7883 $ac_func();
7884 #endif
7885
7886 ; return 0; }
7887 EOF
7888 if { (eval echo configure:7889: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7889   rm -rf conftest*
7890   eval "ac_cv_func_$ac_func=yes"
7891 else
7892   echo "configure: failed program was:" >&5
7893   cat conftest.$ac_ext >&5
7894   rm -rf conftest*
7895   eval "ac_cv_func_$ac_func=no"
7896 fi
7897 rm -f conftest*
7898 fi
7899
7900 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
7901   echo "$ac_t""yes" 1>&6
7902     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
7903   cat >> confdefs.h <<EOF
7904 #define $ac_tr_func 1
7905 EOF
7906
7907 else
7908   echo "$ac_t""no" 1>&6
7909 fi
7910 done
7911
7912   fi
7913
7914
7915   echo $ac_n "checking for ldexpf declaration""... $ac_c" 1>&6
7916 echo "configure:7917: checking for ldexpf declaration" >&5
7917   if test x${glibcpp_cv_func_ldexpf_use+set} != xset; then
7918     if eval "test \"`echo '$''{'glibcpp_cv_func_ldexpf_use'+set}'`\" = set"; then
7919   echo $ac_n "(cached) $ac_c" 1>&6
7920 else
7921
7922
7923       ac_ext=C
7924 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7925 ac_cpp='$CXXCPP $CPPFLAGS'
7926 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7927 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7928 cross_compiling=$ac_cv_prog_cxx_cross
7929
7930       cat > conftest.$ac_ext <<EOF
7931 #line 7932 "configure"
7932 #include "confdefs.h"
7933 #include <math.h>
7934 int main() {
7935  ldexpf(0, 0);
7936 ; return 0; }
7937 EOF
7938 if { (eval echo configure:7939: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
7939   rm -rf conftest*
7940   glibcpp_cv_func_ldexpf_use=yes
7941 else
7942   echo "configure: failed program was:" >&5
7943   cat conftest.$ac_ext >&5
7944   rm -rf conftest*
7945   glibcpp_cv_func_ldexpf_use=no
7946 fi
7947 rm -f conftest*
7948       ac_ext=c
7949 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
7950 ac_cpp='$CPP $CPPFLAGS'
7951 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
7952 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
7953 cross_compiling=$ac_cv_prog_cc_cross
7954
7955
7956 fi
7957
7958   fi
7959   echo "$ac_t""$glibcpp_cv_func_ldexpf_use" 1>&6
7960   if test x$glibcpp_cv_func_ldexpf_use = x"yes"; then
7961     for ac_func in ldexpf
7962 do
7963 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
7964 echo "configure:7965: checking for $ac_func" >&5
7965 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
7966   echo $ac_n "(cached) $ac_c" 1>&6
7967 else
7968   cat > conftest.$ac_ext <<EOF
7969 #line 7970 "configure"
7970 #include "confdefs.h"
7971 /* System header to define __stub macros and hopefully few prototypes,
7972     which can conflict with char $ac_func(); below.  */
7973 #include <assert.h>
7974 /* Override any gcc2 internal prototype to avoid an error.  */
7975 /* We use char because int might match the return type of a gcc2
7976     builtin and then its argument prototype would still apply.  */
7977 char $ac_func();
7978
7979 int main() {
7980
7981 /* The GNU C library defines this for functions which it implements
7982     to always fail with ENOSYS.  Some functions are actually named
7983     something starting with __ and the normal name is an alias.  */
7984 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7985 choke me
7986 #else
7987 $ac_func();
7988 #endif
7989
7990 ; return 0; }
7991 EOF
7992 if { (eval echo configure:7993: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
7993   rm -rf conftest*
7994   eval "ac_cv_func_$ac_func=yes"
7995 else
7996   echo "configure: failed program was:" >&5
7997   cat conftest.$ac_ext >&5
7998   rm -rf conftest*
7999   eval "ac_cv_func_$ac_func=no"
8000 fi
8001 rm -f conftest*
8002 fi
8003
8004 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8005   echo "$ac_t""yes" 1>&6
8006     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8007   cat >> confdefs.h <<EOF
8008 #define $ac_tr_func 1
8009 EOF
8010
8011 else
8012   echo "$ac_t""no" 1>&6
8013 fi
8014 done
8015
8016   fi
8017
8018
8019   echo $ac_n "checking for logf declaration""... $ac_c" 1>&6
8020 echo "configure:8021: checking for logf declaration" >&5
8021   if test x${glibcpp_cv_func_logf_use+set} != xset; then
8022     if eval "test \"`echo '$''{'glibcpp_cv_func_logf_use'+set}'`\" = set"; then
8023   echo $ac_n "(cached) $ac_c" 1>&6
8024 else
8025
8026
8027       ac_ext=C
8028 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8029 ac_cpp='$CXXCPP $CPPFLAGS'
8030 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8031 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8032 cross_compiling=$ac_cv_prog_cxx_cross
8033
8034       cat > conftest.$ac_ext <<EOF
8035 #line 8036 "configure"
8036 #include "confdefs.h"
8037 #include <math.h>
8038 int main() {
8039  logf(0);
8040 ; return 0; }
8041 EOF
8042 if { (eval echo configure:8043: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8043   rm -rf conftest*
8044   glibcpp_cv_func_logf_use=yes
8045 else
8046   echo "configure: failed program was:" >&5
8047   cat conftest.$ac_ext >&5
8048   rm -rf conftest*
8049   glibcpp_cv_func_logf_use=no
8050 fi
8051 rm -f conftest*
8052       ac_ext=c
8053 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8054 ac_cpp='$CPP $CPPFLAGS'
8055 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8056 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8057 cross_compiling=$ac_cv_prog_cc_cross
8058
8059
8060 fi
8061
8062   fi
8063   echo "$ac_t""$glibcpp_cv_func_logf_use" 1>&6
8064   if test x$glibcpp_cv_func_logf_use = x"yes"; then
8065     for ac_func in logf
8066 do
8067 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8068 echo "configure:8069: checking for $ac_func" >&5
8069 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8070   echo $ac_n "(cached) $ac_c" 1>&6
8071 else
8072   cat > conftest.$ac_ext <<EOF
8073 #line 8074 "configure"
8074 #include "confdefs.h"
8075 /* System header to define __stub macros and hopefully few prototypes,
8076     which can conflict with char $ac_func(); below.  */
8077 #include <assert.h>
8078 /* Override any gcc2 internal prototype to avoid an error.  */
8079 /* We use char because int might match the return type of a gcc2
8080     builtin and then its argument prototype would still apply.  */
8081 char $ac_func();
8082
8083 int main() {
8084
8085 /* The GNU C library defines this for functions which it implements
8086     to always fail with ENOSYS.  Some functions are actually named
8087     something starting with __ and the normal name is an alias.  */
8088 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8089 choke me
8090 #else
8091 $ac_func();
8092 #endif
8093
8094 ; return 0; }
8095 EOF
8096 if { (eval echo configure:8097: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8097   rm -rf conftest*
8098   eval "ac_cv_func_$ac_func=yes"
8099 else
8100   echo "configure: failed program was:" >&5
8101   cat conftest.$ac_ext >&5
8102   rm -rf conftest*
8103   eval "ac_cv_func_$ac_func=no"
8104 fi
8105 rm -f conftest*
8106 fi
8107
8108 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8109   echo "$ac_t""yes" 1>&6
8110     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8111   cat >> confdefs.h <<EOF
8112 #define $ac_tr_func 1
8113 EOF
8114
8115 else
8116   echo "$ac_t""no" 1>&6
8117 fi
8118 done
8119
8120   fi
8121
8122
8123   echo $ac_n "checking for log10f declaration""... $ac_c" 1>&6
8124 echo "configure:8125: checking for log10f declaration" >&5
8125   if test x${glibcpp_cv_func_log10f_use+set} != xset; then
8126     if eval "test \"`echo '$''{'glibcpp_cv_func_log10f_use'+set}'`\" = set"; then
8127   echo $ac_n "(cached) $ac_c" 1>&6
8128 else
8129
8130
8131       ac_ext=C
8132 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8133 ac_cpp='$CXXCPP $CPPFLAGS'
8134 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8135 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8136 cross_compiling=$ac_cv_prog_cxx_cross
8137
8138       cat > conftest.$ac_ext <<EOF
8139 #line 8140 "configure"
8140 #include "confdefs.h"
8141 #include <math.h>
8142 int main() {
8143  log10f(0);
8144 ; return 0; }
8145 EOF
8146 if { (eval echo configure:8147: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8147   rm -rf conftest*
8148   glibcpp_cv_func_log10f_use=yes
8149 else
8150   echo "configure: failed program was:" >&5
8151   cat conftest.$ac_ext >&5
8152   rm -rf conftest*
8153   glibcpp_cv_func_log10f_use=no
8154 fi
8155 rm -f conftest*
8156       ac_ext=c
8157 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8158 ac_cpp='$CPP $CPPFLAGS'
8159 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8160 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8161 cross_compiling=$ac_cv_prog_cc_cross
8162
8163
8164 fi
8165
8166   fi
8167   echo "$ac_t""$glibcpp_cv_func_log10f_use" 1>&6
8168   if test x$glibcpp_cv_func_log10f_use = x"yes"; then
8169     for ac_func in log10f
8170 do
8171 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8172 echo "configure:8173: checking for $ac_func" >&5
8173 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8174   echo $ac_n "(cached) $ac_c" 1>&6
8175 else
8176   cat > conftest.$ac_ext <<EOF
8177 #line 8178 "configure"
8178 #include "confdefs.h"
8179 /* System header to define __stub macros and hopefully few prototypes,
8180     which can conflict with char $ac_func(); below.  */
8181 #include <assert.h>
8182 /* Override any gcc2 internal prototype to avoid an error.  */
8183 /* We use char because int might match the return type of a gcc2
8184     builtin and then its argument prototype would still apply.  */
8185 char $ac_func();
8186
8187 int main() {
8188
8189 /* The GNU C library defines this for functions which it implements
8190     to always fail with ENOSYS.  Some functions are actually named
8191     something starting with __ and the normal name is an alias.  */
8192 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8193 choke me
8194 #else
8195 $ac_func();
8196 #endif
8197
8198 ; return 0; }
8199 EOF
8200 if { (eval echo configure:8201: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8201   rm -rf conftest*
8202   eval "ac_cv_func_$ac_func=yes"
8203 else
8204   echo "configure: failed program was:" >&5
8205   cat conftest.$ac_ext >&5
8206   rm -rf conftest*
8207   eval "ac_cv_func_$ac_func=no"
8208 fi
8209 rm -f conftest*
8210 fi
8211
8212 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8213   echo "$ac_t""yes" 1>&6
8214     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8215   cat >> confdefs.h <<EOF
8216 #define $ac_tr_func 1
8217 EOF
8218
8219 else
8220   echo "$ac_t""no" 1>&6
8221 fi
8222 done
8223
8224   fi
8225
8226
8227   echo $ac_n "checking for modff declaration""... $ac_c" 1>&6
8228 echo "configure:8229: checking for modff declaration" >&5
8229   if test x${glibcpp_cv_func_modff_use+set} != xset; then
8230     if eval "test \"`echo '$''{'glibcpp_cv_func_modff_use'+set}'`\" = set"; then
8231   echo $ac_n "(cached) $ac_c" 1>&6
8232 else
8233
8234
8235       ac_ext=C
8236 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8237 ac_cpp='$CXXCPP $CPPFLAGS'
8238 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8239 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8240 cross_compiling=$ac_cv_prog_cxx_cross
8241
8242       cat > conftest.$ac_ext <<EOF
8243 #line 8244 "configure"
8244 #include "confdefs.h"
8245 #include <math.h>
8246 int main() {
8247  modff(0, 0);
8248 ; return 0; }
8249 EOF
8250 if { (eval echo configure:8251: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8251   rm -rf conftest*
8252   glibcpp_cv_func_modff_use=yes
8253 else
8254   echo "configure: failed program was:" >&5
8255   cat conftest.$ac_ext >&5
8256   rm -rf conftest*
8257   glibcpp_cv_func_modff_use=no
8258 fi
8259 rm -f conftest*
8260       ac_ext=c
8261 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8262 ac_cpp='$CPP $CPPFLAGS'
8263 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8264 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8265 cross_compiling=$ac_cv_prog_cc_cross
8266
8267
8268 fi
8269
8270   fi
8271   echo "$ac_t""$glibcpp_cv_func_modff_use" 1>&6
8272   if test x$glibcpp_cv_func_modff_use = x"yes"; then
8273     for ac_func in modff
8274 do
8275 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8276 echo "configure:8277: checking for $ac_func" >&5
8277 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8278   echo $ac_n "(cached) $ac_c" 1>&6
8279 else
8280   cat > conftest.$ac_ext <<EOF
8281 #line 8282 "configure"
8282 #include "confdefs.h"
8283 /* System header to define __stub macros and hopefully few prototypes,
8284     which can conflict with char $ac_func(); below.  */
8285 #include <assert.h>
8286 /* Override any gcc2 internal prototype to avoid an error.  */
8287 /* We use char because int might match the return type of a gcc2
8288     builtin and then its argument prototype would still apply.  */
8289 char $ac_func();
8290
8291 int main() {
8292
8293 /* The GNU C library defines this for functions which it implements
8294     to always fail with ENOSYS.  Some functions are actually named
8295     something starting with __ and the normal name is an alias.  */
8296 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8297 choke me
8298 #else
8299 $ac_func();
8300 #endif
8301
8302 ; return 0; }
8303 EOF
8304 if { (eval echo configure:8305: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8305   rm -rf conftest*
8306   eval "ac_cv_func_$ac_func=yes"
8307 else
8308   echo "configure: failed program was:" >&5
8309   cat conftest.$ac_ext >&5
8310   rm -rf conftest*
8311   eval "ac_cv_func_$ac_func=no"
8312 fi
8313 rm -f conftest*
8314 fi
8315
8316 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8317   echo "$ac_t""yes" 1>&6
8318     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8319   cat >> confdefs.h <<EOF
8320 #define $ac_tr_func 1
8321 EOF
8322
8323 else
8324   echo "$ac_t""no" 1>&6
8325 fi
8326 done
8327
8328   fi
8329
8330
8331   echo $ac_n "checking for powf declaration""... $ac_c" 1>&6
8332 echo "configure:8333: checking for powf declaration" >&5
8333   if test x${glibcpp_cv_func_powf_use+set} != xset; then
8334     if eval "test \"`echo '$''{'glibcpp_cv_func_powf_use'+set}'`\" = set"; then
8335   echo $ac_n "(cached) $ac_c" 1>&6
8336 else
8337
8338
8339       ac_ext=C
8340 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8341 ac_cpp='$CXXCPP $CPPFLAGS'
8342 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8343 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8344 cross_compiling=$ac_cv_prog_cxx_cross
8345
8346       cat > conftest.$ac_ext <<EOF
8347 #line 8348 "configure"
8348 #include "confdefs.h"
8349 #include <math.h>
8350 int main() {
8351  powf(0, 0);
8352 ; return 0; }
8353 EOF
8354 if { (eval echo configure:8355: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8355   rm -rf conftest*
8356   glibcpp_cv_func_powf_use=yes
8357 else
8358   echo "configure: failed program was:" >&5
8359   cat conftest.$ac_ext >&5
8360   rm -rf conftest*
8361   glibcpp_cv_func_powf_use=no
8362 fi
8363 rm -f conftest*
8364       ac_ext=c
8365 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8366 ac_cpp='$CPP $CPPFLAGS'
8367 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8368 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8369 cross_compiling=$ac_cv_prog_cc_cross
8370
8371
8372 fi
8373
8374   fi
8375   echo "$ac_t""$glibcpp_cv_func_powf_use" 1>&6
8376   if test x$glibcpp_cv_func_powf_use = x"yes"; then
8377     for ac_func in powf
8378 do
8379 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8380 echo "configure:8381: checking for $ac_func" >&5
8381 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8382   echo $ac_n "(cached) $ac_c" 1>&6
8383 else
8384   cat > conftest.$ac_ext <<EOF
8385 #line 8386 "configure"
8386 #include "confdefs.h"
8387 /* System header to define __stub macros and hopefully few prototypes,
8388     which can conflict with char $ac_func(); below.  */
8389 #include <assert.h>
8390 /* Override any gcc2 internal prototype to avoid an error.  */
8391 /* We use char because int might match the return type of a gcc2
8392     builtin and then its argument prototype would still apply.  */
8393 char $ac_func();
8394
8395 int main() {
8396
8397 /* The GNU C library defines this for functions which it implements
8398     to always fail with ENOSYS.  Some functions are actually named
8399     something starting with __ and the normal name is an alias.  */
8400 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8401 choke me
8402 #else
8403 $ac_func();
8404 #endif
8405
8406 ; return 0; }
8407 EOF
8408 if { (eval echo configure:8409: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8409   rm -rf conftest*
8410   eval "ac_cv_func_$ac_func=yes"
8411 else
8412   echo "configure: failed program was:" >&5
8413   cat conftest.$ac_ext >&5
8414   rm -rf conftest*
8415   eval "ac_cv_func_$ac_func=no"
8416 fi
8417 rm -f conftest*
8418 fi
8419
8420 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8421   echo "$ac_t""yes" 1>&6
8422     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8423   cat >> confdefs.h <<EOF
8424 #define $ac_tr_func 1
8425 EOF
8426
8427 else
8428   echo "$ac_t""no" 1>&6
8429 fi
8430 done
8431
8432   fi
8433
8434
8435   echo $ac_n "checking for sinf declaration""... $ac_c" 1>&6
8436 echo "configure:8437: checking for sinf declaration" >&5
8437   if test x${glibcpp_cv_func_sinf_use+set} != xset; then
8438     if eval "test \"`echo '$''{'glibcpp_cv_func_sinf_use'+set}'`\" = set"; then
8439   echo $ac_n "(cached) $ac_c" 1>&6
8440 else
8441
8442
8443       ac_ext=C
8444 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8445 ac_cpp='$CXXCPP $CPPFLAGS'
8446 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8447 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8448 cross_compiling=$ac_cv_prog_cxx_cross
8449
8450       cat > conftest.$ac_ext <<EOF
8451 #line 8452 "configure"
8452 #include "confdefs.h"
8453 #include <math.h>
8454 int main() {
8455  sinf(0);
8456 ; return 0; }
8457 EOF
8458 if { (eval echo configure:8459: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8459   rm -rf conftest*
8460   glibcpp_cv_func_sinf_use=yes
8461 else
8462   echo "configure: failed program was:" >&5
8463   cat conftest.$ac_ext >&5
8464   rm -rf conftest*
8465   glibcpp_cv_func_sinf_use=no
8466 fi
8467 rm -f conftest*
8468       ac_ext=c
8469 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8470 ac_cpp='$CPP $CPPFLAGS'
8471 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8472 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8473 cross_compiling=$ac_cv_prog_cc_cross
8474
8475
8476 fi
8477
8478   fi
8479   echo "$ac_t""$glibcpp_cv_func_sinf_use" 1>&6
8480   if test x$glibcpp_cv_func_sinf_use = x"yes"; then
8481     for ac_func in sinf
8482 do
8483 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8484 echo "configure:8485: checking for $ac_func" >&5
8485 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8486   echo $ac_n "(cached) $ac_c" 1>&6
8487 else
8488   cat > conftest.$ac_ext <<EOF
8489 #line 8490 "configure"
8490 #include "confdefs.h"
8491 /* System header to define __stub macros and hopefully few prototypes,
8492     which can conflict with char $ac_func(); below.  */
8493 #include <assert.h>
8494 /* Override any gcc2 internal prototype to avoid an error.  */
8495 /* We use char because int might match the return type of a gcc2
8496     builtin and then its argument prototype would still apply.  */
8497 char $ac_func();
8498
8499 int main() {
8500
8501 /* The GNU C library defines this for functions which it implements
8502     to always fail with ENOSYS.  Some functions are actually named
8503     something starting with __ and the normal name is an alias.  */
8504 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8505 choke me
8506 #else
8507 $ac_func();
8508 #endif
8509
8510 ; return 0; }
8511 EOF
8512 if { (eval echo configure:8513: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8513   rm -rf conftest*
8514   eval "ac_cv_func_$ac_func=yes"
8515 else
8516   echo "configure: failed program was:" >&5
8517   cat conftest.$ac_ext >&5
8518   rm -rf conftest*
8519   eval "ac_cv_func_$ac_func=no"
8520 fi
8521 rm -f conftest*
8522 fi
8523
8524 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8525   echo "$ac_t""yes" 1>&6
8526     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8527   cat >> confdefs.h <<EOF
8528 #define $ac_tr_func 1
8529 EOF
8530
8531 else
8532   echo "$ac_t""no" 1>&6
8533 fi
8534 done
8535
8536   fi
8537
8538
8539   echo $ac_n "checking for sinhf declaration""... $ac_c" 1>&6
8540 echo "configure:8541: checking for sinhf declaration" >&5
8541   if test x${glibcpp_cv_func_sinhf_use+set} != xset; then
8542     if eval "test \"`echo '$''{'glibcpp_cv_func_sinhf_use'+set}'`\" = set"; then
8543   echo $ac_n "(cached) $ac_c" 1>&6
8544 else
8545
8546
8547       ac_ext=C
8548 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8549 ac_cpp='$CXXCPP $CPPFLAGS'
8550 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8551 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8552 cross_compiling=$ac_cv_prog_cxx_cross
8553
8554       cat > conftest.$ac_ext <<EOF
8555 #line 8556 "configure"
8556 #include "confdefs.h"
8557 #include <math.h>
8558 int main() {
8559  sinhf(0);
8560 ; return 0; }
8561 EOF
8562 if { (eval echo configure:8563: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8563   rm -rf conftest*
8564   glibcpp_cv_func_sinhf_use=yes
8565 else
8566   echo "configure: failed program was:" >&5
8567   cat conftest.$ac_ext >&5
8568   rm -rf conftest*
8569   glibcpp_cv_func_sinhf_use=no
8570 fi
8571 rm -f conftest*
8572       ac_ext=c
8573 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8574 ac_cpp='$CPP $CPPFLAGS'
8575 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8576 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8577 cross_compiling=$ac_cv_prog_cc_cross
8578
8579
8580 fi
8581
8582   fi
8583   echo "$ac_t""$glibcpp_cv_func_sinhf_use" 1>&6
8584   if test x$glibcpp_cv_func_sinhf_use = x"yes"; then
8585     for ac_func in sinhf
8586 do
8587 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8588 echo "configure:8589: checking for $ac_func" >&5
8589 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8590   echo $ac_n "(cached) $ac_c" 1>&6
8591 else
8592   cat > conftest.$ac_ext <<EOF
8593 #line 8594 "configure"
8594 #include "confdefs.h"
8595 /* System header to define __stub macros and hopefully few prototypes,
8596     which can conflict with char $ac_func(); below.  */
8597 #include <assert.h>
8598 /* Override any gcc2 internal prototype to avoid an error.  */
8599 /* We use char because int might match the return type of a gcc2
8600     builtin and then its argument prototype would still apply.  */
8601 char $ac_func();
8602
8603 int main() {
8604
8605 /* The GNU C library defines this for functions which it implements
8606     to always fail with ENOSYS.  Some functions are actually named
8607     something starting with __ and the normal name is an alias.  */
8608 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8609 choke me
8610 #else
8611 $ac_func();
8612 #endif
8613
8614 ; return 0; }
8615 EOF
8616 if { (eval echo configure:8617: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8617   rm -rf conftest*
8618   eval "ac_cv_func_$ac_func=yes"
8619 else
8620   echo "configure: failed program was:" >&5
8621   cat conftest.$ac_ext >&5
8622   rm -rf conftest*
8623   eval "ac_cv_func_$ac_func=no"
8624 fi
8625 rm -f conftest*
8626 fi
8627
8628 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8629   echo "$ac_t""yes" 1>&6
8630     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8631   cat >> confdefs.h <<EOF
8632 #define $ac_tr_func 1
8633 EOF
8634
8635 else
8636   echo "$ac_t""no" 1>&6
8637 fi
8638 done
8639
8640   fi
8641
8642
8643   echo $ac_n "checking for sqrtf declaration""... $ac_c" 1>&6
8644 echo "configure:8645: checking for sqrtf declaration" >&5
8645   if test x${glibcpp_cv_func_sqrtf_use+set} != xset; then
8646     if eval "test \"`echo '$''{'glibcpp_cv_func_sqrtf_use'+set}'`\" = set"; then
8647   echo $ac_n "(cached) $ac_c" 1>&6
8648 else
8649
8650
8651       ac_ext=C
8652 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8653 ac_cpp='$CXXCPP $CPPFLAGS'
8654 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8655 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8656 cross_compiling=$ac_cv_prog_cxx_cross
8657
8658       cat > conftest.$ac_ext <<EOF
8659 #line 8660 "configure"
8660 #include "confdefs.h"
8661 #include <math.h>
8662 int main() {
8663  sqrtf(0);
8664 ; return 0; }
8665 EOF
8666 if { (eval echo configure:8667: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8667   rm -rf conftest*
8668   glibcpp_cv_func_sqrtf_use=yes
8669 else
8670   echo "configure: failed program was:" >&5
8671   cat conftest.$ac_ext >&5
8672   rm -rf conftest*
8673   glibcpp_cv_func_sqrtf_use=no
8674 fi
8675 rm -f conftest*
8676       ac_ext=c
8677 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8678 ac_cpp='$CPP $CPPFLAGS'
8679 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8680 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8681 cross_compiling=$ac_cv_prog_cc_cross
8682
8683
8684 fi
8685
8686   fi
8687   echo "$ac_t""$glibcpp_cv_func_sqrtf_use" 1>&6
8688   if test x$glibcpp_cv_func_sqrtf_use = x"yes"; then
8689     for ac_func in sqrtf
8690 do
8691 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8692 echo "configure:8693: checking for $ac_func" >&5
8693 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8694   echo $ac_n "(cached) $ac_c" 1>&6
8695 else
8696   cat > conftest.$ac_ext <<EOF
8697 #line 8698 "configure"
8698 #include "confdefs.h"
8699 /* System header to define __stub macros and hopefully few prototypes,
8700     which can conflict with char $ac_func(); below.  */
8701 #include <assert.h>
8702 /* Override any gcc2 internal prototype to avoid an error.  */
8703 /* We use char because int might match the return type of a gcc2
8704     builtin and then its argument prototype would still apply.  */
8705 char $ac_func();
8706
8707 int main() {
8708
8709 /* The GNU C library defines this for functions which it implements
8710     to always fail with ENOSYS.  Some functions are actually named
8711     something starting with __ and the normal name is an alias.  */
8712 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8713 choke me
8714 #else
8715 $ac_func();
8716 #endif
8717
8718 ; return 0; }
8719 EOF
8720 if { (eval echo configure:8721: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8721   rm -rf conftest*
8722   eval "ac_cv_func_$ac_func=yes"
8723 else
8724   echo "configure: failed program was:" >&5
8725   cat conftest.$ac_ext >&5
8726   rm -rf conftest*
8727   eval "ac_cv_func_$ac_func=no"
8728 fi
8729 rm -f conftest*
8730 fi
8731
8732 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8733   echo "$ac_t""yes" 1>&6
8734     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8735   cat >> confdefs.h <<EOF
8736 #define $ac_tr_func 1
8737 EOF
8738
8739 else
8740   echo "$ac_t""no" 1>&6
8741 fi
8742 done
8743
8744   fi
8745
8746
8747   echo $ac_n "checking for tanf declaration""... $ac_c" 1>&6
8748 echo "configure:8749: checking for tanf declaration" >&5
8749   if test x${glibcpp_cv_func_tanf_use+set} != xset; then
8750     if eval "test \"`echo '$''{'glibcpp_cv_func_tanf_use'+set}'`\" = set"; then
8751   echo $ac_n "(cached) $ac_c" 1>&6
8752 else
8753
8754
8755       ac_ext=C
8756 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8757 ac_cpp='$CXXCPP $CPPFLAGS'
8758 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8759 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8760 cross_compiling=$ac_cv_prog_cxx_cross
8761
8762       cat > conftest.$ac_ext <<EOF
8763 #line 8764 "configure"
8764 #include "confdefs.h"
8765 #include <math.h>
8766 int main() {
8767  tanf(0);
8768 ; return 0; }
8769 EOF
8770 if { (eval echo configure:8771: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8771   rm -rf conftest*
8772   glibcpp_cv_func_tanf_use=yes
8773 else
8774   echo "configure: failed program was:" >&5
8775   cat conftest.$ac_ext >&5
8776   rm -rf conftest*
8777   glibcpp_cv_func_tanf_use=no
8778 fi
8779 rm -f conftest*
8780       ac_ext=c
8781 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8782 ac_cpp='$CPP $CPPFLAGS'
8783 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8784 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8785 cross_compiling=$ac_cv_prog_cc_cross
8786
8787
8788 fi
8789
8790   fi
8791   echo "$ac_t""$glibcpp_cv_func_tanf_use" 1>&6
8792   if test x$glibcpp_cv_func_tanf_use = x"yes"; then
8793     for ac_func in tanf
8794 do
8795 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8796 echo "configure:8797: checking for $ac_func" >&5
8797 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8798   echo $ac_n "(cached) $ac_c" 1>&6
8799 else
8800   cat > conftest.$ac_ext <<EOF
8801 #line 8802 "configure"
8802 #include "confdefs.h"
8803 /* System header to define __stub macros and hopefully few prototypes,
8804     which can conflict with char $ac_func(); below.  */
8805 #include <assert.h>
8806 /* Override any gcc2 internal prototype to avoid an error.  */
8807 /* We use char because int might match the return type of a gcc2
8808     builtin and then its argument prototype would still apply.  */
8809 char $ac_func();
8810
8811 int main() {
8812
8813 /* The GNU C library defines this for functions which it implements
8814     to always fail with ENOSYS.  Some functions are actually named
8815     something starting with __ and the normal name is an alias.  */
8816 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8817 choke me
8818 #else
8819 $ac_func();
8820 #endif
8821
8822 ; return 0; }
8823 EOF
8824 if { (eval echo configure:8825: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8825   rm -rf conftest*
8826   eval "ac_cv_func_$ac_func=yes"
8827 else
8828   echo "configure: failed program was:" >&5
8829   cat conftest.$ac_ext >&5
8830   rm -rf conftest*
8831   eval "ac_cv_func_$ac_func=no"
8832 fi
8833 rm -f conftest*
8834 fi
8835
8836 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8837   echo "$ac_t""yes" 1>&6
8838     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8839   cat >> confdefs.h <<EOF
8840 #define $ac_tr_func 1
8841 EOF
8842
8843 else
8844   echo "$ac_t""no" 1>&6
8845 fi
8846 done
8847
8848   fi
8849
8850
8851   echo $ac_n "checking for tanhf declaration""... $ac_c" 1>&6
8852 echo "configure:8853: checking for tanhf declaration" >&5
8853   if test x${glibcpp_cv_func_tanhf_use+set} != xset; then
8854     if eval "test \"`echo '$''{'glibcpp_cv_func_tanhf_use'+set}'`\" = set"; then
8855   echo $ac_n "(cached) $ac_c" 1>&6
8856 else
8857
8858
8859       ac_ext=C
8860 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8861 ac_cpp='$CXXCPP $CPPFLAGS'
8862 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8863 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8864 cross_compiling=$ac_cv_prog_cxx_cross
8865
8866       cat > conftest.$ac_ext <<EOF
8867 #line 8868 "configure"
8868 #include "confdefs.h"
8869 #include <math.h>
8870 int main() {
8871  tanhf(0);
8872 ; return 0; }
8873 EOF
8874 if { (eval echo configure:8875: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8875   rm -rf conftest*
8876   glibcpp_cv_func_tanhf_use=yes
8877 else
8878   echo "configure: failed program was:" >&5
8879   cat conftest.$ac_ext >&5
8880   rm -rf conftest*
8881   glibcpp_cv_func_tanhf_use=no
8882 fi
8883 rm -f conftest*
8884       ac_ext=c
8885 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8886 ac_cpp='$CPP $CPPFLAGS'
8887 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8888 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8889 cross_compiling=$ac_cv_prog_cc_cross
8890
8891
8892 fi
8893
8894   fi
8895   echo "$ac_t""$glibcpp_cv_func_tanhf_use" 1>&6
8896   if test x$glibcpp_cv_func_tanhf_use = x"yes"; then
8897     for ac_func in tanhf
8898 do
8899 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
8900 echo "configure:8901: checking for $ac_func" >&5
8901 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
8902   echo $ac_n "(cached) $ac_c" 1>&6
8903 else
8904   cat > conftest.$ac_ext <<EOF
8905 #line 8906 "configure"
8906 #include "confdefs.h"
8907 /* System header to define __stub macros and hopefully few prototypes,
8908     which can conflict with char $ac_func(); below.  */
8909 #include <assert.h>
8910 /* Override any gcc2 internal prototype to avoid an error.  */
8911 /* We use char because int might match the return type of a gcc2
8912     builtin and then its argument prototype would still apply.  */
8913 char $ac_func();
8914
8915 int main() {
8916
8917 /* The GNU C library defines this for functions which it implements
8918     to always fail with ENOSYS.  Some functions are actually named
8919     something starting with __ and the normal name is an alias.  */
8920 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8921 choke me
8922 #else
8923 $ac_func();
8924 #endif
8925
8926 ; return 0; }
8927 EOF
8928 if { (eval echo configure:8929: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
8929   rm -rf conftest*
8930   eval "ac_cv_func_$ac_func=yes"
8931 else
8932   echo "configure: failed program was:" >&5
8933   cat conftest.$ac_ext >&5
8934   rm -rf conftest*
8935   eval "ac_cv_func_$ac_func=no"
8936 fi
8937 rm -f conftest*
8938 fi
8939
8940 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
8941   echo "$ac_t""yes" 1>&6
8942     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
8943   cat >> confdefs.h <<EOF
8944 #define $ac_tr_func 1
8945 EOF
8946
8947 else
8948   echo "$ac_t""no" 1>&6
8949 fi
8950 done
8951
8952   fi
8953
8954
8955   echo $ac_n "checking for sincosf declaration""... $ac_c" 1>&6
8956 echo "configure:8957: checking for sincosf declaration" >&5
8957   if test x${glibcpp_cv_func_sincosf_use+set} != xset; then
8958     if eval "test \"`echo '$''{'glibcpp_cv_func_sincosf_use'+set}'`\" = set"; then
8959   echo $ac_n "(cached) $ac_c" 1>&6
8960 else
8961
8962
8963       ac_ext=C
8964 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8965 ac_cpp='$CXXCPP $CPPFLAGS'
8966 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8967 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8968 cross_compiling=$ac_cv_prog_cxx_cross
8969
8970       cat > conftest.$ac_ext <<EOF
8971 #line 8972 "configure"
8972 #include "confdefs.h"
8973 #include <math.h>
8974 int main() {
8975  sincosf(0, 0, 0);
8976 ; return 0; }
8977 EOF
8978 if { (eval echo configure:8979: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
8979   rm -rf conftest*
8980   glibcpp_cv_func_sincosf_use=yes
8981 else
8982   echo "configure: failed program was:" >&5
8983   cat conftest.$ac_ext >&5
8984   rm -rf conftest*
8985   glibcpp_cv_func_sincosf_use=no
8986 fi
8987 rm -f conftest*
8988       ac_ext=c
8989 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
8990 ac_cpp='$CPP $CPPFLAGS'
8991 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
8992 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
8993 cross_compiling=$ac_cv_prog_cc_cross
8994
8995
8996 fi
8997
8998   fi
8999   echo "$ac_t""$glibcpp_cv_func_sincosf_use" 1>&6
9000   if test x$glibcpp_cv_func_sincosf_use = x"yes"; then
9001     for ac_func in sincosf
9002 do
9003 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9004 echo "configure:9005: checking for $ac_func" >&5
9005 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9006   echo $ac_n "(cached) $ac_c" 1>&6
9007 else
9008   cat > conftest.$ac_ext <<EOF
9009 #line 9010 "configure"
9010 #include "confdefs.h"
9011 /* System header to define __stub macros and hopefully few prototypes,
9012     which can conflict with char $ac_func(); below.  */
9013 #include <assert.h>
9014 /* Override any gcc2 internal prototype to avoid an error.  */
9015 /* We use char because int might match the return type of a gcc2
9016     builtin and then its argument prototype would still apply.  */
9017 char $ac_func();
9018
9019 int main() {
9020
9021 /* The GNU C library defines this for functions which it implements
9022     to always fail with ENOSYS.  Some functions are actually named
9023     something starting with __ and the normal name is an alias.  */
9024 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9025 choke me
9026 #else
9027 $ac_func();
9028 #endif
9029
9030 ; return 0; }
9031 EOF
9032 if { (eval echo configure:9033: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9033   rm -rf conftest*
9034   eval "ac_cv_func_$ac_func=yes"
9035 else
9036   echo "configure: failed program was:" >&5
9037   cat conftest.$ac_ext >&5
9038   rm -rf conftest*
9039   eval "ac_cv_func_$ac_func=no"
9040 fi
9041 rm -f conftest*
9042 fi
9043
9044 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9045   echo "$ac_t""yes" 1>&6
9046     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9047   cat >> confdefs.h <<EOF
9048 #define $ac_tr_func 1
9049 EOF
9050
9051 else
9052   echo "$ac_t""no" 1>&6
9053 fi
9054 done
9055
9056   fi
9057
9058
9059   echo $ac_n "checking for finitef declaration""... $ac_c" 1>&6
9060 echo "configure:9061: checking for finitef declaration" >&5
9061   if test x${glibcpp_cv_func_finitef_use+set} != xset; then
9062     if eval "test \"`echo '$''{'glibcpp_cv_func_finitef_use'+set}'`\" = set"; then
9063   echo $ac_n "(cached) $ac_c" 1>&6
9064 else
9065
9066
9067       ac_ext=C
9068 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9069 ac_cpp='$CXXCPP $CPPFLAGS'
9070 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9071 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9072 cross_compiling=$ac_cv_prog_cxx_cross
9073
9074       cat > conftest.$ac_ext <<EOF
9075 #line 9076 "configure"
9076 #include "confdefs.h"
9077 #include <math.h>
9078 int main() {
9079  finitef(0);
9080 ; return 0; }
9081 EOF
9082 if { (eval echo configure:9083: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9083   rm -rf conftest*
9084   glibcpp_cv_func_finitef_use=yes
9085 else
9086   echo "configure: failed program was:" >&5
9087   cat conftest.$ac_ext >&5
9088   rm -rf conftest*
9089   glibcpp_cv_func_finitef_use=no
9090 fi
9091 rm -f conftest*
9092       ac_ext=c
9093 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9094 ac_cpp='$CPP $CPPFLAGS'
9095 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9096 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9097 cross_compiling=$ac_cv_prog_cc_cross
9098
9099
9100 fi
9101
9102   fi
9103   echo "$ac_t""$glibcpp_cv_func_finitef_use" 1>&6
9104   if test x$glibcpp_cv_func_finitef_use = x"yes"; then
9105     for ac_func in finitef
9106 do
9107 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9108 echo "configure:9109: checking for $ac_func" >&5
9109 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9110   echo $ac_n "(cached) $ac_c" 1>&6
9111 else
9112   cat > conftest.$ac_ext <<EOF
9113 #line 9114 "configure"
9114 #include "confdefs.h"
9115 /* System header to define __stub macros and hopefully few prototypes,
9116     which can conflict with char $ac_func(); below.  */
9117 #include <assert.h>
9118 /* Override any gcc2 internal prototype to avoid an error.  */
9119 /* We use char because int might match the return type of a gcc2
9120     builtin and then its argument prototype would still apply.  */
9121 char $ac_func();
9122
9123 int main() {
9124
9125 /* The GNU C library defines this for functions which it implements
9126     to always fail with ENOSYS.  Some functions are actually named
9127     something starting with __ and the normal name is an alias.  */
9128 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9129 choke me
9130 #else
9131 $ac_func();
9132 #endif
9133
9134 ; return 0; }
9135 EOF
9136 if { (eval echo configure:9137: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9137   rm -rf conftest*
9138   eval "ac_cv_func_$ac_func=yes"
9139 else
9140   echo "configure: failed program was:" >&5
9141   cat conftest.$ac_ext >&5
9142   rm -rf conftest*
9143   eval "ac_cv_func_$ac_func=no"
9144 fi
9145 rm -f conftest*
9146 fi
9147
9148 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9149   echo "$ac_t""yes" 1>&6
9150     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9151   cat >> confdefs.h <<EOF
9152 #define $ac_tr_func 1
9153 EOF
9154
9155 else
9156   echo "$ac_t""no" 1>&6
9157 fi
9158 done
9159
9160   fi
9161
9162
9163
9164   echo $ac_n "checking for isnanl declaration""... $ac_c" 1>&6
9165 echo "configure:9166: checking for isnanl declaration" >&5
9166   if test x${glibcpp_cv_func_isnanl_use+set} != xset; then
9167     if eval "test \"`echo '$''{'glibcpp_cv_func_isnanl_use'+set}'`\" = set"; then
9168   echo $ac_n "(cached) $ac_c" 1>&6
9169 else
9170
9171
9172       ac_ext=C
9173 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9174 ac_cpp='$CXXCPP $CPPFLAGS'
9175 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9176 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9177 cross_compiling=$ac_cv_prog_cxx_cross
9178
9179       cat > conftest.$ac_ext <<EOF
9180 #line 9181 "configure"
9181 #include "confdefs.h"
9182 #include <math.h>
9183 int main() {
9184  isnanl(0);
9185 ; return 0; }
9186 EOF
9187 if { (eval echo configure:9188: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9188   rm -rf conftest*
9189   glibcpp_cv_func_isnanl_use=yes
9190 else
9191   echo "configure: failed program was:" >&5
9192   cat conftest.$ac_ext >&5
9193   rm -rf conftest*
9194   glibcpp_cv_func_isnanl_use=no
9195 fi
9196 rm -f conftest*
9197       ac_ext=c
9198 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9199 ac_cpp='$CPP $CPPFLAGS'
9200 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9201 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9202 cross_compiling=$ac_cv_prog_cc_cross
9203
9204
9205 fi
9206
9207   fi
9208   echo "$ac_t""$glibcpp_cv_func_isnanl_use" 1>&6
9209   if test x$glibcpp_cv_func_isnanl_use = x"yes"; then
9210     for ac_func in isnanl
9211 do
9212 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9213 echo "configure:9214: checking for $ac_func" >&5
9214 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9215   echo $ac_n "(cached) $ac_c" 1>&6
9216 else
9217   cat > conftest.$ac_ext <<EOF
9218 #line 9219 "configure"
9219 #include "confdefs.h"
9220 /* System header to define __stub macros and hopefully few prototypes,
9221     which can conflict with char $ac_func(); below.  */
9222 #include <assert.h>
9223 /* Override any gcc2 internal prototype to avoid an error.  */
9224 /* We use char because int might match the return type of a gcc2
9225     builtin and then its argument prototype would still apply.  */
9226 char $ac_func();
9227
9228 int main() {
9229
9230 /* The GNU C library defines this for functions which it implements
9231     to always fail with ENOSYS.  Some functions are actually named
9232     something starting with __ and the normal name is an alias.  */
9233 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9234 choke me
9235 #else
9236 $ac_func();
9237 #endif
9238
9239 ; return 0; }
9240 EOF
9241 if { (eval echo configure:9242: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9242   rm -rf conftest*
9243   eval "ac_cv_func_$ac_func=yes"
9244 else
9245   echo "configure: failed program was:" >&5
9246   cat conftest.$ac_ext >&5
9247   rm -rf conftest*
9248   eval "ac_cv_func_$ac_func=no"
9249 fi
9250 rm -f conftest*
9251 fi
9252
9253 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9254   echo "$ac_t""yes" 1>&6
9255     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9256   cat >> confdefs.h <<EOF
9257 #define $ac_tr_func 1
9258 EOF
9259
9260 else
9261   echo "$ac_t""no" 1>&6
9262 fi
9263 done
9264
9265   fi
9266
9267
9268   echo $ac_n "checking for isinfl declaration""... $ac_c" 1>&6
9269 echo "configure:9270: checking for isinfl declaration" >&5
9270   if test x${glibcpp_cv_func_isinfl_use+set} != xset; then
9271     if eval "test \"`echo '$''{'glibcpp_cv_func_isinfl_use'+set}'`\" = set"; then
9272   echo $ac_n "(cached) $ac_c" 1>&6
9273 else
9274
9275
9276       ac_ext=C
9277 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9278 ac_cpp='$CXXCPP $CPPFLAGS'
9279 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9280 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9281 cross_compiling=$ac_cv_prog_cxx_cross
9282
9283       cat > conftest.$ac_ext <<EOF
9284 #line 9285 "configure"
9285 #include "confdefs.h"
9286 #include <math.h>
9287 int main() {
9288  isinfl(0);
9289 ; return 0; }
9290 EOF
9291 if { (eval echo configure:9292: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9292   rm -rf conftest*
9293   glibcpp_cv_func_isinfl_use=yes
9294 else
9295   echo "configure: failed program was:" >&5
9296   cat conftest.$ac_ext >&5
9297   rm -rf conftest*
9298   glibcpp_cv_func_isinfl_use=no
9299 fi
9300 rm -f conftest*
9301       ac_ext=c
9302 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9303 ac_cpp='$CPP $CPPFLAGS'
9304 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9305 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9306 cross_compiling=$ac_cv_prog_cc_cross
9307
9308
9309 fi
9310
9311   fi
9312   echo "$ac_t""$glibcpp_cv_func_isinfl_use" 1>&6
9313   if test x$glibcpp_cv_func_isinfl_use = x"yes"; then
9314     for ac_func in isinfl
9315 do
9316 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9317 echo "configure:9318: checking for $ac_func" >&5
9318 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9319   echo $ac_n "(cached) $ac_c" 1>&6
9320 else
9321   cat > conftest.$ac_ext <<EOF
9322 #line 9323 "configure"
9323 #include "confdefs.h"
9324 /* System header to define __stub macros and hopefully few prototypes,
9325     which can conflict with char $ac_func(); below.  */
9326 #include <assert.h>
9327 /* Override any gcc2 internal prototype to avoid an error.  */
9328 /* We use char because int might match the return type of a gcc2
9329     builtin and then its argument prototype would still apply.  */
9330 char $ac_func();
9331
9332 int main() {
9333
9334 /* The GNU C library defines this for functions which it implements
9335     to always fail with ENOSYS.  Some functions are actually named
9336     something starting with __ and the normal name is an alias.  */
9337 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9338 choke me
9339 #else
9340 $ac_func();
9341 #endif
9342
9343 ; return 0; }
9344 EOF
9345 if { (eval echo configure:9346: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9346   rm -rf conftest*
9347   eval "ac_cv_func_$ac_func=yes"
9348 else
9349   echo "configure: failed program was:" >&5
9350   cat conftest.$ac_ext >&5
9351   rm -rf conftest*
9352   eval "ac_cv_func_$ac_func=no"
9353 fi
9354 rm -f conftest*
9355 fi
9356
9357 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9358   echo "$ac_t""yes" 1>&6
9359     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9360   cat >> confdefs.h <<EOF
9361 #define $ac_tr_func 1
9362 EOF
9363
9364 else
9365   echo "$ac_t""no" 1>&6
9366 fi
9367 done
9368
9369   fi
9370
9371
9372   echo $ac_n "checking for copysignl declaration""... $ac_c" 1>&6
9373 echo "configure:9374: checking for copysignl declaration" >&5
9374   if test x${glibcpp_cv_func_copysignl_use+set} != xset; then
9375     if eval "test \"`echo '$''{'glibcpp_cv_func_copysignl_use'+set}'`\" = set"; then
9376   echo $ac_n "(cached) $ac_c" 1>&6
9377 else
9378
9379
9380       ac_ext=C
9381 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9382 ac_cpp='$CXXCPP $CPPFLAGS'
9383 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9384 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9385 cross_compiling=$ac_cv_prog_cxx_cross
9386
9387       cat > conftest.$ac_ext <<EOF
9388 #line 9389 "configure"
9389 #include "confdefs.h"
9390 #include <math.h>
9391 int main() {
9392  copysignl(0, 0);
9393 ; return 0; }
9394 EOF
9395 if { (eval echo configure:9396: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9396   rm -rf conftest*
9397   glibcpp_cv_func_copysignl_use=yes
9398 else
9399   echo "configure: failed program was:" >&5
9400   cat conftest.$ac_ext >&5
9401   rm -rf conftest*
9402   glibcpp_cv_func_copysignl_use=no
9403 fi
9404 rm -f conftest*
9405       ac_ext=c
9406 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9407 ac_cpp='$CPP $CPPFLAGS'
9408 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9409 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9410 cross_compiling=$ac_cv_prog_cc_cross
9411
9412
9413 fi
9414
9415   fi
9416   echo "$ac_t""$glibcpp_cv_func_copysignl_use" 1>&6
9417   if test x$glibcpp_cv_func_copysignl_use = x"yes"; then
9418     for ac_func in copysignl
9419 do
9420 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9421 echo "configure:9422: checking for $ac_func" >&5
9422 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9423   echo $ac_n "(cached) $ac_c" 1>&6
9424 else
9425   cat > conftest.$ac_ext <<EOF
9426 #line 9427 "configure"
9427 #include "confdefs.h"
9428 /* System header to define __stub macros and hopefully few prototypes,
9429     which can conflict with char $ac_func(); below.  */
9430 #include <assert.h>
9431 /* Override any gcc2 internal prototype to avoid an error.  */
9432 /* We use char because int might match the return type of a gcc2
9433     builtin and then its argument prototype would still apply.  */
9434 char $ac_func();
9435
9436 int main() {
9437
9438 /* The GNU C library defines this for functions which it implements
9439     to always fail with ENOSYS.  Some functions are actually named
9440     something starting with __ and the normal name is an alias.  */
9441 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9442 choke me
9443 #else
9444 $ac_func();
9445 #endif
9446
9447 ; return 0; }
9448 EOF
9449 if { (eval echo configure:9450: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9450   rm -rf conftest*
9451   eval "ac_cv_func_$ac_func=yes"
9452 else
9453   echo "configure: failed program was:" >&5
9454   cat conftest.$ac_ext >&5
9455   rm -rf conftest*
9456   eval "ac_cv_func_$ac_func=no"
9457 fi
9458 rm -f conftest*
9459 fi
9460
9461 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9462   echo "$ac_t""yes" 1>&6
9463     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9464   cat >> confdefs.h <<EOF
9465 #define $ac_tr_func 1
9466 EOF
9467
9468 else
9469   echo "$ac_t""no" 1>&6
9470 fi
9471 done
9472
9473   fi
9474
9475
9476   echo $ac_n "checking for acosl declaration""... $ac_c" 1>&6
9477 echo "configure:9478: checking for acosl declaration" >&5
9478   if test x${glibcpp_cv_func_acosl_use+set} != xset; then
9479     if eval "test \"`echo '$''{'glibcpp_cv_func_acosl_use'+set}'`\" = set"; then
9480   echo $ac_n "(cached) $ac_c" 1>&6
9481 else
9482
9483
9484       ac_ext=C
9485 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9486 ac_cpp='$CXXCPP $CPPFLAGS'
9487 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9488 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9489 cross_compiling=$ac_cv_prog_cxx_cross
9490
9491       cat > conftest.$ac_ext <<EOF
9492 #line 9493 "configure"
9493 #include "confdefs.h"
9494 #include <math.h>
9495 int main() {
9496  acosl(0);
9497 ; return 0; }
9498 EOF
9499 if { (eval echo configure:9500: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9500   rm -rf conftest*
9501   glibcpp_cv_func_acosl_use=yes
9502 else
9503   echo "configure: failed program was:" >&5
9504   cat conftest.$ac_ext >&5
9505   rm -rf conftest*
9506   glibcpp_cv_func_acosl_use=no
9507 fi
9508 rm -f conftest*
9509       ac_ext=c
9510 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9511 ac_cpp='$CPP $CPPFLAGS'
9512 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9513 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9514 cross_compiling=$ac_cv_prog_cc_cross
9515
9516
9517 fi
9518
9519   fi
9520   echo "$ac_t""$glibcpp_cv_func_acosl_use" 1>&6
9521   if test x$glibcpp_cv_func_acosl_use = x"yes"; then
9522     for ac_func in acosl
9523 do
9524 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9525 echo "configure:9526: checking for $ac_func" >&5
9526 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9527   echo $ac_n "(cached) $ac_c" 1>&6
9528 else
9529   cat > conftest.$ac_ext <<EOF
9530 #line 9531 "configure"
9531 #include "confdefs.h"
9532 /* System header to define __stub macros and hopefully few prototypes,
9533     which can conflict with char $ac_func(); below.  */
9534 #include <assert.h>
9535 /* Override any gcc2 internal prototype to avoid an error.  */
9536 /* We use char because int might match the return type of a gcc2
9537     builtin and then its argument prototype would still apply.  */
9538 char $ac_func();
9539
9540 int main() {
9541
9542 /* The GNU C library defines this for functions which it implements
9543     to always fail with ENOSYS.  Some functions are actually named
9544     something starting with __ and the normal name is an alias.  */
9545 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9546 choke me
9547 #else
9548 $ac_func();
9549 #endif
9550
9551 ; return 0; }
9552 EOF
9553 if { (eval echo configure:9554: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9554   rm -rf conftest*
9555   eval "ac_cv_func_$ac_func=yes"
9556 else
9557   echo "configure: failed program was:" >&5
9558   cat conftest.$ac_ext >&5
9559   rm -rf conftest*
9560   eval "ac_cv_func_$ac_func=no"
9561 fi
9562 rm -f conftest*
9563 fi
9564
9565 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9566   echo "$ac_t""yes" 1>&6
9567     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9568   cat >> confdefs.h <<EOF
9569 #define $ac_tr_func 1
9570 EOF
9571
9572 else
9573   echo "$ac_t""no" 1>&6
9574 fi
9575 done
9576
9577   fi
9578
9579
9580   echo $ac_n "checking for asinl declaration""... $ac_c" 1>&6
9581 echo "configure:9582: checking for asinl declaration" >&5
9582   if test x${glibcpp_cv_func_asinl_use+set} != xset; then
9583     if eval "test \"`echo '$''{'glibcpp_cv_func_asinl_use'+set}'`\" = set"; then
9584   echo $ac_n "(cached) $ac_c" 1>&6
9585 else
9586
9587
9588       ac_ext=C
9589 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9590 ac_cpp='$CXXCPP $CPPFLAGS'
9591 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9592 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9593 cross_compiling=$ac_cv_prog_cxx_cross
9594
9595       cat > conftest.$ac_ext <<EOF
9596 #line 9597 "configure"
9597 #include "confdefs.h"
9598 #include <math.h>
9599 int main() {
9600  asinl(0);
9601 ; return 0; }
9602 EOF
9603 if { (eval echo configure:9604: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9604   rm -rf conftest*
9605   glibcpp_cv_func_asinl_use=yes
9606 else
9607   echo "configure: failed program was:" >&5
9608   cat conftest.$ac_ext >&5
9609   rm -rf conftest*
9610   glibcpp_cv_func_asinl_use=no
9611 fi
9612 rm -f conftest*
9613       ac_ext=c
9614 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9615 ac_cpp='$CPP $CPPFLAGS'
9616 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9617 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9618 cross_compiling=$ac_cv_prog_cc_cross
9619
9620
9621 fi
9622
9623   fi
9624   echo "$ac_t""$glibcpp_cv_func_asinl_use" 1>&6
9625   if test x$glibcpp_cv_func_asinl_use = x"yes"; then
9626     for ac_func in asinl
9627 do
9628 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9629 echo "configure:9630: checking for $ac_func" >&5
9630 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9631   echo $ac_n "(cached) $ac_c" 1>&6
9632 else
9633   cat > conftest.$ac_ext <<EOF
9634 #line 9635 "configure"
9635 #include "confdefs.h"
9636 /* System header to define __stub macros and hopefully few prototypes,
9637     which can conflict with char $ac_func(); below.  */
9638 #include <assert.h>
9639 /* Override any gcc2 internal prototype to avoid an error.  */
9640 /* We use char because int might match the return type of a gcc2
9641     builtin and then its argument prototype would still apply.  */
9642 char $ac_func();
9643
9644 int main() {
9645
9646 /* The GNU C library defines this for functions which it implements
9647     to always fail with ENOSYS.  Some functions are actually named
9648     something starting with __ and the normal name is an alias.  */
9649 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9650 choke me
9651 #else
9652 $ac_func();
9653 #endif
9654
9655 ; return 0; }
9656 EOF
9657 if { (eval echo configure:9658: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9658   rm -rf conftest*
9659   eval "ac_cv_func_$ac_func=yes"
9660 else
9661   echo "configure: failed program was:" >&5
9662   cat conftest.$ac_ext >&5
9663   rm -rf conftest*
9664   eval "ac_cv_func_$ac_func=no"
9665 fi
9666 rm -f conftest*
9667 fi
9668
9669 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9670   echo "$ac_t""yes" 1>&6
9671     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9672   cat >> confdefs.h <<EOF
9673 #define $ac_tr_func 1
9674 EOF
9675
9676 else
9677   echo "$ac_t""no" 1>&6
9678 fi
9679 done
9680
9681   fi
9682
9683
9684   echo $ac_n "checking for atanl declaration""... $ac_c" 1>&6
9685 echo "configure:9686: checking for atanl declaration" >&5
9686   if test x${glibcpp_cv_func_atanl_use+set} != xset; then
9687     if eval "test \"`echo '$''{'glibcpp_cv_func_atanl_use'+set}'`\" = set"; then
9688   echo $ac_n "(cached) $ac_c" 1>&6
9689 else
9690
9691
9692       ac_ext=C
9693 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9694 ac_cpp='$CXXCPP $CPPFLAGS'
9695 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9696 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9697 cross_compiling=$ac_cv_prog_cxx_cross
9698
9699       cat > conftest.$ac_ext <<EOF
9700 #line 9701 "configure"
9701 #include "confdefs.h"
9702 #include <math.h>
9703 int main() {
9704  atanl(0);
9705 ; return 0; }
9706 EOF
9707 if { (eval echo configure:9708: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9708   rm -rf conftest*
9709   glibcpp_cv_func_atanl_use=yes
9710 else
9711   echo "configure: failed program was:" >&5
9712   cat conftest.$ac_ext >&5
9713   rm -rf conftest*
9714   glibcpp_cv_func_atanl_use=no
9715 fi
9716 rm -f conftest*
9717       ac_ext=c
9718 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9719 ac_cpp='$CPP $CPPFLAGS'
9720 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9721 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9722 cross_compiling=$ac_cv_prog_cc_cross
9723
9724
9725 fi
9726
9727   fi
9728   echo "$ac_t""$glibcpp_cv_func_atanl_use" 1>&6
9729   if test x$glibcpp_cv_func_atanl_use = x"yes"; then
9730     for ac_func in atanl
9731 do
9732 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9733 echo "configure:9734: checking for $ac_func" >&5
9734 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9735   echo $ac_n "(cached) $ac_c" 1>&6
9736 else
9737   cat > conftest.$ac_ext <<EOF
9738 #line 9739 "configure"
9739 #include "confdefs.h"
9740 /* System header to define __stub macros and hopefully few prototypes,
9741     which can conflict with char $ac_func(); below.  */
9742 #include <assert.h>
9743 /* Override any gcc2 internal prototype to avoid an error.  */
9744 /* We use char because int might match the return type of a gcc2
9745     builtin and then its argument prototype would still apply.  */
9746 char $ac_func();
9747
9748 int main() {
9749
9750 /* The GNU C library defines this for functions which it implements
9751     to always fail with ENOSYS.  Some functions are actually named
9752     something starting with __ and the normal name is an alias.  */
9753 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9754 choke me
9755 #else
9756 $ac_func();
9757 #endif
9758
9759 ; return 0; }
9760 EOF
9761 if { (eval echo configure:9762: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9762   rm -rf conftest*
9763   eval "ac_cv_func_$ac_func=yes"
9764 else
9765   echo "configure: failed program was:" >&5
9766   cat conftest.$ac_ext >&5
9767   rm -rf conftest*
9768   eval "ac_cv_func_$ac_func=no"
9769 fi
9770 rm -f conftest*
9771 fi
9772
9773 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9774   echo "$ac_t""yes" 1>&6
9775     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9776   cat >> confdefs.h <<EOF
9777 #define $ac_tr_func 1
9778 EOF
9779
9780 else
9781   echo "$ac_t""no" 1>&6
9782 fi
9783 done
9784
9785   fi
9786
9787
9788   echo $ac_n "checking for atan2l declaration""... $ac_c" 1>&6
9789 echo "configure:9790: checking for atan2l declaration" >&5
9790   if test x${glibcpp_cv_func_atan2l_use+set} != xset; then
9791     if eval "test \"`echo '$''{'glibcpp_cv_func_atan2l_use'+set}'`\" = set"; then
9792   echo $ac_n "(cached) $ac_c" 1>&6
9793 else
9794
9795
9796       ac_ext=C
9797 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9798 ac_cpp='$CXXCPP $CPPFLAGS'
9799 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9800 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9801 cross_compiling=$ac_cv_prog_cxx_cross
9802
9803       cat > conftest.$ac_ext <<EOF
9804 #line 9805 "configure"
9805 #include "confdefs.h"
9806 #include <math.h>
9807 int main() {
9808  atan2l(0, 0);
9809 ; return 0; }
9810 EOF
9811 if { (eval echo configure:9812: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9812   rm -rf conftest*
9813   glibcpp_cv_func_atan2l_use=yes
9814 else
9815   echo "configure: failed program was:" >&5
9816   cat conftest.$ac_ext >&5
9817   rm -rf conftest*
9818   glibcpp_cv_func_atan2l_use=no
9819 fi
9820 rm -f conftest*
9821       ac_ext=c
9822 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9823 ac_cpp='$CPP $CPPFLAGS'
9824 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9825 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9826 cross_compiling=$ac_cv_prog_cc_cross
9827
9828
9829 fi
9830
9831   fi
9832   echo "$ac_t""$glibcpp_cv_func_atan2l_use" 1>&6
9833   if test x$glibcpp_cv_func_atan2l_use = x"yes"; then
9834     for ac_func in atan2l
9835 do
9836 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9837 echo "configure:9838: checking for $ac_func" >&5
9838 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9839   echo $ac_n "(cached) $ac_c" 1>&6
9840 else
9841   cat > conftest.$ac_ext <<EOF
9842 #line 9843 "configure"
9843 #include "confdefs.h"
9844 /* System header to define __stub macros and hopefully few prototypes,
9845     which can conflict with char $ac_func(); below.  */
9846 #include <assert.h>
9847 /* Override any gcc2 internal prototype to avoid an error.  */
9848 /* We use char because int might match the return type of a gcc2
9849     builtin and then its argument prototype would still apply.  */
9850 char $ac_func();
9851
9852 int main() {
9853
9854 /* The GNU C library defines this for functions which it implements
9855     to always fail with ENOSYS.  Some functions are actually named
9856     something starting with __ and the normal name is an alias.  */
9857 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9858 choke me
9859 #else
9860 $ac_func();
9861 #endif
9862
9863 ; return 0; }
9864 EOF
9865 if { (eval echo configure:9866: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9866   rm -rf conftest*
9867   eval "ac_cv_func_$ac_func=yes"
9868 else
9869   echo "configure: failed program was:" >&5
9870   cat conftest.$ac_ext >&5
9871   rm -rf conftest*
9872   eval "ac_cv_func_$ac_func=no"
9873 fi
9874 rm -f conftest*
9875 fi
9876
9877 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9878   echo "$ac_t""yes" 1>&6
9879     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9880   cat >> confdefs.h <<EOF
9881 #define $ac_tr_func 1
9882 EOF
9883
9884 else
9885   echo "$ac_t""no" 1>&6
9886 fi
9887 done
9888
9889   fi
9890
9891
9892   echo $ac_n "checking for ceill declaration""... $ac_c" 1>&6
9893 echo "configure:9894: checking for ceill declaration" >&5
9894   if test x${glibcpp_cv_func_ceill_use+set} != xset; then
9895     if eval "test \"`echo '$''{'glibcpp_cv_func_ceill_use'+set}'`\" = set"; then
9896   echo $ac_n "(cached) $ac_c" 1>&6
9897 else
9898
9899
9900       ac_ext=C
9901 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9902 ac_cpp='$CXXCPP $CPPFLAGS'
9903 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9904 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9905 cross_compiling=$ac_cv_prog_cxx_cross
9906
9907       cat > conftest.$ac_ext <<EOF
9908 #line 9909 "configure"
9909 #include "confdefs.h"
9910 #include <math.h>
9911 int main() {
9912  ceill(0);
9913 ; return 0; }
9914 EOF
9915 if { (eval echo configure:9916: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
9916   rm -rf conftest*
9917   glibcpp_cv_func_ceill_use=yes
9918 else
9919   echo "configure: failed program was:" >&5
9920   cat conftest.$ac_ext >&5
9921   rm -rf conftest*
9922   glibcpp_cv_func_ceill_use=no
9923 fi
9924 rm -f conftest*
9925       ac_ext=c
9926 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
9927 ac_cpp='$CPP $CPPFLAGS'
9928 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
9929 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
9930 cross_compiling=$ac_cv_prog_cc_cross
9931
9932
9933 fi
9934
9935   fi
9936   echo "$ac_t""$glibcpp_cv_func_ceill_use" 1>&6
9937   if test x$glibcpp_cv_func_ceill_use = x"yes"; then
9938     for ac_func in ceill
9939 do
9940 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
9941 echo "configure:9942: checking for $ac_func" >&5
9942 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
9943   echo $ac_n "(cached) $ac_c" 1>&6
9944 else
9945   cat > conftest.$ac_ext <<EOF
9946 #line 9947 "configure"
9947 #include "confdefs.h"
9948 /* System header to define __stub macros and hopefully few prototypes,
9949     which can conflict with char $ac_func(); below.  */
9950 #include <assert.h>
9951 /* Override any gcc2 internal prototype to avoid an error.  */
9952 /* We use char because int might match the return type of a gcc2
9953     builtin and then its argument prototype would still apply.  */
9954 char $ac_func();
9955
9956 int main() {
9957
9958 /* The GNU C library defines this for functions which it implements
9959     to always fail with ENOSYS.  Some functions are actually named
9960     something starting with __ and the normal name is an alias.  */
9961 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9962 choke me
9963 #else
9964 $ac_func();
9965 #endif
9966
9967 ; return 0; }
9968 EOF
9969 if { (eval echo configure:9970: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
9970   rm -rf conftest*
9971   eval "ac_cv_func_$ac_func=yes"
9972 else
9973   echo "configure: failed program was:" >&5
9974   cat conftest.$ac_ext >&5
9975   rm -rf conftest*
9976   eval "ac_cv_func_$ac_func=no"
9977 fi
9978 rm -f conftest*
9979 fi
9980
9981 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
9982   echo "$ac_t""yes" 1>&6
9983     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
9984   cat >> confdefs.h <<EOF
9985 #define $ac_tr_func 1
9986 EOF
9987
9988 else
9989   echo "$ac_t""no" 1>&6
9990 fi
9991 done
9992
9993   fi
9994
9995
9996   echo $ac_n "checking for cosl declaration""... $ac_c" 1>&6
9997 echo "configure:9998: checking for cosl declaration" >&5
9998   if test x${glibcpp_cv_func_cosl_use+set} != xset; then
9999     if eval "test \"`echo '$''{'glibcpp_cv_func_cosl_use'+set}'`\" = set"; then
10000   echo $ac_n "(cached) $ac_c" 1>&6
10001 else
10002
10003
10004       ac_ext=C
10005 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10006 ac_cpp='$CXXCPP $CPPFLAGS'
10007 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10008 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10009 cross_compiling=$ac_cv_prog_cxx_cross
10010
10011       cat > conftest.$ac_ext <<EOF
10012 #line 10013 "configure"
10013 #include "confdefs.h"
10014 #include <math.h>
10015 int main() {
10016  cosl(0);
10017 ; return 0; }
10018 EOF
10019 if { (eval echo configure:10020: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10020   rm -rf conftest*
10021   glibcpp_cv_func_cosl_use=yes
10022 else
10023   echo "configure: failed program was:" >&5
10024   cat conftest.$ac_ext >&5
10025   rm -rf conftest*
10026   glibcpp_cv_func_cosl_use=no
10027 fi
10028 rm -f conftest*
10029       ac_ext=c
10030 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10031 ac_cpp='$CPP $CPPFLAGS'
10032 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10033 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10034 cross_compiling=$ac_cv_prog_cc_cross
10035
10036
10037 fi
10038
10039   fi
10040   echo "$ac_t""$glibcpp_cv_func_cosl_use" 1>&6
10041   if test x$glibcpp_cv_func_cosl_use = x"yes"; then
10042     for ac_func in cosl
10043 do
10044 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10045 echo "configure:10046: checking for $ac_func" >&5
10046 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10047   echo $ac_n "(cached) $ac_c" 1>&6
10048 else
10049   cat > conftest.$ac_ext <<EOF
10050 #line 10051 "configure"
10051 #include "confdefs.h"
10052 /* System header to define __stub macros and hopefully few prototypes,
10053     which can conflict with char $ac_func(); below.  */
10054 #include <assert.h>
10055 /* Override any gcc2 internal prototype to avoid an error.  */
10056 /* We use char because int might match the return type of a gcc2
10057     builtin and then its argument prototype would still apply.  */
10058 char $ac_func();
10059
10060 int main() {
10061
10062 /* The GNU C library defines this for functions which it implements
10063     to always fail with ENOSYS.  Some functions are actually named
10064     something starting with __ and the normal name is an alias.  */
10065 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10066 choke me
10067 #else
10068 $ac_func();
10069 #endif
10070
10071 ; return 0; }
10072 EOF
10073 if { (eval echo configure:10074: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10074   rm -rf conftest*
10075   eval "ac_cv_func_$ac_func=yes"
10076 else
10077   echo "configure: failed program was:" >&5
10078   cat conftest.$ac_ext >&5
10079   rm -rf conftest*
10080   eval "ac_cv_func_$ac_func=no"
10081 fi
10082 rm -f conftest*
10083 fi
10084
10085 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10086   echo "$ac_t""yes" 1>&6
10087     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10088   cat >> confdefs.h <<EOF
10089 #define $ac_tr_func 1
10090 EOF
10091
10092 else
10093   echo "$ac_t""no" 1>&6
10094 fi
10095 done
10096
10097   fi
10098
10099
10100   echo $ac_n "checking for coshl declaration""... $ac_c" 1>&6
10101 echo "configure:10102: checking for coshl declaration" >&5
10102   if test x${glibcpp_cv_func_coshl_use+set} != xset; then
10103     if eval "test \"`echo '$''{'glibcpp_cv_func_coshl_use'+set}'`\" = set"; then
10104   echo $ac_n "(cached) $ac_c" 1>&6
10105 else
10106
10107
10108       ac_ext=C
10109 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10110 ac_cpp='$CXXCPP $CPPFLAGS'
10111 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10112 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10113 cross_compiling=$ac_cv_prog_cxx_cross
10114
10115       cat > conftest.$ac_ext <<EOF
10116 #line 10117 "configure"
10117 #include "confdefs.h"
10118 #include <math.h>
10119 int main() {
10120  coshl(0);
10121 ; return 0; }
10122 EOF
10123 if { (eval echo configure:10124: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10124   rm -rf conftest*
10125   glibcpp_cv_func_coshl_use=yes
10126 else
10127   echo "configure: failed program was:" >&5
10128   cat conftest.$ac_ext >&5
10129   rm -rf conftest*
10130   glibcpp_cv_func_coshl_use=no
10131 fi
10132 rm -f conftest*
10133       ac_ext=c
10134 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10135 ac_cpp='$CPP $CPPFLAGS'
10136 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10137 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10138 cross_compiling=$ac_cv_prog_cc_cross
10139
10140
10141 fi
10142
10143   fi
10144   echo "$ac_t""$glibcpp_cv_func_coshl_use" 1>&6
10145   if test x$glibcpp_cv_func_coshl_use = x"yes"; then
10146     for ac_func in coshl
10147 do
10148 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10149 echo "configure:10150: checking for $ac_func" >&5
10150 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10151   echo $ac_n "(cached) $ac_c" 1>&6
10152 else
10153   cat > conftest.$ac_ext <<EOF
10154 #line 10155 "configure"
10155 #include "confdefs.h"
10156 /* System header to define __stub macros and hopefully few prototypes,
10157     which can conflict with char $ac_func(); below.  */
10158 #include <assert.h>
10159 /* Override any gcc2 internal prototype to avoid an error.  */
10160 /* We use char because int might match the return type of a gcc2
10161     builtin and then its argument prototype would still apply.  */
10162 char $ac_func();
10163
10164 int main() {
10165
10166 /* The GNU C library defines this for functions which it implements
10167     to always fail with ENOSYS.  Some functions are actually named
10168     something starting with __ and the normal name is an alias.  */
10169 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10170 choke me
10171 #else
10172 $ac_func();
10173 #endif
10174
10175 ; return 0; }
10176 EOF
10177 if { (eval echo configure:10178: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10178   rm -rf conftest*
10179   eval "ac_cv_func_$ac_func=yes"
10180 else
10181   echo "configure: failed program was:" >&5
10182   cat conftest.$ac_ext >&5
10183   rm -rf conftest*
10184   eval "ac_cv_func_$ac_func=no"
10185 fi
10186 rm -f conftest*
10187 fi
10188
10189 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10190   echo "$ac_t""yes" 1>&6
10191     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10192   cat >> confdefs.h <<EOF
10193 #define $ac_tr_func 1
10194 EOF
10195
10196 else
10197   echo "$ac_t""no" 1>&6
10198 fi
10199 done
10200
10201   fi
10202
10203
10204   echo $ac_n "checking for expl declaration""... $ac_c" 1>&6
10205 echo "configure:10206: checking for expl declaration" >&5
10206   if test x${glibcpp_cv_func_expl_use+set} != xset; then
10207     if eval "test \"`echo '$''{'glibcpp_cv_func_expl_use'+set}'`\" = set"; then
10208   echo $ac_n "(cached) $ac_c" 1>&6
10209 else
10210
10211
10212       ac_ext=C
10213 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10214 ac_cpp='$CXXCPP $CPPFLAGS'
10215 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10216 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10217 cross_compiling=$ac_cv_prog_cxx_cross
10218
10219       cat > conftest.$ac_ext <<EOF
10220 #line 10221 "configure"
10221 #include "confdefs.h"
10222 #include <math.h>
10223 int main() {
10224  expl(0);
10225 ; return 0; }
10226 EOF
10227 if { (eval echo configure:10228: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10228   rm -rf conftest*
10229   glibcpp_cv_func_expl_use=yes
10230 else
10231   echo "configure: failed program was:" >&5
10232   cat conftest.$ac_ext >&5
10233   rm -rf conftest*
10234   glibcpp_cv_func_expl_use=no
10235 fi
10236 rm -f conftest*
10237       ac_ext=c
10238 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10239 ac_cpp='$CPP $CPPFLAGS'
10240 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10241 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10242 cross_compiling=$ac_cv_prog_cc_cross
10243
10244
10245 fi
10246
10247   fi
10248   echo "$ac_t""$glibcpp_cv_func_expl_use" 1>&6
10249   if test x$glibcpp_cv_func_expl_use = x"yes"; then
10250     for ac_func in expl
10251 do
10252 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10253 echo "configure:10254: checking for $ac_func" >&5
10254 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10255   echo $ac_n "(cached) $ac_c" 1>&6
10256 else
10257   cat > conftest.$ac_ext <<EOF
10258 #line 10259 "configure"
10259 #include "confdefs.h"
10260 /* System header to define __stub macros and hopefully few prototypes,
10261     which can conflict with char $ac_func(); below.  */
10262 #include <assert.h>
10263 /* Override any gcc2 internal prototype to avoid an error.  */
10264 /* We use char because int might match the return type of a gcc2
10265     builtin and then its argument prototype would still apply.  */
10266 char $ac_func();
10267
10268 int main() {
10269
10270 /* The GNU C library defines this for functions which it implements
10271     to always fail with ENOSYS.  Some functions are actually named
10272     something starting with __ and the normal name is an alias.  */
10273 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10274 choke me
10275 #else
10276 $ac_func();
10277 #endif
10278
10279 ; return 0; }
10280 EOF
10281 if { (eval echo configure:10282: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10282   rm -rf conftest*
10283   eval "ac_cv_func_$ac_func=yes"
10284 else
10285   echo "configure: failed program was:" >&5
10286   cat conftest.$ac_ext >&5
10287   rm -rf conftest*
10288   eval "ac_cv_func_$ac_func=no"
10289 fi
10290 rm -f conftest*
10291 fi
10292
10293 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10294   echo "$ac_t""yes" 1>&6
10295     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10296   cat >> confdefs.h <<EOF
10297 #define $ac_tr_func 1
10298 EOF
10299
10300 else
10301   echo "$ac_t""no" 1>&6
10302 fi
10303 done
10304
10305   fi
10306
10307
10308   echo $ac_n "checking for fabsl declaration""... $ac_c" 1>&6
10309 echo "configure:10310: checking for fabsl declaration" >&5
10310   if test x${glibcpp_cv_func_fabsl_use+set} != xset; then
10311     if eval "test \"`echo '$''{'glibcpp_cv_func_fabsl_use'+set}'`\" = set"; then
10312   echo $ac_n "(cached) $ac_c" 1>&6
10313 else
10314
10315
10316       ac_ext=C
10317 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10318 ac_cpp='$CXXCPP $CPPFLAGS'
10319 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10320 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10321 cross_compiling=$ac_cv_prog_cxx_cross
10322
10323       cat > conftest.$ac_ext <<EOF
10324 #line 10325 "configure"
10325 #include "confdefs.h"
10326 #include <math.h>
10327 int main() {
10328  fabsl(0);
10329 ; return 0; }
10330 EOF
10331 if { (eval echo configure:10332: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10332   rm -rf conftest*
10333   glibcpp_cv_func_fabsl_use=yes
10334 else
10335   echo "configure: failed program was:" >&5
10336   cat conftest.$ac_ext >&5
10337   rm -rf conftest*
10338   glibcpp_cv_func_fabsl_use=no
10339 fi
10340 rm -f conftest*
10341       ac_ext=c
10342 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10343 ac_cpp='$CPP $CPPFLAGS'
10344 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10345 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10346 cross_compiling=$ac_cv_prog_cc_cross
10347
10348
10349 fi
10350
10351   fi
10352   echo "$ac_t""$glibcpp_cv_func_fabsl_use" 1>&6
10353   if test x$glibcpp_cv_func_fabsl_use = x"yes"; then
10354     for ac_func in fabsl
10355 do
10356 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10357 echo "configure:10358: checking for $ac_func" >&5
10358 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10359   echo $ac_n "(cached) $ac_c" 1>&6
10360 else
10361   cat > conftest.$ac_ext <<EOF
10362 #line 10363 "configure"
10363 #include "confdefs.h"
10364 /* System header to define __stub macros and hopefully few prototypes,
10365     which can conflict with char $ac_func(); below.  */
10366 #include <assert.h>
10367 /* Override any gcc2 internal prototype to avoid an error.  */
10368 /* We use char because int might match the return type of a gcc2
10369     builtin and then its argument prototype would still apply.  */
10370 char $ac_func();
10371
10372 int main() {
10373
10374 /* The GNU C library defines this for functions which it implements
10375     to always fail with ENOSYS.  Some functions are actually named
10376     something starting with __ and the normal name is an alias.  */
10377 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10378 choke me
10379 #else
10380 $ac_func();
10381 #endif
10382
10383 ; return 0; }
10384 EOF
10385 if { (eval echo configure:10386: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10386   rm -rf conftest*
10387   eval "ac_cv_func_$ac_func=yes"
10388 else
10389   echo "configure: failed program was:" >&5
10390   cat conftest.$ac_ext >&5
10391   rm -rf conftest*
10392   eval "ac_cv_func_$ac_func=no"
10393 fi
10394 rm -f conftest*
10395 fi
10396
10397 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10398   echo "$ac_t""yes" 1>&6
10399     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10400   cat >> confdefs.h <<EOF
10401 #define $ac_tr_func 1
10402 EOF
10403
10404 else
10405   echo "$ac_t""no" 1>&6
10406 fi
10407 done
10408
10409   fi
10410
10411
10412   echo $ac_n "checking for floorl declaration""... $ac_c" 1>&6
10413 echo "configure:10414: checking for floorl declaration" >&5
10414   if test x${glibcpp_cv_func_floorl_use+set} != xset; then
10415     if eval "test \"`echo '$''{'glibcpp_cv_func_floorl_use'+set}'`\" = set"; then
10416   echo $ac_n "(cached) $ac_c" 1>&6
10417 else
10418
10419
10420       ac_ext=C
10421 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10422 ac_cpp='$CXXCPP $CPPFLAGS'
10423 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10424 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10425 cross_compiling=$ac_cv_prog_cxx_cross
10426
10427       cat > conftest.$ac_ext <<EOF
10428 #line 10429 "configure"
10429 #include "confdefs.h"
10430 #include <math.h>
10431 int main() {
10432  floorl(0);
10433 ; return 0; }
10434 EOF
10435 if { (eval echo configure:10436: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10436   rm -rf conftest*
10437   glibcpp_cv_func_floorl_use=yes
10438 else
10439   echo "configure: failed program was:" >&5
10440   cat conftest.$ac_ext >&5
10441   rm -rf conftest*
10442   glibcpp_cv_func_floorl_use=no
10443 fi
10444 rm -f conftest*
10445       ac_ext=c
10446 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10447 ac_cpp='$CPP $CPPFLAGS'
10448 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10449 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10450 cross_compiling=$ac_cv_prog_cc_cross
10451
10452
10453 fi
10454
10455   fi
10456   echo "$ac_t""$glibcpp_cv_func_floorl_use" 1>&6
10457   if test x$glibcpp_cv_func_floorl_use = x"yes"; then
10458     for ac_func in floorl
10459 do
10460 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10461 echo "configure:10462: checking for $ac_func" >&5
10462 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10463   echo $ac_n "(cached) $ac_c" 1>&6
10464 else
10465   cat > conftest.$ac_ext <<EOF
10466 #line 10467 "configure"
10467 #include "confdefs.h"
10468 /* System header to define __stub macros and hopefully few prototypes,
10469     which can conflict with char $ac_func(); below.  */
10470 #include <assert.h>
10471 /* Override any gcc2 internal prototype to avoid an error.  */
10472 /* We use char because int might match the return type of a gcc2
10473     builtin and then its argument prototype would still apply.  */
10474 char $ac_func();
10475
10476 int main() {
10477
10478 /* The GNU C library defines this for functions which it implements
10479     to always fail with ENOSYS.  Some functions are actually named
10480     something starting with __ and the normal name is an alias.  */
10481 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10482 choke me
10483 #else
10484 $ac_func();
10485 #endif
10486
10487 ; return 0; }
10488 EOF
10489 if { (eval echo configure:10490: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10490   rm -rf conftest*
10491   eval "ac_cv_func_$ac_func=yes"
10492 else
10493   echo "configure: failed program was:" >&5
10494   cat conftest.$ac_ext >&5
10495   rm -rf conftest*
10496   eval "ac_cv_func_$ac_func=no"
10497 fi
10498 rm -f conftest*
10499 fi
10500
10501 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10502   echo "$ac_t""yes" 1>&6
10503     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10504   cat >> confdefs.h <<EOF
10505 #define $ac_tr_func 1
10506 EOF
10507
10508 else
10509   echo "$ac_t""no" 1>&6
10510 fi
10511 done
10512
10513   fi
10514
10515
10516   echo $ac_n "checking for fmodl declaration""... $ac_c" 1>&6
10517 echo "configure:10518: checking for fmodl declaration" >&5
10518   if test x${glibcpp_cv_func_fmodl_use+set} != xset; then
10519     if eval "test \"`echo '$''{'glibcpp_cv_func_fmodl_use'+set}'`\" = set"; then
10520   echo $ac_n "(cached) $ac_c" 1>&6
10521 else
10522
10523
10524       ac_ext=C
10525 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10526 ac_cpp='$CXXCPP $CPPFLAGS'
10527 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10528 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10529 cross_compiling=$ac_cv_prog_cxx_cross
10530
10531       cat > conftest.$ac_ext <<EOF
10532 #line 10533 "configure"
10533 #include "confdefs.h"
10534 #include <math.h>
10535 int main() {
10536  fmodl(0, 0);
10537 ; return 0; }
10538 EOF
10539 if { (eval echo configure:10540: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10540   rm -rf conftest*
10541   glibcpp_cv_func_fmodl_use=yes
10542 else
10543   echo "configure: failed program was:" >&5
10544   cat conftest.$ac_ext >&5
10545   rm -rf conftest*
10546   glibcpp_cv_func_fmodl_use=no
10547 fi
10548 rm -f conftest*
10549       ac_ext=c
10550 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10551 ac_cpp='$CPP $CPPFLAGS'
10552 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10553 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10554 cross_compiling=$ac_cv_prog_cc_cross
10555
10556
10557 fi
10558
10559   fi
10560   echo "$ac_t""$glibcpp_cv_func_fmodl_use" 1>&6
10561   if test x$glibcpp_cv_func_fmodl_use = x"yes"; then
10562     for ac_func in fmodl
10563 do
10564 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10565 echo "configure:10566: checking for $ac_func" >&5
10566 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10567   echo $ac_n "(cached) $ac_c" 1>&6
10568 else
10569   cat > conftest.$ac_ext <<EOF
10570 #line 10571 "configure"
10571 #include "confdefs.h"
10572 /* System header to define __stub macros and hopefully few prototypes,
10573     which can conflict with char $ac_func(); below.  */
10574 #include <assert.h>
10575 /* Override any gcc2 internal prototype to avoid an error.  */
10576 /* We use char because int might match the return type of a gcc2
10577     builtin and then its argument prototype would still apply.  */
10578 char $ac_func();
10579
10580 int main() {
10581
10582 /* The GNU C library defines this for functions which it implements
10583     to always fail with ENOSYS.  Some functions are actually named
10584     something starting with __ and the normal name is an alias.  */
10585 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10586 choke me
10587 #else
10588 $ac_func();
10589 #endif
10590
10591 ; return 0; }
10592 EOF
10593 if { (eval echo configure:10594: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10594   rm -rf conftest*
10595   eval "ac_cv_func_$ac_func=yes"
10596 else
10597   echo "configure: failed program was:" >&5
10598   cat conftest.$ac_ext >&5
10599   rm -rf conftest*
10600   eval "ac_cv_func_$ac_func=no"
10601 fi
10602 rm -f conftest*
10603 fi
10604
10605 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10606   echo "$ac_t""yes" 1>&6
10607     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10608   cat >> confdefs.h <<EOF
10609 #define $ac_tr_func 1
10610 EOF
10611
10612 else
10613   echo "$ac_t""no" 1>&6
10614 fi
10615 done
10616
10617   fi
10618
10619
10620   echo $ac_n "checking for frexpl declaration""... $ac_c" 1>&6
10621 echo "configure:10622: checking for frexpl declaration" >&5
10622   if test x${glibcpp_cv_func_frexpl_use+set} != xset; then
10623     if eval "test \"`echo '$''{'glibcpp_cv_func_frexpl_use'+set}'`\" = set"; then
10624   echo $ac_n "(cached) $ac_c" 1>&6
10625 else
10626
10627
10628       ac_ext=C
10629 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10630 ac_cpp='$CXXCPP $CPPFLAGS'
10631 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10632 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10633 cross_compiling=$ac_cv_prog_cxx_cross
10634
10635       cat > conftest.$ac_ext <<EOF
10636 #line 10637 "configure"
10637 #include "confdefs.h"
10638 #include <math.h>
10639 int main() {
10640  frexpl(0, 0);
10641 ; return 0; }
10642 EOF
10643 if { (eval echo configure:10644: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10644   rm -rf conftest*
10645   glibcpp_cv_func_frexpl_use=yes
10646 else
10647   echo "configure: failed program was:" >&5
10648   cat conftest.$ac_ext >&5
10649   rm -rf conftest*
10650   glibcpp_cv_func_frexpl_use=no
10651 fi
10652 rm -f conftest*
10653       ac_ext=c
10654 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10655 ac_cpp='$CPP $CPPFLAGS'
10656 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10657 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10658 cross_compiling=$ac_cv_prog_cc_cross
10659
10660
10661 fi
10662
10663   fi
10664   echo "$ac_t""$glibcpp_cv_func_frexpl_use" 1>&6
10665   if test x$glibcpp_cv_func_frexpl_use = x"yes"; then
10666     for ac_func in frexpl
10667 do
10668 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10669 echo "configure:10670: checking for $ac_func" >&5
10670 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10671   echo $ac_n "(cached) $ac_c" 1>&6
10672 else
10673   cat > conftest.$ac_ext <<EOF
10674 #line 10675 "configure"
10675 #include "confdefs.h"
10676 /* System header to define __stub macros and hopefully few prototypes,
10677     which can conflict with char $ac_func(); below.  */
10678 #include <assert.h>
10679 /* Override any gcc2 internal prototype to avoid an error.  */
10680 /* We use char because int might match the return type of a gcc2
10681     builtin and then its argument prototype would still apply.  */
10682 char $ac_func();
10683
10684 int main() {
10685
10686 /* The GNU C library defines this for functions which it implements
10687     to always fail with ENOSYS.  Some functions are actually named
10688     something starting with __ and the normal name is an alias.  */
10689 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10690 choke me
10691 #else
10692 $ac_func();
10693 #endif
10694
10695 ; return 0; }
10696 EOF
10697 if { (eval echo configure:10698: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10698   rm -rf conftest*
10699   eval "ac_cv_func_$ac_func=yes"
10700 else
10701   echo "configure: failed program was:" >&5
10702   cat conftest.$ac_ext >&5
10703   rm -rf conftest*
10704   eval "ac_cv_func_$ac_func=no"
10705 fi
10706 rm -f conftest*
10707 fi
10708
10709 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10710   echo "$ac_t""yes" 1>&6
10711     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10712   cat >> confdefs.h <<EOF
10713 #define $ac_tr_func 1
10714 EOF
10715
10716 else
10717   echo "$ac_t""no" 1>&6
10718 fi
10719 done
10720
10721   fi
10722
10723
10724   echo $ac_n "checking for ldexpl declaration""... $ac_c" 1>&6
10725 echo "configure:10726: checking for ldexpl declaration" >&5
10726   if test x${glibcpp_cv_func_ldexpl_use+set} != xset; then
10727     if eval "test \"`echo '$''{'glibcpp_cv_func_ldexpl_use'+set}'`\" = set"; then
10728   echo $ac_n "(cached) $ac_c" 1>&6
10729 else
10730
10731
10732       ac_ext=C
10733 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10734 ac_cpp='$CXXCPP $CPPFLAGS'
10735 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10736 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10737 cross_compiling=$ac_cv_prog_cxx_cross
10738
10739       cat > conftest.$ac_ext <<EOF
10740 #line 10741 "configure"
10741 #include "confdefs.h"
10742 #include <math.h>
10743 int main() {
10744  ldexpl(0, 0);
10745 ; return 0; }
10746 EOF
10747 if { (eval echo configure:10748: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10748   rm -rf conftest*
10749   glibcpp_cv_func_ldexpl_use=yes
10750 else
10751   echo "configure: failed program was:" >&5
10752   cat conftest.$ac_ext >&5
10753   rm -rf conftest*
10754   glibcpp_cv_func_ldexpl_use=no
10755 fi
10756 rm -f conftest*
10757       ac_ext=c
10758 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10759 ac_cpp='$CPP $CPPFLAGS'
10760 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10761 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10762 cross_compiling=$ac_cv_prog_cc_cross
10763
10764
10765 fi
10766
10767   fi
10768   echo "$ac_t""$glibcpp_cv_func_ldexpl_use" 1>&6
10769   if test x$glibcpp_cv_func_ldexpl_use = x"yes"; then
10770     for ac_func in ldexpl
10771 do
10772 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10773 echo "configure:10774: checking for $ac_func" >&5
10774 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10775   echo $ac_n "(cached) $ac_c" 1>&6
10776 else
10777   cat > conftest.$ac_ext <<EOF
10778 #line 10779 "configure"
10779 #include "confdefs.h"
10780 /* System header to define __stub macros and hopefully few prototypes,
10781     which can conflict with char $ac_func(); below.  */
10782 #include <assert.h>
10783 /* Override any gcc2 internal prototype to avoid an error.  */
10784 /* We use char because int might match the return type of a gcc2
10785     builtin and then its argument prototype would still apply.  */
10786 char $ac_func();
10787
10788 int main() {
10789
10790 /* The GNU C library defines this for functions which it implements
10791     to always fail with ENOSYS.  Some functions are actually named
10792     something starting with __ and the normal name is an alias.  */
10793 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10794 choke me
10795 #else
10796 $ac_func();
10797 #endif
10798
10799 ; return 0; }
10800 EOF
10801 if { (eval echo configure:10802: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10802   rm -rf conftest*
10803   eval "ac_cv_func_$ac_func=yes"
10804 else
10805   echo "configure: failed program was:" >&5
10806   cat conftest.$ac_ext >&5
10807   rm -rf conftest*
10808   eval "ac_cv_func_$ac_func=no"
10809 fi
10810 rm -f conftest*
10811 fi
10812
10813 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10814   echo "$ac_t""yes" 1>&6
10815     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10816   cat >> confdefs.h <<EOF
10817 #define $ac_tr_func 1
10818 EOF
10819
10820 else
10821   echo "$ac_t""no" 1>&6
10822 fi
10823 done
10824
10825   fi
10826
10827
10828   echo $ac_n "checking for logl declaration""... $ac_c" 1>&6
10829 echo "configure:10830: checking for logl declaration" >&5
10830   if test x${glibcpp_cv_func_logl_use+set} != xset; then
10831     if eval "test \"`echo '$''{'glibcpp_cv_func_logl_use'+set}'`\" = set"; then
10832   echo $ac_n "(cached) $ac_c" 1>&6
10833 else
10834
10835
10836       ac_ext=C
10837 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10838 ac_cpp='$CXXCPP $CPPFLAGS'
10839 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10840 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10841 cross_compiling=$ac_cv_prog_cxx_cross
10842
10843       cat > conftest.$ac_ext <<EOF
10844 #line 10845 "configure"
10845 #include "confdefs.h"
10846 #include <math.h>
10847 int main() {
10848  logl(0);
10849 ; return 0; }
10850 EOF
10851 if { (eval echo configure:10852: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10852   rm -rf conftest*
10853   glibcpp_cv_func_logl_use=yes
10854 else
10855   echo "configure: failed program was:" >&5
10856   cat conftest.$ac_ext >&5
10857   rm -rf conftest*
10858   glibcpp_cv_func_logl_use=no
10859 fi
10860 rm -f conftest*
10861       ac_ext=c
10862 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10863 ac_cpp='$CPP $CPPFLAGS'
10864 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10865 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10866 cross_compiling=$ac_cv_prog_cc_cross
10867
10868
10869 fi
10870
10871   fi
10872   echo "$ac_t""$glibcpp_cv_func_logl_use" 1>&6
10873   if test x$glibcpp_cv_func_logl_use = x"yes"; then
10874     for ac_func in logl
10875 do
10876 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10877 echo "configure:10878: checking for $ac_func" >&5
10878 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10879   echo $ac_n "(cached) $ac_c" 1>&6
10880 else
10881   cat > conftest.$ac_ext <<EOF
10882 #line 10883 "configure"
10883 #include "confdefs.h"
10884 /* System header to define __stub macros and hopefully few prototypes,
10885     which can conflict with char $ac_func(); below.  */
10886 #include <assert.h>
10887 /* Override any gcc2 internal prototype to avoid an error.  */
10888 /* We use char because int might match the return type of a gcc2
10889     builtin and then its argument prototype would still apply.  */
10890 char $ac_func();
10891
10892 int main() {
10893
10894 /* The GNU C library defines this for functions which it implements
10895     to always fail with ENOSYS.  Some functions are actually named
10896     something starting with __ and the normal name is an alias.  */
10897 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10898 choke me
10899 #else
10900 $ac_func();
10901 #endif
10902
10903 ; return 0; }
10904 EOF
10905 if { (eval echo configure:10906: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
10906   rm -rf conftest*
10907   eval "ac_cv_func_$ac_func=yes"
10908 else
10909   echo "configure: failed program was:" >&5
10910   cat conftest.$ac_ext >&5
10911   rm -rf conftest*
10912   eval "ac_cv_func_$ac_func=no"
10913 fi
10914 rm -f conftest*
10915 fi
10916
10917 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
10918   echo "$ac_t""yes" 1>&6
10919     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
10920   cat >> confdefs.h <<EOF
10921 #define $ac_tr_func 1
10922 EOF
10923
10924 else
10925   echo "$ac_t""no" 1>&6
10926 fi
10927 done
10928
10929   fi
10930
10931
10932   echo $ac_n "checking for log10l declaration""... $ac_c" 1>&6
10933 echo "configure:10934: checking for log10l declaration" >&5
10934   if test x${glibcpp_cv_func_log10l_use+set} != xset; then
10935     if eval "test \"`echo '$''{'glibcpp_cv_func_log10l_use'+set}'`\" = set"; then
10936   echo $ac_n "(cached) $ac_c" 1>&6
10937 else
10938
10939
10940       ac_ext=C
10941 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10942 ac_cpp='$CXXCPP $CPPFLAGS'
10943 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10944 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10945 cross_compiling=$ac_cv_prog_cxx_cross
10946
10947       cat > conftest.$ac_ext <<EOF
10948 #line 10949 "configure"
10949 #include "confdefs.h"
10950 #include <math.h>
10951 int main() {
10952  log10l(0);
10953 ; return 0; }
10954 EOF
10955 if { (eval echo configure:10956: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
10956   rm -rf conftest*
10957   glibcpp_cv_func_log10l_use=yes
10958 else
10959   echo "configure: failed program was:" >&5
10960   cat conftest.$ac_ext >&5
10961   rm -rf conftest*
10962   glibcpp_cv_func_log10l_use=no
10963 fi
10964 rm -f conftest*
10965       ac_ext=c
10966 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
10967 ac_cpp='$CPP $CPPFLAGS'
10968 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
10969 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
10970 cross_compiling=$ac_cv_prog_cc_cross
10971
10972
10973 fi
10974
10975   fi
10976   echo "$ac_t""$glibcpp_cv_func_log10l_use" 1>&6
10977   if test x$glibcpp_cv_func_log10l_use = x"yes"; then
10978     for ac_func in log10l
10979 do
10980 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
10981 echo "configure:10982: checking for $ac_func" >&5
10982 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
10983   echo $ac_n "(cached) $ac_c" 1>&6
10984 else
10985   cat > conftest.$ac_ext <<EOF
10986 #line 10987 "configure"
10987 #include "confdefs.h"
10988 /* System header to define __stub macros and hopefully few prototypes,
10989     which can conflict with char $ac_func(); below.  */
10990 #include <assert.h>
10991 /* Override any gcc2 internal prototype to avoid an error.  */
10992 /* We use char because int might match the return type of a gcc2
10993     builtin and then its argument prototype would still apply.  */
10994 char $ac_func();
10995
10996 int main() {
10997
10998 /* The GNU C library defines this for functions which it implements
10999     to always fail with ENOSYS.  Some functions are actually named
11000     something starting with __ and the normal name is an alias.  */
11001 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11002 choke me
11003 #else
11004 $ac_func();
11005 #endif
11006
11007 ; return 0; }
11008 EOF
11009 if { (eval echo configure:11010: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11010   rm -rf conftest*
11011   eval "ac_cv_func_$ac_func=yes"
11012 else
11013   echo "configure: failed program was:" >&5
11014   cat conftest.$ac_ext >&5
11015   rm -rf conftest*
11016   eval "ac_cv_func_$ac_func=no"
11017 fi
11018 rm -f conftest*
11019 fi
11020
11021 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11022   echo "$ac_t""yes" 1>&6
11023     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11024   cat >> confdefs.h <<EOF
11025 #define $ac_tr_func 1
11026 EOF
11027
11028 else
11029   echo "$ac_t""no" 1>&6
11030 fi
11031 done
11032
11033   fi
11034
11035
11036   echo $ac_n "checking for modfl declaration""... $ac_c" 1>&6
11037 echo "configure:11038: checking for modfl declaration" >&5
11038   if test x${glibcpp_cv_func_modfl_use+set} != xset; then
11039     if eval "test \"`echo '$''{'glibcpp_cv_func_modfl_use'+set}'`\" = set"; then
11040   echo $ac_n "(cached) $ac_c" 1>&6
11041 else
11042
11043
11044       ac_ext=C
11045 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11046 ac_cpp='$CXXCPP $CPPFLAGS'
11047 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11048 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11049 cross_compiling=$ac_cv_prog_cxx_cross
11050
11051       cat > conftest.$ac_ext <<EOF
11052 #line 11053 "configure"
11053 #include "confdefs.h"
11054 #include <math.h>
11055 int main() {
11056  modfl(0, 0);
11057 ; return 0; }
11058 EOF
11059 if { (eval echo configure:11060: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11060   rm -rf conftest*
11061   glibcpp_cv_func_modfl_use=yes
11062 else
11063   echo "configure: failed program was:" >&5
11064   cat conftest.$ac_ext >&5
11065   rm -rf conftest*
11066   glibcpp_cv_func_modfl_use=no
11067 fi
11068 rm -f conftest*
11069       ac_ext=c
11070 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11071 ac_cpp='$CPP $CPPFLAGS'
11072 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11073 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11074 cross_compiling=$ac_cv_prog_cc_cross
11075
11076
11077 fi
11078
11079   fi
11080   echo "$ac_t""$glibcpp_cv_func_modfl_use" 1>&6
11081   if test x$glibcpp_cv_func_modfl_use = x"yes"; then
11082     for ac_func in modfl
11083 do
11084 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11085 echo "configure:11086: checking for $ac_func" >&5
11086 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11087   echo $ac_n "(cached) $ac_c" 1>&6
11088 else
11089   cat > conftest.$ac_ext <<EOF
11090 #line 11091 "configure"
11091 #include "confdefs.h"
11092 /* System header to define __stub macros and hopefully few prototypes,
11093     which can conflict with char $ac_func(); below.  */
11094 #include <assert.h>
11095 /* Override any gcc2 internal prototype to avoid an error.  */
11096 /* We use char because int might match the return type of a gcc2
11097     builtin and then its argument prototype would still apply.  */
11098 char $ac_func();
11099
11100 int main() {
11101
11102 /* The GNU C library defines this for functions which it implements
11103     to always fail with ENOSYS.  Some functions are actually named
11104     something starting with __ and the normal name is an alias.  */
11105 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11106 choke me
11107 #else
11108 $ac_func();
11109 #endif
11110
11111 ; return 0; }
11112 EOF
11113 if { (eval echo configure:11114: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11114   rm -rf conftest*
11115   eval "ac_cv_func_$ac_func=yes"
11116 else
11117   echo "configure: failed program was:" >&5
11118   cat conftest.$ac_ext >&5
11119   rm -rf conftest*
11120   eval "ac_cv_func_$ac_func=no"
11121 fi
11122 rm -f conftest*
11123 fi
11124
11125 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11126   echo "$ac_t""yes" 1>&6
11127     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11128   cat >> confdefs.h <<EOF
11129 #define $ac_tr_func 1
11130 EOF
11131
11132 else
11133   echo "$ac_t""no" 1>&6
11134 fi
11135 done
11136
11137   fi
11138
11139
11140   echo $ac_n "checking for powl declaration""... $ac_c" 1>&6
11141 echo "configure:11142: checking for powl declaration" >&5
11142   if test x${glibcpp_cv_func_powl_use+set} != xset; then
11143     if eval "test \"`echo '$''{'glibcpp_cv_func_powl_use'+set}'`\" = set"; then
11144   echo $ac_n "(cached) $ac_c" 1>&6
11145 else
11146
11147
11148       ac_ext=C
11149 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11150 ac_cpp='$CXXCPP $CPPFLAGS'
11151 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11152 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11153 cross_compiling=$ac_cv_prog_cxx_cross
11154
11155       cat > conftest.$ac_ext <<EOF
11156 #line 11157 "configure"
11157 #include "confdefs.h"
11158 #include <math.h>
11159 int main() {
11160  powl(0, 0);
11161 ; return 0; }
11162 EOF
11163 if { (eval echo configure:11164: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11164   rm -rf conftest*
11165   glibcpp_cv_func_powl_use=yes
11166 else
11167   echo "configure: failed program was:" >&5
11168   cat conftest.$ac_ext >&5
11169   rm -rf conftest*
11170   glibcpp_cv_func_powl_use=no
11171 fi
11172 rm -f conftest*
11173       ac_ext=c
11174 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11175 ac_cpp='$CPP $CPPFLAGS'
11176 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11177 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11178 cross_compiling=$ac_cv_prog_cc_cross
11179
11180
11181 fi
11182
11183   fi
11184   echo "$ac_t""$glibcpp_cv_func_powl_use" 1>&6
11185   if test x$glibcpp_cv_func_powl_use = x"yes"; then
11186     for ac_func in powl
11187 do
11188 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11189 echo "configure:11190: checking for $ac_func" >&5
11190 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11191   echo $ac_n "(cached) $ac_c" 1>&6
11192 else
11193   cat > conftest.$ac_ext <<EOF
11194 #line 11195 "configure"
11195 #include "confdefs.h"
11196 /* System header to define __stub macros and hopefully few prototypes,
11197     which can conflict with char $ac_func(); below.  */
11198 #include <assert.h>
11199 /* Override any gcc2 internal prototype to avoid an error.  */
11200 /* We use char because int might match the return type of a gcc2
11201     builtin and then its argument prototype would still apply.  */
11202 char $ac_func();
11203
11204 int main() {
11205
11206 /* The GNU C library defines this for functions which it implements
11207     to always fail with ENOSYS.  Some functions are actually named
11208     something starting with __ and the normal name is an alias.  */
11209 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11210 choke me
11211 #else
11212 $ac_func();
11213 #endif
11214
11215 ; return 0; }
11216 EOF
11217 if { (eval echo configure:11218: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11218   rm -rf conftest*
11219   eval "ac_cv_func_$ac_func=yes"
11220 else
11221   echo "configure: failed program was:" >&5
11222   cat conftest.$ac_ext >&5
11223   rm -rf conftest*
11224   eval "ac_cv_func_$ac_func=no"
11225 fi
11226 rm -f conftest*
11227 fi
11228
11229 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11230   echo "$ac_t""yes" 1>&6
11231     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11232   cat >> confdefs.h <<EOF
11233 #define $ac_tr_func 1
11234 EOF
11235
11236 else
11237   echo "$ac_t""no" 1>&6
11238 fi
11239 done
11240
11241   fi
11242
11243
11244   echo $ac_n "checking for sinl declaration""... $ac_c" 1>&6
11245 echo "configure:11246: checking for sinl declaration" >&5
11246   if test x${glibcpp_cv_func_sinl_use+set} != xset; then
11247     if eval "test \"`echo '$''{'glibcpp_cv_func_sinl_use'+set}'`\" = set"; then
11248   echo $ac_n "(cached) $ac_c" 1>&6
11249 else
11250
11251
11252       ac_ext=C
11253 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11254 ac_cpp='$CXXCPP $CPPFLAGS'
11255 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11256 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11257 cross_compiling=$ac_cv_prog_cxx_cross
11258
11259       cat > conftest.$ac_ext <<EOF
11260 #line 11261 "configure"
11261 #include "confdefs.h"
11262 #include <math.h>
11263 int main() {
11264  sinl(0);
11265 ; return 0; }
11266 EOF
11267 if { (eval echo configure:11268: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11268   rm -rf conftest*
11269   glibcpp_cv_func_sinl_use=yes
11270 else
11271   echo "configure: failed program was:" >&5
11272   cat conftest.$ac_ext >&5
11273   rm -rf conftest*
11274   glibcpp_cv_func_sinl_use=no
11275 fi
11276 rm -f conftest*
11277       ac_ext=c
11278 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11279 ac_cpp='$CPP $CPPFLAGS'
11280 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11281 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11282 cross_compiling=$ac_cv_prog_cc_cross
11283
11284
11285 fi
11286
11287   fi
11288   echo "$ac_t""$glibcpp_cv_func_sinl_use" 1>&6
11289   if test x$glibcpp_cv_func_sinl_use = x"yes"; then
11290     for ac_func in sinl
11291 do
11292 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11293 echo "configure:11294: checking for $ac_func" >&5
11294 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11295   echo $ac_n "(cached) $ac_c" 1>&6
11296 else
11297   cat > conftest.$ac_ext <<EOF
11298 #line 11299 "configure"
11299 #include "confdefs.h"
11300 /* System header to define __stub macros and hopefully few prototypes,
11301     which can conflict with char $ac_func(); below.  */
11302 #include <assert.h>
11303 /* Override any gcc2 internal prototype to avoid an error.  */
11304 /* We use char because int might match the return type of a gcc2
11305     builtin and then its argument prototype would still apply.  */
11306 char $ac_func();
11307
11308 int main() {
11309
11310 /* The GNU C library defines this for functions which it implements
11311     to always fail with ENOSYS.  Some functions are actually named
11312     something starting with __ and the normal name is an alias.  */
11313 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11314 choke me
11315 #else
11316 $ac_func();
11317 #endif
11318
11319 ; return 0; }
11320 EOF
11321 if { (eval echo configure:11322: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11322   rm -rf conftest*
11323   eval "ac_cv_func_$ac_func=yes"
11324 else
11325   echo "configure: failed program was:" >&5
11326   cat conftest.$ac_ext >&5
11327   rm -rf conftest*
11328   eval "ac_cv_func_$ac_func=no"
11329 fi
11330 rm -f conftest*
11331 fi
11332
11333 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11334   echo "$ac_t""yes" 1>&6
11335     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11336   cat >> confdefs.h <<EOF
11337 #define $ac_tr_func 1
11338 EOF
11339
11340 else
11341   echo "$ac_t""no" 1>&6
11342 fi
11343 done
11344
11345   fi
11346
11347
11348   echo $ac_n "checking for sinhl declaration""... $ac_c" 1>&6
11349 echo "configure:11350: checking for sinhl declaration" >&5
11350   if test x${glibcpp_cv_func_sinhl_use+set} != xset; then
11351     if eval "test \"`echo '$''{'glibcpp_cv_func_sinhl_use'+set}'`\" = set"; then
11352   echo $ac_n "(cached) $ac_c" 1>&6
11353 else
11354
11355
11356       ac_ext=C
11357 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11358 ac_cpp='$CXXCPP $CPPFLAGS'
11359 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11360 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11361 cross_compiling=$ac_cv_prog_cxx_cross
11362
11363       cat > conftest.$ac_ext <<EOF
11364 #line 11365 "configure"
11365 #include "confdefs.h"
11366 #include <math.h>
11367 int main() {
11368  sinhl(0);
11369 ; return 0; }
11370 EOF
11371 if { (eval echo configure:11372: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11372   rm -rf conftest*
11373   glibcpp_cv_func_sinhl_use=yes
11374 else
11375   echo "configure: failed program was:" >&5
11376   cat conftest.$ac_ext >&5
11377   rm -rf conftest*
11378   glibcpp_cv_func_sinhl_use=no
11379 fi
11380 rm -f conftest*
11381       ac_ext=c
11382 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11383 ac_cpp='$CPP $CPPFLAGS'
11384 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11385 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11386 cross_compiling=$ac_cv_prog_cc_cross
11387
11388
11389 fi
11390
11391   fi
11392   echo "$ac_t""$glibcpp_cv_func_sinhl_use" 1>&6
11393   if test x$glibcpp_cv_func_sinhl_use = x"yes"; then
11394     for ac_func in sinhl
11395 do
11396 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11397 echo "configure:11398: checking for $ac_func" >&5
11398 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11399   echo $ac_n "(cached) $ac_c" 1>&6
11400 else
11401   cat > conftest.$ac_ext <<EOF
11402 #line 11403 "configure"
11403 #include "confdefs.h"
11404 /* System header to define __stub macros and hopefully few prototypes,
11405     which can conflict with char $ac_func(); below.  */
11406 #include <assert.h>
11407 /* Override any gcc2 internal prototype to avoid an error.  */
11408 /* We use char because int might match the return type of a gcc2
11409     builtin and then its argument prototype would still apply.  */
11410 char $ac_func();
11411
11412 int main() {
11413
11414 /* The GNU C library defines this for functions which it implements
11415     to always fail with ENOSYS.  Some functions are actually named
11416     something starting with __ and the normal name is an alias.  */
11417 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11418 choke me
11419 #else
11420 $ac_func();
11421 #endif
11422
11423 ; return 0; }
11424 EOF
11425 if { (eval echo configure:11426: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11426   rm -rf conftest*
11427   eval "ac_cv_func_$ac_func=yes"
11428 else
11429   echo "configure: failed program was:" >&5
11430   cat conftest.$ac_ext >&5
11431   rm -rf conftest*
11432   eval "ac_cv_func_$ac_func=no"
11433 fi
11434 rm -f conftest*
11435 fi
11436
11437 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11438   echo "$ac_t""yes" 1>&6
11439     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11440   cat >> confdefs.h <<EOF
11441 #define $ac_tr_func 1
11442 EOF
11443
11444 else
11445   echo "$ac_t""no" 1>&6
11446 fi
11447 done
11448
11449   fi
11450
11451
11452   echo $ac_n "checking for sqrtl declaration""... $ac_c" 1>&6
11453 echo "configure:11454: checking for sqrtl declaration" >&5
11454   if test x${glibcpp_cv_func_sqrtl_use+set} != xset; then
11455     if eval "test \"`echo '$''{'glibcpp_cv_func_sqrtl_use'+set}'`\" = set"; then
11456   echo $ac_n "(cached) $ac_c" 1>&6
11457 else
11458
11459
11460       ac_ext=C
11461 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11462 ac_cpp='$CXXCPP $CPPFLAGS'
11463 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11464 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11465 cross_compiling=$ac_cv_prog_cxx_cross
11466
11467       cat > conftest.$ac_ext <<EOF
11468 #line 11469 "configure"
11469 #include "confdefs.h"
11470 #include <math.h>
11471 int main() {
11472  sqrtl(0);
11473 ; return 0; }
11474 EOF
11475 if { (eval echo configure:11476: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11476   rm -rf conftest*
11477   glibcpp_cv_func_sqrtl_use=yes
11478 else
11479   echo "configure: failed program was:" >&5
11480   cat conftest.$ac_ext >&5
11481   rm -rf conftest*
11482   glibcpp_cv_func_sqrtl_use=no
11483 fi
11484 rm -f conftest*
11485       ac_ext=c
11486 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11487 ac_cpp='$CPP $CPPFLAGS'
11488 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11489 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11490 cross_compiling=$ac_cv_prog_cc_cross
11491
11492
11493 fi
11494
11495   fi
11496   echo "$ac_t""$glibcpp_cv_func_sqrtl_use" 1>&6
11497   if test x$glibcpp_cv_func_sqrtl_use = x"yes"; then
11498     for ac_func in sqrtl
11499 do
11500 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11501 echo "configure:11502: checking for $ac_func" >&5
11502 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11503   echo $ac_n "(cached) $ac_c" 1>&6
11504 else
11505   cat > conftest.$ac_ext <<EOF
11506 #line 11507 "configure"
11507 #include "confdefs.h"
11508 /* System header to define __stub macros and hopefully few prototypes,
11509     which can conflict with char $ac_func(); below.  */
11510 #include <assert.h>
11511 /* Override any gcc2 internal prototype to avoid an error.  */
11512 /* We use char because int might match the return type of a gcc2
11513     builtin and then its argument prototype would still apply.  */
11514 char $ac_func();
11515
11516 int main() {
11517
11518 /* The GNU C library defines this for functions which it implements
11519     to always fail with ENOSYS.  Some functions are actually named
11520     something starting with __ and the normal name is an alias.  */
11521 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11522 choke me
11523 #else
11524 $ac_func();
11525 #endif
11526
11527 ; return 0; }
11528 EOF
11529 if { (eval echo configure:11530: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11530   rm -rf conftest*
11531   eval "ac_cv_func_$ac_func=yes"
11532 else
11533   echo "configure: failed program was:" >&5
11534   cat conftest.$ac_ext >&5
11535   rm -rf conftest*
11536   eval "ac_cv_func_$ac_func=no"
11537 fi
11538 rm -f conftest*
11539 fi
11540
11541 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11542   echo "$ac_t""yes" 1>&6
11543     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11544   cat >> confdefs.h <<EOF
11545 #define $ac_tr_func 1
11546 EOF
11547
11548 else
11549   echo "$ac_t""no" 1>&6
11550 fi
11551 done
11552
11553   fi
11554
11555
11556   echo $ac_n "checking for tanl declaration""... $ac_c" 1>&6
11557 echo "configure:11558: checking for tanl declaration" >&5
11558   if test x${glibcpp_cv_func_tanl_use+set} != xset; then
11559     if eval "test \"`echo '$''{'glibcpp_cv_func_tanl_use'+set}'`\" = set"; then
11560   echo $ac_n "(cached) $ac_c" 1>&6
11561 else
11562
11563
11564       ac_ext=C
11565 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11566 ac_cpp='$CXXCPP $CPPFLAGS'
11567 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11568 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11569 cross_compiling=$ac_cv_prog_cxx_cross
11570
11571       cat > conftest.$ac_ext <<EOF
11572 #line 11573 "configure"
11573 #include "confdefs.h"
11574 #include <math.h>
11575 int main() {
11576  tanl(0);
11577 ; return 0; }
11578 EOF
11579 if { (eval echo configure:11580: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11580   rm -rf conftest*
11581   glibcpp_cv_func_tanl_use=yes
11582 else
11583   echo "configure: failed program was:" >&5
11584   cat conftest.$ac_ext >&5
11585   rm -rf conftest*
11586   glibcpp_cv_func_tanl_use=no
11587 fi
11588 rm -f conftest*
11589       ac_ext=c
11590 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11591 ac_cpp='$CPP $CPPFLAGS'
11592 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11593 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11594 cross_compiling=$ac_cv_prog_cc_cross
11595
11596
11597 fi
11598
11599   fi
11600   echo "$ac_t""$glibcpp_cv_func_tanl_use" 1>&6
11601   if test x$glibcpp_cv_func_tanl_use = x"yes"; then
11602     for ac_func in tanl
11603 do
11604 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11605 echo "configure:11606: checking for $ac_func" >&5
11606 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11607   echo $ac_n "(cached) $ac_c" 1>&6
11608 else
11609   cat > conftest.$ac_ext <<EOF
11610 #line 11611 "configure"
11611 #include "confdefs.h"
11612 /* System header to define __stub macros and hopefully few prototypes,
11613     which can conflict with char $ac_func(); below.  */
11614 #include <assert.h>
11615 /* Override any gcc2 internal prototype to avoid an error.  */
11616 /* We use char because int might match the return type of a gcc2
11617     builtin and then its argument prototype would still apply.  */
11618 char $ac_func();
11619
11620 int main() {
11621
11622 /* The GNU C library defines this for functions which it implements
11623     to always fail with ENOSYS.  Some functions are actually named
11624     something starting with __ and the normal name is an alias.  */
11625 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11626 choke me
11627 #else
11628 $ac_func();
11629 #endif
11630
11631 ; return 0; }
11632 EOF
11633 if { (eval echo configure:11634: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11634   rm -rf conftest*
11635   eval "ac_cv_func_$ac_func=yes"
11636 else
11637   echo "configure: failed program was:" >&5
11638   cat conftest.$ac_ext >&5
11639   rm -rf conftest*
11640   eval "ac_cv_func_$ac_func=no"
11641 fi
11642 rm -f conftest*
11643 fi
11644
11645 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11646   echo "$ac_t""yes" 1>&6
11647     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11648   cat >> confdefs.h <<EOF
11649 #define $ac_tr_func 1
11650 EOF
11651
11652 else
11653   echo "$ac_t""no" 1>&6
11654 fi
11655 done
11656
11657   fi
11658
11659
11660   echo $ac_n "checking for tanhl declaration""... $ac_c" 1>&6
11661 echo "configure:11662: checking for tanhl declaration" >&5
11662   if test x${glibcpp_cv_func_tanhl_use+set} != xset; then
11663     if eval "test \"`echo '$''{'glibcpp_cv_func_tanhl_use'+set}'`\" = set"; then
11664   echo $ac_n "(cached) $ac_c" 1>&6
11665 else
11666
11667
11668       ac_ext=C
11669 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11670 ac_cpp='$CXXCPP $CPPFLAGS'
11671 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11672 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11673 cross_compiling=$ac_cv_prog_cxx_cross
11674
11675       cat > conftest.$ac_ext <<EOF
11676 #line 11677 "configure"
11677 #include "confdefs.h"
11678 #include <math.h>
11679 int main() {
11680  tanhl(0);
11681 ; return 0; }
11682 EOF
11683 if { (eval echo configure:11684: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11684   rm -rf conftest*
11685   glibcpp_cv_func_tanhl_use=yes
11686 else
11687   echo "configure: failed program was:" >&5
11688   cat conftest.$ac_ext >&5
11689   rm -rf conftest*
11690   glibcpp_cv_func_tanhl_use=no
11691 fi
11692 rm -f conftest*
11693       ac_ext=c
11694 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11695 ac_cpp='$CPP $CPPFLAGS'
11696 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11697 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11698 cross_compiling=$ac_cv_prog_cc_cross
11699
11700
11701 fi
11702
11703   fi
11704   echo "$ac_t""$glibcpp_cv_func_tanhl_use" 1>&6
11705   if test x$glibcpp_cv_func_tanhl_use = x"yes"; then
11706     for ac_func in tanhl
11707 do
11708 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11709 echo "configure:11710: checking for $ac_func" >&5
11710 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11711   echo $ac_n "(cached) $ac_c" 1>&6
11712 else
11713   cat > conftest.$ac_ext <<EOF
11714 #line 11715 "configure"
11715 #include "confdefs.h"
11716 /* System header to define __stub macros and hopefully few prototypes,
11717     which can conflict with char $ac_func(); below.  */
11718 #include <assert.h>
11719 /* Override any gcc2 internal prototype to avoid an error.  */
11720 /* We use char because int might match the return type of a gcc2
11721     builtin and then its argument prototype would still apply.  */
11722 char $ac_func();
11723
11724 int main() {
11725
11726 /* The GNU C library defines this for functions which it implements
11727     to always fail with ENOSYS.  Some functions are actually named
11728     something starting with __ and the normal name is an alias.  */
11729 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11730 choke me
11731 #else
11732 $ac_func();
11733 #endif
11734
11735 ; return 0; }
11736 EOF
11737 if { (eval echo configure:11738: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11738   rm -rf conftest*
11739   eval "ac_cv_func_$ac_func=yes"
11740 else
11741   echo "configure: failed program was:" >&5
11742   cat conftest.$ac_ext >&5
11743   rm -rf conftest*
11744   eval "ac_cv_func_$ac_func=no"
11745 fi
11746 rm -f conftest*
11747 fi
11748
11749 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11750   echo "$ac_t""yes" 1>&6
11751     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11752   cat >> confdefs.h <<EOF
11753 #define $ac_tr_func 1
11754 EOF
11755
11756 else
11757   echo "$ac_t""no" 1>&6
11758 fi
11759 done
11760
11761   fi
11762
11763
11764   echo $ac_n "checking for sincosl declaration""... $ac_c" 1>&6
11765 echo "configure:11766: checking for sincosl declaration" >&5
11766   if test x${glibcpp_cv_func_sincosl_use+set} != xset; then
11767     if eval "test \"`echo '$''{'glibcpp_cv_func_sincosl_use'+set}'`\" = set"; then
11768   echo $ac_n "(cached) $ac_c" 1>&6
11769 else
11770
11771
11772       ac_ext=C
11773 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11774 ac_cpp='$CXXCPP $CPPFLAGS'
11775 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11776 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11777 cross_compiling=$ac_cv_prog_cxx_cross
11778
11779       cat > conftest.$ac_ext <<EOF
11780 #line 11781 "configure"
11781 #include "confdefs.h"
11782 #include <math.h>
11783 int main() {
11784  sincosl(0, 0, 0);
11785 ; return 0; }
11786 EOF
11787 if { (eval echo configure:11788: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11788   rm -rf conftest*
11789   glibcpp_cv_func_sincosl_use=yes
11790 else
11791   echo "configure: failed program was:" >&5
11792   cat conftest.$ac_ext >&5
11793   rm -rf conftest*
11794   glibcpp_cv_func_sincosl_use=no
11795 fi
11796 rm -f conftest*
11797       ac_ext=c
11798 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11799 ac_cpp='$CPP $CPPFLAGS'
11800 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11801 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11802 cross_compiling=$ac_cv_prog_cc_cross
11803
11804
11805 fi
11806
11807   fi
11808   echo "$ac_t""$glibcpp_cv_func_sincosl_use" 1>&6
11809   if test x$glibcpp_cv_func_sincosl_use = x"yes"; then
11810     for ac_func in sincosl
11811 do
11812 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11813 echo "configure:11814: checking for $ac_func" >&5
11814 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11815   echo $ac_n "(cached) $ac_c" 1>&6
11816 else
11817   cat > conftest.$ac_ext <<EOF
11818 #line 11819 "configure"
11819 #include "confdefs.h"
11820 /* System header to define __stub macros and hopefully few prototypes,
11821     which can conflict with char $ac_func(); below.  */
11822 #include <assert.h>
11823 /* Override any gcc2 internal prototype to avoid an error.  */
11824 /* We use char because int might match the return type of a gcc2
11825     builtin and then its argument prototype would still apply.  */
11826 char $ac_func();
11827
11828 int main() {
11829
11830 /* The GNU C library defines this for functions which it implements
11831     to always fail with ENOSYS.  Some functions are actually named
11832     something starting with __ and the normal name is an alias.  */
11833 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11834 choke me
11835 #else
11836 $ac_func();
11837 #endif
11838
11839 ; return 0; }
11840 EOF
11841 if { (eval echo configure:11842: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11842   rm -rf conftest*
11843   eval "ac_cv_func_$ac_func=yes"
11844 else
11845   echo "configure: failed program was:" >&5
11846   cat conftest.$ac_ext >&5
11847   rm -rf conftest*
11848   eval "ac_cv_func_$ac_func=no"
11849 fi
11850 rm -f conftest*
11851 fi
11852
11853 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11854   echo "$ac_t""yes" 1>&6
11855     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11856   cat >> confdefs.h <<EOF
11857 #define $ac_tr_func 1
11858 EOF
11859
11860 else
11861   echo "$ac_t""no" 1>&6
11862 fi
11863 done
11864
11865   fi
11866
11867
11868   echo $ac_n "checking for finitel declaration""... $ac_c" 1>&6
11869 echo "configure:11870: checking for finitel declaration" >&5
11870   if test x${glibcpp_cv_func_finitel_use+set} != xset; then
11871     if eval "test \"`echo '$''{'glibcpp_cv_func_finitel_use'+set}'`\" = set"; then
11872   echo $ac_n "(cached) $ac_c" 1>&6
11873 else
11874
11875
11876       ac_ext=C
11877 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11878 ac_cpp='$CXXCPP $CPPFLAGS'
11879 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11880 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11881 cross_compiling=$ac_cv_prog_cxx_cross
11882
11883       cat > conftest.$ac_ext <<EOF
11884 #line 11885 "configure"
11885 #include "confdefs.h"
11886 #include <math.h>
11887 int main() {
11888  finitel(0);
11889 ; return 0; }
11890 EOF
11891 if { (eval echo configure:11892: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11892   rm -rf conftest*
11893   glibcpp_cv_func_finitel_use=yes
11894 else
11895   echo "configure: failed program was:" >&5
11896   cat conftest.$ac_ext >&5
11897   rm -rf conftest*
11898   glibcpp_cv_func_finitel_use=no
11899 fi
11900 rm -f conftest*
11901       ac_ext=c
11902 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11903 ac_cpp='$CPP $CPPFLAGS'
11904 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11905 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11906 cross_compiling=$ac_cv_prog_cc_cross
11907
11908
11909 fi
11910
11911   fi
11912   echo "$ac_t""$glibcpp_cv_func_finitel_use" 1>&6
11913   if test x$glibcpp_cv_func_finitel_use = x"yes"; then
11914     for ac_func in finitel
11915 do
11916 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
11917 echo "configure:11918: checking for $ac_func" >&5
11918 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
11919   echo $ac_n "(cached) $ac_c" 1>&6
11920 else
11921   cat > conftest.$ac_ext <<EOF
11922 #line 11923 "configure"
11923 #include "confdefs.h"
11924 /* System header to define __stub macros and hopefully few prototypes,
11925     which can conflict with char $ac_func(); below.  */
11926 #include <assert.h>
11927 /* Override any gcc2 internal prototype to avoid an error.  */
11928 /* We use char because int might match the return type of a gcc2
11929     builtin and then its argument prototype would still apply.  */
11930 char $ac_func();
11931
11932 int main() {
11933
11934 /* The GNU C library defines this for functions which it implements
11935     to always fail with ENOSYS.  Some functions are actually named
11936     something starting with __ and the normal name is an alias.  */
11937 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
11938 choke me
11939 #else
11940 $ac_func();
11941 #endif
11942
11943 ; return 0; }
11944 EOF
11945 if { (eval echo configure:11946: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
11946   rm -rf conftest*
11947   eval "ac_cv_func_$ac_func=yes"
11948 else
11949   echo "configure: failed program was:" >&5
11950   cat conftest.$ac_ext >&5
11951   rm -rf conftest*
11952   eval "ac_cv_func_$ac_func=no"
11953 fi
11954 rm -f conftest*
11955 fi
11956
11957 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
11958   echo "$ac_t""yes" 1>&6
11959     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
11960   cat >> confdefs.h <<EOF
11961 #define $ac_tr_func 1
11962 EOF
11963
11964 else
11965   echo "$ac_t""no" 1>&6
11966 fi
11967 done
11968
11969   fi
11970
11971
11972
11973   echo $ac_n "checking for _isinf declaration""... $ac_c" 1>&6
11974 echo "configure:11975: checking for _isinf declaration" >&5
11975   if test x${glibcpp_cv_func__isinf_use+set} != xset; then
11976     if eval "test \"`echo '$''{'glibcpp_cv_func__isinf_use'+set}'`\" = set"; then
11977   echo $ac_n "(cached) $ac_c" 1>&6
11978 else
11979
11980
11981       ac_ext=C
11982 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
11983 ac_cpp='$CXXCPP $CPPFLAGS'
11984 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
11985 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
11986 cross_compiling=$ac_cv_prog_cxx_cross
11987
11988       cat > conftest.$ac_ext <<EOF
11989 #line 11990 "configure"
11990 #include "confdefs.h"
11991 #include <math.h>
11992 int main() {
11993  _isinf(0);
11994 ; return 0; }
11995 EOF
11996 if { (eval echo configure:11997: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
11997   rm -rf conftest*
11998   glibcpp_cv_func__isinf_use=yes
11999 else
12000   echo "configure: failed program was:" >&5
12001   cat conftest.$ac_ext >&5
12002   rm -rf conftest*
12003   glibcpp_cv_func__isinf_use=no
12004 fi
12005 rm -f conftest*
12006       ac_ext=c
12007 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12008 ac_cpp='$CPP $CPPFLAGS'
12009 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12010 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12011 cross_compiling=$ac_cv_prog_cc_cross
12012
12013
12014 fi
12015
12016   fi
12017   echo "$ac_t""$glibcpp_cv_func__isinf_use" 1>&6
12018   if test x$glibcpp_cv_func__isinf_use = x"yes"; then
12019     for ac_func in _isinf
12020 do
12021 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12022 echo "configure:12023: checking for $ac_func" >&5
12023 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12024   echo $ac_n "(cached) $ac_c" 1>&6
12025 else
12026   cat > conftest.$ac_ext <<EOF
12027 #line 12028 "configure"
12028 #include "confdefs.h"
12029 /* System header to define __stub macros and hopefully few prototypes,
12030     which can conflict with char $ac_func(); below.  */
12031 #include <assert.h>
12032 /* Override any gcc2 internal prototype to avoid an error.  */
12033 /* We use char because int might match the return type of a gcc2
12034     builtin and then its argument prototype would still apply.  */
12035 char $ac_func();
12036
12037 int main() {
12038
12039 /* The GNU C library defines this for functions which it implements
12040     to always fail with ENOSYS.  Some functions are actually named
12041     something starting with __ and the normal name is an alias.  */
12042 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12043 choke me
12044 #else
12045 $ac_func();
12046 #endif
12047
12048 ; return 0; }
12049 EOF
12050 if { (eval echo configure:12051: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12051   rm -rf conftest*
12052   eval "ac_cv_func_$ac_func=yes"
12053 else
12054   echo "configure: failed program was:" >&5
12055   cat conftest.$ac_ext >&5
12056   rm -rf conftest*
12057   eval "ac_cv_func_$ac_func=no"
12058 fi
12059 rm -f conftest*
12060 fi
12061
12062 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12063   echo "$ac_t""yes" 1>&6
12064     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12065   cat >> confdefs.h <<EOF
12066 #define $ac_tr_func 1
12067 EOF
12068
12069 else
12070   echo "$ac_t""no" 1>&6
12071 fi
12072 done
12073
12074   fi
12075
12076
12077   echo $ac_n "checking for _isnan declaration""... $ac_c" 1>&6
12078 echo "configure:12079: checking for _isnan declaration" >&5
12079   if test x${glibcpp_cv_func__isnan_use+set} != xset; then
12080     if eval "test \"`echo '$''{'glibcpp_cv_func__isnan_use'+set}'`\" = set"; then
12081   echo $ac_n "(cached) $ac_c" 1>&6
12082 else
12083
12084
12085       ac_ext=C
12086 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12087 ac_cpp='$CXXCPP $CPPFLAGS'
12088 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12089 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12090 cross_compiling=$ac_cv_prog_cxx_cross
12091
12092       cat > conftest.$ac_ext <<EOF
12093 #line 12094 "configure"
12094 #include "confdefs.h"
12095 #include <math.h>
12096 int main() {
12097  _isnan(0);
12098 ; return 0; }
12099 EOF
12100 if { (eval echo configure:12101: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12101   rm -rf conftest*
12102   glibcpp_cv_func__isnan_use=yes
12103 else
12104   echo "configure: failed program was:" >&5
12105   cat conftest.$ac_ext >&5
12106   rm -rf conftest*
12107   glibcpp_cv_func__isnan_use=no
12108 fi
12109 rm -f conftest*
12110       ac_ext=c
12111 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12112 ac_cpp='$CPP $CPPFLAGS'
12113 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12114 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12115 cross_compiling=$ac_cv_prog_cc_cross
12116
12117
12118 fi
12119
12120   fi
12121   echo "$ac_t""$glibcpp_cv_func__isnan_use" 1>&6
12122   if test x$glibcpp_cv_func__isnan_use = x"yes"; then
12123     for ac_func in _isnan
12124 do
12125 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12126 echo "configure:12127: checking for $ac_func" >&5
12127 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12128   echo $ac_n "(cached) $ac_c" 1>&6
12129 else
12130   cat > conftest.$ac_ext <<EOF
12131 #line 12132 "configure"
12132 #include "confdefs.h"
12133 /* System header to define __stub macros and hopefully few prototypes,
12134     which can conflict with char $ac_func(); below.  */
12135 #include <assert.h>
12136 /* Override any gcc2 internal prototype to avoid an error.  */
12137 /* We use char because int might match the return type of a gcc2
12138     builtin and then its argument prototype would still apply.  */
12139 char $ac_func();
12140
12141 int main() {
12142
12143 /* The GNU C library defines this for functions which it implements
12144     to always fail with ENOSYS.  Some functions are actually named
12145     something starting with __ and the normal name is an alias.  */
12146 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12147 choke me
12148 #else
12149 $ac_func();
12150 #endif
12151
12152 ; return 0; }
12153 EOF
12154 if { (eval echo configure:12155: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12155   rm -rf conftest*
12156   eval "ac_cv_func_$ac_func=yes"
12157 else
12158   echo "configure: failed program was:" >&5
12159   cat conftest.$ac_ext >&5
12160   rm -rf conftest*
12161   eval "ac_cv_func_$ac_func=no"
12162 fi
12163 rm -f conftest*
12164 fi
12165
12166 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12167   echo "$ac_t""yes" 1>&6
12168     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12169   cat >> confdefs.h <<EOF
12170 #define $ac_tr_func 1
12171 EOF
12172
12173 else
12174   echo "$ac_t""no" 1>&6
12175 fi
12176 done
12177
12178   fi
12179
12180
12181   echo $ac_n "checking for _finite declaration""... $ac_c" 1>&6
12182 echo "configure:12183: checking for _finite declaration" >&5
12183   if test x${glibcpp_cv_func__finite_use+set} != xset; then
12184     if eval "test \"`echo '$''{'glibcpp_cv_func__finite_use'+set}'`\" = set"; then
12185   echo $ac_n "(cached) $ac_c" 1>&6
12186 else
12187
12188
12189       ac_ext=C
12190 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12191 ac_cpp='$CXXCPP $CPPFLAGS'
12192 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12193 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12194 cross_compiling=$ac_cv_prog_cxx_cross
12195
12196       cat > conftest.$ac_ext <<EOF
12197 #line 12198 "configure"
12198 #include "confdefs.h"
12199 #include <math.h>
12200 int main() {
12201  _finite(0);
12202 ; return 0; }
12203 EOF
12204 if { (eval echo configure:12205: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12205   rm -rf conftest*
12206   glibcpp_cv_func__finite_use=yes
12207 else
12208   echo "configure: failed program was:" >&5
12209   cat conftest.$ac_ext >&5
12210   rm -rf conftest*
12211   glibcpp_cv_func__finite_use=no
12212 fi
12213 rm -f conftest*
12214       ac_ext=c
12215 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12216 ac_cpp='$CPP $CPPFLAGS'
12217 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12218 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12219 cross_compiling=$ac_cv_prog_cc_cross
12220
12221
12222 fi
12223
12224   fi
12225   echo "$ac_t""$glibcpp_cv_func__finite_use" 1>&6
12226   if test x$glibcpp_cv_func__finite_use = x"yes"; then
12227     for ac_func in _finite
12228 do
12229 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12230 echo "configure:12231: checking for $ac_func" >&5
12231 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12232   echo $ac_n "(cached) $ac_c" 1>&6
12233 else
12234   cat > conftest.$ac_ext <<EOF
12235 #line 12236 "configure"
12236 #include "confdefs.h"
12237 /* System header to define __stub macros and hopefully few prototypes,
12238     which can conflict with char $ac_func(); below.  */
12239 #include <assert.h>
12240 /* Override any gcc2 internal prototype to avoid an error.  */
12241 /* We use char because int might match the return type of a gcc2
12242     builtin and then its argument prototype would still apply.  */
12243 char $ac_func();
12244
12245 int main() {
12246
12247 /* The GNU C library defines this for functions which it implements
12248     to always fail with ENOSYS.  Some functions are actually named
12249     something starting with __ and the normal name is an alias.  */
12250 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12251 choke me
12252 #else
12253 $ac_func();
12254 #endif
12255
12256 ; return 0; }
12257 EOF
12258 if { (eval echo configure:12259: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12259   rm -rf conftest*
12260   eval "ac_cv_func_$ac_func=yes"
12261 else
12262   echo "configure: failed program was:" >&5
12263   cat conftest.$ac_ext >&5
12264   rm -rf conftest*
12265   eval "ac_cv_func_$ac_func=no"
12266 fi
12267 rm -f conftest*
12268 fi
12269
12270 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12271   echo "$ac_t""yes" 1>&6
12272     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12273   cat >> confdefs.h <<EOF
12274 #define $ac_tr_func 1
12275 EOF
12276
12277 else
12278   echo "$ac_t""no" 1>&6
12279 fi
12280 done
12281
12282   fi
12283
12284
12285   echo $ac_n "checking for _copysign declaration""... $ac_c" 1>&6
12286 echo "configure:12287: checking for _copysign declaration" >&5
12287   if test x${glibcpp_cv_func__copysign_use+set} != xset; then
12288     if eval "test \"`echo '$''{'glibcpp_cv_func__copysign_use'+set}'`\" = set"; then
12289   echo $ac_n "(cached) $ac_c" 1>&6
12290 else
12291
12292
12293       ac_ext=C
12294 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12295 ac_cpp='$CXXCPP $CPPFLAGS'
12296 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12297 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12298 cross_compiling=$ac_cv_prog_cxx_cross
12299
12300       cat > conftest.$ac_ext <<EOF
12301 #line 12302 "configure"
12302 #include "confdefs.h"
12303 #include <math.h>
12304 int main() {
12305  _copysign(0, 0);
12306 ; return 0; }
12307 EOF
12308 if { (eval echo configure:12309: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12309   rm -rf conftest*
12310   glibcpp_cv_func__copysign_use=yes
12311 else
12312   echo "configure: failed program was:" >&5
12313   cat conftest.$ac_ext >&5
12314   rm -rf conftest*
12315   glibcpp_cv_func__copysign_use=no
12316 fi
12317 rm -f conftest*
12318       ac_ext=c
12319 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12320 ac_cpp='$CPP $CPPFLAGS'
12321 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12322 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12323 cross_compiling=$ac_cv_prog_cc_cross
12324
12325
12326 fi
12327
12328   fi
12329   echo "$ac_t""$glibcpp_cv_func__copysign_use" 1>&6
12330   if test x$glibcpp_cv_func__copysign_use = x"yes"; then
12331     for ac_func in _copysign
12332 do
12333 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12334 echo "configure:12335: checking for $ac_func" >&5
12335 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12336   echo $ac_n "(cached) $ac_c" 1>&6
12337 else
12338   cat > conftest.$ac_ext <<EOF
12339 #line 12340 "configure"
12340 #include "confdefs.h"
12341 /* System header to define __stub macros and hopefully few prototypes,
12342     which can conflict with char $ac_func(); below.  */
12343 #include <assert.h>
12344 /* Override any gcc2 internal prototype to avoid an error.  */
12345 /* We use char because int might match the return type of a gcc2
12346     builtin and then its argument prototype would still apply.  */
12347 char $ac_func();
12348
12349 int main() {
12350
12351 /* The GNU C library defines this for functions which it implements
12352     to always fail with ENOSYS.  Some functions are actually named
12353     something starting with __ and the normal name is an alias.  */
12354 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12355 choke me
12356 #else
12357 $ac_func();
12358 #endif
12359
12360 ; return 0; }
12361 EOF
12362 if { (eval echo configure:12363: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12363   rm -rf conftest*
12364   eval "ac_cv_func_$ac_func=yes"
12365 else
12366   echo "configure: failed program was:" >&5
12367   cat conftest.$ac_ext >&5
12368   rm -rf conftest*
12369   eval "ac_cv_func_$ac_func=no"
12370 fi
12371 rm -f conftest*
12372 fi
12373
12374 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12375   echo "$ac_t""yes" 1>&6
12376     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12377   cat >> confdefs.h <<EOF
12378 #define $ac_tr_func 1
12379 EOF
12380
12381 else
12382   echo "$ac_t""no" 1>&6
12383 fi
12384 done
12385
12386   fi
12387
12388
12389   echo $ac_n "checking for _sincos declaration""... $ac_c" 1>&6
12390 echo "configure:12391: checking for _sincos declaration" >&5
12391   if test x${glibcpp_cv_func__sincos_use+set} != xset; then
12392     if eval "test \"`echo '$''{'glibcpp_cv_func__sincos_use'+set}'`\" = set"; then
12393   echo $ac_n "(cached) $ac_c" 1>&6
12394 else
12395
12396
12397       ac_ext=C
12398 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12399 ac_cpp='$CXXCPP $CPPFLAGS'
12400 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12401 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12402 cross_compiling=$ac_cv_prog_cxx_cross
12403
12404       cat > conftest.$ac_ext <<EOF
12405 #line 12406 "configure"
12406 #include "confdefs.h"
12407 #include <math.h>
12408 int main() {
12409  _sincos(0, 0, 0);
12410 ; return 0; }
12411 EOF
12412 if { (eval echo configure:12413: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12413   rm -rf conftest*
12414   glibcpp_cv_func__sincos_use=yes
12415 else
12416   echo "configure: failed program was:" >&5
12417   cat conftest.$ac_ext >&5
12418   rm -rf conftest*
12419   glibcpp_cv_func__sincos_use=no
12420 fi
12421 rm -f conftest*
12422       ac_ext=c
12423 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12424 ac_cpp='$CPP $CPPFLAGS'
12425 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12426 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12427 cross_compiling=$ac_cv_prog_cc_cross
12428
12429
12430 fi
12431
12432   fi
12433   echo "$ac_t""$glibcpp_cv_func__sincos_use" 1>&6
12434   if test x$glibcpp_cv_func__sincos_use = x"yes"; then
12435     for ac_func in _sincos
12436 do
12437 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12438 echo "configure:12439: checking for $ac_func" >&5
12439 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12440   echo $ac_n "(cached) $ac_c" 1>&6
12441 else
12442   cat > conftest.$ac_ext <<EOF
12443 #line 12444 "configure"
12444 #include "confdefs.h"
12445 /* System header to define __stub macros and hopefully few prototypes,
12446     which can conflict with char $ac_func(); below.  */
12447 #include <assert.h>
12448 /* Override any gcc2 internal prototype to avoid an error.  */
12449 /* We use char because int might match the return type of a gcc2
12450     builtin and then its argument prototype would still apply.  */
12451 char $ac_func();
12452
12453 int main() {
12454
12455 /* The GNU C library defines this for functions which it implements
12456     to always fail with ENOSYS.  Some functions are actually named
12457     something starting with __ and the normal name is an alias.  */
12458 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12459 choke me
12460 #else
12461 $ac_func();
12462 #endif
12463
12464 ; return 0; }
12465 EOF
12466 if { (eval echo configure:12467: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12467   rm -rf conftest*
12468   eval "ac_cv_func_$ac_func=yes"
12469 else
12470   echo "configure: failed program was:" >&5
12471   cat conftest.$ac_ext >&5
12472   rm -rf conftest*
12473   eval "ac_cv_func_$ac_func=no"
12474 fi
12475 rm -f conftest*
12476 fi
12477
12478 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12479   echo "$ac_t""yes" 1>&6
12480     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12481   cat >> confdefs.h <<EOF
12482 #define $ac_tr_func 1
12483 EOF
12484
12485 else
12486   echo "$ac_t""no" 1>&6
12487 fi
12488 done
12489
12490   fi
12491
12492
12493   echo $ac_n "checking for _fpclass declaration""... $ac_c" 1>&6
12494 echo "configure:12495: checking for _fpclass declaration" >&5
12495   if test x${glibcpp_cv_func__fpclass_use+set} != xset; then
12496     if eval "test \"`echo '$''{'glibcpp_cv_func__fpclass_use'+set}'`\" = set"; then
12497   echo $ac_n "(cached) $ac_c" 1>&6
12498 else
12499
12500
12501       ac_ext=C
12502 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12503 ac_cpp='$CXXCPP $CPPFLAGS'
12504 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12505 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12506 cross_compiling=$ac_cv_prog_cxx_cross
12507
12508       cat > conftest.$ac_ext <<EOF
12509 #line 12510 "configure"
12510 #include "confdefs.h"
12511 #include <math.h>
12512 int main() {
12513  _fpclass(0);
12514 ; return 0; }
12515 EOF
12516 if { (eval echo configure:12517: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12517   rm -rf conftest*
12518   glibcpp_cv_func__fpclass_use=yes
12519 else
12520   echo "configure: failed program was:" >&5
12521   cat conftest.$ac_ext >&5
12522   rm -rf conftest*
12523   glibcpp_cv_func__fpclass_use=no
12524 fi
12525 rm -f conftest*
12526       ac_ext=c
12527 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12528 ac_cpp='$CPP $CPPFLAGS'
12529 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12530 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12531 cross_compiling=$ac_cv_prog_cc_cross
12532
12533
12534 fi
12535
12536   fi
12537   echo "$ac_t""$glibcpp_cv_func__fpclass_use" 1>&6
12538   if test x$glibcpp_cv_func__fpclass_use = x"yes"; then
12539     for ac_func in _fpclass
12540 do
12541 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12542 echo "configure:12543: checking for $ac_func" >&5
12543 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12544   echo $ac_n "(cached) $ac_c" 1>&6
12545 else
12546   cat > conftest.$ac_ext <<EOF
12547 #line 12548 "configure"
12548 #include "confdefs.h"
12549 /* System header to define __stub macros and hopefully few prototypes,
12550     which can conflict with char $ac_func(); below.  */
12551 #include <assert.h>
12552 /* Override any gcc2 internal prototype to avoid an error.  */
12553 /* We use char because int might match the return type of a gcc2
12554     builtin and then its argument prototype would still apply.  */
12555 char $ac_func();
12556
12557 int main() {
12558
12559 /* The GNU C library defines this for functions which it implements
12560     to always fail with ENOSYS.  Some functions are actually named
12561     something starting with __ and the normal name is an alias.  */
12562 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12563 choke me
12564 #else
12565 $ac_func();
12566 #endif
12567
12568 ; return 0; }
12569 EOF
12570 if { (eval echo configure:12571: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12571   rm -rf conftest*
12572   eval "ac_cv_func_$ac_func=yes"
12573 else
12574   echo "configure: failed program was:" >&5
12575   cat conftest.$ac_ext >&5
12576   rm -rf conftest*
12577   eval "ac_cv_func_$ac_func=no"
12578 fi
12579 rm -f conftest*
12580 fi
12581
12582 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12583   echo "$ac_t""yes" 1>&6
12584     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12585   cat >> confdefs.h <<EOF
12586 #define $ac_tr_func 1
12587 EOF
12588
12589 else
12590   echo "$ac_t""no" 1>&6
12591 fi
12592 done
12593
12594   fi
12595
12596
12597   echo $ac_n "checking for _qfpclass declaration""... $ac_c" 1>&6
12598 echo "configure:12599: checking for _qfpclass declaration" >&5
12599   if test x${glibcpp_cv_func__qfpclass_use+set} != xset; then
12600     if eval "test \"`echo '$''{'glibcpp_cv_func__qfpclass_use'+set}'`\" = set"; then
12601   echo $ac_n "(cached) $ac_c" 1>&6
12602 else
12603
12604
12605       ac_ext=C
12606 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12607 ac_cpp='$CXXCPP $CPPFLAGS'
12608 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12609 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12610 cross_compiling=$ac_cv_prog_cxx_cross
12611
12612       cat > conftest.$ac_ext <<EOF
12613 #line 12614 "configure"
12614 #include "confdefs.h"
12615 #include <math.h>
12616 int main() {
12617  _qfpclass(0);
12618 ; return 0; }
12619 EOF
12620 if { (eval echo configure:12621: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12621   rm -rf conftest*
12622   glibcpp_cv_func__qfpclass_use=yes
12623 else
12624   echo "configure: failed program was:" >&5
12625   cat conftest.$ac_ext >&5
12626   rm -rf conftest*
12627   glibcpp_cv_func__qfpclass_use=no
12628 fi
12629 rm -f conftest*
12630       ac_ext=c
12631 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12632 ac_cpp='$CPP $CPPFLAGS'
12633 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12634 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12635 cross_compiling=$ac_cv_prog_cc_cross
12636
12637
12638 fi
12639
12640   fi
12641   echo "$ac_t""$glibcpp_cv_func__qfpclass_use" 1>&6
12642   if test x$glibcpp_cv_func__qfpclass_use = x"yes"; then
12643     for ac_func in _qfpclass
12644 do
12645 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12646 echo "configure:12647: checking for $ac_func" >&5
12647 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12648   echo $ac_n "(cached) $ac_c" 1>&6
12649 else
12650   cat > conftest.$ac_ext <<EOF
12651 #line 12652 "configure"
12652 #include "confdefs.h"
12653 /* System header to define __stub macros and hopefully few prototypes,
12654     which can conflict with char $ac_func(); below.  */
12655 #include <assert.h>
12656 /* Override any gcc2 internal prototype to avoid an error.  */
12657 /* We use char because int might match the return type of a gcc2
12658     builtin and then its argument prototype would still apply.  */
12659 char $ac_func();
12660
12661 int main() {
12662
12663 /* The GNU C library defines this for functions which it implements
12664     to always fail with ENOSYS.  Some functions are actually named
12665     something starting with __ and the normal name is an alias.  */
12666 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12667 choke me
12668 #else
12669 $ac_func();
12670 #endif
12671
12672 ; return 0; }
12673 EOF
12674 if { (eval echo configure:12675: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12675   rm -rf conftest*
12676   eval "ac_cv_func_$ac_func=yes"
12677 else
12678   echo "configure: failed program was:" >&5
12679   cat conftest.$ac_ext >&5
12680   rm -rf conftest*
12681   eval "ac_cv_func_$ac_func=no"
12682 fi
12683 rm -f conftest*
12684 fi
12685
12686 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12687   echo "$ac_t""yes" 1>&6
12688     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12689   cat >> confdefs.h <<EOF
12690 #define $ac_tr_func 1
12691 EOF
12692
12693 else
12694   echo "$ac_t""no" 1>&6
12695 fi
12696 done
12697
12698   fi
12699
12700
12701
12702   echo $ac_n "checking for _isnanf declaration""... $ac_c" 1>&6
12703 echo "configure:12704: checking for _isnanf declaration" >&5
12704   if test x${glibcpp_cv_func__isnanf_use+set} != xset; then
12705     if eval "test \"`echo '$''{'glibcpp_cv_func__isnanf_use'+set}'`\" = set"; then
12706   echo $ac_n "(cached) $ac_c" 1>&6
12707 else
12708
12709
12710       ac_ext=C
12711 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12712 ac_cpp='$CXXCPP $CPPFLAGS'
12713 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12714 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12715 cross_compiling=$ac_cv_prog_cxx_cross
12716
12717       cat > conftest.$ac_ext <<EOF
12718 #line 12719 "configure"
12719 #include "confdefs.h"
12720 #include <math.h>
12721 int main() {
12722  _isnanf(0);
12723 ; return 0; }
12724 EOF
12725 if { (eval echo configure:12726: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12726   rm -rf conftest*
12727   glibcpp_cv_func__isnanf_use=yes
12728 else
12729   echo "configure: failed program was:" >&5
12730   cat conftest.$ac_ext >&5
12731   rm -rf conftest*
12732   glibcpp_cv_func__isnanf_use=no
12733 fi
12734 rm -f conftest*
12735       ac_ext=c
12736 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12737 ac_cpp='$CPP $CPPFLAGS'
12738 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12739 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12740 cross_compiling=$ac_cv_prog_cc_cross
12741
12742
12743 fi
12744
12745   fi
12746   echo "$ac_t""$glibcpp_cv_func__isnanf_use" 1>&6
12747   if test x$glibcpp_cv_func__isnanf_use = x"yes"; then
12748     for ac_func in _isnanf
12749 do
12750 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12751 echo "configure:12752: checking for $ac_func" >&5
12752 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12753   echo $ac_n "(cached) $ac_c" 1>&6
12754 else
12755   cat > conftest.$ac_ext <<EOF
12756 #line 12757 "configure"
12757 #include "confdefs.h"
12758 /* System header to define __stub macros and hopefully few prototypes,
12759     which can conflict with char $ac_func(); below.  */
12760 #include <assert.h>
12761 /* Override any gcc2 internal prototype to avoid an error.  */
12762 /* We use char because int might match the return type of a gcc2
12763     builtin and then its argument prototype would still apply.  */
12764 char $ac_func();
12765
12766 int main() {
12767
12768 /* The GNU C library defines this for functions which it implements
12769     to always fail with ENOSYS.  Some functions are actually named
12770     something starting with __ and the normal name is an alias.  */
12771 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12772 choke me
12773 #else
12774 $ac_func();
12775 #endif
12776
12777 ; return 0; }
12778 EOF
12779 if { (eval echo configure:12780: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12780   rm -rf conftest*
12781   eval "ac_cv_func_$ac_func=yes"
12782 else
12783   echo "configure: failed program was:" >&5
12784   cat conftest.$ac_ext >&5
12785   rm -rf conftest*
12786   eval "ac_cv_func_$ac_func=no"
12787 fi
12788 rm -f conftest*
12789 fi
12790
12791 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12792   echo "$ac_t""yes" 1>&6
12793     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12794   cat >> confdefs.h <<EOF
12795 #define $ac_tr_func 1
12796 EOF
12797
12798 else
12799   echo "$ac_t""no" 1>&6
12800 fi
12801 done
12802
12803   fi
12804
12805
12806   echo $ac_n "checking for _isinff declaration""... $ac_c" 1>&6
12807 echo "configure:12808: checking for _isinff declaration" >&5
12808   if test x${glibcpp_cv_func__isinff_use+set} != xset; then
12809     if eval "test \"`echo '$''{'glibcpp_cv_func__isinff_use'+set}'`\" = set"; then
12810   echo $ac_n "(cached) $ac_c" 1>&6
12811 else
12812
12813
12814       ac_ext=C
12815 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12816 ac_cpp='$CXXCPP $CPPFLAGS'
12817 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12818 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12819 cross_compiling=$ac_cv_prog_cxx_cross
12820
12821       cat > conftest.$ac_ext <<EOF
12822 #line 12823 "configure"
12823 #include "confdefs.h"
12824 #include <math.h>
12825 int main() {
12826  _isinff(0);
12827 ; return 0; }
12828 EOF
12829 if { (eval echo configure:12830: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12830   rm -rf conftest*
12831   glibcpp_cv_func__isinff_use=yes
12832 else
12833   echo "configure: failed program was:" >&5
12834   cat conftest.$ac_ext >&5
12835   rm -rf conftest*
12836   glibcpp_cv_func__isinff_use=no
12837 fi
12838 rm -f conftest*
12839       ac_ext=c
12840 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12841 ac_cpp='$CPP $CPPFLAGS'
12842 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12843 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12844 cross_compiling=$ac_cv_prog_cc_cross
12845
12846
12847 fi
12848
12849   fi
12850   echo "$ac_t""$glibcpp_cv_func__isinff_use" 1>&6
12851   if test x$glibcpp_cv_func__isinff_use = x"yes"; then
12852     for ac_func in _isinff
12853 do
12854 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12855 echo "configure:12856: checking for $ac_func" >&5
12856 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12857   echo $ac_n "(cached) $ac_c" 1>&6
12858 else
12859   cat > conftest.$ac_ext <<EOF
12860 #line 12861 "configure"
12861 #include "confdefs.h"
12862 /* System header to define __stub macros and hopefully few prototypes,
12863     which can conflict with char $ac_func(); below.  */
12864 #include <assert.h>
12865 /* Override any gcc2 internal prototype to avoid an error.  */
12866 /* We use char because int might match the return type of a gcc2
12867     builtin and then its argument prototype would still apply.  */
12868 char $ac_func();
12869
12870 int main() {
12871
12872 /* The GNU C library defines this for functions which it implements
12873     to always fail with ENOSYS.  Some functions are actually named
12874     something starting with __ and the normal name is an alias.  */
12875 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12876 choke me
12877 #else
12878 $ac_func();
12879 #endif
12880
12881 ; return 0; }
12882 EOF
12883 if { (eval echo configure:12884: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12884   rm -rf conftest*
12885   eval "ac_cv_func_$ac_func=yes"
12886 else
12887   echo "configure: failed program was:" >&5
12888   cat conftest.$ac_ext >&5
12889   rm -rf conftest*
12890   eval "ac_cv_func_$ac_func=no"
12891 fi
12892 rm -f conftest*
12893 fi
12894
12895 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
12896   echo "$ac_t""yes" 1>&6
12897     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
12898   cat >> confdefs.h <<EOF
12899 #define $ac_tr_func 1
12900 EOF
12901
12902 else
12903   echo "$ac_t""no" 1>&6
12904 fi
12905 done
12906
12907   fi
12908
12909
12910   echo $ac_n "checking for _acosf declaration""... $ac_c" 1>&6
12911 echo "configure:12912: checking for _acosf declaration" >&5
12912   if test x${glibcpp_cv_func__acosf_use+set} != xset; then
12913     if eval "test \"`echo '$''{'glibcpp_cv_func__acosf_use'+set}'`\" = set"; then
12914   echo $ac_n "(cached) $ac_c" 1>&6
12915 else
12916
12917
12918       ac_ext=C
12919 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12920 ac_cpp='$CXXCPP $CPPFLAGS'
12921 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12922 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12923 cross_compiling=$ac_cv_prog_cxx_cross
12924
12925       cat > conftest.$ac_ext <<EOF
12926 #line 12927 "configure"
12927 #include "confdefs.h"
12928 #include <math.h>
12929 int main() {
12930  _acosf(0);
12931 ; return 0; }
12932 EOF
12933 if { (eval echo configure:12934: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
12934   rm -rf conftest*
12935   glibcpp_cv_func__acosf_use=yes
12936 else
12937   echo "configure: failed program was:" >&5
12938   cat conftest.$ac_ext >&5
12939   rm -rf conftest*
12940   glibcpp_cv_func__acosf_use=no
12941 fi
12942 rm -f conftest*
12943       ac_ext=c
12944 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
12945 ac_cpp='$CPP $CPPFLAGS'
12946 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
12947 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
12948 cross_compiling=$ac_cv_prog_cc_cross
12949
12950
12951 fi
12952
12953   fi
12954   echo "$ac_t""$glibcpp_cv_func__acosf_use" 1>&6
12955   if test x$glibcpp_cv_func__acosf_use = x"yes"; then
12956     for ac_func in _acosf
12957 do
12958 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
12959 echo "configure:12960: checking for $ac_func" >&5
12960 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
12961   echo $ac_n "(cached) $ac_c" 1>&6
12962 else
12963   cat > conftest.$ac_ext <<EOF
12964 #line 12965 "configure"
12965 #include "confdefs.h"
12966 /* System header to define __stub macros and hopefully few prototypes,
12967     which can conflict with char $ac_func(); below.  */
12968 #include <assert.h>
12969 /* Override any gcc2 internal prototype to avoid an error.  */
12970 /* We use char because int might match the return type of a gcc2
12971     builtin and then its argument prototype would still apply.  */
12972 char $ac_func();
12973
12974 int main() {
12975
12976 /* The GNU C library defines this for functions which it implements
12977     to always fail with ENOSYS.  Some functions are actually named
12978     something starting with __ and the normal name is an alias.  */
12979 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
12980 choke me
12981 #else
12982 $ac_func();
12983 #endif
12984
12985 ; return 0; }
12986 EOF
12987 if { (eval echo configure:12988: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
12988   rm -rf conftest*
12989   eval "ac_cv_func_$ac_func=yes"
12990 else
12991   echo "configure: failed program was:" >&5
12992   cat conftest.$ac_ext >&5
12993   rm -rf conftest*
12994   eval "ac_cv_func_$ac_func=no"
12995 fi
12996 rm -f conftest*
12997 fi
12998
12999 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13000   echo "$ac_t""yes" 1>&6
13001     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13002   cat >> confdefs.h <<EOF
13003 #define $ac_tr_func 1
13004 EOF
13005
13006 else
13007   echo "$ac_t""no" 1>&6
13008 fi
13009 done
13010
13011   fi
13012
13013
13014   echo $ac_n "checking for _asinf declaration""... $ac_c" 1>&6
13015 echo "configure:13016: checking for _asinf declaration" >&5
13016   if test x${glibcpp_cv_func__asinf_use+set} != xset; then
13017     if eval "test \"`echo '$''{'glibcpp_cv_func__asinf_use'+set}'`\" = set"; then
13018   echo $ac_n "(cached) $ac_c" 1>&6
13019 else
13020
13021
13022       ac_ext=C
13023 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13024 ac_cpp='$CXXCPP $CPPFLAGS'
13025 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13026 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13027 cross_compiling=$ac_cv_prog_cxx_cross
13028
13029       cat > conftest.$ac_ext <<EOF
13030 #line 13031 "configure"
13031 #include "confdefs.h"
13032 #include <math.h>
13033 int main() {
13034  _asinf(0);
13035 ; return 0; }
13036 EOF
13037 if { (eval echo configure:13038: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13038   rm -rf conftest*
13039   glibcpp_cv_func__asinf_use=yes
13040 else
13041   echo "configure: failed program was:" >&5
13042   cat conftest.$ac_ext >&5
13043   rm -rf conftest*
13044   glibcpp_cv_func__asinf_use=no
13045 fi
13046 rm -f conftest*
13047       ac_ext=c
13048 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13049 ac_cpp='$CPP $CPPFLAGS'
13050 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13051 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13052 cross_compiling=$ac_cv_prog_cc_cross
13053
13054
13055 fi
13056
13057   fi
13058   echo "$ac_t""$glibcpp_cv_func__asinf_use" 1>&6
13059   if test x$glibcpp_cv_func__asinf_use = x"yes"; then
13060     for ac_func in _asinf
13061 do
13062 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13063 echo "configure:13064: checking for $ac_func" >&5
13064 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13065   echo $ac_n "(cached) $ac_c" 1>&6
13066 else
13067   cat > conftest.$ac_ext <<EOF
13068 #line 13069 "configure"
13069 #include "confdefs.h"
13070 /* System header to define __stub macros and hopefully few prototypes,
13071     which can conflict with char $ac_func(); below.  */
13072 #include <assert.h>
13073 /* Override any gcc2 internal prototype to avoid an error.  */
13074 /* We use char because int might match the return type of a gcc2
13075     builtin and then its argument prototype would still apply.  */
13076 char $ac_func();
13077
13078 int main() {
13079
13080 /* The GNU C library defines this for functions which it implements
13081     to always fail with ENOSYS.  Some functions are actually named
13082     something starting with __ and the normal name is an alias.  */
13083 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13084 choke me
13085 #else
13086 $ac_func();
13087 #endif
13088
13089 ; return 0; }
13090 EOF
13091 if { (eval echo configure:13092: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13092   rm -rf conftest*
13093   eval "ac_cv_func_$ac_func=yes"
13094 else
13095   echo "configure: failed program was:" >&5
13096   cat conftest.$ac_ext >&5
13097   rm -rf conftest*
13098   eval "ac_cv_func_$ac_func=no"
13099 fi
13100 rm -f conftest*
13101 fi
13102
13103 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13104   echo "$ac_t""yes" 1>&6
13105     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13106   cat >> confdefs.h <<EOF
13107 #define $ac_tr_func 1
13108 EOF
13109
13110 else
13111   echo "$ac_t""no" 1>&6
13112 fi
13113 done
13114
13115   fi
13116
13117
13118   echo $ac_n "checking for _atanf declaration""... $ac_c" 1>&6
13119 echo "configure:13120: checking for _atanf declaration" >&5
13120   if test x${glibcpp_cv_func__atanf_use+set} != xset; then
13121     if eval "test \"`echo '$''{'glibcpp_cv_func__atanf_use'+set}'`\" = set"; then
13122   echo $ac_n "(cached) $ac_c" 1>&6
13123 else
13124
13125
13126       ac_ext=C
13127 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13128 ac_cpp='$CXXCPP $CPPFLAGS'
13129 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13130 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13131 cross_compiling=$ac_cv_prog_cxx_cross
13132
13133       cat > conftest.$ac_ext <<EOF
13134 #line 13135 "configure"
13135 #include "confdefs.h"
13136 #include <math.h>
13137 int main() {
13138  _atanf(0);
13139 ; return 0; }
13140 EOF
13141 if { (eval echo configure:13142: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13142   rm -rf conftest*
13143   glibcpp_cv_func__atanf_use=yes
13144 else
13145   echo "configure: failed program was:" >&5
13146   cat conftest.$ac_ext >&5
13147   rm -rf conftest*
13148   glibcpp_cv_func__atanf_use=no
13149 fi
13150 rm -f conftest*
13151       ac_ext=c
13152 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13153 ac_cpp='$CPP $CPPFLAGS'
13154 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13155 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13156 cross_compiling=$ac_cv_prog_cc_cross
13157
13158
13159 fi
13160
13161   fi
13162   echo "$ac_t""$glibcpp_cv_func__atanf_use" 1>&6
13163   if test x$glibcpp_cv_func__atanf_use = x"yes"; then
13164     for ac_func in _atanf
13165 do
13166 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13167 echo "configure:13168: checking for $ac_func" >&5
13168 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13169   echo $ac_n "(cached) $ac_c" 1>&6
13170 else
13171   cat > conftest.$ac_ext <<EOF
13172 #line 13173 "configure"
13173 #include "confdefs.h"
13174 /* System header to define __stub macros and hopefully few prototypes,
13175     which can conflict with char $ac_func(); below.  */
13176 #include <assert.h>
13177 /* Override any gcc2 internal prototype to avoid an error.  */
13178 /* We use char because int might match the return type of a gcc2
13179     builtin and then its argument prototype would still apply.  */
13180 char $ac_func();
13181
13182 int main() {
13183
13184 /* The GNU C library defines this for functions which it implements
13185     to always fail with ENOSYS.  Some functions are actually named
13186     something starting with __ and the normal name is an alias.  */
13187 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13188 choke me
13189 #else
13190 $ac_func();
13191 #endif
13192
13193 ; return 0; }
13194 EOF
13195 if { (eval echo configure:13196: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13196   rm -rf conftest*
13197   eval "ac_cv_func_$ac_func=yes"
13198 else
13199   echo "configure: failed program was:" >&5
13200   cat conftest.$ac_ext >&5
13201   rm -rf conftest*
13202   eval "ac_cv_func_$ac_func=no"
13203 fi
13204 rm -f conftest*
13205 fi
13206
13207 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13208   echo "$ac_t""yes" 1>&6
13209     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13210   cat >> confdefs.h <<EOF
13211 #define $ac_tr_func 1
13212 EOF
13213
13214 else
13215   echo "$ac_t""no" 1>&6
13216 fi
13217 done
13218
13219   fi
13220
13221
13222   echo $ac_n "checking for _ceilf declaration""... $ac_c" 1>&6
13223 echo "configure:13224: checking for _ceilf declaration" >&5
13224   if test x${glibcpp_cv_func__ceilf_use+set} != xset; then
13225     if eval "test \"`echo '$''{'glibcpp_cv_func__ceilf_use'+set}'`\" = set"; then
13226   echo $ac_n "(cached) $ac_c" 1>&6
13227 else
13228
13229
13230       ac_ext=C
13231 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13232 ac_cpp='$CXXCPP $CPPFLAGS'
13233 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13234 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13235 cross_compiling=$ac_cv_prog_cxx_cross
13236
13237       cat > conftest.$ac_ext <<EOF
13238 #line 13239 "configure"
13239 #include "confdefs.h"
13240 #include <math.h>
13241 int main() {
13242  _ceilf(0);
13243 ; return 0; }
13244 EOF
13245 if { (eval echo configure:13246: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13246   rm -rf conftest*
13247   glibcpp_cv_func__ceilf_use=yes
13248 else
13249   echo "configure: failed program was:" >&5
13250   cat conftest.$ac_ext >&5
13251   rm -rf conftest*
13252   glibcpp_cv_func__ceilf_use=no
13253 fi
13254 rm -f conftest*
13255       ac_ext=c
13256 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13257 ac_cpp='$CPP $CPPFLAGS'
13258 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13259 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13260 cross_compiling=$ac_cv_prog_cc_cross
13261
13262
13263 fi
13264
13265   fi
13266   echo "$ac_t""$glibcpp_cv_func__ceilf_use" 1>&6
13267   if test x$glibcpp_cv_func__ceilf_use = x"yes"; then
13268     for ac_func in _ceilf
13269 do
13270 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13271 echo "configure:13272: checking for $ac_func" >&5
13272 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13273   echo $ac_n "(cached) $ac_c" 1>&6
13274 else
13275   cat > conftest.$ac_ext <<EOF
13276 #line 13277 "configure"
13277 #include "confdefs.h"
13278 /* System header to define __stub macros and hopefully few prototypes,
13279     which can conflict with char $ac_func(); below.  */
13280 #include <assert.h>
13281 /* Override any gcc2 internal prototype to avoid an error.  */
13282 /* We use char because int might match the return type of a gcc2
13283     builtin and then its argument prototype would still apply.  */
13284 char $ac_func();
13285
13286 int main() {
13287
13288 /* The GNU C library defines this for functions which it implements
13289     to always fail with ENOSYS.  Some functions are actually named
13290     something starting with __ and the normal name is an alias.  */
13291 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13292 choke me
13293 #else
13294 $ac_func();
13295 #endif
13296
13297 ; return 0; }
13298 EOF
13299 if { (eval echo configure:13300: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13300   rm -rf conftest*
13301   eval "ac_cv_func_$ac_func=yes"
13302 else
13303   echo "configure: failed program was:" >&5
13304   cat conftest.$ac_ext >&5
13305   rm -rf conftest*
13306   eval "ac_cv_func_$ac_func=no"
13307 fi
13308 rm -f conftest*
13309 fi
13310
13311 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13312   echo "$ac_t""yes" 1>&6
13313     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13314   cat >> confdefs.h <<EOF
13315 #define $ac_tr_func 1
13316 EOF
13317
13318 else
13319   echo "$ac_t""no" 1>&6
13320 fi
13321 done
13322
13323   fi
13324
13325
13326   echo $ac_n "checking for _cosf declaration""... $ac_c" 1>&6
13327 echo "configure:13328: checking for _cosf declaration" >&5
13328   if test x${glibcpp_cv_func__cosf_use+set} != xset; then
13329     if eval "test \"`echo '$''{'glibcpp_cv_func__cosf_use'+set}'`\" = set"; then
13330   echo $ac_n "(cached) $ac_c" 1>&6
13331 else
13332
13333
13334       ac_ext=C
13335 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13336 ac_cpp='$CXXCPP $CPPFLAGS'
13337 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13338 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13339 cross_compiling=$ac_cv_prog_cxx_cross
13340
13341       cat > conftest.$ac_ext <<EOF
13342 #line 13343 "configure"
13343 #include "confdefs.h"
13344 #include <math.h>
13345 int main() {
13346  _cosf(0);
13347 ; return 0; }
13348 EOF
13349 if { (eval echo configure:13350: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13350   rm -rf conftest*
13351   glibcpp_cv_func__cosf_use=yes
13352 else
13353   echo "configure: failed program was:" >&5
13354   cat conftest.$ac_ext >&5
13355   rm -rf conftest*
13356   glibcpp_cv_func__cosf_use=no
13357 fi
13358 rm -f conftest*
13359       ac_ext=c
13360 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13361 ac_cpp='$CPP $CPPFLAGS'
13362 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13363 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13364 cross_compiling=$ac_cv_prog_cc_cross
13365
13366
13367 fi
13368
13369   fi
13370   echo "$ac_t""$glibcpp_cv_func__cosf_use" 1>&6
13371   if test x$glibcpp_cv_func__cosf_use = x"yes"; then
13372     for ac_func in _cosf
13373 do
13374 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13375 echo "configure:13376: checking for $ac_func" >&5
13376 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13377   echo $ac_n "(cached) $ac_c" 1>&6
13378 else
13379   cat > conftest.$ac_ext <<EOF
13380 #line 13381 "configure"
13381 #include "confdefs.h"
13382 /* System header to define __stub macros and hopefully few prototypes,
13383     which can conflict with char $ac_func(); below.  */
13384 #include <assert.h>
13385 /* Override any gcc2 internal prototype to avoid an error.  */
13386 /* We use char because int might match the return type of a gcc2
13387     builtin and then its argument prototype would still apply.  */
13388 char $ac_func();
13389
13390 int main() {
13391
13392 /* The GNU C library defines this for functions which it implements
13393     to always fail with ENOSYS.  Some functions are actually named
13394     something starting with __ and the normal name is an alias.  */
13395 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13396 choke me
13397 #else
13398 $ac_func();
13399 #endif
13400
13401 ; return 0; }
13402 EOF
13403 if { (eval echo configure:13404: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13404   rm -rf conftest*
13405   eval "ac_cv_func_$ac_func=yes"
13406 else
13407   echo "configure: failed program was:" >&5
13408   cat conftest.$ac_ext >&5
13409   rm -rf conftest*
13410   eval "ac_cv_func_$ac_func=no"
13411 fi
13412 rm -f conftest*
13413 fi
13414
13415 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13416   echo "$ac_t""yes" 1>&6
13417     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13418   cat >> confdefs.h <<EOF
13419 #define $ac_tr_func 1
13420 EOF
13421
13422 else
13423   echo "$ac_t""no" 1>&6
13424 fi
13425 done
13426
13427   fi
13428
13429
13430   echo $ac_n "checking for _coshf declaration""... $ac_c" 1>&6
13431 echo "configure:13432: checking for _coshf declaration" >&5
13432   if test x${glibcpp_cv_func__coshf_use+set} != xset; then
13433     if eval "test \"`echo '$''{'glibcpp_cv_func__coshf_use'+set}'`\" = set"; then
13434   echo $ac_n "(cached) $ac_c" 1>&6
13435 else
13436
13437
13438       ac_ext=C
13439 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13440 ac_cpp='$CXXCPP $CPPFLAGS'
13441 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13442 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13443 cross_compiling=$ac_cv_prog_cxx_cross
13444
13445       cat > conftest.$ac_ext <<EOF
13446 #line 13447 "configure"
13447 #include "confdefs.h"
13448 #include <math.h>
13449 int main() {
13450  _coshf(0);
13451 ; return 0; }
13452 EOF
13453 if { (eval echo configure:13454: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13454   rm -rf conftest*
13455   glibcpp_cv_func__coshf_use=yes
13456 else
13457   echo "configure: failed program was:" >&5
13458   cat conftest.$ac_ext >&5
13459   rm -rf conftest*
13460   glibcpp_cv_func__coshf_use=no
13461 fi
13462 rm -f conftest*
13463       ac_ext=c
13464 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13465 ac_cpp='$CPP $CPPFLAGS'
13466 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13467 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13468 cross_compiling=$ac_cv_prog_cc_cross
13469
13470
13471 fi
13472
13473   fi
13474   echo "$ac_t""$glibcpp_cv_func__coshf_use" 1>&6
13475   if test x$glibcpp_cv_func__coshf_use = x"yes"; then
13476     for ac_func in _coshf
13477 do
13478 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13479 echo "configure:13480: checking for $ac_func" >&5
13480 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13481   echo $ac_n "(cached) $ac_c" 1>&6
13482 else
13483   cat > conftest.$ac_ext <<EOF
13484 #line 13485 "configure"
13485 #include "confdefs.h"
13486 /* System header to define __stub macros and hopefully few prototypes,
13487     which can conflict with char $ac_func(); below.  */
13488 #include <assert.h>
13489 /* Override any gcc2 internal prototype to avoid an error.  */
13490 /* We use char because int might match the return type of a gcc2
13491     builtin and then its argument prototype would still apply.  */
13492 char $ac_func();
13493
13494 int main() {
13495
13496 /* The GNU C library defines this for functions which it implements
13497     to always fail with ENOSYS.  Some functions are actually named
13498     something starting with __ and the normal name is an alias.  */
13499 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13500 choke me
13501 #else
13502 $ac_func();
13503 #endif
13504
13505 ; return 0; }
13506 EOF
13507 if { (eval echo configure:13508: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13508   rm -rf conftest*
13509   eval "ac_cv_func_$ac_func=yes"
13510 else
13511   echo "configure: failed program was:" >&5
13512   cat conftest.$ac_ext >&5
13513   rm -rf conftest*
13514   eval "ac_cv_func_$ac_func=no"
13515 fi
13516 rm -f conftest*
13517 fi
13518
13519 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13520   echo "$ac_t""yes" 1>&6
13521     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13522   cat >> confdefs.h <<EOF
13523 #define $ac_tr_func 1
13524 EOF
13525
13526 else
13527   echo "$ac_t""no" 1>&6
13528 fi
13529 done
13530
13531   fi
13532
13533
13534   echo $ac_n "checking for _fabsf declaration""... $ac_c" 1>&6
13535 echo "configure:13536: checking for _fabsf declaration" >&5
13536   if test x${glibcpp_cv_func__fabsf_use+set} != xset; then
13537     if eval "test \"`echo '$''{'glibcpp_cv_func__fabsf_use'+set}'`\" = set"; then
13538   echo $ac_n "(cached) $ac_c" 1>&6
13539 else
13540
13541
13542       ac_ext=C
13543 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13544 ac_cpp='$CXXCPP $CPPFLAGS'
13545 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13546 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13547 cross_compiling=$ac_cv_prog_cxx_cross
13548
13549       cat > conftest.$ac_ext <<EOF
13550 #line 13551 "configure"
13551 #include "confdefs.h"
13552 #include <math.h>
13553 int main() {
13554  _fabsf(0);
13555 ; return 0; }
13556 EOF
13557 if { (eval echo configure:13558: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13558   rm -rf conftest*
13559   glibcpp_cv_func__fabsf_use=yes
13560 else
13561   echo "configure: failed program was:" >&5
13562   cat conftest.$ac_ext >&5
13563   rm -rf conftest*
13564   glibcpp_cv_func__fabsf_use=no
13565 fi
13566 rm -f conftest*
13567       ac_ext=c
13568 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13569 ac_cpp='$CPP $CPPFLAGS'
13570 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13571 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13572 cross_compiling=$ac_cv_prog_cc_cross
13573
13574
13575 fi
13576
13577   fi
13578   echo "$ac_t""$glibcpp_cv_func__fabsf_use" 1>&6
13579   if test x$glibcpp_cv_func__fabsf_use = x"yes"; then
13580     for ac_func in _fabsf
13581 do
13582 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13583 echo "configure:13584: checking for $ac_func" >&5
13584 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13585   echo $ac_n "(cached) $ac_c" 1>&6
13586 else
13587   cat > conftest.$ac_ext <<EOF
13588 #line 13589 "configure"
13589 #include "confdefs.h"
13590 /* System header to define __stub macros and hopefully few prototypes,
13591     which can conflict with char $ac_func(); below.  */
13592 #include <assert.h>
13593 /* Override any gcc2 internal prototype to avoid an error.  */
13594 /* We use char because int might match the return type of a gcc2
13595     builtin and then its argument prototype would still apply.  */
13596 char $ac_func();
13597
13598 int main() {
13599
13600 /* The GNU C library defines this for functions which it implements
13601     to always fail with ENOSYS.  Some functions are actually named
13602     something starting with __ and the normal name is an alias.  */
13603 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13604 choke me
13605 #else
13606 $ac_func();
13607 #endif
13608
13609 ; return 0; }
13610 EOF
13611 if { (eval echo configure:13612: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13612   rm -rf conftest*
13613   eval "ac_cv_func_$ac_func=yes"
13614 else
13615   echo "configure: failed program was:" >&5
13616   cat conftest.$ac_ext >&5
13617   rm -rf conftest*
13618   eval "ac_cv_func_$ac_func=no"
13619 fi
13620 rm -f conftest*
13621 fi
13622
13623 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13624   echo "$ac_t""yes" 1>&6
13625     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13626   cat >> confdefs.h <<EOF
13627 #define $ac_tr_func 1
13628 EOF
13629
13630 else
13631   echo "$ac_t""no" 1>&6
13632 fi
13633 done
13634
13635   fi
13636
13637
13638   echo $ac_n "checking for _floorf declaration""... $ac_c" 1>&6
13639 echo "configure:13640: checking for _floorf declaration" >&5
13640   if test x${glibcpp_cv_func__floorf_use+set} != xset; then
13641     if eval "test \"`echo '$''{'glibcpp_cv_func__floorf_use'+set}'`\" = set"; then
13642   echo $ac_n "(cached) $ac_c" 1>&6
13643 else
13644
13645
13646       ac_ext=C
13647 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13648 ac_cpp='$CXXCPP $CPPFLAGS'
13649 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13650 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13651 cross_compiling=$ac_cv_prog_cxx_cross
13652
13653       cat > conftest.$ac_ext <<EOF
13654 #line 13655 "configure"
13655 #include "confdefs.h"
13656 #include <math.h>
13657 int main() {
13658  _floorf(0);
13659 ; return 0; }
13660 EOF
13661 if { (eval echo configure:13662: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13662   rm -rf conftest*
13663   glibcpp_cv_func__floorf_use=yes
13664 else
13665   echo "configure: failed program was:" >&5
13666   cat conftest.$ac_ext >&5
13667   rm -rf conftest*
13668   glibcpp_cv_func__floorf_use=no
13669 fi
13670 rm -f conftest*
13671       ac_ext=c
13672 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13673 ac_cpp='$CPP $CPPFLAGS'
13674 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13675 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13676 cross_compiling=$ac_cv_prog_cc_cross
13677
13678
13679 fi
13680
13681   fi
13682   echo "$ac_t""$glibcpp_cv_func__floorf_use" 1>&6
13683   if test x$glibcpp_cv_func__floorf_use = x"yes"; then
13684     for ac_func in _floorf
13685 do
13686 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13687 echo "configure:13688: checking for $ac_func" >&5
13688 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13689   echo $ac_n "(cached) $ac_c" 1>&6
13690 else
13691   cat > conftest.$ac_ext <<EOF
13692 #line 13693 "configure"
13693 #include "confdefs.h"
13694 /* System header to define __stub macros and hopefully few prototypes,
13695     which can conflict with char $ac_func(); below.  */
13696 #include <assert.h>
13697 /* Override any gcc2 internal prototype to avoid an error.  */
13698 /* We use char because int might match the return type of a gcc2
13699     builtin and then its argument prototype would still apply.  */
13700 char $ac_func();
13701
13702 int main() {
13703
13704 /* The GNU C library defines this for functions which it implements
13705     to always fail with ENOSYS.  Some functions are actually named
13706     something starting with __ and the normal name is an alias.  */
13707 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13708 choke me
13709 #else
13710 $ac_func();
13711 #endif
13712
13713 ; return 0; }
13714 EOF
13715 if { (eval echo configure:13716: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13716   rm -rf conftest*
13717   eval "ac_cv_func_$ac_func=yes"
13718 else
13719   echo "configure: failed program was:" >&5
13720   cat conftest.$ac_ext >&5
13721   rm -rf conftest*
13722   eval "ac_cv_func_$ac_func=no"
13723 fi
13724 rm -f conftest*
13725 fi
13726
13727 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13728   echo "$ac_t""yes" 1>&6
13729     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13730   cat >> confdefs.h <<EOF
13731 #define $ac_tr_func 1
13732 EOF
13733
13734 else
13735   echo "$ac_t""no" 1>&6
13736 fi
13737 done
13738
13739   fi
13740
13741
13742   echo $ac_n "checking for _fmodf declaration""... $ac_c" 1>&6
13743 echo "configure:13744: checking for _fmodf declaration" >&5
13744   if test x${glibcpp_cv_func__fmodf_use+set} != xset; then
13745     if eval "test \"`echo '$''{'glibcpp_cv_func__fmodf_use'+set}'`\" = set"; then
13746   echo $ac_n "(cached) $ac_c" 1>&6
13747 else
13748
13749
13750       ac_ext=C
13751 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13752 ac_cpp='$CXXCPP $CPPFLAGS'
13753 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13754 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13755 cross_compiling=$ac_cv_prog_cxx_cross
13756
13757       cat > conftest.$ac_ext <<EOF
13758 #line 13759 "configure"
13759 #include "confdefs.h"
13760 #include <math.h>
13761 int main() {
13762  _fmodf(0, 0);
13763 ; return 0; }
13764 EOF
13765 if { (eval echo configure:13766: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13766   rm -rf conftest*
13767   glibcpp_cv_func__fmodf_use=yes
13768 else
13769   echo "configure: failed program was:" >&5
13770   cat conftest.$ac_ext >&5
13771   rm -rf conftest*
13772   glibcpp_cv_func__fmodf_use=no
13773 fi
13774 rm -f conftest*
13775       ac_ext=c
13776 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13777 ac_cpp='$CPP $CPPFLAGS'
13778 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13779 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13780 cross_compiling=$ac_cv_prog_cc_cross
13781
13782
13783 fi
13784
13785   fi
13786   echo "$ac_t""$glibcpp_cv_func__fmodf_use" 1>&6
13787   if test x$glibcpp_cv_func__fmodf_use = x"yes"; then
13788     for ac_func in _fmodf
13789 do
13790 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13791 echo "configure:13792: checking for $ac_func" >&5
13792 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13793   echo $ac_n "(cached) $ac_c" 1>&6
13794 else
13795   cat > conftest.$ac_ext <<EOF
13796 #line 13797 "configure"
13797 #include "confdefs.h"
13798 /* System header to define __stub macros and hopefully few prototypes,
13799     which can conflict with char $ac_func(); below.  */
13800 #include <assert.h>
13801 /* Override any gcc2 internal prototype to avoid an error.  */
13802 /* We use char because int might match the return type of a gcc2
13803     builtin and then its argument prototype would still apply.  */
13804 char $ac_func();
13805
13806 int main() {
13807
13808 /* The GNU C library defines this for functions which it implements
13809     to always fail with ENOSYS.  Some functions are actually named
13810     something starting with __ and the normal name is an alias.  */
13811 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13812 choke me
13813 #else
13814 $ac_func();
13815 #endif
13816
13817 ; return 0; }
13818 EOF
13819 if { (eval echo configure:13820: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13820   rm -rf conftest*
13821   eval "ac_cv_func_$ac_func=yes"
13822 else
13823   echo "configure: failed program was:" >&5
13824   cat conftest.$ac_ext >&5
13825   rm -rf conftest*
13826   eval "ac_cv_func_$ac_func=no"
13827 fi
13828 rm -f conftest*
13829 fi
13830
13831 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13832   echo "$ac_t""yes" 1>&6
13833     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13834   cat >> confdefs.h <<EOF
13835 #define $ac_tr_func 1
13836 EOF
13837
13838 else
13839   echo "$ac_t""no" 1>&6
13840 fi
13841 done
13842
13843   fi
13844
13845
13846   echo $ac_n "checking for _frexpf declaration""... $ac_c" 1>&6
13847 echo "configure:13848: checking for _frexpf declaration" >&5
13848   if test x${glibcpp_cv_func__frexpf_use+set} != xset; then
13849     if eval "test \"`echo '$''{'glibcpp_cv_func__frexpf_use'+set}'`\" = set"; then
13850   echo $ac_n "(cached) $ac_c" 1>&6
13851 else
13852
13853
13854       ac_ext=C
13855 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13856 ac_cpp='$CXXCPP $CPPFLAGS'
13857 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13858 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13859 cross_compiling=$ac_cv_prog_cxx_cross
13860
13861       cat > conftest.$ac_ext <<EOF
13862 #line 13863 "configure"
13863 #include "confdefs.h"
13864 #include <math.h>
13865 int main() {
13866  _frexpf(0, 0);
13867 ; return 0; }
13868 EOF
13869 if { (eval echo configure:13870: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13870   rm -rf conftest*
13871   glibcpp_cv_func__frexpf_use=yes
13872 else
13873   echo "configure: failed program was:" >&5
13874   cat conftest.$ac_ext >&5
13875   rm -rf conftest*
13876   glibcpp_cv_func__frexpf_use=no
13877 fi
13878 rm -f conftest*
13879       ac_ext=c
13880 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13881 ac_cpp='$CPP $CPPFLAGS'
13882 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13883 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13884 cross_compiling=$ac_cv_prog_cc_cross
13885
13886
13887 fi
13888
13889   fi
13890   echo "$ac_t""$glibcpp_cv_func__frexpf_use" 1>&6
13891   if test x$glibcpp_cv_func__frexpf_use = x"yes"; then
13892     for ac_func in _frexpf
13893 do
13894 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13895 echo "configure:13896: checking for $ac_func" >&5
13896 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
13897   echo $ac_n "(cached) $ac_c" 1>&6
13898 else
13899   cat > conftest.$ac_ext <<EOF
13900 #line 13901 "configure"
13901 #include "confdefs.h"
13902 /* System header to define __stub macros and hopefully few prototypes,
13903     which can conflict with char $ac_func(); below.  */
13904 #include <assert.h>
13905 /* Override any gcc2 internal prototype to avoid an error.  */
13906 /* We use char because int might match the return type of a gcc2
13907     builtin and then its argument prototype would still apply.  */
13908 char $ac_func();
13909
13910 int main() {
13911
13912 /* The GNU C library defines this for functions which it implements
13913     to always fail with ENOSYS.  Some functions are actually named
13914     something starting with __ and the normal name is an alias.  */
13915 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
13916 choke me
13917 #else
13918 $ac_func();
13919 #endif
13920
13921 ; return 0; }
13922 EOF
13923 if { (eval echo configure:13924: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
13924   rm -rf conftest*
13925   eval "ac_cv_func_$ac_func=yes"
13926 else
13927   echo "configure: failed program was:" >&5
13928   cat conftest.$ac_ext >&5
13929   rm -rf conftest*
13930   eval "ac_cv_func_$ac_func=no"
13931 fi
13932 rm -f conftest*
13933 fi
13934
13935 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
13936   echo "$ac_t""yes" 1>&6
13937     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
13938   cat >> confdefs.h <<EOF
13939 #define $ac_tr_func 1
13940 EOF
13941
13942 else
13943   echo "$ac_t""no" 1>&6
13944 fi
13945 done
13946
13947   fi
13948
13949
13950   echo $ac_n "checking for _ldexpf declaration""... $ac_c" 1>&6
13951 echo "configure:13952: checking for _ldexpf declaration" >&5
13952   if test x${glibcpp_cv_func__ldexpf_use+set} != xset; then
13953     if eval "test \"`echo '$''{'glibcpp_cv_func__ldexpf_use'+set}'`\" = set"; then
13954   echo $ac_n "(cached) $ac_c" 1>&6
13955 else
13956
13957
13958       ac_ext=C
13959 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13960 ac_cpp='$CXXCPP $CPPFLAGS'
13961 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13962 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13963 cross_compiling=$ac_cv_prog_cxx_cross
13964
13965       cat > conftest.$ac_ext <<EOF
13966 #line 13967 "configure"
13967 #include "confdefs.h"
13968 #include <math.h>
13969 int main() {
13970  _ldexpf(0, 0);
13971 ; return 0; }
13972 EOF
13973 if { (eval echo configure:13974: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
13974   rm -rf conftest*
13975   glibcpp_cv_func__ldexpf_use=yes
13976 else
13977   echo "configure: failed program was:" >&5
13978   cat conftest.$ac_ext >&5
13979   rm -rf conftest*
13980   glibcpp_cv_func__ldexpf_use=no
13981 fi
13982 rm -f conftest*
13983       ac_ext=c
13984 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
13985 ac_cpp='$CPP $CPPFLAGS'
13986 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
13987 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
13988 cross_compiling=$ac_cv_prog_cc_cross
13989
13990
13991 fi
13992
13993   fi
13994   echo "$ac_t""$glibcpp_cv_func__ldexpf_use" 1>&6
13995   if test x$glibcpp_cv_func__ldexpf_use = x"yes"; then
13996     for ac_func in _ldexpf
13997 do
13998 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
13999 echo "configure:14000: checking for $ac_func" >&5
14000 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14001   echo $ac_n "(cached) $ac_c" 1>&6
14002 else
14003   cat > conftest.$ac_ext <<EOF
14004 #line 14005 "configure"
14005 #include "confdefs.h"
14006 /* System header to define __stub macros and hopefully few prototypes,
14007     which can conflict with char $ac_func(); below.  */
14008 #include <assert.h>
14009 /* Override any gcc2 internal prototype to avoid an error.  */
14010 /* We use char because int might match the return type of a gcc2
14011     builtin and then its argument prototype would still apply.  */
14012 char $ac_func();
14013
14014 int main() {
14015
14016 /* The GNU C library defines this for functions which it implements
14017     to always fail with ENOSYS.  Some functions are actually named
14018     something starting with __ and the normal name is an alias.  */
14019 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14020 choke me
14021 #else
14022 $ac_func();
14023 #endif
14024
14025 ; return 0; }
14026 EOF
14027 if { (eval echo configure:14028: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14028   rm -rf conftest*
14029   eval "ac_cv_func_$ac_func=yes"
14030 else
14031   echo "configure: failed program was:" >&5
14032   cat conftest.$ac_ext >&5
14033   rm -rf conftest*
14034   eval "ac_cv_func_$ac_func=no"
14035 fi
14036 rm -f conftest*
14037 fi
14038
14039 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14040   echo "$ac_t""yes" 1>&6
14041     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14042   cat >> confdefs.h <<EOF
14043 #define $ac_tr_func 1
14044 EOF
14045
14046 else
14047   echo "$ac_t""no" 1>&6
14048 fi
14049 done
14050
14051   fi
14052
14053
14054   echo $ac_n "checking for _logf declaration""... $ac_c" 1>&6
14055 echo "configure:14056: checking for _logf declaration" >&5
14056   if test x${glibcpp_cv_func__logf_use+set} != xset; then
14057     if eval "test \"`echo '$''{'glibcpp_cv_func__logf_use'+set}'`\" = set"; then
14058   echo $ac_n "(cached) $ac_c" 1>&6
14059 else
14060
14061
14062       ac_ext=C
14063 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14064 ac_cpp='$CXXCPP $CPPFLAGS'
14065 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14066 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14067 cross_compiling=$ac_cv_prog_cxx_cross
14068
14069       cat > conftest.$ac_ext <<EOF
14070 #line 14071 "configure"
14071 #include "confdefs.h"
14072 #include <math.h>
14073 int main() {
14074  _logf(0);
14075 ; return 0; }
14076 EOF
14077 if { (eval echo configure:14078: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14078   rm -rf conftest*
14079   glibcpp_cv_func__logf_use=yes
14080 else
14081   echo "configure: failed program was:" >&5
14082   cat conftest.$ac_ext >&5
14083   rm -rf conftest*
14084   glibcpp_cv_func__logf_use=no
14085 fi
14086 rm -f conftest*
14087       ac_ext=c
14088 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14089 ac_cpp='$CPP $CPPFLAGS'
14090 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14091 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14092 cross_compiling=$ac_cv_prog_cc_cross
14093
14094
14095 fi
14096
14097   fi
14098   echo "$ac_t""$glibcpp_cv_func__logf_use" 1>&6
14099   if test x$glibcpp_cv_func__logf_use = x"yes"; then
14100     for ac_func in _logf
14101 do
14102 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14103 echo "configure:14104: checking for $ac_func" >&5
14104 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14105   echo $ac_n "(cached) $ac_c" 1>&6
14106 else
14107   cat > conftest.$ac_ext <<EOF
14108 #line 14109 "configure"
14109 #include "confdefs.h"
14110 /* System header to define __stub macros and hopefully few prototypes,
14111     which can conflict with char $ac_func(); below.  */
14112 #include <assert.h>
14113 /* Override any gcc2 internal prototype to avoid an error.  */
14114 /* We use char because int might match the return type of a gcc2
14115     builtin and then its argument prototype would still apply.  */
14116 char $ac_func();
14117
14118 int main() {
14119
14120 /* The GNU C library defines this for functions which it implements
14121     to always fail with ENOSYS.  Some functions are actually named
14122     something starting with __ and the normal name is an alias.  */
14123 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14124 choke me
14125 #else
14126 $ac_func();
14127 #endif
14128
14129 ; return 0; }
14130 EOF
14131 if { (eval echo configure:14132: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14132   rm -rf conftest*
14133   eval "ac_cv_func_$ac_func=yes"
14134 else
14135   echo "configure: failed program was:" >&5
14136   cat conftest.$ac_ext >&5
14137   rm -rf conftest*
14138   eval "ac_cv_func_$ac_func=no"
14139 fi
14140 rm -f conftest*
14141 fi
14142
14143 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14144   echo "$ac_t""yes" 1>&6
14145     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14146   cat >> confdefs.h <<EOF
14147 #define $ac_tr_func 1
14148 EOF
14149
14150 else
14151   echo "$ac_t""no" 1>&6
14152 fi
14153 done
14154
14155   fi
14156
14157
14158   echo $ac_n "checking for _log10f declaration""... $ac_c" 1>&6
14159 echo "configure:14160: checking for _log10f declaration" >&5
14160   if test x${glibcpp_cv_func__log10f_use+set} != xset; then
14161     if eval "test \"`echo '$''{'glibcpp_cv_func__log10f_use'+set}'`\" = set"; then
14162   echo $ac_n "(cached) $ac_c" 1>&6
14163 else
14164
14165
14166       ac_ext=C
14167 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14168 ac_cpp='$CXXCPP $CPPFLAGS'
14169 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14170 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14171 cross_compiling=$ac_cv_prog_cxx_cross
14172
14173       cat > conftest.$ac_ext <<EOF
14174 #line 14175 "configure"
14175 #include "confdefs.h"
14176 #include <math.h>
14177 int main() {
14178  _log10f(0);
14179 ; return 0; }
14180 EOF
14181 if { (eval echo configure:14182: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14182   rm -rf conftest*
14183   glibcpp_cv_func__log10f_use=yes
14184 else
14185   echo "configure: failed program was:" >&5
14186   cat conftest.$ac_ext >&5
14187   rm -rf conftest*
14188   glibcpp_cv_func__log10f_use=no
14189 fi
14190 rm -f conftest*
14191       ac_ext=c
14192 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14193 ac_cpp='$CPP $CPPFLAGS'
14194 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14195 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14196 cross_compiling=$ac_cv_prog_cc_cross
14197
14198
14199 fi
14200
14201   fi
14202   echo "$ac_t""$glibcpp_cv_func__log10f_use" 1>&6
14203   if test x$glibcpp_cv_func__log10f_use = x"yes"; then
14204     for ac_func in _log10f
14205 do
14206 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14207 echo "configure:14208: checking for $ac_func" >&5
14208 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14209   echo $ac_n "(cached) $ac_c" 1>&6
14210 else
14211   cat > conftest.$ac_ext <<EOF
14212 #line 14213 "configure"
14213 #include "confdefs.h"
14214 /* System header to define __stub macros and hopefully few prototypes,
14215     which can conflict with char $ac_func(); below.  */
14216 #include <assert.h>
14217 /* Override any gcc2 internal prototype to avoid an error.  */
14218 /* We use char because int might match the return type of a gcc2
14219     builtin and then its argument prototype would still apply.  */
14220 char $ac_func();
14221
14222 int main() {
14223
14224 /* The GNU C library defines this for functions which it implements
14225     to always fail with ENOSYS.  Some functions are actually named
14226     something starting with __ and the normal name is an alias.  */
14227 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14228 choke me
14229 #else
14230 $ac_func();
14231 #endif
14232
14233 ; return 0; }
14234 EOF
14235 if { (eval echo configure:14236: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14236   rm -rf conftest*
14237   eval "ac_cv_func_$ac_func=yes"
14238 else
14239   echo "configure: failed program was:" >&5
14240   cat conftest.$ac_ext >&5
14241   rm -rf conftest*
14242   eval "ac_cv_func_$ac_func=no"
14243 fi
14244 rm -f conftest*
14245 fi
14246
14247 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14248   echo "$ac_t""yes" 1>&6
14249     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14250   cat >> confdefs.h <<EOF
14251 #define $ac_tr_func 1
14252 EOF
14253
14254 else
14255   echo "$ac_t""no" 1>&6
14256 fi
14257 done
14258
14259   fi
14260
14261
14262   echo $ac_n "checking for _modff declaration""... $ac_c" 1>&6
14263 echo "configure:14264: checking for _modff declaration" >&5
14264   if test x${glibcpp_cv_func__modff_use+set} != xset; then
14265     if eval "test \"`echo '$''{'glibcpp_cv_func__modff_use'+set}'`\" = set"; then
14266   echo $ac_n "(cached) $ac_c" 1>&6
14267 else
14268
14269
14270       ac_ext=C
14271 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14272 ac_cpp='$CXXCPP $CPPFLAGS'
14273 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14274 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14275 cross_compiling=$ac_cv_prog_cxx_cross
14276
14277       cat > conftest.$ac_ext <<EOF
14278 #line 14279 "configure"
14279 #include "confdefs.h"
14280 #include <math.h>
14281 int main() {
14282  _modff(0, 0);
14283 ; return 0; }
14284 EOF
14285 if { (eval echo configure:14286: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14286   rm -rf conftest*
14287   glibcpp_cv_func__modff_use=yes
14288 else
14289   echo "configure: failed program was:" >&5
14290   cat conftest.$ac_ext >&5
14291   rm -rf conftest*
14292   glibcpp_cv_func__modff_use=no
14293 fi
14294 rm -f conftest*
14295       ac_ext=c
14296 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14297 ac_cpp='$CPP $CPPFLAGS'
14298 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14299 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14300 cross_compiling=$ac_cv_prog_cc_cross
14301
14302
14303 fi
14304
14305   fi
14306   echo "$ac_t""$glibcpp_cv_func__modff_use" 1>&6
14307   if test x$glibcpp_cv_func__modff_use = x"yes"; then
14308     for ac_func in _modff
14309 do
14310 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14311 echo "configure:14312: checking for $ac_func" >&5
14312 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14313   echo $ac_n "(cached) $ac_c" 1>&6
14314 else
14315   cat > conftest.$ac_ext <<EOF
14316 #line 14317 "configure"
14317 #include "confdefs.h"
14318 /* System header to define __stub macros and hopefully few prototypes,
14319     which can conflict with char $ac_func(); below.  */
14320 #include <assert.h>
14321 /* Override any gcc2 internal prototype to avoid an error.  */
14322 /* We use char because int might match the return type of a gcc2
14323     builtin and then its argument prototype would still apply.  */
14324 char $ac_func();
14325
14326 int main() {
14327
14328 /* The GNU C library defines this for functions which it implements
14329     to always fail with ENOSYS.  Some functions are actually named
14330     something starting with __ and the normal name is an alias.  */
14331 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14332 choke me
14333 #else
14334 $ac_func();
14335 #endif
14336
14337 ; return 0; }
14338 EOF
14339 if { (eval echo configure:14340: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14340   rm -rf conftest*
14341   eval "ac_cv_func_$ac_func=yes"
14342 else
14343   echo "configure: failed program was:" >&5
14344   cat conftest.$ac_ext >&5
14345   rm -rf conftest*
14346   eval "ac_cv_func_$ac_func=no"
14347 fi
14348 rm -f conftest*
14349 fi
14350
14351 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14352   echo "$ac_t""yes" 1>&6
14353     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14354   cat >> confdefs.h <<EOF
14355 #define $ac_tr_func 1
14356 EOF
14357
14358 else
14359   echo "$ac_t""no" 1>&6
14360 fi
14361 done
14362
14363   fi
14364
14365
14366   echo $ac_n "checking for _powf declaration""... $ac_c" 1>&6
14367 echo "configure:14368: checking for _powf declaration" >&5
14368   if test x${glibcpp_cv_func__powf_use+set} != xset; then
14369     if eval "test \"`echo '$''{'glibcpp_cv_func__powf_use'+set}'`\" = set"; then
14370   echo $ac_n "(cached) $ac_c" 1>&6
14371 else
14372
14373
14374       ac_ext=C
14375 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14376 ac_cpp='$CXXCPP $CPPFLAGS'
14377 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14378 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14379 cross_compiling=$ac_cv_prog_cxx_cross
14380
14381       cat > conftest.$ac_ext <<EOF
14382 #line 14383 "configure"
14383 #include "confdefs.h"
14384 #include <math.h>
14385 int main() {
14386  _powf(0, 0);
14387 ; return 0; }
14388 EOF
14389 if { (eval echo configure:14390: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14390   rm -rf conftest*
14391   glibcpp_cv_func__powf_use=yes
14392 else
14393   echo "configure: failed program was:" >&5
14394   cat conftest.$ac_ext >&5
14395   rm -rf conftest*
14396   glibcpp_cv_func__powf_use=no
14397 fi
14398 rm -f conftest*
14399       ac_ext=c
14400 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14401 ac_cpp='$CPP $CPPFLAGS'
14402 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14403 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14404 cross_compiling=$ac_cv_prog_cc_cross
14405
14406
14407 fi
14408
14409   fi
14410   echo "$ac_t""$glibcpp_cv_func__powf_use" 1>&6
14411   if test x$glibcpp_cv_func__powf_use = x"yes"; then
14412     for ac_func in _powf
14413 do
14414 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14415 echo "configure:14416: checking for $ac_func" >&5
14416 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14417   echo $ac_n "(cached) $ac_c" 1>&6
14418 else
14419   cat > conftest.$ac_ext <<EOF
14420 #line 14421 "configure"
14421 #include "confdefs.h"
14422 /* System header to define __stub macros and hopefully few prototypes,
14423     which can conflict with char $ac_func(); below.  */
14424 #include <assert.h>
14425 /* Override any gcc2 internal prototype to avoid an error.  */
14426 /* We use char because int might match the return type of a gcc2
14427     builtin and then its argument prototype would still apply.  */
14428 char $ac_func();
14429
14430 int main() {
14431
14432 /* The GNU C library defines this for functions which it implements
14433     to always fail with ENOSYS.  Some functions are actually named
14434     something starting with __ and the normal name is an alias.  */
14435 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14436 choke me
14437 #else
14438 $ac_func();
14439 #endif
14440
14441 ; return 0; }
14442 EOF
14443 if { (eval echo configure:14444: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14444   rm -rf conftest*
14445   eval "ac_cv_func_$ac_func=yes"
14446 else
14447   echo "configure: failed program was:" >&5
14448   cat conftest.$ac_ext >&5
14449   rm -rf conftest*
14450   eval "ac_cv_func_$ac_func=no"
14451 fi
14452 rm -f conftest*
14453 fi
14454
14455 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14456   echo "$ac_t""yes" 1>&6
14457     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14458   cat >> confdefs.h <<EOF
14459 #define $ac_tr_func 1
14460 EOF
14461
14462 else
14463   echo "$ac_t""no" 1>&6
14464 fi
14465 done
14466
14467   fi
14468
14469
14470   echo $ac_n "checking for _sinf declaration""... $ac_c" 1>&6
14471 echo "configure:14472: checking for _sinf declaration" >&5
14472   if test x${glibcpp_cv_func__sinf_use+set} != xset; then
14473     if eval "test \"`echo '$''{'glibcpp_cv_func__sinf_use'+set}'`\" = set"; then
14474   echo $ac_n "(cached) $ac_c" 1>&6
14475 else
14476
14477
14478       ac_ext=C
14479 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14480 ac_cpp='$CXXCPP $CPPFLAGS'
14481 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14482 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14483 cross_compiling=$ac_cv_prog_cxx_cross
14484
14485       cat > conftest.$ac_ext <<EOF
14486 #line 14487 "configure"
14487 #include "confdefs.h"
14488 #include <math.h>
14489 int main() {
14490  _sinf(0);
14491 ; return 0; }
14492 EOF
14493 if { (eval echo configure:14494: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14494   rm -rf conftest*
14495   glibcpp_cv_func__sinf_use=yes
14496 else
14497   echo "configure: failed program was:" >&5
14498   cat conftest.$ac_ext >&5
14499   rm -rf conftest*
14500   glibcpp_cv_func__sinf_use=no
14501 fi
14502 rm -f conftest*
14503       ac_ext=c
14504 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14505 ac_cpp='$CPP $CPPFLAGS'
14506 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14507 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14508 cross_compiling=$ac_cv_prog_cc_cross
14509
14510
14511 fi
14512
14513   fi
14514   echo "$ac_t""$glibcpp_cv_func__sinf_use" 1>&6
14515   if test x$glibcpp_cv_func__sinf_use = x"yes"; then
14516     for ac_func in _sinf
14517 do
14518 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14519 echo "configure:14520: checking for $ac_func" >&5
14520 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14521   echo $ac_n "(cached) $ac_c" 1>&6
14522 else
14523   cat > conftest.$ac_ext <<EOF
14524 #line 14525 "configure"
14525 #include "confdefs.h"
14526 /* System header to define __stub macros and hopefully few prototypes,
14527     which can conflict with char $ac_func(); below.  */
14528 #include <assert.h>
14529 /* Override any gcc2 internal prototype to avoid an error.  */
14530 /* We use char because int might match the return type of a gcc2
14531     builtin and then its argument prototype would still apply.  */
14532 char $ac_func();
14533
14534 int main() {
14535
14536 /* The GNU C library defines this for functions which it implements
14537     to always fail with ENOSYS.  Some functions are actually named
14538     something starting with __ and the normal name is an alias.  */
14539 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14540 choke me
14541 #else
14542 $ac_func();
14543 #endif
14544
14545 ; return 0; }
14546 EOF
14547 if { (eval echo configure:14548: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14548   rm -rf conftest*
14549   eval "ac_cv_func_$ac_func=yes"
14550 else
14551   echo "configure: failed program was:" >&5
14552   cat conftest.$ac_ext >&5
14553   rm -rf conftest*
14554   eval "ac_cv_func_$ac_func=no"
14555 fi
14556 rm -f conftest*
14557 fi
14558
14559 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14560   echo "$ac_t""yes" 1>&6
14561     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14562   cat >> confdefs.h <<EOF
14563 #define $ac_tr_func 1
14564 EOF
14565
14566 else
14567   echo "$ac_t""no" 1>&6
14568 fi
14569 done
14570
14571   fi
14572
14573
14574   echo $ac_n "checking for _sinhf declaration""... $ac_c" 1>&6
14575 echo "configure:14576: checking for _sinhf declaration" >&5
14576   if test x${glibcpp_cv_func__sinhf_use+set} != xset; then
14577     if eval "test \"`echo '$''{'glibcpp_cv_func__sinhf_use'+set}'`\" = set"; then
14578   echo $ac_n "(cached) $ac_c" 1>&6
14579 else
14580
14581
14582       ac_ext=C
14583 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14584 ac_cpp='$CXXCPP $CPPFLAGS'
14585 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14586 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14587 cross_compiling=$ac_cv_prog_cxx_cross
14588
14589       cat > conftest.$ac_ext <<EOF
14590 #line 14591 "configure"
14591 #include "confdefs.h"
14592 #include <math.h>
14593 int main() {
14594  _sinhf(0);
14595 ; return 0; }
14596 EOF
14597 if { (eval echo configure:14598: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14598   rm -rf conftest*
14599   glibcpp_cv_func__sinhf_use=yes
14600 else
14601   echo "configure: failed program was:" >&5
14602   cat conftest.$ac_ext >&5
14603   rm -rf conftest*
14604   glibcpp_cv_func__sinhf_use=no
14605 fi
14606 rm -f conftest*
14607       ac_ext=c
14608 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14609 ac_cpp='$CPP $CPPFLAGS'
14610 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14611 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14612 cross_compiling=$ac_cv_prog_cc_cross
14613
14614
14615 fi
14616
14617   fi
14618   echo "$ac_t""$glibcpp_cv_func__sinhf_use" 1>&6
14619   if test x$glibcpp_cv_func__sinhf_use = x"yes"; then
14620     for ac_func in _sinhf
14621 do
14622 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14623 echo "configure:14624: checking for $ac_func" >&5
14624 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14625   echo $ac_n "(cached) $ac_c" 1>&6
14626 else
14627   cat > conftest.$ac_ext <<EOF
14628 #line 14629 "configure"
14629 #include "confdefs.h"
14630 /* System header to define __stub macros and hopefully few prototypes,
14631     which can conflict with char $ac_func(); below.  */
14632 #include <assert.h>
14633 /* Override any gcc2 internal prototype to avoid an error.  */
14634 /* We use char because int might match the return type of a gcc2
14635     builtin and then its argument prototype would still apply.  */
14636 char $ac_func();
14637
14638 int main() {
14639
14640 /* The GNU C library defines this for functions which it implements
14641     to always fail with ENOSYS.  Some functions are actually named
14642     something starting with __ and the normal name is an alias.  */
14643 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14644 choke me
14645 #else
14646 $ac_func();
14647 #endif
14648
14649 ; return 0; }
14650 EOF
14651 if { (eval echo configure:14652: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14652   rm -rf conftest*
14653   eval "ac_cv_func_$ac_func=yes"
14654 else
14655   echo "configure: failed program was:" >&5
14656   cat conftest.$ac_ext >&5
14657   rm -rf conftest*
14658   eval "ac_cv_func_$ac_func=no"
14659 fi
14660 rm -f conftest*
14661 fi
14662
14663 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14664   echo "$ac_t""yes" 1>&6
14665     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14666   cat >> confdefs.h <<EOF
14667 #define $ac_tr_func 1
14668 EOF
14669
14670 else
14671   echo "$ac_t""no" 1>&6
14672 fi
14673 done
14674
14675   fi
14676
14677
14678   echo $ac_n "checking for _sqrtf declaration""... $ac_c" 1>&6
14679 echo "configure:14680: checking for _sqrtf declaration" >&5
14680   if test x${glibcpp_cv_func__sqrtf_use+set} != xset; then
14681     if eval "test \"`echo '$''{'glibcpp_cv_func__sqrtf_use'+set}'`\" = set"; then
14682   echo $ac_n "(cached) $ac_c" 1>&6
14683 else
14684
14685
14686       ac_ext=C
14687 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14688 ac_cpp='$CXXCPP $CPPFLAGS'
14689 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14690 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14691 cross_compiling=$ac_cv_prog_cxx_cross
14692
14693       cat > conftest.$ac_ext <<EOF
14694 #line 14695 "configure"
14695 #include "confdefs.h"
14696 #include <math.h>
14697 int main() {
14698  _sqrtf(0);
14699 ; return 0; }
14700 EOF
14701 if { (eval echo configure:14702: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14702   rm -rf conftest*
14703   glibcpp_cv_func__sqrtf_use=yes
14704 else
14705   echo "configure: failed program was:" >&5
14706   cat conftest.$ac_ext >&5
14707   rm -rf conftest*
14708   glibcpp_cv_func__sqrtf_use=no
14709 fi
14710 rm -f conftest*
14711       ac_ext=c
14712 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14713 ac_cpp='$CPP $CPPFLAGS'
14714 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14715 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14716 cross_compiling=$ac_cv_prog_cc_cross
14717
14718
14719 fi
14720
14721   fi
14722   echo "$ac_t""$glibcpp_cv_func__sqrtf_use" 1>&6
14723   if test x$glibcpp_cv_func__sqrtf_use = x"yes"; then
14724     for ac_func in _sqrtf
14725 do
14726 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14727 echo "configure:14728: checking for $ac_func" >&5
14728 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14729   echo $ac_n "(cached) $ac_c" 1>&6
14730 else
14731   cat > conftest.$ac_ext <<EOF
14732 #line 14733 "configure"
14733 #include "confdefs.h"
14734 /* System header to define __stub macros and hopefully few prototypes,
14735     which can conflict with char $ac_func(); below.  */
14736 #include <assert.h>
14737 /* Override any gcc2 internal prototype to avoid an error.  */
14738 /* We use char because int might match the return type of a gcc2
14739     builtin and then its argument prototype would still apply.  */
14740 char $ac_func();
14741
14742 int main() {
14743
14744 /* The GNU C library defines this for functions which it implements
14745     to always fail with ENOSYS.  Some functions are actually named
14746     something starting with __ and the normal name is an alias.  */
14747 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14748 choke me
14749 #else
14750 $ac_func();
14751 #endif
14752
14753 ; return 0; }
14754 EOF
14755 if { (eval echo configure:14756: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14756   rm -rf conftest*
14757   eval "ac_cv_func_$ac_func=yes"
14758 else
14759   echo "configure: failed program was:" >&5
14760   cat conftest.$ac_ext >&5
14761   rm -rf conftest*
14762   eval "ac_cv_func_$ac_func=no"
14763 fi
14764 rm -f conftest*
14765 fi
14766
14767 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14768   echo "$ac_t""yes" 1>&6
14769     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14770   cat >> confdefs.h <<EOF
14771 #define $ac_tr_func 1
14772 EOF
14773
14774 else
14775   echo "$ac_t""no" 1>&6
14776 fi
14777 done
14778
14779   fi
14780
14781
14782   echo $ac_n "checking for _tanf declaration""... $ac_c" 1>&6
14783 echo "configure:14784: checking for _tanf declaration" >&5
14784   if test x${glibcpp_cv_func__tanf_use+set} != xset; then
14785     if eval "test \"`echo '$''{'glibcpp_cv_func__tanf_use'+set}'`\" = set"; then
14786   echo $ac_n "(cached) $ac_c" 1>&6
14787 else
14788
14789
14790       ac_ext=C
14791 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14792 ac_cpp='$CXXCPP $CPPFLAGS'
14793 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14794 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14795 cross_compiling=$ac_cv_prog_cxx_cross
14796
14797       cat > conftest.$ac_ext <<EOF
14798 #line 14799 "configure"
14799 #include "confdefs.h"
14800 #include <math.h>
14801 int main() {
14802  _tanf(0);
14803 ; return 0; }
14804 EOF
14805 if { (eval echo configure:14806: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14806   rm -rf conftest*
14807   glibcpp_cv_func__tanf_use=yes
14808 else
14809   echo "configure: failed program was:" >&5
14810   cat conftest.$ac_ext >&5
14811   rm -rf conftest*
14812   glibcpp_cv_func__tanf_use=no
14813 fi
14814 rm -f conftest*
14815       ac_ext=c
14816 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14817 ac_cpp='$CPP $CPPFLAGS'
14818 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14819 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14820 cross_compiling=$ac_cv_prog_cc_cross
14821
14822
14823 fi
14824
14825   fi
14826   echo "$ac_t""$glibcpp_cv_func__tanf_use" 1>&6
14827   if test x$glibcpp_cv_func__tanf_use = x"yes"; then
14828     for ac_func in _tanf
14829 do
14830 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14831 echo "configure:14832: checking for $ac_func" >&5
14832 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14833   echo $ac_n "(cached) $ac_c" 1>&6
14834 else
14835   cat > conftest.$ac_ext <<EOF
14836 #line 14837 "configure"
14837 #include "confdefs.h"
14838 /* System header to define __stub macros and hopefully few prototypes,
14839     which can conflict with char $ac_func(); below.  */
14840 #include <assert.h>
14841 /* Override any gcc2 internal prototype to avoid an error.  */
14842 /* We use char because int might match the return type of a gcc2
14843     builtin and then its argument prototype would still apply.  */
14844 char $ac_func();
14845
14846 int main() {
14847
14848 /* The GNU C library defines this for functions which it implements
14849     to always fail with ENOSYS.  Some functions are actually named
14850     something starting with __ and the normal name is an alias.  */
14851 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14852 choke me
14853 #else
14854 $ac_func();
14855 #endif
14856
14857 ; return 0; }
14858 EOF
14859 if { (eval echo configure:14860: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14860   rm -rf conftest*
14861   eval "ac_cv_func_$ac_func=yes"
14862 else
14863   echo "configure: failed program was:" >&5
14864   cat conftest.$ac_ext >&5
14865   rm -rf conftest*
14866   eval "ac_cv_func_$ac_func=no"
14867 fi
14868 rm -f conftest*
14869 fi
14870
14871 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14872   echo "$ac_t""yes" 1>&6
14873     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14874   cat >> confdefs.h <<EOF
14875 #define $ac_tr_func 1
14876 EOF
14877
14878 else
14879   echo "$ac_t""no" 1>&6
14880 fi
14881 done
14882
14883   fi
14884
14885
14886   echo $ac_n "checking for _tanhf declaration""... $ac_c" 1>&6
14887 echo "configure:14888: checking for _tanhf declaration" >&5
14888   if test x${glibcpp_cv_func__tanhf_use+set} != xset; then
14889     if eval "test \"`echo '$''{'glibcpp_cv_func__tanhf_use'+set}'`\" = set"; then
14890   echo $ac_n "(cached) $ac_c" 1>&6
14891 else
14892
14893
14894       ac_ext=C
14895 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14896 ac_cpp='$CXXCPP $CPPFLAGS'
14897 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14898 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14899 cross_compiling=$ac_cv_prog_cxx_cross
14900
14901       cat > conftest.$ac_ext <<EOF
14902 #line 14903 "configure"
14903 #include "confdefs.h"
14904 #include <math.h>
14905 int main() {
14906  _tanhf(0);
14907 ; return 0; }
14908 EOF
14909 if { (eval echo configure:14910: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
14910   rm -rf conftest*
14911   glibcpp_cv_func__tanhf_use=yes
14912 else
14913   echo "configure: failed program was:" >&5
14914   cat conftest.$ac_ext >&5
14915   rm -rf conftest*
14916   glibcpp_cv_func__tanhf_use=no
14917 fi
14918 rm -f conftest*
14919       ac_ext=c
14920 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
14921 ac_cpp='$CPP $CPPFLAGS'
14922 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
14923 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
14924 cross_compiling=$ac_cv_prog_cc_cross
14925
14926
14927 fi
14928
14929   fi
14930   echo "$ac_t""$glibcpp_cv_func__tanhf_use" 1>&6
14931   if test x$glibcpp_cv_func__tanhf_use = x"yes"; then
14932     for ac_func in _tanhf
14933 do
14934 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
14935 echo "configure:14936: checking for $ac_func" >&5
14936 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
14937   echo $ac_n "(cached) $ac_c" 1>&6
14938 else
14939   cat > conftest.$ac_ext <<EOF
14940 #line 14941 "configure"
14941 #include "confdefs.h"
14942 /* System header to define __stub macros and hopefully few prototypes,
14943     which can conflict with char $ac_func(); below.  */
14944 #include <assert.h>
14945 /* Override any gcc2 internal prototype to avoid an error.  */
14946 /* We use char because int might match the return type of a gcc2
14947     builtin and then its argument prototype would still apply.  */
14948 char $ac_func();
14949
14950 int main() {
14951
14952 /* The GNU C library defines this for functions which it implements
14953     to always fail with ENOSYS.  Some functions are actually named
14954     something starting with __ and the normal name is an alias.  */
14955 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
14956 choke me
14957 #else
14958 $ac_func();
14959 #endif
14960
14961 ; return 0; }
14962 EOF
14963 if { (eval echo configure:14964: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
14964   rm -rf conftest*
14965   eval "ac_cv_func_$ac_func=yes"
14966 else
14967   echo "configure: failed program was:" >&5
14968   cat conftest.$ac_ext >&5
14969   rm -rf conftest*
14970   eval "ac_cv_func_$ac_func=no"
14971 fi
14972 rm -f conftest*
14973 fi
14974
14975 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
14976   echo "$ac_t""yes" 1>&6
14977     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
14978   cat >> confdefs.h <<EOF
14979 #define $ac_tr_func 1
14980 EOF
14981
14982 else
14983   echo "$ac_t""no" 1>&6
14984 fi
14985 done
14986
14987   fi
14988
14989
14990   echo $ac_n "checking for _sincosf declaration""... $ac_c" 1>&6
14991 echo "configure:14992: checking for _sincosf declaration" >&5
14992   if test x${glibcpp_cv_func__sincosf_use+set} != xset; then
14993     if eval "test \"`echo '$''{'glibcpp_cv_func__sincosf_use'+set}'`\" = set"; then
14994   echo $ac_n "(cached) $ac_c" 1>&6
14995 else
14996
14997
14998       ac_ext=C
14999 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15000 ac_cpp='$CXXCPP $CPPFLAGS'
15001 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15002 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15003 cross_compiling=$ac_cv_prog_cxx_cross
15004
15005       cat > conftest.$ac_ext <<EOF
15006 #line 15007 "configure"
15007 #include "confdefs.h"
15008 #include <math.h>
15009 int main() {
15010  _sincosf(0, 0, 0);
15011 ; return 0; }
15012 EOF
15013 if { (eval echo configure:15014: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15014   rm -rf conftest*
15015   glibcpp_cv_func__sincosf_use=yes
15016 else
15017   echo "configure: failed program was:" >&5
15018   cat conftest.$ac_ext >&5
15019   rm -rf conftest*
15020   glibcpp_cv_func__sincosf_use=no
15021 fi
15022 rm -f conftest*
15023       ac_ext=c
15024 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15025 ac_cpp='$CPP $CPPFLAGS'
15026 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15027 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15028 cross_compiling=$ac_cv_prog_cc_cross
15029
15030
15031 fi
15032
15033   fi
15034   echo "$ac_t""$glibcpp_cv_func__sincosf_use" 1>&6
15035   if test x$glibcpp_cv_func__sincosf_use = x"yes"; then
15036     for ac_func in _sincosf
15037 do
15038 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15039 echo "configure:15040: checking for $ac_func" >&5
15040 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15041   echo $ac_n "(cached) $ac_c" 1>&6
15042 else
15043   cat > conftest.$ac_ext <<EOF
15044 #line 15045 "configure"
15045 #include "confdefs.h"
15046 /* System header to define __stub macros and hopefully few prototypes,
15047     which can conflict with char $ac_func(); below.  */
15048 #include <assert.h>
15049 /* Override any gcc2 internal prototype to avoid an error.  */
15050 /* We use char because int might match the return type of a gcc2
15051     builtin and then its argument prototype would still apply.  */
15052 char $ac_func();
15053
15054 int main() {
15055
15056 /* The GNU C library defines this for functions which it implements
15057     to always fail with ENOSYS.  Some functions are actually named
15058     something starting with __ and the normal name is an alias.  */
15059 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15060 choke me
15061 #else
15062 $ac_func();
15063 #endif
15064
15065 ; return 0; }
15066 EOF
15067 if { (eval echo configure:15068: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15068   rm -rf conftest*
15069   eval "ac_cv_func_$ac_func=yes"
15070 else
15071   echo "configure: failed program was:" >&5
15072   cat conftest.$ac_ext >&5
15073   rm -rf conftest*
15074   eval "ac_cv_func_$ac_func=no"
15075 fi
15076 rm -f conftest*
15077 fi
15078
15079 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15080   echo "$ac_t""yes" 1>&6
15081     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15082   cat >> confdefs.h <<EOF
15083 #define $ac_tr_func 1
15084 EOF
15085
15086 else
15087   echo "$ac_t""no" 1>&6
15088 fi
15089 done
15090
15091   fi
15092
15093
15094   echo $ac_n "checking for _finitef declaration""... $ac_c" 1>&6
15095 echo "configure:15096: checking for _finitef declaration" >&5
15096   if test x${glibcpp_cv_func__finitef_use+set} != xset; then
15097     if eval "test \"`echo '$''{'glibcpp_cv_func__finitef_use'+set}'`\" = set"; then
15098   echo $ac_n "(cached) $ac_c" 1>&6
15099 else
15100
15101
15102       ac_ext=C
15103 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15104 ac_cpp='$CXXCPP $CPPFLAGS'
15105 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15106 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15107 cross_compiling=$ac_cv_prog_cxx_cross
15108
15109       cat > conftest.$ac_ext <<EOF
15110 #line 15111 "configure"
15111 #include "confdefs.h"
15112 #include <math.h>
15113 int main() {
15114  _finitef(0);
15115 ; return 0; }
15116 EOF
15117 if { (eval echo configure:15118: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15118   rm -rf conftest*
15119   glibcpp_cv_func__finitef_use=yes
15120 else
15121   echo "configure: failed program was:" >&5
15122   cat conftest.$ac_ext >&5
15123   rm -rf conftest*
15124   glibcpp_cv_func__finitef_use=no
15125 fi
15126 rm -f conftest*
15127       ac_ext=c
15128 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15129 ac_cpp='$CPP $CPPFLAGS'
15130 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15131 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15132 cross_compiling=$ac_cv_prog_cc_cross
15133
15134
15135 fi
15136
15137   fi
15138   echo "$ac_t""$glibcpp_cv_func__finitef_use" 1>&6
15139   if test x$glibcpp_cv_func__finitef_use = x"yes"; then
15140     for ac_func in _finitef
15141 do
15142 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15143 echo "configure:15144: checking for $ac_func" >&5
15144 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15145   echo $ac_n "(cached) $ac_c" 1>&6
15146 else
15147   cat > conftest.$ac_ext <<EOF
15148 #line 15149 "configure"
15149 #include "confdefs.h"
15150 /* System header to define __stub macros and hopefully few prototypes,
15151     which can conflict with char $ac_func(); below.  */
15152 #include <assert.h>
15153 /* Override any gcc2 internal prototype to avoid an error.  */
15154 /* We use char because int might match the return type of a gcc2
15155     builtin and then its argument prototype would still apply.  */
15156 char $ac_func();
15157
15158 int main() {
15159
15160 /* The GNU C library defines this for functions which it implements
15161     to always fail with ENOSYS.  Some functions are actually named
15162     something starting with __ and the normal name is an alias.  */
15163 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15164 choke me
15165 #else
15166 $ac_func();
15167 #endif
15168
15169 ; return 0; }
15170 EOF
15171 if { (eval echo configure:15172: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15172   rm -rf conftest*
15173   eval "ac_cv_func_$ac_func=yes"
15174 else
15175   echo "configure: failed program was:" >&5
15176   cat conftest.$ac_ext >&5
15177   rm -rf conftest*
15178   eval "ac_cv_func_$ac_func=no"
15179 fi
15180 rm -f conftest*
15181 fi
15182
15183 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15184   echo "$ac_t""yes" 1>&6
15185     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15186   cat >> confdefs.h <<EOF
15187 #define $ac_tr_func 1
15188 EOF
15189
15190 else
15191   echo "$ac_t""no" 1>&6
15192 fi
15193 done
15194
15195   fi
15196
15197
15198
15199   echo $ac_n "checking for _isnanl declaration""... $ac_c" 1>&6
15200 echo "configure:15201: checking for _isnanl declaration" >&5
15201   if test x${glibcpp_cv_func__isnanl_use+set} != xset; then
15202     if eval "test \"`echo '$''{'glibcpp_cv_func__isnanl_use'+set}'`\" = set"; then
15203   echo $ac_n "(cached) $ac_c" 1>&6
15204 else
15205
15206
15207       ac_ext=C
15208 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15209 ac_cpp='$CXXCPP $CPPFLAGS'
15210 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15211 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15212 cross_compiling=$ac_cv_prog_cxx_cross
15213
15214       cat > conftest.$ac_ext <<EOF
15215 #line 15216 "configure"
15216 #include "confdefs.h"
15217 #include <math.h>
15218 int main() {
15219  _isnanl(0);
15220 ; return 0; }
15221 EOF
15222 if { (eval echo configure:15223: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15223   rm -rf conftest*
15224   glibcpp_cv_func__isnanl_use=yes
15225 else
15226   echo "configure: failed program was:" >&5
15227   cat conftest.$ac_ext >&5
15228   rm -rf conftest*
15229   glibcpp_cv_func__isnanl_use=no
15230 fi
15231 rm -f conftest*
15232       ac_ext=c
15233 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15234 ac_cpp='$CPP $CPPFLAGS'
15235 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15236 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15237 cross_compiling=$ac_cv_prog_cc_cross
15238
15239
15240 fi
15241
15242   fi
15243   echo "$ac_t""$glibcpp_cv_func__isnanl_use" 1>&6
15244   if test x$glibcpp_cv_func__isnanl_use = x"yes"; then
15245     for ac_func in _isnanl
15246 do
15247 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15248 echo "configure:15249: checking for $ac_func" >&5
15249 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15250   echo $ac_n "(cached) $ac_c" 1>&6
15251 else
15252   cat > conftest.$ac_ext <<EOF
15253 #line 15254 "configure"
15254 #include "confdefs.h"
15255 /* System header to define __stub macros and hopefully few prototypes,
15256     which can conflict with char $ac_func(); below.  */
15257 #include <assert.h>
15258 /* Override any gcc2 internal prototype to avoid an error.  */
15259 /* We use char because int might match the return type of a gcc2
15260     builtin and then its argument prototype would still apply.  */
15261 char $ac_func();
15262
15263 int main() {
15264
15265 /* The GNU C library defines this for functions which it implements
15266     to always fail with ENOSYS.  Some functions are actually named
15267     something starting with __ and the normal name is an alias.  */
15268 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15269 choke me
15270 #else
15271 $ac_func();
15272 #endif
15273
15274 ; return 0; }
15275 EOF
15276 if { (eval echo configure:15277: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15277   rm -rf conftest*
15278   eval "ac_cv_func_$ac_func=yes"
15279 else
15280   echo "configure: failed program was:" >&5
15281   cat conftest.$ac_ext >&5
15282   rm -rf conftest*
15283   eval "ac_cv_func_$ac_func=no"
15284 fi
15285 rm -f conftest*
15286 fi
15287
15288 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15289   echo "$ac_t""yes" 1>&6
15290     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15291   cat >> confdefs.h <<EOF
15292 #define $ac_tr_func 1
15293 EOF
15294
15295 else
15296   echo "$ac_t""no" 1>&6
15297 fi
15298 done
15299
15300   fi
15301
15302
15303   echo $ac_n "checking for _isinfl declaration""... $ac_c" 1>&6
15304 echo "configure:15305: checking for _isinfl declaration" >&5
15305   if test x${glibcpp_cv_func__isinfl_use+set} != xset; then
15306     if eval "test \"`echo '$''{'glibcpp_cv_func__isinfl_use'+set}'`\" = set"; then
15307   echo $ac_n "(cached) $ac_c" 1>&6
15308 else
15309
15310
15311       ac_ext=C
15312 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15313 ac_cpp='$CXXCPP $CPPFLAGS'
15314 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15315 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15316 cross_compiling=$ac_cv_prog_cxx_cross
15317
15318       cat > conftest.$ac_ext <<EOF
15319 #line 15320 "configure"
15320 #include "confdefs.h"
15321 #include <math.h>
15322 int main() {
15323  _isinfl(0);
15324 ; return 0; }
15325 EOF
15326 if { (eval echo configure:15327: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15327   rm -rf conftest*
15328   glibcpp_cv_func__isinfl_use=yes
15329 else
15330   echo "configure: failed program was:" >&5
15331   cat conftest.$ac_ext >&5
15332   rm -rf conftest*
15333   glibcpp_cv_func__isinfl_use=no
15334 fi
15335 rm -f conftest*
15336       ac_ext=c
15337 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15338 ac_cpp='$CPP $CPPFLAGS'
15339 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15340 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15341 cross_compiling=$ac_cv_prog_cc_cross
15342
15343
15344 fi
15345
15346   fi
15347   echo "$ac_t""$glibcpp_cv_func__isinfl_use" 1>&6
15348   if test x$glibcpp_cv_func__isinfl_use = x"yes"; then
15349     for ac_func in _isinfl
15350 do
15351 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15352 echo "configure:15353: checking for $ac_func" >&5
15353 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15354   echo $ac_n "(cached) $ac_c" 1>&6
15355 else
15356   cat > conftest.$ac_ext <<EOF
15357 #line 15358 "configure"
15358 #include "confdefs.h"
15359 /* System header to define __stub macros and hopefully few prototypes,
15360     which can conflict with char $ac_func(); below.  */
15361 #include <assert.h>
15362 /* Override any gcc2 internal prototype to avoid an error.  */
15363 /* We use char because int might match the return type of a gcc2
15364     builtin and then its argument prototype would still apply.  */
15365 char $ac_func();
15366
15367 int main() {
15368
15369 /* The GNU C library defines this for functions which it implements
15370     to always fail with ENOSYS.  Some functions are actually named
15371     something starting with __ and the normal name is an alias.  */
15372 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15373 choke me
15374 #else
15375 $ac_func();
15376 #endif
15377
15378 ; return 0; }
15379 EOF
15380 if { (eval echo configure:15381: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15381   rm -rf conftest*
15382   eval "ac_cv_func_$ac_func=yes"
15383 else
15384   echo "configure: failed program was:" >&5
15385   cat conftest.$ac_ext >&5
15386   rm -rf conftest*
15387   eval "ac_cv_func_$ac_func=no"
15388 fi
15389 rm -f conftest*
15390 fi
15391
15392 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15393   echo "$ac_t""yes" 1>&6
15394     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15395   cat >> confdefs.h <<EOF
15396 #define $ac_tr_func 1
15397 EOF
15398
15399 else
15400   echo "$ac_t""no" 1>&6
15401 fi
15402 done
15403
15404   fi
15405
15406
15407   echo $ac_n "checking for _copysignl declaration""... $ac_c" 1>&6
15408 echo "configure:15409: checking for _copysignl declaration" >&5
15409   if test x${glibcpp_cv_func__copysignl_use+set} != xset; then
15410     if eval "test \"`echo '$''{'glibcpp_cv_func__copysignl_use'+set}'`\" = set"; then
15411   echo $ac_n "(cached) $ac_c" 1>&6
15412 else
15413
15414
15415       ac_ext=C
15416 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15417 ac_cpp='$CXXCPP $CPPFLAGS'
15418 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15419 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15420 cross_compiling=$ac_cv_prog_cxx_cross
15421
15422       cat > conftest.$ac_ext <<EOF
15423 #line 15424 "configure"
15424 #include "confdefs.h"
15425 #include <math.h>
15426 int main() {
15427  _copysignl(0, 0);
15428 ; return 0; }
15429 EOF
15430 if { (eval echo configure:15431: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15431   rm -rf conftest*
15432   glibcpp_cv_func__copysignl_use=yes
15433 else
15434   echo "configure: failed program was:" >&5
15435   cat conftest.$ac_ext >&5
15436   rm -rf conftest*
15437   glibcpp_cv_func__copysignl_use=no
15438 fi
15439 rm -f conftest*
15440       ac_ext=c
15441 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15442 ac_cpp='$CPP $CPPFLAGS'
15443 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15444 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15445 cross_compiling=$ac_cv_prog_cc_cross
15446
15447
15448 fi
15449
15450   fi
15451   echo "$ac_t""$glibcpp_cv_func__copysignl_use" 1>&6
15452   if test x$glibcpp_cv_func__copysignl_use = x"yes"; then
15453     for ac_func in _copysignl
15454 do
15455 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15456 echo "configure:15457: checking for $ac_func" >&5
15457 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15458   echo $ac_n "(cached) $ac_c" 1>&6
15459 else
15460   cat > conftest.$ac_ext <<EOF
15461 #line 15462 "configure"
15462 #include "confdefs.h"
15463 /* System header to define __stub macros and hopefully few prototypes,
15464     which can conflict with char $ac_func(); below.  */
15465 #include <assert.h>
15466 /* Override any gcc2 internal prototype to avoid an error.  */
15467 /* We use char because int might match the return type of a gcc2
15468     builtin and then its argument prototype would still apply.  */
15469 char $ac_func();
15470
15471 int main() {
15472
15473 /* The GNU C library defines this for functions which it implements
15474     to always fail with ENOSYS.  Some functions are actually named
15475     something starting with __ and the normal name is an alias.  */
15476 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15477 choke me
15478 #else
15479 $ac_func();
15480 #endif
15481
15482 ; return 0; }
15483 EOF
15484 if { (eval echo configure:15485: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15485   rm -rf conftest*
15486   eval "ac_cv_func_$ac_func=yes"
15487 else
15488   echo "configure: failed program was:" >&5
15489   cat conftest.$ac_ext >&5
15490   rm -rf conftest*
15491   eval "ac_cv_func_$ac_func=no"
15492 fi
15493 rm -f conftest*
15494 fi
15495
15496 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15497   echo "$ac_t""yes" 1>&6
15498     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15499   cat >> confdefs.h <<EOF
15500 #define $ac_tr_func 1
15501 EOF
15502
15503 else
15504   echo "$ac_t""no" 1>&6
15505 fi
15506 done
15507
15508   fi
15509
15510
15511   echo $ac_n "checking for _acosl declaration""... $ac_c" 1>&6
15512 echo "configure:15513: checking for _acosl declaration" >&5
15513   if test x${glibcpp_cv_func__acosl_use+set} != xset; then
15514     if eval "test \"`echo '$''{'glibcpp_cv_func__acosl_use'+set}'`\" = set"; then
15515   echo $ac_n "(cached) $ac_c" 1>&6
15516 else
15517
15518
15519       ac_ext=C
15520 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15521 ac_cpp='$CXXCPP $CPPFLAGS'
15522 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15523 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15524 cross_compiling=$ac_cv_prog_cxx_cross
15525
15526       cat > conftest.$ac_ext <<EOF
15527 #line 15528 "configure"
15528 #include "confdefs.h"
15529 #include <math.h>
15530 int main() {
15531  _acosl(0);
15532 ; return 0; }
15533 EOF
15534 if { (eval echo configure:15535: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15535   rm -rf conftest*
15536   glibcpp_cv_func__acosl_use=yes
15537 else
15538   echo "configure: failed program was:" >&5
15539   cat conftest.$ac_ext >&5
15540   rm -rf conftest*
15541   glibcpp_cv_func__acosl_use=no
15542 fi
15543 rm -f conftest*
15544       ac_ext=c
15545 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15546 ac_cpp='$CPP $CPPFLAGS'
15547 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15548 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15549 cross_compiling=$ac_cv_prog_cc_cross
15550
15551
15552 fi
15553
15554   fi
15555   echo "$ac_t""$glibcpp_cv_func__acosl_use" 1>&6
15556   if test x$glibcpp_cv_func__acosl_use = x"yes"; then
15557     for ac_func in _acosl
15558 do
15559 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15560 echo "configure:15561: checking for $ac_func" >&5
15561 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15562   echo $ac_n "(cached) $ac_c" 1>&6
15563 else
15564   cat > conftest.$ac_ext <<EOF
15565 #line 15566 "configure"
15566 #include "confdefs.h"
15567 /* System header to define __stub macros and hopefully few prototypes,
15568     which can conflict with char $ac_func(); below.  */
15569 #include <assert.h>
15570 /* Override any gcc2 internal prototype to avoid an error.  */
15571 /* We use char because int might match the return type of a gcc2
15572     builtin and then its argument prototype would still apply.  */
15573 char $ac_func();
15574
15575 int main() {
15576
15577 /* The GNU C library defines this for functions which it implements
15578     to always fail with ENOSYS.  Some functions are actually named
15579     something starting with __ and the normal name is an alias.  */
15580 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15581 choke me
15582 #else
15583 $ac_func();
15584 #endif
15585
15586 ; return 0; }
15587 EOF
15588 if { (eval echo configure:15589: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15589   rm -rf conftest*
15590   eval "ac_cv_func_$ac_func=yes"
15591 else
15592   echo "configure: failed program was:" >&5
15593   cat conftest.$ac_ext >&5
15594   rm -rf conftest*
15595   eval "ac_cv_func_$ac_func=no"
15596 fi
15597 rm -f conftest*
15598 fi
15599
15600 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15601   echo "$ac_t""yes" 1>&6
15602     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15603   cat >> confdefs.h <<EOF
15604 #define $ac_tr_func 1
15605 EOF
15606
15607 else
15608   echo "$ac_t""no" 1>&6
15609 fi
15610 done
15611
15612   fi
15613
15614
15615   echo $ac_n "checking for _asinl declaration""... $ac_c" 1>&6
15616 echo "configure:15617: checking for _asinl declaration" >&5
15617   if test x${glibcpp_cv_func__asinl_use+set} != xset; then
15618     if eval "test \"`echo '$''{'glibcpp_cv_func__asinl_use'+set}'`\" = set"; then
15619   echo $ac_n "(cached) $ac_c" 1>&6
15620 else
15621
15622
15623       ac_ext=C
15624 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15625 ac_cpp='$CXXCPP $CPPFLAGS'
15626 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15627 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15628 cross_compiling=$ac_cv_prog_cxx_cross
15629
15630       cat > conftest.$ac_ext <<EOF
15631 #line 15632 "configure"
15632 #include "confdefs.h"
15633 #include <math.h>
15634 int main() {
15635  _asinl(0);
15636 ; return 0; }
15637 EOF
15638 if { (eval echo configure:15639: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15639   rm -rf conftest*
15640   glibcpp_cv_func__asinl_use=yes
15641 else
15642   echo "configure: failed program was:" >&5
15643   cat conftest.$ac_ext >&5
15644   rm -rf conftest*
15645   glibcpp_cv_func__asinl_use=no
15646 fi
15647 rm -f conftest*
15648       ac_ext=c
15649 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15650 ac_cpp='$CPP $CPPFLAGS'
15651 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15652 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15653 cross_compiling=$ac_cv_prog_cc_cross
15654
15655
15656 fi
15657
15658   fi
15659   echo "$ac_t""$glibcpp_cv_func__asinl_use" 1>&6
15660   if test x$glibcpp_cv_func__asinl_use = x"yes"; then
15661     for ac_func in _asinl
15662 do
15663 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15664 echo "configure:15665: checking for $ac_func" >&5
15665 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15666   echo $ac_n "(cached) $ac_c" 1>&6
15667 else
15668   cat > conftest.$ac_ext <<EOF
15669 #line 15670 "configure"
15670 #include "confdefs.h"
15671 /* System header to define __stub macros and hopefully few prototypes,
15672     which can conflict with char $ac_func(); below.  */
15673 #include <assert.h>
15674 /* Override any gcc2 internal prototype to avoid an error.  */
15675 /* We use char because int might match the return type of a gcc2
15676     builtin and then its argument prototype would still apply.  */
15677 char $ac_func();
15678
15679 int main() {
15680
15681 /* The GNU C library defines this for functions which it implements
15682     to always fail with ENOSYS.  Some functions are actually named
15683     something starting with __ and the normal name is an alias.  */
15684 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15685 choke me
15686 #else
15687 $ac_func();
15688 #endif
15689
15690 ; return 0; }
15691 EOF
15692 if { (eval echo configure:15693: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15693   rm -rf conftest*
15694   eval "ac_cv_func_$ac_func=yes"
15695 else
15696   echo "configure: failed program was:" >&5
15697   cat conftest.$ac_ext >&5
15698   rm -rf conftest*
15699   eval "ac_cv_func_$ac_func=no"
15700 fi
15701 rm -f conftest*
15702 fi
15703
15704 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15705   echo "$ac_t""yes" 1>&6
15706     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15707   cat >> confdefs.h <<EOF
15708 #define $ac_tr_func 1
15709 EOF
15710
15711 else
15712   echo "$ac_t""no" 1>&6
15713 fi
15714 done
15715
15716   fi
15717
15718
15719   echo $ac_n "checking for _atanl declaration""... $ac_c" 1>&6
15720 echo "configure:15721: checking for _atanl declaration" >&5
15721   if test x${glibcpp_cv_func__atanl_use+set} != xset; then
15722     if eval "test \"`echo '$''{'glibcpp_cv_func__atanl_use'+set}'`\" = set"; then
15723   echo $ac_n "(cached) $ac_c" 1>&6
15724 else
15725
15726
15727       ac_ext=C
15728 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15729 ac_cpp='$CXXCPP $CPPFLAGS'
15730 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15731 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15732 cross_compiling=$ac_cv_prog_cxx_cross
15733
15734       cat > conftest.$ac_ext <<EOF
15735 #line 15736 "configure"
15736 #include "confdefs.h"
15737 #include <math.h>
15738 int main() {
15739  _atanl(0);
15740 ; return 0; }
15741 EOF
15742 if { (eval echo configure:15743: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15743   rm -rf conftest*
15744   glibcpp_cv_func__atanl_use=yes
15745 else
15746   echo "configure: failed program was:" >&5
15747   cat conftest.$ac_ext >&5
15748   rm -rf conftest*
15749   glibcpp_cv_func__atanl_use=no
15750 fi
15751 rm -f conftest*
15752       ac_ext=c
15753 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15754 ac_cpp='$CPP $CPPFLAGS'
15755 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15756 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15757 cross_compiling=$ac_cv_prog_cc_cross
15758
15759
15760 fi
15761
15762   fi
15763   echo "$ac_t""$glibcpp_cv_func__atanl_use" 1>&6
15764   if test x$glibcpp_cv_func__atanl_use = x"yes"; then
15765     for ac_func in _atanl
15766 do
15767 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15768 echo "configure:15769: checking for $ac_func" >&5
15769 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15770   echo $ac_n "(cached) $ac_c" 1>&6
15771 else
15772   cat > conftest.$ac_ext <<EOF
15773 #line 15774 "configure"
15774 #include "confdefs.h"
15775 /* System header to define __stub macros and hopefully few prototypes,
15776     which can conflict with char $ac_func(); below.  */
15777 #include <assert.h>
15778 /* Override any gcc2 internal prototype to avoid an error.  */
15779 /* We use char because int might match the return type of a gcc2
15780     builtin and then its argument prototype would still apply.  */
15781 char $ac_func();
15782
15783 int main() {
15784
15785 /* The GNU C library defines this for functions which it implements
15786     to always fail with ENOSYS.  Some functions are actually named
15787     something starting with __ and the normal name is an alias.  */
15788 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15789 choke me
15790 #else
15791 $ac_func();
15792 #endif
15793
15794 ; return 0; }
15795 EOF
15796 if { (eval echo configure:15797: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15797   rm -rf conftest*
15798   eval "ac_cv_func_$ac_func=yes"
15799 else
15800   echo "configure: failed program was:" >&5
15801   cat conftest.$ac_ext >&5
15802   rm -rf conftest*
15803   eval "ac_cv_func_$ac_func=no"
15804 fi
15805 rm -f conftest*
15806 fi
15807
15808 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15809   echo "$ac_t""yes" 1>&6
15810     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15811   cat >> confdefs.h <<EOF
15812 #define $ac_tr_func 1
15813 EOF
15814
15815 else
15816   echo "$ac_t""no" 1>&6
15817 fi
15818 done
15819
15820   fi
15821
15822
15823   echo $ac_n "checking for _atan2l declaration""... $ac_c" 1>&6
15824 echo "configure:15825: checking for _atan2l declaration" >&5
15825   if test x${glibcpp_cv_func__atan2l_use+set} != xset; then
15826     if eval "test \"`echo '$''{'glibcpp_cv_func__atan2l_use'+set}'`\" = set"; then
15827   echo $ac_n "(cached) $ac_c" 1>&6
15828 else
15829
15830
15831       ac_ext=C
15832 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15833 ac_cpp='$CXXCPP $CPPFLAGS'
15834 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15835 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15836 cross_compiling=$ac_cv_prog_cxx_cross
15837
15838       cat > conftest.$ac_ext <<EOF
15839 #line 15840 "configure"
15840 #include "confdefs.h"
15841 #include <math.h>
15842 int main() {
15843  _atan2l(0, 0);
15844 ; return 0; }
15845 EOF
15846 if { (eval echo configure:15847: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15847   rm -rf conftest*
15848   glibcpp_cv_func__atan2l_use=yes
15849 else
15850   echo "configure: failed program was:" >&5
15851   cat conftest.$ac_ext >&5
15852   rm -rf conftest*
15853   glibcpp_cv_func__atan2l_use=no
15854 fi
15855 rm -f conftest*
15856       ac_ext=c
15857 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15858 ac_cpp='$CPP $CPPFLAGS'
15859 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15860 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15861 cross_compiling=$ac_cv_prog_cc_cross
15862
15863
15864 fi
15865
15866   fi
15867   echo "$ac_t""$glibcpp_cv_func__atan2l_use" 1>&6
15868   if test x$glibcpp_cv_func__atan2l_use = x"yes"; then
15869     for ac_func in _atan2l
15870 do
15871 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15872 echo "configure:15873: checking for $ac_func" >&5
15873 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15874   echo $ac_n "(cached) $ac_c" 1>&6
15875 else
15876   cat > conftest.$ac_ext <<EOF
15877 #line 15878 "configure"
15878 #include "confdefs.h"
15879 /* System header to define __stub macros and hopefully few prototypes,
15880     which can conflict with char $ac_func(); below.  */
15881 #include <assert.h>
15882 /* Override any gcc2 internal prototype to avoid an error.  */
15883 /* We use char because int might match the return type of a gcc2
15884     builtin and then its argument prototype would still apply.  */
15885 char $ac_func();
15886
15887 int main() {
15888
15889 /* The GNU C library defines this for functions which it implements
15890     to always fail with ENOSYS.  Some functions are actually named
15891     something starting with __ and the normal name is an alias.  */
15892 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15893 choke me
15894 #else
15895 $ac_func();
15896 #endif
15897
15898 ; return 0; }
15899 EOF
15900 if { (eval echo configure:15901: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
15901   rm -rf conftest*
15902   eval "ac_cv_func_$ac_func=yes"
15903 else
15904   echo "configure: failed program was:" >&5
15905   cat conftest.$ac_ext >&5
15906   rm -rf conftest*
15907   eval "ac_cv_func_$ac_func=no"
15908 fi
15909 rm -f conftest*
15910 fi
15911
15912 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
15913   echo "$ac_t""yes" 1>&6
15914     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
15915   cat >> confdefs.h <<EOF
15916 #define $ac_tr_func 1
15917 EOF
15918
15919 else
15920   echo "$ac_t""no" 1>&6
15921 fi
15922 done
15923
15924   fi
15925
15926
15927   echo $ac_n "checking for _ceill declaration""... $ac_c" 1>&6
15928 echo "configure:15929: checking for _ceill declaration" >&5
15929   if test x${glibcpp_cv_func__ceill_use+set} != xset; then
15930     if eval "test \"`echo '$''{'glibcpp_cv_func__ceill_use'+set}'`\" = set"; then
15931   echo $ac_n "(cached) $ac_c" 1>&6
15932 else
15933
15934
15935       ac_ext=C
15936 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15937 ac_cpp='$CXXCPP $CPPFLAGS'
15938 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15939 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15940 cross_compiling=$ac_cv_prog_cxx_cross
15941
15942       cat > conftest.$ac_ext <<EOF
15943 #line 15944 "configure"
15944 #include "confdefs.h"
15945 #include <math.h>
15946 int main() {
15947  _ceill(0);
15948 ; return 0; }
15949 EOF
15950 if { (eval echo configure:15951: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
15951   rm -rf conftest*
15952   glibcpp_cv_func__ceill_use=yes
15953 else
15954   echo "configure: failed program was:" >&5
15955   cat conftest.$ac_ext >&5
15956   rm -rf conftest*
15957   glibcpp_cv_func__ceill_use=no
15958 fi
15959 rm -f conftest*
15960       ac_ext=c
15961 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
15962 ac_cpp='$CPP $CPPFLAGS'
15963 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
15964 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
15965 cross_compiling=$ac_cv_prog_cc_cross
15966
15967
15968 fi
15969
15970   fi
15971   echo "$ac_t""$glibcpp_cv_func__ceill_use" 1>&6
15972   if test x$glibcpp_cv_func__ceill_use = x"yes"; then
15973     for ac_func in _ceill
15974 do
15975 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
15976 echo "configure:15977: checking for $ac_func" >&5
15977 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
15978   echo $ac_n "(cached) $ac_c" 1>&6
15979 else
15980   cat > conftest.$ac_ext <<EOF
15981 #line 15982 "configure"
15982 #include "confdefs.h"
15983 /* System header to define __stub macros and hopefully few prototypes,
15984     which can conflict with char $ac_func(); below.  */
15985 #include <assert.h>
15986 /* Override any gcc2 internal prototype to avoid an error.  */
15987 /* We use char because int might match the return type of a gcc2
15988     builtin and then its argument prototype would still apply.  */
15989 char $ac_func();
15990
15991 int main() {
15992
15993 /* The GNU C library defines this for functions which it implements
15994     to always fail with ENOSYS.  Some functions are actually named
15995     something starting with __ and the normal name is an alias.  */
15996 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
15997 choke me
15998 #else
15999 $ac_func();
16000 #endif
16001
16002 ; return 0; }
16003 EOF
16004 if { (eval echo configure:16005: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16005   rm -rf conftest*
16006   eval "ac_cv_func_$ac_func=yes"
16007 else
16008   echo "configure: failed program was:" >&5
16009   cat conftest.$ac_ext >&5
16010   rm -rf conftest*
16011   eval "ac_cv_func_$ac_func=no"
16012 fi
16013 rm -f conftest*
16014 fi
16015
16016 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16017   echo "$ac_t""yes" 1>&6
16018     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16019   cat >> confdefs.h <<EOF
16020 #define $ac_tr_func 1
16021 EOF
16022
16023 else
16024   echo "$ac_t""no" 1>&6
16025 fi
16026 done
16027
16028   fi
16029
16030
16031   echo $ac_n "checking for _cosl declaration""... $ac_c" 1>&6
16032 echo "configure:16033: checking for _cosl declaration" >&5
16033   if test x${glibcpp_cv_func__cosl_use+set} != xset; then
16034     if eval "test \"`echo '$''{'glibcpp_cv_func__cosl_use'+set}'`\" = set"; then
16035   echo $ac_n "(cached) $ac_c" 1>&6
16036 else
16037
16038
16039       ac_ext=C
16040 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16041 ac_cpp='$CXXCPP $CPPFLAGS'
16042 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16043 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16044 cross_compiling=$ac_cv_prog_cxx_cross
16045
16046       cat > conftest.$ac_ext <<EOF
16047 #line 16048 "configure"
16048 #include "confdefs.h"
16049 #include <math.h>
16050 int main() {
16051  _cosl(0);
16052 ; return 0; }
16053 EOF
16054 if { (eval echo configure:16055: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16055   rm -rf conftest*
16056   glibcpp_cv_func__cosl_use=yes
16057 else
16058   echo "configure: failed program was:" >&5
16059   cat conftest.$ac_ext >&5
16060   rm -rf conftest*
16061   glibcpp_cv_func__cosl_use=no
16062 fi
16063 rm -f conftest*
16064       ac_ext=c
16065 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16066 ac_cpp='$CPP $CPPFLAGS'
16067 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16068 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16069 cross_compiling=$ac_cv_prog_cc_cross
16070
16071
16072 fi
16073
16074   fi
16075   echo "$ac_t""$glibcpp_cv_func__cosl_use" 1>&6
16076   if test x$glibcpp_cv_func__cosl_use = x"yes"; then
16077     for ac_func in _cosl
16078 do
16079 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16080 echo "configure:16081: checking for $ac_func" >&5
16081 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16082   echo $ac_n "(cached) $ac_c" 1>&6
16083 else
16084   cat > conftest.$ac_ext <<EOF
16085 #line 16086 "configure"
16086 #include "confdefs.h"
16087 /* System header to define __stub macros and hopefully few prototypes,
16088     which can conflict with char $ac_func(); below.  */
16089 #include <assert.h>
16090 /* Override any gcc2 internal prototype to avoid an error.  */
16091 /* We use char because int might match the return type of a gcc2
16092     builtin and then its argument prototype would still apply.  */
16093 char $ac_func();
16094
16095 int main() {
16096
16097 /* The GNU C library defines this for functions which it implements
16098     to always fail with ENOSYS.  Some functions are actually named
16099     something starting with __ and the normal name is an alias.  */
16100 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16101 choke me
16102 #else
16103 $ac_func();
16104 #endif
16105
16106 ; return 0; }
16107 EOF
16108 if { (eval echo configure:16109: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16109   rm -rf conftest*
16110   eval "ac_cv_func_$ac_func=yes"
16111 else
16112   echo "configure: failed program was:" >&5
16113   cat conftest.$ac_ext >&5
16114   rm -rf conftest*
16115   eval "ac_cv_func_$ac_func=no"
16116 fi
16117 rm -f conftest*
16118 fi
16119
16120 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16121   echo "$ac_t""yes" 1>&6
16122     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16123   cat >> confdefs.h <<EOF
16124 #define $ac_tr_func 1
16125 EOF
16126
16127 else
16128   echo "$ac_t""no" 1>&6
16129 fi
16130 done
16131
16132   fi
16133
16134
16135   echo $ac_n "checking for _coshl declaration""... $ac_c" 1>&6
16136 echo "configure:16137: checking for _coshl declaration" >&5
16137   if test x${glibcpp_cv_func__coshl_use+set} != xset; then
16138     if eval "test \"`echo '$''{'glibcpp_cv_func__coshl_use'+set}'`\" = set"; then
16139   echo $ac_n "(cached) $ac_c" 1>&6
16140 else
16141
16142
16143       ac_ext=C
16144 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16145 ac_cpp='$CXXCPP $CPPFLAGS'
16146 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16147 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16148 cross_compiling=$ac_cv_prog_cxx_cross
16149
16150       cat > conftest.$ac_ext <<EOF
16151 #line 16152 "configure"
16152 #include "confdefs.h"
16153 #include <math.h>
16154 int main() {
16155  _coshl(0);
16156 ; return 0; }
16157 EOF
16158 if { (eval echo configure:16159: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16159   rm -rf conftest*
16160   glibcpp_cv_func__coshl_use=yes
16161 else
16162   echo "configure: failed program was:" >&5
16163   cat conftest.$ac_ext >&5
16164   rm -rf conftest*
16165   glibcpp_cv_func__coshl_use=no
16166 fi
16167 rm -f conftest*
16168       ac_ext=c
16169 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16170 ac_cpp='$CPP $CPPFLAGS'
16171 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16172 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16173 cross_compiling=$ac_cv_prog_cc_cross
16174
16175
16176 fi
16177
16178   fi
16179   echo "$ac_t""$glibcpp_cv_func__coshl_use" 1>&6
16180   if test x$glibcpp_cv_func__coshl_use = x"yes"; then
16181     for ac_func in _coshl
16182 do
16183 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16184 echo "configure:16185: checking for $ac_func" >&5
16185 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16186   echo $ac_n "(cached) $ac_c" 1>&6
16187 else
16188   cat > conftest.$ac_ext <<EOF
16189 #line 16190 "configure"
16190 #include "confdefs.h"
16191 /* System header to define __stub macros and hopefully few prototypes,
16192     which can conflict with char $ac_func(); below.  */
16193 #include <assert.h>
16194 /* Override any gcc2 internal prototype to avoid an error.  */
16195 /* We use char because int might match the return type of a gcc2
16196     builtin and then its argument prototype would still apply.  */
16197 char $ac_func();
16198
16199 int main() {
16200
16201 /* The GNU C library defines this for functions which it implements
16202     to always fail with ENOSYS.  Some functions are actually named
16203     something starting with __ and the normal name is an alias.  */
16204 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16205 choke me
16206 #else
16207 $ac_func();
16208 #endif
16209
16210 ; return 0; }
16211 EOF
16212 if { (eval echo configure:16213: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16213   rm -rf conftest*
16214   eval "ac_cv_func_$ac_func=yes"
16215 else
16216   echo "configure: failed program was:" >&5
16217   cat conftest.$ac_ext >&5
16218   rm -rf conftest*
16219   eval "ac_cv_func_$ac_func=no"
16220 fi
16221 rm -f conftest*
16222 fi
16223
16224 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16225   echo "$ac_t""yes" 1>&6
16226     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16227   cat >> confdefs.h <<EOF
16228 #define $ac_tr_func 1
16229 EOF
16230
16231 else
16232   echo "$ac_t""no" 1>&6
16233 fi
16234 done
16235
16236   fi
16237
16238
16239   echo $ac_n "checking for _expl declaration""... $ac_c" 1>&6
16240 echo "configure:16241: checking for _expl declaration" >&5
16241   if test x${glibcpp_cv_func__expl_use+set} != xset; then
16242     if eval "test \"`echo '$''{'glibcpp_cv_func__expl_use'+set}'`\" = set"; then
16243   echo $ac_n "(cached) $ac_c" 1>&6
16244 else
16245
16246
16247       ac_ext=C
16248 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16249 ac_cpp='$CXXCPP $CPPFLAGS'
16250 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16251 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16252 cross_compiling=$ac_cv_prog_cxx_cross
16253
16254       cat > conftest.$ac_ext <<EOF
16255 #line 16256 "configure"
16256 #include "confdefs.h"
16257 #include <math.h>
16258 int main() {
16259  _expl(0);
16260 ; return 0; }
16261 EOF
16262 if { (eval echo configure:16263: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16263   rm -rf conftest*
16264   glibcpp_cv_func__expl_use=yes
16265 else
16266   echo "configure: failed program was:" >&5
16267   cat conftest.$ac_ext >&5
16268   rm -rf conftest*
16269   glibcpp_cv_func__expl_use=no
16270 fi
16271 rm -f conftest*
16272       ac_ext=c
16273 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16274 ac_cpp='$CPP $CPPFLAGS'
16275 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16276 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16277 cross_compiling=$ac_cv_prog_cc_cross
16278
16279
16280 fi
16281
16282   fi
16283   echo "$ac_t""$glibcpp_cv_func__expl_use" 1>&6
16284   if test x$glibcpp_cv_func__expl_use = x"yes"; then
16285     for ac_func in _expl
16286 do
16287 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16288 echo "configure:16289: checking for $ac_func" >&5
16289 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16290   echo $ac_n "(cached) $ac_c" 1>&6
16291 else
16292   cat > conftest.$ac_ext <<EOF
16293 #line 16294 "configure"
16294 #include "confdefs.h"
16295 /* System header to define __stub macros and hopefully few prototypes,
16296     which can conflict with char $ac_func(); below.  */
16297 #include <assert.h>
16298 /* Override any gcc2 internal prototype to avoid an error.  */
16299 /* We use char because int might match the return type of a gcc2
16300     builtin and then its argument prototype would still apply.  */
16301 char $ac_func();
16302
16303 int main() {
16304
16305 /* The GNU C library defines this for functions which it implements
16306     to always fail with ENOSYS.  Some functions are actually named
16307     something starting with __ and the normal name is an alias.  */
16308 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16309 choke me
16310 #else
16311 $ac_func();
16312 #endif
16313
16314 ; return 0; }
16315 EOF
16316 if { (eval echo configure:16317: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16317   rm -rf conftest*
16318   eval "ac_cv_func_$ac_func=yes"
16319 else
16320   echo "configure: failed program was:" >&5
16321   cat conftest.$ac_ext >&5
16322   rm -rf conftest*
16323   eval "ac_cv_func_$ac_func=no"
16324 fi
16325 rm -f conftest*
16326 fi
16327
16328 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16329   echo "$ac_t""yes" 1>&6
16330     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16331   cat >> confdefs.h <<EOF
16332 #define $ac_tr_func 1
16333 EOF
16334
16335 else
16336   echo "$ac_t""no" 1>&6
16337 fi
16338 done
16339
16340   fi
16341
16342
16343   echo $ac_n "checking for _fabsl declaration""... $ac_c" 1>&6
16344 echo "configure:16345: checking for _fabsl declaration" >&5
16345   if test x${glibcpp_cv_func__fabsl_use+set} != xset; then
16346     if eval "test \"`echo '$''{'glibcpp_cv_func__fabsl_use'+set}'`\" = set"; then
16347   echo $ac_n "(cached) $ac_c" 1>&6
16348 else
16349
16350
16351       ac_ext=C
16352 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16353 ac_cpp='$CXXCPP $CPPFLAGS'
16354 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16355 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16356 cross_compiling=$ac_cv_prog_cxx_cross
16357
16358       cat > conftest.$ac_ext <<EOF
16359 #line 16360 "configure"
16360 #include "confdefs.h"
16361 #include <math.h>
16362 int main() {
16363  _fabsl(0);
16364 ; return 0; }
16365 EOF
16366 if { (eval echo configure:16367: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16367   rm -rf conftest*
16368   glibcpp_cv_func__fabsl_use=yes
16369 else
16370   echo "configure: failed program was:" >&5
16371   cat conftest.$ac_ext >&5
16372   rm -rf conftest*
16373   glibcpp_cv_func__fabsl_use=no
16374 fi
16375 rm -f conftest*
16376       ac_ext=c
16377 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16378 ac_cpp='$CPP $CPPFLAGS'
16379 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16380 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16381 cross_compiling=$ac_cv_prog_cc_cross
16382
16383
16384 fi
16385
16386   fi
16387   echo "$ac_t""$glibcpp_cv_func__fabsl_use" 1>&6
16388   if test x$glibcpp_cv_func__fabsl_use = x"yes"; then
16389     for ac_func in _fabsl
16390 do
16391 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16392 echo "configure:16393: checking for $ac_func" >&5
16393 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16394   echo $ac_n "(cached) $ac_c" 1>&6
16395 else
16396   cat > conftest.$ac_ext <<EOF
16397 #line 16398 "configure"
16398 #include "confdefs.h"
16399 /* System header to define __stub macros and hopefully few prototypes,
16400     which can conflict with char $ac_func(); below.  */
16401 #include <assert.h>
16402 /* Override any gcc2 internal prototype to avoid an error.  */
16403 /* We use char because int might match the return type of a gcc2
16404     builtin and then its argument prototype would still apply.  */
16405 char $ac_func();
16406
16407 int main() {
16408
16409 /* The GNU C library defines this for functions which it implements
16410     to always fail with ENOSYS.  Some functions are actually named
16411     something starting with __ and the normal name is an alias.  */
16412 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16413 choke me
16414 #else
16415 $ac_func();
16416 #endif
16417
16418 ; return 0; }
16419 EOF
16420 if { (eval echo configure:16421: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16421   rm -rf conftest*
16422   eval "ac_cv_func_$ac_func=yes"
16423 else
16424   echo "configure: failed program was:" >&5
16425   cat conftest.$ac_ext >&5
16426   rm -rf conftest*
16427   eval "ac_cv_func_$ac_func=no"
16428 fi
16429 rm -f conftest*
16430 fi
16431
16432 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16433   echo "$ac_t""yes" 1>&6
16434     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16435   cat >> confdefs.h <<EOF
16436 #define $ac_tr_func 1
16437 EOF
16438
16439 else
16440   echo "$ac_t""no" 1>&6
16441 fi
16442 done
16443
16444   fi
16445
16446
16447   echo $ac_n "checking for _floorl declaration""... $ac_c" 1>&6
16448 echo "configure:16449: checking for _floorl declaration" >&5
16449   if test x${glibcpp_cv_func__floorl_use+set} != xset; then
16450     if eval "test \"`echo '$''{'glibcpp_cv_func__floorl_use'+set}'`\" = set"; then
16451   echo $ac_n "(cached) $ac_c" 1>&6
16452 else
16453
16454
16455       ac_ext=C
16456 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16457 ac_cpp='$CXXCPP $CPPFLAGS'
16458 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16459 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16460 cross_compiling=$ac_cv_prog_cxx_cross
16461
16462       cat > conftest.$ac_ext <<EOF
16463 #line 16464 "configure"
16464 #include "confdefs.h"
16465 #include <math.h>
16466 int main() {
16467  _floorl(0);
16468 ; return 0; }
16469 EOF
16470 if { (eval echo configure:16471: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16471   rm -rf conftest*
16472   glibcpp_cv_func__floorl_use=yes
16473 else
16474   echo "configure: failed program was:" >&5
16475   cat conftest.$ac_ext >&5
16476   rm -rf conftest*
16477   glibcpp_cv_func__floorl_use=no
16478 fi
16479 rm -f conftest*
16480       ac_ext=c
16481 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16482 ac_cpp='$CPP $CPPFLAGS'
16483 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16484 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16485 cross_compiling=$ac_cv_prog_cc_cross
16486
16487
16488 fi
16489
16490   fi
16491   echo "$ac_t""$glibcpp_cv_func__floorl_use" 1>&6
16492   if test x$glibcpp_cv_func__floorl_use = x"yes"; then
16493     for ac_func in _floorl
16494 do
16495 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16496 echo "configure:16497: checking for $ac_func" >&5
16497 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16498   echo $ac_n "(cached) $ac_c" 1>&6
16499 else
16500   cat > conftest.$ac_ext <<EOF
16501 #line 16502 "configure"
16502 #include "confdefs.h"
16503 /* System header to define __stub macros and hopefully few prototypes,
16504     which can conflict with char $ac_func(); below.  */
16505 #include <assert.h>
16506 /* Override any gcc2 internal prototype to avoid an error.  */
16507 /* We use char because int might match the return type of a gcc2
16508     builtin and then its argument prototype would still apply.  */
16509 char $ac_func();
16510
16511 int main() {
16512
16513 /* The GNU C library defines this for functions which it implements
16514     to always fail with ENOSYS.  Some functions are actually named
16515     something starting with __ and the normal name is an alias.  */
16516 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16517 choke me
16518 #else
16519 $ac_func();
16520 #endif
16521
16522 ; return 0; }
16523 EOF
16524 if { (eval echo configure:16525: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16525   rm -rf conftest*
16526   eval "ac_cv_func_$ac_func=yes"
16527 else
16528   echo "configure: failed program was:" >&5
16529   cat conftest.$ac_ext >&5
16530   rm -rf conftest*
16531   eval "ac_cv_func_$ac_func=no"
16532 fi
16533 rm -f conftest*
16534 fi
16535
16536 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16537   echo "$ac_t""yes" 1>&6
16538     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16539   cat >> confdefs.h <<EOF
16540 #define $ac_tr_func 1
16541 EOF
16542
16543 else
16544   echo "$ac_t""no" 1>&6
16545 fi
16546 done
16547
16548   fi
16549
16550
16551   echo $ac_n "checking for _fmodl declaration""... $ac_c" 1>&6
16552 echo "configure:16553: checking for _fmodl declaration" >&5
16553   if test x${glibcpp_cv_func__fmodl_use+set} != xset; then
16554     if eval "test \"`echo '$''{'glibcpp_cv_func__fmodl_use'+set}'`\" = set"; then
16555   echo $ac_n "(cached) $ac_c" 1>&6
16556 else
16557
16558
16559       ac_ext=C
16560 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16561 ac_cpp='$CXXCPP $CPPFLAGS'
16562 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16563 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16564 cross_compiling=$ac_cv_prog_cxx_cross
16565
16566       cat > conftest.$ac_ext <<EOF
16567 #line 16568 "configure"
16568 #include "confdefs.h"
16569 #include <math.h>
16570 int main() {
16571  _fmodl(0, 0);
16572 ; return 0; }
16573 EOF
16574 if { (eval echo configure:16575: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16575   rm -rf conftest*
16576   glibcpp_cv_func__fmodl_use=yes
16577 else
16578   echo "configure: failed program was:" >&5
16579   cat conftest.$ac_ext >&5
16580   rm -rf conftest*
16581   glibcpp_cv_func__fmodl_use=no
16582 fi
16583 rm -f conftest*
16584       ac_ext=c
16585 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16586 ac_cpp='$CPP $CPPFLAGS'
16587 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16588 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16589 cross_compiling=$ac_cv_prog_cc_cross
16590
16591
16592 fi
16593
16594   fi
16595   echo "$ac_t""$glibcpp_cv_func__fmodl_use" 1>&6
16596   if test x$glibcpp_cv_func__fmodl_use = x"yes"; then
16597     for ac_func in _fmodl
16598 do
16599 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16600 echo "configure:16601: checking for $ac_func" >&5
16601 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16602   echo $ac_n "(cached) $ac_c" 1>&6
16603 else
16604   cat > conftest.$ac_ext <<EOF
16605 #line 16606 "configure"
16606 #include "confdefs.h"
16607 /* System header to define __stub macros and hopefully few prototypes,
16608     which can conflict with char $ac_func(); below.  */
16609 #include <assert.h>
16610 /* Override any gcc2 internal prototype to avoid an error.  */
16611 /* We use char because int might match the return type of a gcc2
16612     builtin and then its argument prototype would still apply.  */
16613 char $ac_func();
16614
16615 int main() {
16616
16617 /* The GNU C library defines this for functions which it implements
16618     to always fail with ENOSYS.  Some functions are actually named
16619     something starting with __ and the normal name is an alias.  */
16620 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16621 choke me
16622 #else
16623 $ac_func();
16624 #endif
16625
16626 ; return 0; }
16627 EOF
16628 if { (eval echo configure:16629: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16629   rm -rf conftest*
16630   eval "ac_cv_func_$ac_func=yes"
16631 else
16632   echo "configure: failed program was:" >&5
16633   cat conftest.$ac_ext >&5
16634   rm -rf conftest*
16635   eval "ac_cv_func_$ac_func=no"
16636 fi
16637 rm -f conftest*
16638 fi
16639
16640 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16641   echo "$ac_t""yes" 1>&6
16642     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16643   cat >> confdefs.h <<EOF
16644 #define $ac_tr_func 1
16645 EOF
16646
16647 else
16648   echo "$ac_t""no" 1>&6
16649 fi
16650 done
16651
16652   fi
16653
16654
16655   echo $ac_n "checking for _frexpl declaration""... $ac_c" 1>&6
16656 echo "configure:16657: checking for _frexpl declaration" >&5
16657   if test x${glibcpp_cv_func__frexpl_use+set} != xset; then
16658     if eval "test \"`echo '$''{'glibcpp_cv_func__frexpl_use'+set}'`\" = set"; then
16659   echo $ac_n "(cached) $ac_c" 1>&6
16660 else
16661
16662
16663       ac_ext=C
16664 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16665 ac_cpp='$CXXCPP $CPPFLAGS'
16666 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16667 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16668 cross_compiling=$ac_cv_prog_cxx_cross
16669
16670       cat > conftest.$ac_ext <<EOF
16671 #line 16672 "configure"
16672 #include "confdefs.h"
16673 #include <math.h>
16674 int main() {
16675  _frexpl(0, 0);
16676 ; return 0; }
16677 EOF
16678 if { (eval echo configure:16679: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16679   rm -rf conftest*
16680   glibcpp_cv_func__frexpl_use=yes
16681 else
16682   echo "configure: failed program was:" >&5
16683   cat conftest.$ac_ext >&5
16684   rm -rf conftest*
16685   glibcpp_cv_func__frexpl_use=no
16686 fi
16687 rm -f conftest*
16688       ac_ext=c
16689 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16690 ac_cpp='$CPP $CPPFLAGS'
16691 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16692 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16693 cross_compiling=$ac_cv_prog_cc_cross
16694
16695
16696 fi
16697
16698   fi
16699   echo "$ac_t""$glibcpp_cv_func__frexpl_use" 1>&6
16700   if test x$glibcpp_cv_func__frexpl_use = x"yes"; then
16701     for ac_func in _frexpl
16702 do
16703 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16704 echo "configure:16705: checking for $ac_func" >&5
16705 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16706   echo $ac_n "(cached) $ac_c" 1>&6
16707 else
16708   cat > conftest.$ac_ext <<EOF
16709 #line 16710 "configure"
16710 #include "confdefs.h"
16711 /* System header to define __stub macros and hopefully few prototypes,
16712     which can conflict with char $ac_func(); below.  */
16713 #include <assert.h>
16714 /* Override any gcc2 internal prototype to avoid an error.  */
16715 /* We use char because int might match the return type of a gcc2
16716     builtin and then its argument prototype would still apply.  */
16717 char $ac_func();
16718
16719 int main() {
16720
16721 /* The GNU C library defines this for functions which it implements
16722     to always fail with ENOSYS.  Some functions are actually named
16723     something starting with __ and the normal name is an alias.  */
16724 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16725 choke me
16726 #else
16727 $ac_func();
16728 #endif
16729
16730 ; return 0; }
16731 EOF
16732 if { (eval echo configure:16733: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16733   rm -rf conftest*
16734   eval "ac_cv_func_$ac_func=yes"
16735 else
16736   echo "configure: failed program was:" >&5
16737   cat conftest.$ac_ext >&5
16738   rm -rf conftest*
16739   eval "ac_cv_func_$ac_func=no"
16740 fi
16741 rm -f conftest*
16742 fi
16743
16744 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16745   echo "$ac_t""yes" 1>&6
16746     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16747   cat >> confdefs.h <<EOF
16748 #define $ac_tr_func 1
16749 EOF
16750
16751 else
16752   echo "$ac_t""no" 1>&6
16753 fi
16754 done
16755
16756   fi
16757
16758
16759   echo $ac_n "checking for _ldexpl declaration""... $ac_c" 1>&6
16760 echo "configure:16761: checking for _ldexpl declaration" >&5
16761   if test x${glibcpp_cv_func__ldexpl_use+set} != xset; then
16762     if eval "test \"`echo '$''{'glibcpp_cv_func__ldexpl_use'+set}'`\" = set"; then
16763   echo $ac_n "(cached) $ac_c" 1>&6
16764 else
16765
16766
16767       ac_ext=C
16768 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16769 ac_cpp='$CXXCPP $CPPFLAGS'
16770 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16771 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16772 cross_compiling=$ac_cv_prog_cxx_cross
16773
16774       cat > conftest.$ac_ext <<EOF
16775 #line 16776 "configure"
16776 #include "confdefs.h"
16777 #include <math.h>
16778 int main() {
16779  _ldexpl(0, 0);
16780 ; return 0; }
16781 EOF
16782 if { (eval echo configure:16783: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16783   rm -rf conftest*
16784   glibcpp_cv_func__ldexpl_use=yes
16785 else
16786   echo "configure: failed program was:" >&5
16787   cat conftest.$ac_ext >&5
16788   rm -rf conftest*
16789   glibcpp_cv_func__ldexpl_use=no
16790 fi
16791 rm -f conftest*
16792       ac_ext=c
16793 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16794 ac_cpp='$CPP $CPPFLAGS'
16795 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16796 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16797 cross_compiling=$ac_cv_prog_cc_cross
16798
16799
16800 fi
16801
16802   fi
16803   echo "$ac_t""$glibcpp_cv_func__ldexpl_use" 1>&6
16804   if test x$glibcpp_cv_func__ldexpl_use = x"yes"; then
16805     for ac_func in _ldexpl
16806 do
16807 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16808 echo "configure:16809: checking for $ac_func" >&5
16809 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16810   echo $ac_n "(cached) $ac_c" 1>&6
16811 else
16812   cat > conftest.$ac_ext <<EOF
16813 #line 16814 "configure"
16814 #include "confdefs.h"
16815 /* System header to define __stub macros and hopefully few prototypes,
16816     which can conflict with char $ac_func(); below.  */
16817 #include <assert.h>
16818 /* Override any gcc2 internal prototype to avoid an error.  */
16819 /* We use char because int might match the return type of a gcc2
16820     builtin and then its argument prototype would still apply.  */
16821 char $ac_func();
16822
16823 int main() {
16824
16825 /* The GNU C library defines this for functions which it implements
16826     to always fail with ENOSYS.  Some functions are actually named
16827     something starting with __ and the normal name is an alias.  */
16828 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16829 choke me
16830 #else
16831 $ac_func();
16832 #endif
16833
16834 ; return 0; }
16835 EOF
16836 if { (eval echo configure:16837: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16837   rm -rf conftest*
16838   eval "ac_cv_func_$ac_func=yes"
16839 else
16840   echo "configure: failed program was:" >&5
16841   cat conftest.$ac_ext >&5
16842   rm -rf conftest*
16843   eval "ac_cv_func_$ac_func=no"
16844 fi
16845 rm -f conftest*
16846 fi
16847
16848 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16849   echo "$ac_t""yes" 1>&6
16850     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16851   cat >> confdefs.h <<EOF
16852 #define $ac_tr_func 1
16853 EOF
16854
16855 else
16856   echo "$ac_t""no" 1>&6
16857 fi
16858 done
16859
16860   fi
16861
16862
16863   echo $ac_n "checking for _logl declaration""... $ac_c" 1>&6
16864 echo "configure:16865: checking for _logl declaration" >&5
16865   if test x${glibcpp_cv_func__logl_use+set} != xset; then
16866     if eval "test \"`echo '$''{'glibcpp_cv_func__logl_use'+set}'`\" = set"; then
16867   echo $ac_n "(cached) $ac_c" 1>&6
16868 else
16869
16870
16871       ac_ext=C
16872 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16873 ac_cpp='$CXXCPP $CPPFLAGS'
16874 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16875 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16876 cross_compiling=$ac_cv_prog_cxx_cross
16877
16878       cat > conftest.$ac_ext <<EOF
16879 #line 16880 "configure"
16880 #include "confdefs.h"
16881 #include <math.h>
16882 int main() {
16883  _logl(0);
16884 ; return 0; }
16885 EOF
16886 if { (eval echo configure:16887: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16887   rm -rf conftest*
16888   glibcpp_cv_func__logl_use=yes
16889 else
16890   echo "configure: failed program was:" >&5
16891   cat conftest.$ac_ext >&5
16892   rm -rf conftest*
16893   glibcpp_cv_func__logl_use=no
16894 fi
16895 rm -f conftest*
16896       ac_ext=c
16897 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16898 ac_cpp='$CPP $CPPFLAGS'
16899 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16900 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16901 cross_compiling=$ac_cv_prog_cc_cross
16902
16903
16904 fi
16905
16906   fi
16907   echo "$ac_t""$glibcpp_cv_func__logl_use" 1>&6
16908   if test x$glibcpp_cv_func__logl_use = x"yes"; then
16909     for ac_func in _logl
16910 do
16911 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
16912 echo "configure:16913: checking for $ac_func" >&5
16913 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
16914   echo $ac_n "(cached) $ac_c" 1>&6
16915 else
16916   cat > conftest.$ac_ext <<EOF
16917 #line 16918 "configure"
16918 #include "confdefs.h"
16919 /* System header to define __stub macros and hopefully few prototypes,
16920     which can conflict with char $ac_func(); below.  */
16921 #include <assert.h>
16922 /* Override any gcc2 internal prototype to avoid an error.  */
16923 /* We use char because int might match the return type of a gcc2
16924     builtin and then its argument prototype would still apply.  */
16925 char $ac_func();
16926
16927 int main() {
16928
16929 /* The GNU C library defines this for functions which it implements
16930     to always fail with ENOSYS.  Some functions are actually named
16931     something starting with __ and the normal name is an alias.  */
16932 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
16933 choke me
16934 #else
16935 $ac_func();
16936 #endif
16937
16938 ; return 0; }
16939 EOF
16940 if { (eval echo configure:16941: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
16941   rm -rf conftest*
16942   eval "ac_cv_func_$ac_func=yes"
16943 else
16944   echo "configure: failed program was:" >&5
16945   cat conftest.$ac_ext >&5
16946   rm -rf conftest*
16947   eval "ac_cv_func_$ac_func=no"
16948 fi
16949 rm -f conftest*
16950 fi
16951
16952 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
16953   echo "$ac_t""yes" 1>&6
16954     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
16955   cat >> confdefs.h <<EOF
16956 #define $ac_tr_func 1
16957 EOF
16958
16959 else
16960   echo "$ac_t""no" 1>&6
16961 fi
16962 done
16963
16964   fi
16965
16966
16967   echo $ac_n "checking for _log10l declaration""... $ac_c" 1>&6
16968 echo "configure:16969: checking for _log10l declaration" >&5
16969   if test x${glibcpp_cv_func__log10l_use+set} != xset; then
16970     if eval "test \"`echo '$''{'glibcpp_cv_func__log10l_use'+set}'`\" = set"; then
16971   echo $ac_n "(cached) $ac_c" 1>&6
16972 else
16973
16974
16975       ac_ext=C
16976 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
16977 ac_cpp='$CXXCPP $CPPFLAGS'
16978 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
16979 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
16980 cross_compiling=$ac_cv_prog_cxx_cross
16981
16982       cat > conftest.$ac_ext <<EOF
16983 #line 16984 "configure"
16984 #include "confdefs.h"
16985 #include <math.h>
16986 int main() {
16987  _log10l(0);
16988 ; return 0; }
16989 EOF
16990 if { (eval echo configure:16991: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
16991   rm -rf conftest*
16992   glibcpp_cv_func__log10l_use=yes
16993 else
16994   echo "configure: failed program was:" >&5
16995   cat conftest.$ac_ext >&5
16996   rm -rf conftest*
16997   glibcpp_cv_func__log10l_use=no
16998 fi
16999 rm -f conftest*
17000       ac_ext=c
17001 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17002 ac_cpp='$CPP $CPPFLAGS'
17003 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17004 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17005 cross_compiling=$ac_cv_prog_cc_cross
17006
17007
17008 fi
17009
17010   fi
17011   echo "$ac_t""$glibcpp_cv_func__log10l_use" 1>&6
17012   if test x$glibcpp_cv_func__log10l_use = x"yes"; then
17013     for ac_func in _log10l
17014 do
17015 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17016 echo "configure:17017: checking for $ac_func" >&5
17017 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17018   echo $ac_n "(cached) $ac_c" 1>&6
17019 else
17020   cat > conftest.$ac_ext <<EOF
17021 #line 17022 "configure"
17022 #include "confdefs.h"
17023 /* System header to define __stub macros and hopefully few prototypes,
17024     which can conflict with char $ac_func(); below.  */
17025 #include <assert.h>
17026 /* Override any gcc2 internal prototype to avoid an error.  */
17027 /* We use char because int might match the return type of a gcc2
17028     builtin and then its argument prototype would still apply.  */
17029 char $ac_func();
17030
17031 int main() {
17032
17033 /* The GNU C library defines this for functions which it implements
17034     to always fail with ENOSYS.  Some functions are actually named
17035     something starting with __ and the normal name is an alias.  */
17036 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17037 choke me
17038 #else
17039 $ac_func();
17040 #endif
17041
17042 ; return 0; }
17043 EOF
17044 if { (eval echo configure:17045: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17045   rm -rf conftest*
17046   eval "ac_cv_func_$ac_func=yes"
17047 else
17048   echo "configure: failed program was:" >&5
17049   cat conftest.$ac_ext >&5
17050   rm -rf conftest*
17051   eval "ac_cv_func_$ac_func=no"
17052 fi
17053 rm -f conftest*
17054 fi
17055
17056 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17057   echo "$ac_t""yes" 1>&6
17058     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17059   cat >> confdefs.h <<EOF
17060 #define $ac_tr_func 1
17061 EOF
17062
17063 else
17064   echo "$ac_t""no" 1>&6
17065 fi
17066 done
17067
17068   fi
17069
17070
17071   echo $ac_n "checking for _modfl declaration""... $ac_c" 1>&6
17072 echo "configure:17073: checking for _modfl declaration" >&5
17073   if test x${glibcpp_cv_func__modfl_use+set} != xset; then
17074     if eval "test \"`echo '$''{'glibcpp_cv_func__modfl_use'+set}'`\" = set"; then
17075   echo $ac_n "(cached) $ac_c" 1>&6
17076 else
17077
17078
17079       ac_ext=C
17080 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17081 ac_cpp='$CXXCPP $CPPFLAGS'
17082 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17083 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17084 cross_compiling=$ac_cv_prog_cxx_cross
17085
17086       cat > conftest.$ac_ext <<EOF
17087 #line 17088 "configure"
17088 #include "confdefs.h"
17089 #include <math.h>
17090 int main() {
17091  _modfl(0, 0);
17092 ; return 0; }
17093 EOF
17094 if { (eval echo configure:17095: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17095   rm -rf conftest*
17096   glibcpp_cv_func__modfl_use=yes
17097 else
17098   echo "configure: failed program was:" >&5
17099   cat conftest.$ac_ext >&5
17100   rm -rf conftest*
17101   glibcpp_cv_func__modfl_use=no
17102 fi
17103 rm -f conftest*
17104       ac_ext=c
17105 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17106 ac_cpp='$CPP $CPPFLAGS'
17107 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17108 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17109 cross_compiling=$ac_cv_prog_cc_cross
17110
17111
17112 fi
17113
17114   fi
17115   echo "$ac_t""$glibcpp_cv_func__modfl_use" 1>&6
17116   if test x$glibcpp_cv_func__modfl_use = x"yes"; then
17117     for ac_func in _modfl
17118 do
17119 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17120 echo "configure:17121: checking for $ac_func" >&5
17121 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17122   echo $ac_n "(cached) $ac_c" 1>&6
17123 else
17124   cat > conftest.$ac_ext <<EOF
17125 #line 17126 "configure"
17126 #include "confdefs.h"
17127 /* System header to define __stub macros and hopefully few prototypes,
17128     which can conflict with char $ac_func(); below.  */
17129 #include <assert.h>
17130 /* Override any gcc2 internal prototype to avoid an error.  */
17131 /* We use char because int might match the return type of a gcc2
17132     builtin and then its argument prototype would still apply.  */
17133 char $ac_func();
17134
17135 int main() {
17136
17137 /* The GNU C library defines this for functions which it implements
17138     to always fail with ENOSYS.  Some functions are actually named
17139     something starting with __ and the normal name is an alias.  */
17140 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17141 choke me
17142 #else
17143 $ac_func();
17144 #endif
17145
17146 ; return 0; }
17147 EOF
17148 if { (eval echo configure:17149: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17149   rm -rf conftest*
17150   eval "ac_cv_func_$ac_func=yes"
17151 else
17152   echo "configure: failed program was:" >&5
17153   cat conftest.$ac_ext >&5
17154   rm -rf conftest*
17155   eval "ac_cv_func_$ac_func=no"
17156 fi
17157 rm -f conftest*
17158 fi
17159
17160 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17161   echo "$ac_t""yes" 1>&6
17162     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17163   cat >> confdefs.h <<EOF
17164 #define $ac_tr_func 1
17165 EOF
17166
17167 else
17168   echo "$ac_t""no" 1>&6
17169 fi
17170 done
17171
17172   fi
17173
17174
17175   echo $ac_n "checking for _powl declaration""... $ac_c" 1>&6
17176 echo "configure:17177: checking for _powl declaration" >&5
17177   if test x${glibcpp_cv_func__powl_use+set} != xset; then
17178     if eval "test \"`echo '$''{'glibcpp_cv_func__powl_use'+set}'`\" = set"; then
17179   echo $ac_n "(cached) $ac_c" 1>&6
17180 else
17181
17182
17183       ac_ext=C
17184 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17185 ac_cpp='$CXXCPP $CPPFLAGS'
17186 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17187 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17188 cross_compiling=$ac_cv_prog_cxx_cross
17189
17190       cat > conftest.$ac_ext <<EOF
17191 #line 17192 "configure"
17192 #include "confdefs.h"
17193 #include <math.h>
17194 int main() {
17195  _powl(0, 0);
17196 ; return 0; }
17197 EOF
17198 if { (eval echo configure:17199: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17199   rm -rf conftest*
17200   glibcpp_cv_func__powl_use=yes
17201 else
17202   echo "configure: failed program was:" >&5
17203   cat conftest.$ac_ext >&5
17204   rm -rf conftest*
17205   glibcpp_cv_func__powl_use=no
17206 fi
17207 rm -f conftest*
17208       ac_ext=c
17209 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17210 ac_cpp='$CPP $CPPFLAGS'
17211 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17212 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17213 cross_compiling=$ac_cv_prog_cc_cross
17214
17215
17216 fi
17217
17218   fi
17219   echo "$ac_t""$glibcpp_cv_func__powl_use" 1>&6
17220   if test x$glibcpp_cv_func__powl_use = x"yes"; then
17221     for ac_func in _powl
17222 do
17223 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17224 echo "configure:17225: checking for $ac_func" >&5
17225 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17226   echo $ac_n "(cached) $ac_c" 1>&6
17227 else
17228   cat > conftest.$ac_ext <<EOF
17229 #line 17230 "configure"
17230 #include "confdefs.h"
17231 /* System header to define __stub macros and hopefully few prototypes,
17232     which can conflict with char $ac_func(); below.  */
17233 #include <assert.h>
17234 /* Override any gcc2 internal prototype to avoid an error.  */
17235 /* We use char because int might match the return type of a gcc2
17236     builtin and then its argument prototype would still apply.  */
17237 char $ac_func();
17238
17239 int main() {
17240
17241 /* The GNU C library defines this for functions which it implements
17242     to always fail with ENOSYS.  Some functions are actually named
17243     something starting with __ and the normal name is an alias.  */
17244 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17245 choke me
17246 #else
17247 $ac_func();
17248 #endif
17249
17250 ; return 0; }
17251 EOF
17252 if { (eval echo configure:17253: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17253   rm -rf conftest*
17254   eval "ac_cv_func_$ac_func=yes"
17255 else
17256   echo "configure: failed program was:" >&5
17257   cat conftest.$ac_ext >&5
17258   rm -rf conftest*
17259   eval "ac_cv_func_$ac_func=no"
17260 fi
17261 rm -f conftest*
17262 fi
17263
17264 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17265   echo "$ac_t""yes" 1>&6
17266     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17267   cat >> confdefs.h <<EOF
17268 #define $ac_tr_func 1
17269 EOF
17270
17271 else
17272   echo "$ac_t""no" 1>&6
17273 fi
17274 done
17275
17276   fi
17277
17278
17279   echo $ac_n "checking for _sinl declaration""... $ac_c" 1>&6
17280 echo "configure:17281: checking for _sinl declaration" >&5
17281   if test x${glibcpp_cv_func__sinl_use+set} != xset; then
17282     if eval "test \"`echo '$''{'glibcpp_cv_func__sinl_use'+set}'`\" = set"; then
17283   echo $ac_n "(cached) $ac_c" 1>&6
17284 else
17285
17286
17287       ac_ext=C
17288 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17289 ac_cpp='$CXXCPP $CPPFLAGS'
17290 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17291 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17292 cross_compiling=$ac_cv_prog_cxx_cross
17293
17294       cat > conftest.$ac_ext <<EOF
17295 #line 17296 "configure"
17296 #include "confdefs.h"
17297 #include <math.h>
17298 int main() {
17299  _sinl(0);
17300 ; return 0; }
17301 EOF
17302 if { (eval echo configure:17303: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17303   rm -rf conftest*
17304   glibcpp_cv_func__sinl_use=yes
17305 else
17306   echo "configure: failed program was:" >&5
17307   cat conftest.$ac_ext >&5
17308   rm -rf conftest*
17309   glibcpp_cv_func__sinl_use=no
17310 fi
17311 rm -f conftest*
17312       ac_ext=c
17313 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17314 ac_cpp='$CPP $CPPFLAGS'
17315 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17316 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17317 cross_compiling=$ac_cv_prog_cc_cross
17318
17319
17320 fi
17321
17322   fi
17323   echo "$ac_t""$glibcpp_cv_func__sinl_use" 1>&6
17324   if test x$glibcpp_cv_func__sinl_use = x"yes"; then
17325     for ac_func in _sinl
17326 do
17327 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17328 echo "configure:17329: checking for $ac_func" >&5
17329 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17330   echo $ac_n "(cached) $ac_c" 1>&6
17331 else
17332   cat > conftest.$ac_ext <<EOF
17333 #line 17334 "configure"
17334 #include "confdefs.h"
17335 /* System header to define __stub macros and hopefully few prototypes,
17336     which can conflict with char $ac_func(); below.  */
17337 #include <assert.h>
17338 /* Override any gcc2 internal prototype to avoid an error.  */
17339 /* We use char because int might match the return type of a gcc2
17340     builtin and then its argument prototype would still apply.  */
17341 char $ac_func();
17342
17343 int main() {
17344
17345 /* The GNU C library defines this for functions which it implements
17346     to always fail with ENOSYS.  Some functions are actually named
17347     something starting with __ and the normal name is an alias.  */
17348 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17349 choke me
17350 #else
17351 $ac_func();
17352 #endif
17353
17354 ; return 0; }
17355 EOF
17356 if { (eval echo configure:17357: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17357   rm -rf conftest*
17358   eval "ac_cv_func_$ac_func=yes"
17359 else
17360   echo "configure: failed program was:" >&5
17361   cat conftest.$ac_ext >&5
17362   rm -rf conftest*
17363   eval "ac_cv_func_$ac_func=no"
17364 fi
17365 rm -f conftest*
17366 fi
17367
17368 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17369   echo "$ac_t""yes" 1>&6
17370     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17371   cat >> confdefs.h <<EOF
17372 #define $ac_tr_func 1
17373 EOF
17374
17375 else
17376   echo "$ac_t""no" 1>&6
17377 fi
17378 done
17379
17380   fi
17381
17382
17383   echo $ac_n "checking for _sinhl declaration""... $ac_c" 1>&6
17384 echo "configure:17385: checking for _sinhl declaration" >&5
17385   if test x${glibcpp_cv_func__sinhl_use+set} != xset; then
17386     if eval "test \"`echo '$''{'glibcpp_cv_func__sinhl_use'+set}'`\" = set"; then
17387   echo $ac_n "(cached) $ac_c" 1>&6
17388 else
17389
17390
17391       ac_ext=C
17392 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17393 ac_cpp='$CXXCPP $CPPFLAGS'
17394 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17395 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17396 cross_compiling=$ac_cv_prog_cxx_cross
17397
17398       cat > conftest.$ac_ext <<EOF
17399 #line 17400 "configure"
17400 #include "confdefs.h"
17401 #include <math.h>
17402 int main() {
17403  _sinhl(0);
17404 ; return 0; }
17405 EOF
17406 if { (eval echo configure:17407: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17407   rm -rf conftest*
17408   glibcpp_cv_func__sinhl_use=yes
17409 else
17410   echo "configure: failed program was:" >&5
17411   cat conftest.$ac_ext >&5
17412   rm -rf conftest*
17413   glibcpp_cv_func__sinhl_use=no
17414 fi
17415 rm -f conftest*
17416       ac_ext=c
17417 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17418 ac_cpp='$CPP $CPPFLAGS'
17419 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17420 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17421 cross_compiling=$ac_cv_prog_cc_cross
17422
17423
17424 fi
17425
17426   fi
17427   echo "$ac_t""$glibcpp_cv_func__sinhl_use" 1>&6
17428   if test x$glibcpp_cv_func__sinhl_use = x"yes"; then
17429     for ac_func in _sinhl
17430 do
17431 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17432 echo "configure:17433: checking for $ac_func" >&5
17433 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17434   echo $ac_n "(cached) $ac_c" 1>&6
17435 else
17436   cat > conftest.$ac_ext <<EOF
17437 #line 17438 "configure"
17438 #include "confdefs.h"
17439 /* System header to define __stub macros and hopefully few prototypes,
17440     which can conflict with char $ac_func(); below.  */
17441 #include <assert.h>
17442 /* Override any gcc2 internal prototype to avoid an error.  */
17443 /* We use char because int might match the return type of a gcc2
17444     builtin and then its argument prototype would still apply.  */
17445 char $ac_func();
17446
17447 int main() {
17448
17449 /* The GNU C library defines this for functions which it implements
17450     to always fail with ENOSYS.  Some functions are actually named
17451     something starting with __ and the normal name is an alias.  */
17452 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17453 choke me
17454 #else
17455 $ac_func();
17456 #endif
17457
17458 ; return 0; }
17459 EOF
17460 if { (eval echo configure:17461: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17461   rm -rf conftest*
17462   eval "ac_cv_func_$ac_func=yes"
17463 else
17464   echo "configure: failed program was:" >&5
17465   cat conftest.$ac_ext >&5
17466   rm -rf conftest*
17467   eval "ac_cv_func_$ac_func=no"
17468 fi
17469 rm -f conftest*
17470 fi
17471
17472 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17473   echo "$ac_t""yes" 1>&6
17474     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17475   cat >> confdefs.h <<EOF
17476 #define $ac_tr_func 1
17477 EOF
17478
17479 else
17480   echo "$ac_t""no" 1>&6
17481 fi
17482 done
17483
17484   fi
17485
17486
17487   echo $ac_n "checking for _sqrtl declaration""... $ac_c" 1>&6
17488 echo "configure:17489: checking for _sqrtl declaration" >&5
17489   if test x${glibcpp_cv_func__sqrtl_use+set} != xset; then
17490     if eval "test \"`echo '$''{'glibcpp_cv_func__sqrtl_use'+set}'`\" = set"; then
17491   echo $ac_n "(cached) $ac_c" 1>&6
17492 else
17493
17494
17495       ac_ext=C
17496 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17497 ac_cpp='$CXXCPP $CPPFLAGS'
17498 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17499 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17500 cross_compiling=$ac_cv_prog_cxx_cross
17501
17502       cat > conftest.$ac_ext <<EOF
17503 #line 17504 "configure"
17504 #include "confdefs.h"
17505 #include <math.h>
17506 int main() {
17507  _sqrtl(0);
17508 ; return 0; }
17509 EOF
17510 if { (eval echo configure:17511: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17511   rm -rf conftest*
17512   glibcpp_cv_func__sqrtl_use=yes
17513 else
17514   echo "configure: failed program was:" >&5
17515   cat conftest.$ac_ext >&5
17516   rm -rf conftest*
17517   glibcpp_cv_func__sqrtl_use=no
17518 fi
17519 rm -f conftest*
17520       ac_ext=c
17521 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17522 ac_cpp='$CPP $CPPFLAGS'
17523 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17524 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17525 cross_compiling=$ac_cv_prog_cc_cross
17526
17527
17528 fi
17529
17530   fi
17531   echo "$ac_t""$glibcpp_cv_func__sqrtl_use" 1>&6
17532   if test x$glibcpp_cv_func__sqrtl_use = x"yes"; then
17533     for ac_func in _sqrtl
17534 do
17535 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17536 echo "configure:17537: checking for $ac_func" >&5
17537 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17538   echo $ac_n "(cached) $ac_c" 1>&6
17539 else
17540   cat > conftest.$ac_ext <<EOF
17541 #line 17542 "configure"
17542 #include "confdefs.h"
17543 /* System header to define __stub macros and hopefully few prototypes,
17544     which can conflict with char $ac_func(); below.  */
17545 #include <assert.h>
17546 /* Override any gcc2 internal prototype to avoid an error.  */
17547 /* We use char because int might match the return type of a gcc2
17548     builtin and then its argument prototype would still apply.  */
17549 char $ac_func();
17550
17551 int main() {
17552
17553 /* The GNU C library defines this for functions which it implements
17554     to always fail with ENOSYS.  Some functions are actually named
17555     something starting with __ and the normal name is an alias.  */
17556 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17557 choke me
17558 #else
17559 $ac_func();
17560 #endif
17561
17562 ; return 0; }
17563 EOF
17564 if { (eval echo configure:17565: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17565   rm -rf conftest*
17566   eval "ac_cv_func_$ac_func=yes"
17567 else
17568   echo "configure: failed program was:" >&5
17569   cat conftest.$ac_ext >&5
17570   rm -rf conftest*
17571   eval "ac_cv_func_$ac_func=no"
17572 fi
17573 rm -f conftest*
17574 fi
17575
17576 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17577   echo "$ac_t""yes" 1>&6
17578     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17579   cat >> confdefs.h <<EOF
17580 #define $ac_tr_func 1
17581 EOF
17582
17583 else
17584   echo "$ac_t""no" 1>&6
17585 fi
17586 done
17587
17588   fi
17589
17590
17591   echo $ac_n "checking for _tanl declaration""... $ac_c" 1>&6
17592 echo "configure:17593: checking for _tanl declaration" >&5
17593   if test x${glibcpp_cv_func__tanl_use+set} != xset; then
17594     if eval "test \"`echo '$''{'glibcpp_cv_func__tanl_use'+set}'`\" = set"; then
17595   echo $ac_n "(cached) $ac_c" 1>&6
17596 else
17597
17598
17599       ac_ext=C
17600 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17601 ac_cpp='$CXXCPP $CPPFLAGS'
17602 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17603 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17604 cross_compiling=$ac_cv_prog_cxx_cross
17605
17606       cat > conftest.$ac_ext <<EOF
17607 #line 17608 "configure"
17608 #include "confdefs.h"
17609 #include <math.h>
17610 int main() {
17611  _tanl(0);
17612 ; return 0; }
17613 EOF
17614 if { (eval echo configure:17615: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17615   rm -rf conftest*
17616   glibcpp_cv_func__tanl_use=yes
17617 else
17618   echo "configure: failed program was:" >&5
17619   cat conftest.$ac_ext >&5
17620   rm -rf conftest*
17621   glibcpp_cv_func__tanl_use=no
17622 fi
17623 rm -f conftest*
17624       ac_ext=c
17625 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17626 ac_cpp='$CPP $CPPFLAGS'
17627 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17628 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17629 cross_compiling=$ac_cv_prog_cc_cross
17630
17631
17632 fi
17633
17634   fi
17635   echo "$ac_t""$glibcpp_cv_func__tanl_use" 1>&6
17636   if test x$glibcpp_cv_func__tanl_use = x"yes"; then
17637     for ac_func in _tanl
17638 do
17639 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17640 echo "configure:17641: checking for $ac_func" >&5
17641 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17642   echo $ac_n "(cached) $ac_c" 1>&6
17643 else
17644   cat > conftest.$ac_ext <<EOF
17645 #line 17646 "configure"
17646 #include "confdefs.h"
17647 /* System header to define __stub macros and hopefully few prototypes,
17648     which can conflict with char $ac_func(); below.  */
17649 #include <assert.h>
17650 /* Override any gcc2 internal prototype to avoid an error.  */
17651 /* We use char because int might match the return type of a gcc2
17652     builtin and then its argument prototype would still apply.  */
17653 char $ac_func();
17654
17655 int main() {
17656
17657 /* The GNU C library defines this for functions which it implements
17658     to always fail with ENOSYS.  Some functions are actually named
17659     something starting with __ and the normal name is an alias.  */
17660 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17661 choke me
17662 #else
17663 $ac_func();
17664 #endif
17665
17666 ; return 0; }
17667 EOF
17668 if { (eval echo configure:17669: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17669   rm -rf conftest*
17670   eval "ac_cv_func_$ac_func=yes"
17671 else
17672   echo "configure: failed program was:" >&5
17673   cat conftest.$ac_ext >&5
17674   rm -rf conftest*
17675   eval "ac_cv_func_$ac_func=no"
17676 fi
17677 rm -f conftest*
17678 fi
17679
17680 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17681   echo "$ac_t""yes" 1>&6
17682     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17683   cat >> confdefs.h <<EOF
17684 #define $ac_tr_func 1
17685 EOF
17686
17687 else
17688   echo "$ac_t""no" 1>&6
17689 fi
17690 done
17691
17692   fi
17693
17694
17695   echo $ac_n "checking for _tanhl declaration""... $ac_c" 1>&6
17696 echo "configure:17697: checking for _tanhl declaration" >&5
17697   if test x${glibcpp_cv_func__tanhl_use+set} != xset; then
17698     if eval "test \"`echo '$''{'glibcpp_cv_func__tanhl_use'+set}'`\" = set"; then
17699   echo $ac_n "(cached) $ac_c" 1>&6
17700 else
17701
17702
17703       ac_ext=C
17704 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17705 ac_cpp='$CXXCPP $CPPFLAGS'
17706 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17707 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17708 cross_compiling=$ac_cv_prog_cxx_cross
17709
17710       cat > conftest.$ac_ext <<EOF
17711 #line 17712 "configure"
17712 #include "confdefs.h"
17713 #include <math.h>
17714 int main() {
17715  _tanhl(0);
17716 ; return 0; }
17717 EOF
17718 if { (eval echo configure:17719: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17719   rm -rf conftest*
17720   glibcpp_cv_func__tanhl_use=yes
17721 else
17722   echo "configure: failed program was:" >&5
17723   cat conftest.$ac_ext >&5
17724   rm -rf conftest*
17725   glibcpp_cv_func__tanhl_use=no
17726 fi
17727 rm -f conftest*
17728       ac_ext=c
17729 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17730 ac_cpp='$CPP $CPPFLAGS'
17731 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17732 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17733 cross_compiling=$ac_cv_prog_cc_cross
17734
17735
17736 fi
17737
17738   fi
17739   echo "$ac_t""$glibcpp_cv_func__tanhl_use" 1>&6
17740   if test x$glibcpp_cv_func__tanhl_use = x"yes"; then
17741     for ac_func in _tanhl
17742 do
17743 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17744 echo "configure:17745: checking for $ac_func" >&5
17745 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17746   echo $ac_n "(cached) $ac_c" 1>&6
17747 else
17748   cat > conftest.$ac_ext <<EOF
17749 #line 17750 "configure"
17750 #include "confdefs.h"
17751 /* System header to define __stub macros and hopefully few prototypes,
17752     which can conflict with char $ac_func(); below.  */
17753 #include <assert.h>
17754 /* Override any gcc2 internal prototype to avoid an error.  */
17755 /* We use char because int might match the return type of a gcc2
17756     builtin and then its argument prototype would still apply.  */
17757 char $ac_func();
17758
17759 int main() {
17760
17761 /* The GNU C library defines this for functions which it implements
17762     to always fail with ENOSYS.  Some functions are actually named
17763     something starting with __ and the normal name is an alias.  */
17764 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17765 choke me
17766 #else
17767 $ac_func();
17768 #endif
17769
17770 ; return 0; }
17771 EOF
17772 if { (eval echo configure:17773: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17773   rm -rf conftest*
17774   eval "ac_cv_func_$ac_func=yes"
17775 else
17776   echo "configure: failed program was:" >&5
17777   cat conftest.$ac_ext >&5
17778   rm -rf conftest*
17779   eval "ac_cv_func_$ac_func=no"
17780 fi
17781 rm -f conftest*
17782 fi
17783
17784 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17785   echo "$ac_t""yes" 1>&6
17786     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17787   cat >> confdefs.h <<EOF
17788 #define $ac_tr_func 1
17789 EOF
17790
17791 else
17792   echo "$ac_t""no" 1>&6
17793 fi
17794 done
17795
17796   fi
17797
17798
17799   echo $ac_n "checking for _sincosl declaration""... $ac_c" 1>&6
17800 echo "configure:17801: checking for _sincosl declaration" >&5
17801   if test x${glibcpp_cv_func__sincosl_use+set} != xset; then
17802     if eval "test \"`echo '$''{'glibcpp_cv_func__sincosl_use'+set}'`\" = set"; then
17803   echo $ac_n "(cached) $ac_c" 1>&6
17804 else
17805
17806
17807       ac_ext=C
17808 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17809 ac_cpp='$CXXCPP $CPPFLAGS'
17810 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17811 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17812 cross_compiling=$ac_cv_prog_cxx_cross
17813
17814       cat > conftest.$ac_ext <<EOF
17815 #line 17816 "configure"
17816 #include "confdefs.h"
17817 #include <math.h>
17818 int main() {
17819  _sincosl(0, 0, 0);
17820 ; return 0; }
17821 EOF
17822 if { (eval echo configure:17823: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17823   rm -rf conftest*
17824   glibcpp_cv_func__sincosl_use=yes
17825 else
17826   echo "configure: failed program was:" >&5
17827   cat conftest.$ac_ext >&5
17828   rm -rf conftest*
17829   glibcpp_cv_func__sincosl_use=no
17830 fi
17831 rm -f conftest*
17832       ac_ext=c
17833 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17834 ac_cpp='$CPP $CPPFLAGS'
17835 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17836 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17837 cross_compiling=$ac_cv_prog_cc_cross
17838
17839
17840 fi
17841
17842   fi
17843   echo "$ac_t""$glibcpp_cv_func__sincosl_use" 1>&6
17844   if test x$glibcpp_cv_func__sincosl_use = x"yes"; then
17845     for ac_func in _sincosl
17846 do
17847 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17848 echo "configure:17849: checking for $ac_func" >&5
17849 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17850   echo $ac_n "(cached) $ac_c" 1>&6
17851 else
17852   cat > conftest.$ac_ext <<EOF
17853 #line 17854 "configure"
17854 #include "confdefs.h"
17855 /* System header to define __stub macros and hopefully few prototypes,
17856     which can conflict with char $ac_func(); below.  */
17857 #include <assert.h>
17858 /* Override any gcc2 internal prototype to avoid an error.  */
17859 /* We use char because int might match the return type of a gcc2
17860     builtin and then its argument prototype would still apply.  */
17861 char $ac_func();
17862
17863 int main() {
17864
17865 /* The GNU C library defines this for functions which it implements
17866     to always fail with ENOSYS.  Some functions are actually named
17867     something starting with __ and the normal name is an alias.  */
17868 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17869 choke me
17870 #else
17871 $ac_func();
17872 #endif
17873
17874 ; return 0; }
17875 EOF
17876 if { (eval echo configure:17877: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17877   rm -rf conftest*
17878   eval "ac_cv_func_$ac_func=yes"
17879 else
17880   echo "configure: failed program was:" >&5
17881   cat conftest.$ac_ext >&5
17882   rm -rf conftest*
17883   eval "ac_cv_func_$ac_func=no"
17884 fi
17885 rm -f conftest*
17886 fi
17887
17888 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17889   echo "$ac_t""yes" 1>&6
17890     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17891   cat >> confdefs.h <<EOF
17892 #define $ac_tr_func 1
17893 EOF
17894
17895 else
17896   echo "$ac_t""no" 1>&6
17897 fi
17898 done
17899
17900   fi
17901
17902
17903   echo $ac_n "checking for _finitel declaration""... $ac_c" 1>&6
17904 echo "configure:17905: checking for _finitel declaration" >&5
17905   if test x${glibcpp_cv_func__finitel_use+set} != xset; then
17906     if eval "test \"`echo '$''{'glibcpp_cv_func__finitel_use'+set}'`\" = set"; then
17907   echo $ac_n "(cached) $ac_c" 1>&6
17908 else
17909
17910
17911       ac_ext=C
17912 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17913 ac_cpp='$CXXCPP $CPPFLAGS'
17914 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17915 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17916 cross_compiling=$ac_cv_prog_cxx_cross
17917
17918       cat > conftest.$ac_ext <<EOF
17919 #line 17920 "configure"
17920 #include "confdefs.h"
17921 #include <math.h>
17922 int main() {
17923  _finitel(0);
17924 ; return 0; }
17925 EOF
17926 if { (eval echo configure:17927: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
17927   rm -rf conftest*
17928   glibcpp_cv_func__finitel_use=yes
17929 else
17930   echo "configure: failed program was:" >&5
17931   cat conftest.$ac_ext >&5
17932   rm -rf conftest*
17933   glibcpp_cv_func__finitel_use=no
17934 fi
17935 rm -f conftest*
17936       ac_ext=c
17937 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
17938 ac_cpp='$CPP $CPPFLAGS'
17939 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
17940 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
17941 cross_compiling=$ac_cv_prog_cc_cross
17942
17943
17944 fi
17945
17946   fi
17947   echo "$ac_t""$glibcpp_cv_func__finitel_use" 1>&6
17948   if test x$glibcpp_cv_func__finitel_use = x"yes"; then
17949     for ac_func in _finitel
17950 do
17951 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
17952 echo "configure:17953: checking for $ac_func" >&5
17953 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
17954   echo $ac_n "(cached) $ac_c" 1>&6
17955 else
17956   cat > conftest.$ac_ext <<EOF
17957 #line 17958 "configure"
17958 #include "confdefs.h"
17959 /* System header to define __stub macros and hopefully few prototypes,
17960     which can conflict with char $ac_func(); below.  */
17961 #include <assert.h>
17962 /* Override any gcc2 internal prototype to avoid an error.  */
17963 /* We use char because int might match the return type of a gcc2
17964     builtin and then its argument prototype would still apply.  */
17965 char $ac_func();
17966
17967 int main() {
17968
17969 /* The GNU C library defines this for functions which it implements
17970     to always fail with ENOSYS.  Some functions are actually named
17971     something starting with __ and the normal name is an alias.  */
17972 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
17973 choke me
17974 #else
17975 $ac_func();
17976 #endif
17977
17978 ; return 0; }
17979 EOF
17980 if { (eval echo configure:17981: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
17981   rm -rf conftest*
17982   eval "ac_cv_func_$ac_func=yes"
17983 else
17984   echo "configure: failed program was:" >&5
17985   cat conftest.$ac_ext >&5
17986   rm -rf conftest*
17987   eval "ac_cv_func_$ac_func=no"
17988 fi
17989 rm -f conftest*
17990 fi
17991
17992 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
17993   echo "$ac_t""yes" 1>&6
17994     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
17995   cat >> confdefs.h <<EOF
17996 #define $ac_tr_func 1
17997 EOF
17998
17999 else
18000   echo "$ac_t""no" 1>&6
18001 fi
18002 done
18003
18004   fi
18005
18006
18007   LIBS="$ac_save_LIBS"
18008   CXXFLAGS="$ac_save_CXXFLAGS"
18009
18010
18011     for ac_hdr in complex.h
18012 do
18013 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
18014 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
18015 echo "configure:18016: checking for $ac_hdr" >&5
18016 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18017   echo $ac_n "(cached) $ac_c" 1>&6
18018 else
18019   cat > conftest.$ac_ext <<EOF
18020 #line 18021 "configure"
18021 #include "confdefs.h"
18022 #include <$ac_hdr>
18023 EOF
18024 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18025 { (eval echo configure:18026: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18026 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18027 if test -z "$ac_err"; then
18028   rm -rf conftest*
18029   eval "ac_cv_header_$ac_safe=yes"
18030 else
18031   echo "$ac_err" >&5
18032   echo "configure: failed program was:" >&5
18033   cat conftest.$ac_ext >&5
18034   rm -rf conftest*
18035   eval "ac_cv_header_$ac_safe=no"
18036 fi
18037 rm -f conftest*
18038 fi
18039 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18040   echo "$ac_t""yes" 1>&6
18041     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
18042   cat >> confdefs.h <<EOF
18043 #define $ac_tr_hdr 1
18044 EOF
18045
18046 else
18047   echo "$ac_t""no" 1>&6
18048 fi
18049 done
18050
18051   echo $ac_n "checking for main in -lm""... $ac_c" 1>&6
18052 echo "configure:18053: checking for main in -lm" >&5
18053 ac_lib_var=`echo m'_'main | sed 'y%./+-%__p_%'`
18054 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
18055   echo $ac_n "(cached) $ac_c" 1>&6
18056 else
18057   ac_save_LIBS="$LIBS"
18058 LIBS="-lm  $LIBS"
18059 cat > conftest.$ac_ext <<EOF
18060 #line 18061 "configure"
18061 #include "confdefs.h"
18062
18063 int main() {
18064 main()
18065 ; return 0; }
18066 EOF
18067 if { (eval echo configure:18068: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18068   rm -rf conftest*
18069   eval "ac_cv_lib_$ac_lib_var=yes"
18070 else
18071   echo "configure: failed program was:" >&5
18072   cat conftest.$ac_ext >&5
18073   rm -rf conftest*
18074   eval "ac_cv_lib_$ac_lib_var=no"
18075 fi
18076 rm -f conftest*
18077 LIBS="$ac_save_LIBS"
18078
18079 fi
18080 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
18081   echo "$ac_t""yes" 1>&6
18082     ac_tr_lib=HAVE_LIB`echo m | sed -e 's/[^a-zA-Z0-9_]/_/g' \
18083     -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
18084   cat >> confdefs.h <<EOF
18085 #define $ac_tr_lib 1
18086 EOF
18087
18088   LIBS="-lm $LIBS"
18089
18090 else
18091   echo "$ac_t""no" 1>&6
18092 fi
18093
18094   for ac_func in csqrt csqrtf nan hypot hypotf atan2f expf copysignf
18095 do
18096 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18097 echo "configure:18098: checking for $ac_func" >&5
18098 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18099   echo $ac_n "(cached) $ac_c" 1>&6
18100 else
18101   cat > conftest.$ac_ext <<EOF
18102 #line 18103 "configure"
18103 #include "confdefs.h"
18104 /* System header to define __stub macros and hopefully few prototypes,
18105     which can conflict with char $ac_func(); below.  */
18106 #include <assert.h>
18107 /* Override any gcc2 internal prototype to avoid an error.  */
18108 /* We use char because int might match the return type of a gcc2
18109     builtin and then its argument prototype would still apply.  */
18110 char $ac_func();
18111
18112 int main() {
18113
18114 /* The GNU C library defines this for functions which it implements
18115     to always fail with ENOSYS.  Some functions are actually named
18116     something starting with __ and the normal name is an alias.  */
18117 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18118 choke me
18119 #else
18120 $ac_func();
18121 #endif
18122
18123 ; return 0; }
18124 EOF
18125 if { (eval echo configure:18126: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18126   rm -rf conftest*
18127   eval "ac_cv_func_$ac_func=yes"
18128 else
18129   echo "configure: failed program was:" >&5
18130   cat conftest.$ac_ext >&5
18131   rm -rf conftest*
18132   eval "ac_cv_func_$ac_func=no"
18133 fi
18134 rm -f conftest*
18135 fi
18136
18137 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18138   echo "$ac_t""yes" 1>&6
18139     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18140   cat >> confdefs.h <<EOF
18141 #define $ac_tr_func 1
18142 EOF
18143
18144 else
18145   echo "$ac_t""no" 1>&6
18146 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
18147 fi
18148 done
18149
18150
18151
18152           USE_COMPLEX_LONG_DOUBLE=no
18153   if test x$ac_cv_func_atan2l = x"yes" \
18154      && test x$ac_cv_func_copysignl = x"yes"; then
18155     USE_COMPLEX_LONG_DOUBLE=yes
18156     for ac_func in csqrtl hypotl signbitl
18157 do
18158 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18159 echo "configure:18160: checking for $ac_func" >&5
18160 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18161   echo $ac_n "(cached) $ac_c" 1>&6
18162 else
18163   cat > conftest.$ac_ext <<EOF
18164 #line 18165 "configure"
18165 #include "confdefs.h"
18166 /* System header to define __stub macros and hopefully few prototypes,
18167     which can conflict with char $ac_func(); below.  */
18168 #include <assert.h>
18169 /* Override any gcc2 internal prototype to avoid an error.  */
18170 /* We use char because int might match the return type of a gcc2
18171     builtin and then its argument prototype would still apply.  */
18172 char $ac_func();
18173
18174 int main() {
18175
18176 /* The GNU C library defines this for functions which it implements
18177     to always fail with ENOSYS.  Some functions are actually named
18178     something starting with __ and the normal name is an alias.  */
18179 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18180 choke me
18181 #else
18182 $ac_func();
18183 #endif
18184
18185 ; return 0; }
18186 EOF
18187 if { (eval echo configure:18188: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18188   rm -rf conftest*
18189   eval "ac_cv_func_$ac_func=yes"
18190 else
18191   echo "configure: failed program was:" >&5
18192   cat conftest.$ac_ext >&5
18193   rm -rf conftest*
18194   eval "ac_cv_func_$ac_func=no"
18195 fi
18196 rm -f conftest*
18197 fi
18198
18199 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18200   echo "$ac_t""yes" 1>&6
18201     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18202   cat >> confdefs.h <<EOF
18203 #define $ac_tr_func 1
18204 EOF
18205
18206 else
18207   echo "$ac_t""no" 1>&6
18208 LIBMATHOBJS="$LIBMATHOBJS ${ac_func}.lo"
18209 fi
18210 done
18211
18212
18213   fi
18214
18215
18216
18217
18218
18219
18220   echo $ac_n "checking for GNU C++ __complex__ support""... $ac_c" 1>&6
18221 echo "configure:18222: checking for GNU C++ __complex__ support" >&5
18222   if eval "test \"`echo '$''{'glibcpp_cv_complex'+set}'`\" = set"; then
18223   echo $ac_n "(cached) $ac_c" 1>&6
18224 else
18225
18226
18227     ac_ext=C
18228 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18229 ac_cpp='$CXXCPP $CPPFLAGS'
18230 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18231 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18232 cross_compiling=$ac_cv_prog_cxx_cross
18233
18234     cat > conftest.$ac_ext <<EOF
18235 #line 18236 "configure"
18236 #include "confdefs.h"
18237 struct dcomplex { __complex__ double x; }; \
18238                     dcomplex f(const dcomplex& x) { return dcomplex(x); }
18239 int main() {
18240 \
18241                      dcomplex x; f(x);
18242 ; return 0; }
18243 EOF
18244 if { (eval echo configure:18245: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18245   rm -rf conftest*
18246   glibcpp_cv_complex=ok
18247 else
18248   echo "configure: failed program was:" >&5
18249   cat conftest.$ac_ext >&5
18250   rm -rf conftest*
18251   glibcpp_cv_complex=buggy
18252
18253 fi
18254 rm -f conftest*
18255     ac_ext=c
18256 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18257 ac_cpp='$CPP $CPPFLAGS'
18258 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18259 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18260 cross_compiling=$ac_cv_prog_cc_cross
18261
18262
18263 fi
18264
18265   echo "$ac_t""$glibcpp_cv_complex" 1>&6
18266   if test $glibcpp_cv_complex = buggy; then
18267     cat >> confdefs.h <<\EOF
18268 #define _GLIBCPP_BUGGY_COMPLEX 1
18269 EOF
18270
18271   fi
18272
18273   echo $ac_n "checking for GNU C++ __complex__ float support""... $ac_c" 1>&6
18274 echo "configure:18275: checking for GNU C++ __complex__ float support" >&5
18275   if eval "test \"`echo '$''{'glibcpp_cv_float_complex'+set}'`\" = set"; then
18276   echo $ac_n "(cached) $ac_c" 1>&6
18277 else
18278
18279
18280     ac_ext=C
18281 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18282 ac_cpp='$CXXCPP $CPPFLAGS'
18283 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18284 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18285 cross_compiling=$ac_cv_prog_cxx_cross
18286
18287     rm -f conftest.h
18288     cat > conftest.h <<EOB
18289       //
18290       // Check for buggy __complex__ that causes ICE in most versions of egcs
18291       // and gcc-2.95.x on certain platforms (eg., x86-win32).
18292       //
18293       // See http://gcc.gnu.org/ml/gcc-bugs/1999-07n/msg00845.html for
18294       // more info on the bug itself.
18295       //
18296       struct
18297       float_complex
18298       {
18299        __complex__ float m_value;
18300        float_complex (float = 0.0f, float = 0.0f);
18301        float_complex (__complex__ float val) : m_value (val) {}
18302        float_complex foo (const float_complex &val)
18303          { return float_complex (~val.m_value); }
18304       };
18305 EOB
18306     cat > conftest.$ac_ext <<EOF
18307 #line 18308 "configure"
18308 #include "confdefs.h"
18309 #include "conftest.h"
18310 int main() {
18311
18312 ; return 0; }
18313 EOF
18314 if { (eval echo configure:18315: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18315   rm -rf conftest*
18316   glibcpp_cv_float_complex=ok
18317 else
18318   echo "configure: failed program was:" >&5
18319   cat conftest.$ac_ext >&5
18320   rm -rf conftest*
18321   glibcpp_cv_float_complex=buggy
18322
18323 fi
18324 rm -f conftest*
18325     ac_ext=c
18326 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18327 ac_cpp='$CPP $CPPFLAGS'
18328 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18329 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18330 cross_compiling=$ac_cv_prog_cc_cross
18331
18332
18333 fi
18334
18335   echo "$ac_t""$glibcpp_cv_float_complex" 1>&6
18336   if test $glibcpp_cv_float_complex = buggy; then
18337     cat >> confdefs.h <<\EOF
18338 #define _GLIBCPP_BUGGY_FLOAT_COMPLEX 1
18339 EOF
18340
18341   fi
18342
18343
18344   if test x$enable_c_mbchar != xno; then
18345
18346         ac_safe=`echo "wchar.h" | sed 'y%./+-%__p_%'`
18347 echo $ac_n "checking for wchar.h""... $ac_c" 1>&6
18348 echo "configure:18349: checking for wchar.h" >&5
18349 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18350   echo $ac_n "(cached) $ac_c" 1>&6
18351 else
18352   cat > conftest.$ac_ext <<EOF
18353 #line 18354 "configure"
18354 #include "confdefs.h"
18355 #include <wchar.h>
18356 EOF
18357 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18358 { (eval echo configure:18359: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18359 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18360 if test -z "$ac_err"; then
18361   rm -rf conftest*
18362   eval "ac_cv_header_$ac_safe=yes"
18363 else
18364   echo "$ac_err" >&5
18365   echo "configure: failed program was:" >&5
18366   cat conftest.$ac_ext >&5
18367   rm -rf conftest*
18368   eval "ac_cv_header_$ac_safe=no"
18369 fi
18370 rm -f conftest*
18371 fi
18372 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18373   echo "$ac_t""yes" 1>&6
18374   ac_has_wchar_h=yes
18375 else
18376   echo "$ac_t""no" 1>&6
18377 ac_has_wchar_h=no
18378 fi
18379
18380     ac_safe=`echo "wctype.h" | sed 'y%./+-%__p_%'`
18381 echo $ac_n "checking for wctype.h""... $ac_c" 1>&6
18382 echo "configure:18383: checking for wctype.h" >&5
18383 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18384   echo $ac_n "(cached) $ac_c" 1>&6
18385 else
18386   cat > conftest.$ac_ext <<EOF
18387 #line 18388 "configure"
18388 #include "confdefs.h"
18389 #include <wctype.h>
18390 EOF
18391 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18392 { (eval echo configure:18393: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18393 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18394 if test -z "$ac_err"; then
18395   rm -rf conftest*
18396   eval "ac_cv_header_$ac_safe=yes"
18397 else
18398   echo "$ac_err" >&5
18399   echo "configure: failed program was:" >&5
18400   cat conftest.$ac_ext >&5
18401   rm -rf conftest*
18402   eval "ac_cv_header_$ac_safe=no"
18403 fi
18404 rm -f conftest*
18405 fi
18406 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18407   echo "$ac_t""yes" 1>&6
18408   ac_has_wctype_h=yes
18409 else
18410   echo "$ac_t""no" 1>&6
18411 ac_has_wctype_h=no
18412 fi
18413
18414
18415         if test x"$ac_has_wchar_h" = xyes && test x"$ac_has_wctype_h" = xyes; then
18416
18417                   echo $ac_n "checking for mbstate_t""... $ac_c" 1>&6
18418 echo "configure:18419: checking for mbstate_t" >&5
18419       cat > conftest.$ac_ext <<EOF
18420 #line 18421 "configure"
18421 #include "confdefs.h"
18422 #include <wchar.h>
18423 int main() {
18424 mbstate_t teststate;
18425 ; return 0; }
18426 EOF
18427 if { (eval echo configure:18428: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18428   rm -rf conftest*
18429   use_native_mbstatet=yes
18430 else
18431   echo "configure: failed program was:" >&5
18432   cat conftest.$ac_ext >&5
18433   rm -rf conftest*
18434   use_native_mbstatet=no
18435 fi
18436 rm -f conftest*
18437       echo "$ac_t""$use_native_mbstatet" 1>&6
18438
18439                   echo $ac_n "checking for WCHAR_MIN and WCHAR_MAX""... $ac_c" 1>&6
18440 echo "configure:18441: checking for WCHAR_MIN and WCHAR_MAX" >&5
18441       cat > conftest.$ac_ext <<EOF
18442 #line 18443 "configure"
18443 #include "confdefs.h"
18444 #include <wchar.h>
18445 int main() {
18446 int i = WCHAR_MIN; int j = WCHAR_MAX;
18447 ; return 0; }
18448 EOF
18449 if { (eval echo configure:18450: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18450   rm -rf conftest*
18451   has_wchar_minmax=yes
18452 else
18453   echo "configure: failed program was:" >&5
18454   cat conftest.$ac_ext >&5
18455   rm -rf conftest*
18456   has_wchar_minmax=no
18457 fi
18458 rm -f conftest*
18459       echo "$ac_t""$has_wchar_minmax" 1>&6
18460
18461                   echo $ac_n "checking for WEOF""... $ac_c" 1>&6
18462 echo "configure:18463: checking for WEOF" >&5
18463       cat > conftest.$ac_ext <<EOF
18464 #line 18465 "configure"
18465 #include "confdefs.h"
18466
18467         #include <wchar.h>
18468         #include <stddef.h>
18469 int main() {
18470 wint_t i = WEOF;
18471 ; return 0; }
18472 EOF
18473 if { (eval echo configure:18474: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18474   rm -rf conftest*
18475   has_weof=yes
18476 else
18477   echo "configure: failed program was:" >&5
18478   cat conftest.$ac_ext >&5
18479   rm -rf conftest*
18480   has_weof=no
18481 fi
18482 rm -f conftest*
18483       echo "$ac_t""$has_weof" 1>&6
18484
18485             for ac_func in wcslen wmemchr wmemcmp wmemcpy wmemmove wmemset \
18486       wcsrtombs mbsrtowcs
18487 do
18488 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18489 echo "configure:18490: checking for $ac_func" >&5
18490 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18491   echo $ac_n "(cached) $ac_c" 1>&6
18492 else
18493   cat > conftest.$ac_ext <<EOF
18494 #line 18495 "configure"
18495 #include "confdefs.h"
18496 /* System header to define __stub macros and hopefully few prototypes,
18497     which can conflict with char $ac_func(); below.  */
18498 #include <assert.h>
18499 /* Override any gcc2 internal prototype to avoid an error.  */
18500 /* We use char because int might match the return type of a gcc2
18501     builtin and then its argument prototype would still apply.  */
18502 char $ac_func();
18503
18504 int main() {
18505
18506 /* The GNU C library defines this for functions which it implements
18507     to always fail with ENOSYS.  Some functions are actually named
18508     something starting with __ and the normal name is an alias.  */
18509 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18510 choke me
18511 #else
18512 $ac_func();
18513 #endif
18514
18515 ; return 0; }
18516 EOF
18517 if { (eval echo configure:18518: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18518   rm -rf conftest*
18519   eval "ac_cv_func_$ac_func=yes"
18520 else
18521   echo "configure: failed program was:" >&5
18522   cat conftest.$ac_ext >&5
18523   rm -rf conftest*
18524   eval "ac_cv_func_$ac_func=no"
18525 fi
18526 rm -f conftest*
18527 fi
18528
18529 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18530   echo "$ac_t""yes" 1>&6
18531     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18532   cat >> confdefs.h <<EOF
18533 #define $ac_tr_func 1
18534 EOF
18535  ac_wfuncs=yes
18536 else
18537   echo "$ac_t""no" 1>&6
18538 ac_wfuncs=no
18539 fi
18540 done
18541
18542
18543       echo $ac_n "checking for ISO C99 wchar_t support""... $ac_c" 1>&6
18544 echo "configure:18545: checking for ISO C99 wchar_t support" >&5
18545       if test x"$has_weof" = xyes && test x"$has_wchar_minmax" = xyes \
18546          && test x"$ac_wfuncs" = xyes; then
18547         ac_isoC99_wchar_t=yes
18548       else
18549         ac_isoC99_wchar_t=no
18550       fi
18551       echo "$ac_t""$ac_isoC99_wchar_t" 1>&6
18552
18553                   ac_safe=`echo "iconv.h" | sed 'y%./+-%__p_%'`
18554 echo $ac_n "checking for iconv.h""... $ac_c" 1>&6
18555 echo "configure:18556: checking for iconv.h" >&5
18556 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18557   echo $ac_n "(cached) $ac_c" 1>&6
18558 else
18559   cat > conftest.$ac_ext <<EOF
18560 #line 18561 "configure"
18561 #include "confdefs.h"
18562 #include <iconv.h>
18563 EOF
18564 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18565 { (eval echo configure:18566: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18566 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18567 if test -z "$ac_err"; then
18568   rm -rf conftest*
18569   eval "ac_cv_header_$ac_safe=yes"
18570 else
18571   echo "$ac_err" >&5
18572   echo "configure: failed program was:" >&5
18573   cat conftest.$ac_ext >&5
18574   rm -rf conftest*
18575   eval "ac_cv_header_$ac_safe=no"
18576 fi
18577 rm -f conftest*
18578 fi
18579 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18580   echo "$ac_t""yes" 1>&6
18581   ac_has_iconv_h=yes
18582 else
18583   echo "$ac_t""no" 1>&6
18584 ac_has_iconv_h=no
18585 fi
18586
18587       ac_safe=`echo "langinfo.h" | sed 'y%./+-%__p_%'`
18588 echo $ac_n "checking for langinfo.h""... $ac_c" 1>&6
18589 echo "configure:18590: checking for langinfo.h" >&5
18590 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18591   echo $ac_n "(cached) $ac_c" 1>&6
18592 else
18593   cat > conftest.$ac_ext <<EOF
18594 #line 18595 "configure"
18595 #include "confdefs.h"
18596 #include <langinfo.h>
18597 EOF
18598 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18599 { (eval echo configure:18600: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18600 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18601 if test -z "$ac_err"; then
18602   rm -rf conftest*
18603   eval "ac_cv_header_$ac_safe=yes"
18604 else
18605   echo "$ac_err" >&5
18606   echo "configure: failed program was:" >&5
18607   cat conftest.$ac_ext >&5
18608   rm -rf conftest*
18609   eval "ac_cv_header_$ac_safe=no"
18610 fi
18611 rm -f conftest*
18612 fi
18613 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18614   echo "$ac_t""yes" 1>&6
18615   ac_has_langinfo_h=yes
18616 else
18617   echo "$ac_t""no" 1>&6
18618 ac_has_langinfo_h=no
18619 fi
18620
18621
18622             echo $ac_n "checking for iconv in -liconv""... $ac_c" 1>&6
18623 echo "configure:18624: checking for iconv in -liconv" >&5
18624 ac_lib_var=`echo iconv'_'iconv | sed 'y%./+-%__p_%'`
18625 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
18626   echo $ac_n "(cached) $ac_c" 1>&6
18627 else
18628   ac_save_LIBS="$LIBS"
18629 LIBS="-liconv  $LIBS"
18630 cat > conftest.$ac_ext <<EOF
18631 #line 18632 "configure"
18632 #include "confdefs.h"
18633 /* Override any gcc2 internal prototype to avoid an error.  */
18634 /* We use char because int might match the return type of a gcc2
18635     builtin and then its argument prototype would still apply.  */
18636 char iconv();
18637
18638 int main() {
18639 iconv()
18640 ; return 0; }
18641 EOF
18642 if { (eval echo configure:18643: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18643   rm -rf conftest*
18644   eval "ac_cv_lib_$ac_lib_var=yes"
18645 else
18646   echo "configure: failed program was:" >&5
18647   cat conftest.$ac_ext >&5
18648   rm -rf conftest*
18649   eval "ac_cv_lib_$ac_lib_var=no"
18650 fi
18651 rm -f conftest*
18652 LIBS="$ac_save_LIBS"
18653
18654 fi
18655 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
18656   echo "$ac_t""yes" 1>&6
18657   libiconv="-liconv"
18658 else
18659   echo "$ac_t""no" 1>&6
18660 fi
18661
18662       ac_save_LIBS="$LIBS"
18663       LIBS="$LIBS $libiconv"
18664
18665       for ac_func in iconv_open iconv_close iconv nl_langinfo
18666 do
18667 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
18668 echo "configure:18669: checking for $ac_func" >&5
18669 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
18670   echo $ac_n "(cached) $ac_c" 1>&6
18671 else
18672   cat > conftest.$ac_ext <<EOF
18673 #line 18674 "configure"
18674 #include "confdefs.h"
18675 /* System header to define __stub macros and hopefully few prototypes,
18676     which can conflict with char $ac_func(); below.  */
18677 #include <assert.h>
18678 /* Override any gcc2 internal prototype to avoid an error.  */
18679 /* We use char because int might match the return type of a gcc2
18680     builtin and then its argument prototype would still apply.  */
18681 char $ac_func();
18682
18683 int main() {
18684
18685 /* The GNU C library defines this for functions which it implements
18686     to always fail with ENOSYS.  Some functions are actually named
18687     something starting with __ and the normal name is an alias.  */
18688 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
18689 choke me
18690 #else
18691 $ac_func();
18692 #endif
18693
18694 ; return 0; }
18695 EOF
18696 if { (eval echo configure:18697: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
18697   rm -rf conftest*
18698   eval "ac_cv_func_$ac_func=yes"
18699 else
18700   echo "configure: failed program was:" >&5
18701   cat conftest.$ac_ext >&5
18702   rm -rf conftest*
18703   eval "ac_cv_func_$ac_func=no"
18704 fi
18705 rm -f conftest*
18706 fi
18707
18708 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
18709   echo "$ac_t""yes" 1>&6
18710     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
18711   cat >> confdefs.h <<EOF
18712 #define $ac_tr_func 1
18713 EOF
18714  \
18715       ac_XPG2funcs=yes
18716 else
18717   echo "$ac_t""no" 1>&6
18718 ac_XPG2funcs=no
18719 fi
18720 done
18721
18722
18723       LIBS="$ac_save_LIBS"
18724
18725       echo $ac_n "checking for XPG2 wchar_t support""... $ac_c" 1>&6
18726 echo "configure:18727: checking for XPG2 wchar_t support" >&5
18727       if test x"$ac_has_iconv_h" = xyes && test x"$ac_has_langinfo_h" = xyes \
18728          && test x"$ac_XPG2funcs" = xyes; then
18729         ac_XPG2_wchar_t=yes
18730       else
18731         ac_XPG2_wchar_t=no
18732       fi
18733       echo "$ac_t""$ac_XPG2_wchar_t" 1>&6
18734
18735                   echo $ac_n "checking for enabled wchar_t specializations""... $ac_c" 1>&6
18736 echo "configure:18737: checking for enabled wchar_t specializations" >&5
18737       if test x"$ac_isoC99_wchar_t" = xyes \
18738          && test x"$ac_XPG2_wchar_t" = xyes; then
18739         libinst_wstring_la="libinst-wstring.la"
18740         cat >> confdefs.h <<\EOF
18741 #define _GLIBCPP_USE_WCHAR_T 1
18742 EOF
18743
18744         echo "$ac_t"""yes"" 1>&6
18745       else
18746         libinst_wstring_la=""
18747         echo "$ac_t"""no"" 1>&6
18748       fi
18749
18750
18751     else
18752       echo "configure: warning: <wchar.h> not found" 1>&2
18753     fi
18754
18755   else
18756         :
18757   fi
18758
18759
18760   ac_safe=`echo "ctype.h" | sed 'y%./+-%__p_%'`
18761 echo $ac_n "checking for ctype.h""... $ac_c" 1>&6
18762 echo "configure:18763: checking for ctype.h" >&5
18763 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
18764   echo $ac_n "(cached) $ac_c" 1>&6
18765 else
18766   cat > conftest.$ac_ext <<EOF
18767 #line 18768 "configure"
18768 #include "confdefs.h"
18769 #include <ctype.h>
18770 EOF
18771 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
18772 { (eval echo configure:18773: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
18773 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
18774 if test -z "$ac_err"; then
18775   rm -rf conftest*
18776   eval "ac_cv_header_$ac_safe=yes"
18777 else
18778   echo "$ac_err" >&5
18779   echo "configure: failed program was:" >&5
18780   cat conftest.$ac_ext >&5
18781   rm -rf conftest*
18782   eval "ac_cv_header_$ac_safe=no"
18783 fi
18784 rm -f conftest*
18785 fi
18786 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
18787   echo "$ac_t""yes" 1>&6
18788
18789
18790         ctype_default=yes
18791
18792         echo $ac_n "checking <ctype> for GNU/Linux""... $ac_c" 1>&6
18793 echo "configure:18794: checking <ctype> for GNU/Linux" >&5
18794     cat > conftest.$ac_ext <<EOF
18795 #line 18796 "configure"
18796 #include "confdefs.h"
18797 #include <ctype.h>
18798 int main() {
18799 int
18800     foo (int a)
18801     { return _ISspace + _ISprint + _IScntrl + _ISupper + _ISlower + _ISalpha \
18802         + _ISdigit + _ISpunct + _ISxdigit + _ISalnum + _ISgraph \
18803         + __ctype_tolower[a] + __ctype_toupper[a] + __ctype_b[a];}
18804 ; return 0; }
18805 EOF
18806 if { (eval echo configure:18807: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18807   rm -rf conftest*
18808   \
18809     ctype_linux=yes
18810 else
18811   echo "configure: failed program was:" >&5
18812   cat conftest.$ac_ext >&5
18813   rm -rf conftest*
18814   ctype_linux=no
18815 fi
18816 rm -f conftest*
18817     echo "$ac_t""$ctype_linux" 1>&6
18818     if test $ctype_linux = "yes"; then
18819       ctype_include_dir="config/os/gnu-linux"
18820       ctype_default=no
18821     fi
18822
18823         if test $ctype_default = "yes"; then
18824     echo $ac_n "checking <ctype> for FreeBSD 4.0""... $ac_c" 1>&6
18825 echo "configure:18826: checking <ctype> for FreeBSD 4.0" >&5
18826     cat > conftest.$ac_ext <<EOF
18827 #line 18828 "configure"
18828 #include "confdefs.h"
18829 #include <ctype.h>
18830 int main() {
18831 int
18832     foo (int a)
18833     { return _CTYPE_S + _CTYPE_R + _CTYPE_C + _CTYPE_U + _CTYPE_L + _CTYPE_A \
18834         + _CTYPE_D + _CTYPE_P + _CTYPE_X + _CTYPE_G ;}
18835 ; return 0; }
18836 EOF
18837 if { (eval echo configure:18838: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18838   rm -rf conftest*
18839   \
18840     ctype_bsd=yes
18841 else
18842   echo "configure: failed program was:" >&5
18843   cat conftest.$ac_ext >&5
18844   rm -rf conftest*
18845   ctype_bsd=no
18846 fi
18847 rm -f conftest*
18848     echo "$ac_t""$ctype_bsd" 1>&6
18849     if test $ctype_bsd = "yes"; then
18850       ctype_include_dir="config/os/bsd/freebsd"
18851       ctype_default=no
18852     fi
18853     fi
18854
18855         if test $ctype_default = "yes"; then
18856     echo $ac_n "checking <ctype> for FreeBSD 3.4""... $ac_c" 1>&6
18857 echo "configure:18858: checking <ctype> for FreeBSD 3.4" >&5
18858     cat > conftest.$ac_ext <<EOF
18859 #line 18860 "configure"
18860 #include "confdefs.h"
18861 #include <ctype.h>
18862 int main() {
18863 int
18864     foo (int a)
18865     { return _S + _R + _C + _U + _L + _A \
18866       + _D + _P + _X + _G + __istype (a, 0);}
18867 ; return 0; }
18868 EOF
18869 if { (eval echo configure:18870: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18870   rm -rf conftest*
18871   \
18872     ctype_freebsd34=yes
18873 else
18874   echo "configure: failed program was:" >&5
18875   cat conftest.$ac_ext >&5
18876   rm -rf conftest*
18877   ctype_freebsd34=no
18878 fi
18879 rm -f conftest*
18880     echo "$ac_t""$ctype_freebsd34" 1>&6
18881     if test $ctype_freebsd34 = "yes"; then
18882       ctype_include_dir="config/os/bsd/freebsd"
18883       ctype_default=no
18884     fi
18885     fi
18886
18887         if test $ctype_default = "yes"; then
18888     echo $ac_n "checking <ctype> for NetBSD""... $ac_c" 1>&6
18889 echo "configure:18890: checking <ctype> for NetBSD" >&5
18890     cat > conftest.$ac_ext <<EOF
18891 #line 18892 "configure"
18892 #include "confdefs.h"
18893 #include <ctype.h>
18894 int main() {
18895 int
18896     foo (int a)
18897     { return _S + _C + _U + _L \
18898       + _N + _P + _X + _tolower_tab_[a] + _toupper_tab_[a];}
18899 ; return 0; }
18900 EOF
18901 if { (eval echo configure:18902: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18902   rm -rf conftest*
18903   \
18904     ctype_netbsd=yes
18905 else
18906   echo "configure: failed program was:" >&5
18907   cat conftest.$ac_ext >&5
18908   rm -rf conftest*
18909   ctype_netbsd=no
18910 fi
18911 rm -f conftest*
18912     echo "$ac_t""$ctype_netbsd" 1>&6
18913     if test $ctype_netbsd = "yes"; then
18914       ctype_include_dir="config/os/bsd/netbsd"
18915       ctype_default=no
18916     fi
18917     fi
18918
18919         if test $ctype_default = "yes"; then
18920     echo $ac_n "checking <ctype> for Solaris 2.6,7,8""... $ac_c" 1>&6
18921 echo "configure:18922: checking <ctype> for Solaris 2.6,7,8" >&5
18922     cat > conftest.$ac_ext <<EOF
18923 #line 18924 "configure"
18924 #include "confdefs.h"
18925 #include <ctype.h>
18926 int main() {
18927 int
18928     foo (int a)
18929     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
18930         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
18931         + __trans_lower[a] + __trans_upper[a] + __ctype_mask[a];}
18932 ; return 0; }
18933 EOF
18934 if { (eval echo configure:18935: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18935   rm -rf conftest*
18936   \
18937     ctype_solaris=yes
18938 else
18939   echo "configure: failed program was:" >&5
18940   cat conftest.$ac_ext >&5
18941   rm -rf conftest*
18942   ctype_solaris=no
18943 fi
18944 rm -f conftest*
18945     echo "$ac_t""$ctype_solaris" 1>&6
18946
18947     if test $ctype_solaris = "yes"; then
18948       echo $ac_n "checking   for version""... $ac_c" 1>&6
18949 echo "configure:18950: checking   for version" >&5
18950       ac_ext=C
18951 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18952 ac_cpp='$CXXCPP $CPPFLAGS'
18953 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18954 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18955 cross_compiling=$ac_cv_prog_cxx_cross
18956
18957       cat > conftest.$ac_ext <<EOF
18958 #line 18959 "configure"
18959 #include "confdefs.h"
18960 #include <ctype.h>
18961 int main() {
18962 typedef long* __to_type; __to_type const& _M_toupper = __trans_upper;
18963 ; return 0; }
18964 EOF
18965 if { (eval echo configure:18966: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
18966   rm -rf conftest*
18967   \
18968       ctype_solaris26=yes
18969 else
18970   echo "configure: failed program was:" >&5
18971   cat conftest.$ac_ext >&5
18972   rm -rf conftest*
18973   ctype_solaris26=no
18974 fi
18975 rm -f conftest*
18976       ac_ext=c
18977 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
18978 ac_cpp='$CPP $CPPFLAGS'
18979 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
18980 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
18981 cross_compiling=$ac_cv_prog_cc_cross
18982
18983       if test $ctype_solaris26 = "yes"; then
18984         ctype_include_dir="config/os/solaris/solaris2.6"
18985         echo "$ac_t""Solaris 2.6" 1>&6
18986         ctype_default=no
18987       else
18988         ctype_include_dir="config/os/solaris/solaris2.7"
18989         echo "$ac_t""Solaris 7,8" 1>&6
18990         ctype_default=no
18991       fi
18992     fi
18993     fi
18994
18995         if test $ctype_default = "yes"; then
18996     echo $ac_n "checking <ctype> for Solaris 2.5.1""... $ac_c" 1>&6
18997 echo "configure:18998: checking <ctype> for Solaris 2.5.1" >&5
18998     cat > conftest.$ac_ext <<EOF
18999 #line 19000 "configure"
19000 #include "confdefs.h"
19001 #include <ctype.h>
19002 int main() {
19003 int
19004     foo (int a)
19005     { return _U + _L + _N + _S + _P + _C + _X + _B \
19006         + __ctype[a];}
19007 ; return 0; }
19008 EOF
19009 if { (eval echo configure:19010: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19010   rm -rf conftest*
19011   \
19012     ctype_solaris25=yes
19013 else
19014   echo "configure: failed program was:" >&5
19015   cat conftest.$ac_ext >&5
19016   rm -rf conftest*
19017   ctype_solaris25=no
19018 fi
19019 rm -f conftest*
19020     echo "$ac_t""$ctype_solaris25" 1>&6
19021     if test $ctype_solaris25 = "yes"; then
19022       ctype_include_dir="config/os/solaris/solaris2.5"
19023       ctype_default=no
19024     fi
19025     fi
19026
19027         if test $ctype_default = "yes"; then
19028     echo $ac_n "checking <ctype> for AIX""... $ac_c" 1>&6
19029 echo "configure:19030: checking <ctype> for AIX" >&5
19030     cat > conftest.$ac_ext <<EOF
19031 #line 19032 "configure"
19032 #include "confdefs.h"
19033 #include <ctype.h>
19034 int main() {
19035 int
19036     foo (int a)
19037     { return _ISSPACE + _ISPRINT + _ISCNTRL + _ISUPPER + _ISLOWER + _ISALPHA \
19038         + _ISDIGIT + _ISPUNCT + _ISXDIGIT + _ISALNUM + _ISGRAPH \
19039         + _VALC('a') + _IS('c', 0);}
19040 ; return 0; }
19041 EOF
19042 if { (eval echo configure:19043: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19043   rm -rf conftest*
19044   \
19045     ctype_aix=yes
19046 else
19047   echo "configure: failed program was:" >&5
19048   cat conftest.$ac_ext >&5
19049   rm -rf conftest*
19050   ctype_aix=no
19051 fi
19052 rm -f conftest*
19053     echo "$ac_t""$ctype_aix" 1>&6
19054     if test $ctype_aix = "yes"; then
19055       ctype_include_dir="config/os/aix"
19056       ctype_default=no
19057     fi
19058     fi
19059
19060         if test $ctype_default = "yes"; then
19061     echo $ac_n "checking <ctype> for IRIX""... $ac_c" 1>&6
19062 echo "configure:19063: checking <ctype> for IRIX" >&5
19063     cat > conftest.$ac_ext <<EOF
19064 #line 19065 "configure"
19065 #include "confdefs.h"
19066 #include <ctype.h>
19067 int main() {
19068 int
19069     foo (int a)
19070     { return _U + _L + _N + _S + _P + _C + _B + _X + \
19071              _A + _PR + _G + _BL;}
19072 ; return 0; }
19073 EOF
19074 if { (eval echo configure:19075: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19075   rm -rf conftest*
19076   \
19077     ctype_irix=yes
19078 else
19079   echo "configure: failed program was:" >&5
19080   cat conftest.$ac_ext >&5
19081   rm -rf conftest*
19082   ctype_irix=no
19083 fi
19084 rm -f conftest*
19085     echo "$ac_t""$ctype_irix" 1>&6
19086     if test $ctype_irix = "yes"; then
19087       ctype_include_dir="config/os/irix"
19088       ctype_default=no
19089     fi
19090     fi
19091
19092         if test $ctype_default = "yes"; then
19093     echo $ac_n "checking <ctype> for newlib""... $ac_c" 1>&6
19094 echo "configure:19095: checking <ctype> for newlib" >&5
19095     cat > conftest.$ac_ext <<EOF
19096 #line 19097 "configure"
19097 #include "confdefs.h"
19098 #include <ctype.h>
19099 int main() {
19100 int
19101     foo (int a)
19102     { return _U + _L + _N + _S + _P + _C + _X + _B \
19103         + _ctype_[a];}
19104 ; return 0; }
19105 EOF
19106 if { (eval echo configure:19107: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19107   rm -rf conftest*
19108   \
19109     ctype_newlib=yes
19110 else
19111   echo "configure: failed program was:" >&5
19112   cat conftest.$ac_ext >&5
19113   rm -rf conftest*
19114   ctype_newlib=no
19115 fi
19116 rm -f conftest*
19117     echo "$ac_t""$ctype_newlib" 1>&6
19118     if test $ctype_newlib = "yes"; then
19119       ctype_include_dir="config/os/newlib"
19120       ctype_default=no
19121     fi
19122     fi
19123
19124     if test $ctype_default = "yes"; then
19125       ctype_include_dir="config/os/generic"
19126       echo "configure: warning: "Using default ctype headers."" 1>&2
19127     fi
19128
19129 else
19130   echo "$ac_t""no" 1>&6
19131 fi
19132
19133
19134
19135   ac_test_CXXFLAGS="${CXXFLAGS+set}"
19136   ac_save_CXXFLAGS="$CXXFLAGS"
19137   CXXFLAGS='-fno-builtins -D_GNU_SOURCE'
19138
19139   for ac_func in strtof
19140 do
19141 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
19142 echo "configure:19143: checking for $ac_func" >&5
19143 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
19144   echo $ac_n "(cached) $ac_c" 1>&6
19145 else
19146   cat > conftest.$ac_ext <<EOF
19147 #line 19148 "configure"
19148 #include "confdefs.h"
19149 /* System header to define __stub macros and hopefully few prototypes,
19150     which can conflict with char $ac_func(); below.  */
19151 #include <assert.h>
19152 /* Override any gcc2 internal prototype to avoid an error.  */
19153 /* We use char because int might match the return type of a gcc2
19154     builtin and then its argument prototype would still apply.  */
19155 char $ac_func();
19156
19157 int main() {
19158
19159 /* The GNU C library defines this for functions which it implements
19160     to always fail with ENOSYS.  Some functions are actually named
19161     something starting with __ and the normal name is an alias.  */
19162 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
19163 choke me
19164 #else
19165 $ac_func();
19166 #endif
19167
19168 ; return 0; }
19169 EOF
19170 if { (eval echo configure:19171: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
19171   rm -rf conftest*
19172   eval "ac_cv_func_$ac_func=yes"
19173 else
19174   echo "configure: failed program was:" >&5
19175   cat conftest.$ac_ext >&5
19176   rm -rf conftest*
19177   eval "ac_cv_func_$ac_func=no"
19178 fi
19179 rm -f conftest*
19180 fi
19181
19182 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
19183   echo "$ac_t""yes" 1>&6
19184     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
19185   cat >> confdefs.h <<EOF
19186 #define $ac_tr_func 1
19187 EOF
19188
19189 else
19190   echo "$ac_t""no" 1>&6
19191 fi
19192 done
19193
19194
19195   echo $ac_n "checking for strtold declaration""... $ac_c" 1>&6
19196 echo "configure:19197: checking for strtold declaration" >&5
19197   if test x${glibcpp_cv_func_strtold_use+set} != xset; then
19198     if eval "test \"`echo '$''{'glibcpp_cv_func_strtold_use'+set}'`\" = set"; then
19199   echo $ac_n "(cached) $ac_c" 1>&6
19200 else
19201
19202
19203       ac_ext=C
19204 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
19205 ac_cpp='$CXXCPP $CPPFLAGS'
19206 ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
19207 ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
19208 cross_compiling=$ac_cv_prog_cxx_cross
19209
19210       cat > conftest.$ac_ext <<EOF
19211 #line 19212 "configure"
19212 #include "confdefs.h"
19213 #include <stdlib.h>
19214 int main() {
19215  strtold(0, 0);
19216 ; return 0; }
19217 EOF
19218 if { (eval echo configure:19219: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
19219   rm -rf conftest*
19220   glibcpp_cv_func_strtold_use=yes
19221 else
19222   echo "configure: failed program was:" >&5
19223   cat conftest.$ac_ext >&5
19224   rm -rf conftest*
19225   glibcpp_cv_func_strtold_use=no
19226 fi
19227 rm -f conftest*
19228       ac_ext=c
19229 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
19230 ac_cpp='$CPP $CPPFLAGS'
19231 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
19232 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
19233 cross_compiling=$ac_cv_prog_cc_cross
19234
19235
19236 fi
19237
19238   fi
19239   echo "$ac_t""$glibcpp_cv_func_strtold_use" 1>&6
19240   if test x$glibcpp_cv_func_strtold_use = x"yes"; then
19241     for ac_func in strtold
19242 do
19243 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
19244 echo "configure:19245: checking for $ac_func" >&5
19245 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
19246   echo $ac_n "(cached) $ac_c" 1>&6
19247 else
19248   cat > conftest.$ac_ext <<EOF
19249 #line 19250 "configure"
19250 #include "confdefs.h"
19251 /* System header to define __stub macros and hopefully few prototypes,
19252     which can conflict with char $ac_func(); below.  */
19253 #include <assert.h>
19254 /* Override any gcc2 internal prototype to avoid an error.  */
19255 /* We use char because int might match the return type of a gcc2
19256     builtin and then its argument prototype would still apply.  */
19257 char $ac_func();
19258
19259 int main() {
19260
19261 /* The GNU C library defines this for functions which it implements
19262     to always fail with ENOSYS.  Some functions are actually named
19263     something starting with __ and the normal name is an alias.  */
19264 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
19265 choke me
19266 #else
19267 $ac_func();
19268 #endif
19269
19270 ; return 0; }
19271 EOF
19272 if { (eval echo configure:19273: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
19273   rm -rf conftest*
19274   eval "ac_cv_func_$ac_func=yes"
19275 else
19276   echo "configure: failed program was:" >&5
19277   cat conftest.$ac_ext >&5
19278   rm -rf conftest*
19279   eval "ac_cv_func_$ac_func=no"
19280 fi
19281 rm -f conftest*
19282 fi
19283
19284 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
19285   echo "$ac_t""yes" 1>&6
19286     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
19287   cat >> confdefs.h <<EOF
19288 #define $ac_tr_func 1
19289 EOF
19290
19291 else
19292   echo "$ac_t""no" 1>&6
19293 fi
19294 done
19295
19296   fi
19297
19298
19299   CXXFLAGS="$ac_save_CXXFLAGS"
19300
19301
19302   for ac_hdr in unistd.h
19303 do
19304 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
19305 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
19306 echo "configure:19307: checking for $ac_hdr" >&5
19307 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
19308   echo $ac_n "(cached) $ac_c" 1>&6
19309 else
19310   cat > conftest.$ac_ext <<EOF
19311 #line 19312 "configure"
19312 #include "confdefs.h"
19313 #include <$ac_hdr>
19314 EOF
19315 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
19316 { (eval echo configure:19317: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
19317 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
19318 if test -z "$ac_err"; then
19319   rm -rf conftest*
19320   eval "ac_cv_header_$ac_safe=yes"
19321 else
19322   echo "$ac_err" >&5
19323   echo "configure: failed program was:" >&5
19324   cat conftest.$ac_ext >&5
19325   rm -rf conftest*
19326   eval "ac_cv_header_$ac_safe=no"
19327 fi
19328 rm -f conftest*
19329 fi
19330 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
19331   echo "$ac_t""yes" 1>&6
19332     ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
19333   cat >> confdefs.h <<EOF
19334 #define $ac_tr_hdr 1
19335 EOF
19336
19337 else
19338   echo "$ac_t""no" 1>&6
19339 fi
19340 done
19341
19342 for ac_func in getpagesize
19343 do
19344 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
19345 echo "configure:19346: checking for $ac_func" >&5
19346 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
19347   echo $ac_n "(cached) $ac_c" 1>&6
19348 else
19349   cat > conftest.$ac_ext <<EOF
19350 #line 19351 "configure"
19351 #include "confdefs.h"
19352 /* System header to define __stub macros and hopefully few prototypes,
19353     which can conflict with char $ac_func(); below.  */
19354 #include <assert.h>
19355 /* Override any gcc2 internal prototype to avoid an error.  */
19356 /* We use char because int might match the return type of a gcc2
19357     builtin and then its argument prototype would still apply.  */
19358 char $ac_func();
19359
19360 int main() {
19361
19362 /* The GNU C library defines this for functions which it implements
19363     to always fail with ENOSYS.  Some functions are actually named
19364     something starting with __ and the normal name is an alias.  */
19365 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
19366 choke me
19367 #else
19368 $ac_func();
19369 #endif
19370
19371 ; return 0; }
19372 EOF
19373 if { (eval echo configure:19374: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
19374   rm -rf conftest*
19375   eval "ac_cv_func_$ac_func=yes"
19376 else
19377   echo "configure: failed program was:" >&5
19378   cat conftest.$ac_ext >&5
19379   rm -rf conftest*
19380   eval "ac_cv_func_$ac_func=no"
19381 fi
19382 rm -f conftest*
19383 fi
19384
19385 if eval "test \"`echo '$ac_cv_func_'$ac_func`\" = yes"; then
19386   echo "$ac_t""yes" 1>&6
19387     ac_tr_func=HAVE_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
19388   cat >> confdefs.h <<EOF
19389 #define $ac_tr_func 1
19390 EOF
19391
19392 else
19393   echo "$ac_t""no" 1>&6
19394 fi
19395 done
19396
19397 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
19398 echo "configure:19399: checking for working mmap" >&5
19399 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
19400   echo $ac_n "(cached) $ac_c" 1>&6
19401 else
19402   if test "$cross_compiling" = yes; then
19403   ac_cv_func_mmap_fixed_mapped=no
19404 else
19405   cat > conftest.$ac_ext <<EOF
19406 #line 19407 "configure"
19407 #include "confdefs.h"
19408
19409 /* Thanks to Mike Haertel and Jim Avera for this test.
19410    Here is a matrix of mmap possibilities:
19411         mmap private not fixed
19412         mmap private fixed at somewhere currently unmapped
19413         mmap private fixed at somewhere already mapped
19414         mmap shared not fixed
19415         mmap shared fixed at somewhere currently unmapped
19416         mmap shared fixed at somewhere already mapped
19417    For private mappings, we should verify that changes cannot be read()
19418    back from the file, nor mmap's back from the file at a different
19419    address.  (There have been systems where private was not correctly
19420    implemented like the infamous i386 svr4.0, and systems where the
19421    VM page cache was not coherent with the filesystem buffer cache
19422    like early versions of FreeBSD and possibly contemporary NetBSD.)
19423    For shared mappings, we should conversely verify that changes get
19424    propogated back to all the places they're supposed to be.
19425
19426    Grep wants private fixed already mapped.
19427    The main things grep needs to know about mmap are:
19428    * does it exist and is it safe to write into the mmap'd area
19429    * how to use it (BSD variants)  */
19430 #include <sys/types.h>
19431 #include <fcntl.h>
19432 #include <sys/mman.h>
19433
19434 /* This mess was copied from the GNU getpagesize.h.  */
19435 #ifndef HAVE_GETPAGESIZE
19436 # ifdef HAVE_UNISTD_H
19437 #  include <unistd.h>
19438 # endif
19439
19440 /* Assume that all systems that can run configure have sys/param.h.  */
19441 # ifndef HAVE_SYS_PARAM_H
19442 #  define HAVE_SYS_PARAM_H 1
19443 # endif
19444
19445 # ifdef _SC_PAGESIZE
19446 #  define getpagesize() sysconf(_SC_PAGESIZE)
19447 # else /* no _SC_PAGESIZE */
19448 #  ifdef HAVE_SYS_PARAM_H
19449 #   include <sys/param.h>
19450 #   ifdef EXEC_PAGESIZE
19451 #    define getpagesize() EXEC_PAGESIZE
19452 #   else /* no EXEC_PAGESIZE */
19453 #    ifdef NBPG
19454 #     define getpagesize() NBPG * CLSIZE
19455 #     ifndef CLSIZE
19456 #      define CLSIZE 1
19457 #     endif /* no CLSIZE */
19458 #    else /* no NBPG */
19459 #     ifdef NBPC
19460 #      define getpagesize() NBPC
19461 #     else /* no NBPC */
19462 #      ifdef PAGESIZE
19463 #       define getpagesize() PAGESIZE
19464 #      endif /* PAGESIZE */
19465 #     endif /* no NBPC */
19466 #    endif /* no NBPG */
19467 #   endif /* no EXEC_PAGESIZE */
19468 #  else /* no HAVE_SYS_PARAM_H */
19469 #   define getpagesize() 8192   /* punt totally */
19470 #  endif /* no HAVE_SYS_PARAM_H */
19471 # endif /* no _SC_PAGESIZE */
19472
19473 #endif /* no HAVE_GETPAGESIZE */
19474
19475 #ifdef __cplusplus
19476 extern "C" { void *malloc(unsigned); }
19477 #else
19478 char *malloc();
19479 #endif
19480
19481 int
19482 main()
19483 {
19484         char *data, *data2, *data3;
19485         int i, pagesize;
19486         int fd;
19487
19488         pagesize = getpagesize();
19489
19490         /*
19491          * First, make a file with some known garbage in it.
19492          */
19493         data = malloc(pagesize);
19494         if (!data)
19495                 exit(1);
19496         for (i = 0; i < pagesize; ++i)
19497                 *(data + i) = rand();
19498         umask(0);
19499         fd = creat("conftestmmap", 0600);
19500         if (fd < 0)
19501                 exit(1);
19502         if (write(fd, data, pagesize) != pagesize)
19503                 exit(1);
19504         close(fd);
19505
19506         /*
19507          * Next, try to mmap the file at a fixed address which
19508          * already has something else allocated at it.  If we can,
19509          * also make sure that we see the same garbage.
19510          */
19511         fd = open("conftestmmap", O_RDWR);
19512         if (fd < 0)
19513                 exit(1);
19514         data2 = malloc(2 * pagesize);
19515         if (!data2)
19516                 exit(1);
19517         data2 += (pagesize - ((int) data2 & (pagesize - 1))) & (pagesize - 1);
19518         if (data2 != mmap(data2, pagesize, PROT_READ | PROT_WRITE,
19519             MAP_PRIVATE | MAP_FIXED, fd, 0L))
19520                 exit(1);
19521         for (i = 0; i < pagesize; ++i)
19522                 if (*(data + i) != *(data2 + i))
19523                         exit(1);
19524
19525         /*
19526          * Finally, make sure that changes to the mapped area
19527          * do not percolate back to the file as seen by read().
19528          * (This is a bug on some variants of i386 svr4.0.)
19529          */
19530         for (i = 0; i < pagesize; ++i)
19531                 *(data2 + i) = *(data2 + i) + 1;
19532         data3 = malloc(pagesize);
19533         if (!data3)
19534                 exit(1);
19535         if (read(fd, data3, pagesize) != pagesize)
19536                 exit(1);
19537         for (i = 0; i < pagesize; ++i)
19538                 if (*(data + i) != *(data3 + i))
19539                         exit(1);
19540         close(fd);
19541         unlink("conftestmmap");
19542         exit(0);
19543 }
19544
19545 EOF
19546 if { (eval echo configure:19547: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
19547 then
19548   ac_cv_func_mmap_fixed_mapped=yes
19549 else
19550   echo "configure: failed program was:" >&5
19551   cat conftest.$ac_ext >&5
19552   rm -fr conftest*
19553   ac_cv_func_mmap_fixed_mapped=no
19554 fi
19555 rm -fr conftest*
19556 fi
19557
19558 fi
19559
19560 echo "$ac_t""$ac_cv_func_mmap_fixed_mapped" 1>&6
19561 if test $ac_cv_func_mmap_fixed_mapped = yes; then
19562   cat >> confdefs.h <<\EOF
19563 #define HAVE_MMAP 1
19564 EOF
19565
19566 fi
19567
19568 fi
19569
19570 # Now that ctype is determined for all possible targets, we can do this...
19571
19572
19573
19574
19575
19576
19577 if test "$NULL_TARGET" = yes; then
19578   NULL_TARGET_TRUE=
19579   NULL_TARGET_FALSE='#'
19580 else
19581   NULL_TARGET_TRUE='#'
19582   NULL_TARGET_FALSE=
19583 fi
19584
19585
19586 if test "$NATIVE" = yes || test "$NULL_TARGET" = yes; then
19587   NATIVE_TRUE=
19588   NATIVE_FALSE='#'
19589 else
19590   NATIVE_TRUE='#'
19591   NATIVE_FALSE=
19592 fi
19593
19594
19595 if test -z "$with_cross_host"; then
19596   USE_LIBDIR_TRUE=
19597   USE_LIBDIR_FALSE='#'
19598 else
19599   USE_LIBDIR_TRUE='#'
19600   USE_LIBDIR_FALSE=
19601 fi
19602
19603
19604 if test "$CANADIAN" = yes; then
19605   CANADIAN_TRUE=
19606   CANADIAN_FALSE='#'
19607 else
19608   CANADIAN_TRUE='#'
19609   CANADIAN_FALSE=
19610 fi
19611
19612 cat > confcache <<\EOF
19613 # This file is a shell script that caches the results of configure
19614 # tests run on this system so they can be shared between configure
19615 # scripts and configure runs.  It is not useful on other systems.
19616 # If it contains results you don't want to keep, you may remove or edit it.
19617 #
19618 # By default, configure uses ./config.cache as the cache file,
19619 # creating it if it does not exist already.  You can give configure
19620 # the --cache-file=FILE option to use a different cache file; that is
19621 # what configure does when it calls configure scripts in
19622 # subdirectories, so they share the cache.
19623 # Giving --cache-file=/dev/null disables caching, for debugging configure.
19624 # config.status only pays attention to the cache file if you give it the
19625 # --recheck option to rerun configure.
19626 #
19627 EOF
19628 # The following way of writing the cache mishandles newlines in values,
19629 # but we know of no workaround that is simple, portable, and efficient.
19630 # So, don't put newlines in cache variables' values.
19631 # Ultrix sh set writes to stderr and can't be redirected directly,
19632 # and sets the high bit in the cache file unless we assign to the vars.
19633 (set) 2>&1 |
19634   case `(ac_space=' '; set | grep ac_space) 2>&1` in
19635   *ac_space=\ *)
19636     # `set' does not quote correctly, so add quotes (double-quote substitution
19637     # turns \\\\ into \\, and sed turns \\ into \).
19638     sed -n \
19639       -e "s/'/'\\\\''/g" \
19640       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
19641     ;;
19642   *)
19643     # `set' quotes correctly as required by POSIX, so do not add quotes.
19644     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
19645     ;;
19646   esac >> confcache
19647 if cmp -s $cache_file confcache; then
19648   :
19649 else
19650   if test -w $cache_file; then
19651     echo "updating cache $cache_file"
19652     cat confcache > $cache_file
19653   else
19654     echo "not updating unwritable cache $cache_file"
19655   fi
19656 fi
19657 rm -f confcache
19658
19659
19660   ac_safe=`echo "locale.h" | sed 'y%./+-%__p_%'`
19661 echo $ac_n "checking for locale.h""... $ac_c" 1>&6
19662 echo "configure:19663: checking for locale.h" >&5
19663 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
19664   echo $ac_n "(cached) $ac_c" 1>&6
19665 else
19666   cat > conftest.$ac_ext <<EOF
19667 #line 19668 "configure"
19668 #include "confdefs.h"
19669 #include <locale.h>
19670 EOF
19671 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
19672 { (eval echo configure:19673: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
19673 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
19674 if test -z "$ac_err"; then
19675   rm -rf conftest*
19676   eval "ac_cv_header_$ac_safe=yes"
19677 else
19678   echo "$ac_err" >&5
19679   echo "configure: failed program was:" >&5
19680   cat conftest.$ac_ext >&5
19681   rm -rf conftest*
19682   eval "ac_cv_header_$ac_safe=no"
19683 fi
19684 rm -f conftest*
19685 fi
19686 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
19687   echo "$ac_t""yes" 1>&6
19688
19689     echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
19690 echo "configure:19691: checking for LC_MESSAGES" >&5
19691 if eval "test \"`echo '$''{'ac_cv_val_LC_MESSAGES'+set}'`\" = set"; then
19692   echo $ac_n "(cached) $ac_c" 1>&6
19693 else
19694   cat > conftest.$ac_ext <<EOF
19695 #line 19696 "configure"
19696 #include "confdefs.h"
19697 #include <locale.h>
19698 int main() {
19699 return LC_MESSAGES
19700 ; return 0; }
19701 EOF
19702 if { (eval echo configure:19703: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
19703   rm -rf conftest*
19704   ac_cv_val_LC_MESSAGES=yes
19705 else
19706   echo "configure: failed program was:" >&5
19707   cat conftest.$ac_ext >&5
19708   rm -rf conftest*
19709   ac_cv_val_LC_MESSAGES=no
19710 fi
19711 rm -f conftest*
19712 fi
19713
19714 echo "$ac_t""$ac_cv_val_LC_MESSAGES" 1>&6
19715     if test $ac_cv_val_LC_MESSAGES = yes; then
19716       cat >> confdefs.h <<\EOF
19717 #define HAVE_LC_MESSAGES 1
19718 EOF
19719
19720     fi
19721
19722 else
19723   echo "$ac_t""no" 1>&6
19724 fi
19725
19726
19727
19728 if test "${multilib}" = "yes"; then
19729   multilib_arg="--enable-multilib"
19730 else
19731   multilib_arg=
19732 fi
19733
19734
19735 # Generate the various Makefiles, include files, and scripts.
19736
19737 # This helps subvert libstdcxx_interface, as calculated by devo/config.if
19738 # Needed so that g++ can find the correct include subdir automatically.
19739 INTERFACE=v3
19740
19741 # Check for the interface version number for specifying where header
19742 # files are installed, if a version number is provided.
19743 echo $ac_n "checking for interface version number""... $ac_c" 1>&6
19744 echo "configure:19745: checking for interface version number" >&5
19745 libstdcxx_interface=$INTERFACE
19746 echo "$ac_t""$libstdcxx_interface" 1>&6
19747
19748
19749 # Process the option --with-gxx-include-dir=<path to include-files directory>
19750 echo $ac_n "checking for --with-gxx-include-dir""... $ac_c" 1>&6
19751 echo "configure:19752: checking for --with-gxx-include-dir" >&5
19752 # Check whether --with-gxx-include-dir or --without-gxx-include-dir was given.
19753 if test "${with_gxx_include_dir+set}" = set; then
19754   withval="$with_gxx_include_dir"
19755   case "${withval}" in
19756   yes)
19757     { echo "configure: error: Missing directory for --with-gxx-include-dir" 1>&2; exit 1; }
19758     gxx_include_dir=no
19759     ;;
19760   no)
19761     gxx_include_dir=no
19762     ;;
19763   *)
19764     gxx_include_dir=${withval}
19765     ;;
19766 esac
19767 else
19768   gxx_include_dir=no
19769 fi
19770
19771 echo "$ac_t""$gxx_include_dir" 1>&6
19772
19773
19774
19775 if test x${gxx_include_dir} != xno; then
19776   GXX_INCLUDE_DIR_TRUE=
19777   GXX_INCLUDE_DIR_FALSE='#'
19778 else
19779   GXX_INCLUDE_DIR_TRUE='#'
19780   GXX_INCLUDE_DIR_FALSE=
19781 fi
19782
19783 # Process the option "--enable-version-specific-runtime-libs"
19784 echo $ac_n "checking for --enable-version-specific-runtime-libs""... $ac_c" 1>&6
19785 echo "configure:19786: checking for --enable-version-specific-runtime-libs" >&5
19786 # Check whether --enable-version-specific-runtime-libs or --disable-version-specific-runtime-libs was given.
19787 if test "${enable_version_specific_runtime_libs+set}" = set; then
19788   enableval="$enable_version_specific_runtime_libs"
19789     version_specific_libs=yes
19790 # Need the gcc compiler version to know where to install libraries
19791 # and header files if --enable-version-specific-runtime-libs option
19792 # is selected.
19793 gcc_tmp=`grep version_string ${srcdir}/../gcc/version.c | awk '{print $6}'`
19794 gcc_num=`echo ${gcc_tmp} | sed 's/\"//g'`
19795 #gcc_date=`grep version_string ${srcdir}/../gcc/version.c | awk '{print $7}'`
19796 #gcc_version=$gcc_num-$gcc_date
19797 gcc_version=$gcc_num
19798
19799
19800 else
19801   version_specific_libs=no
19802 fi
19803
19804 echo "$ac_t""$version_specific_libs" 1>&6
19805 if test x${version_specific_libs} = xyes; then
19806
19807
19808 if test x${version_specific_libs} = xyes; then
19809   VERSION_SPECIFIC_LIBS_TRUE=
19810   VERSION_SPECIFIC_LIBS_FALSE='#'
19811 else
19812   VERSION_SPECIFIC_LIBS_TRUE='#'
19813   VERSION_SPECIFIC_LIBS_FALSE=
19814 fi
19815   echo "configure: warning: version specific directory is: $gcc_version" 1>&2
19816 fi
19817
19818 # We have to install all the generated or linked includes files
19819 # specified as build_headers in src/Makefile.am in a target-dependent
19820 # place, or else multiple installs for different compilers will
19821 # overwrite these files.
19822 # NB: Keep this and gcc/Makefile.in's -DGPLUSPLUS_TOOL_INCLUDE_DIR in sync.
19823 gxx_target_include_dir='$(exec_prefix)/$(target_alias)/include/g++-$(libstdcxx_interface)'
19824
19825
19826
19827 # Export all the include and flag information to makefiles.
19828
19829   # Root level of the include sources.
19830   GLIBCPP_INCLUDE_DIR='$(top_srcdir)/include'
19831
19832   # Can either use include/c or include/c_std to grab "C" headers. This
19833   # variable is set to the include directory currently in use.
19834   # set with C_INCLUDE_DIR in GLIBCPP_ENABLE_SHADOW
19835
19836   # Passed down for canadian crosses.
19837   if  test x"$CANADIAN" = xyes; then
19838     TOPLEVEL_INCLUDES='-I$(includedir)'
19839   fi
19840
19841   LIBMATH_INCLUDES='-I$(top_srcdir)/libmath'
19842
19843   LIBSUPCXX_INCLUDES='-I$(top_srcdir)/libsupc++'
19844
19845   #if GLIBCPP_NEED_LIBIO
19846   LIBIO_INCLUDES='-I$(top_builddir)/libio -I$(top_srcdir)/libio'
19847   #else
19848   #LIBIO_INCLUDES='-I$(top_srcdir)/libio'
19849   #endif
19850
19851   #if GLIBCPP_USE_CSHADOW
19852   #  CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR) \
19853   #                   -I$(top_blddir)/cshadow'
19854   #else
19855   CSHADOW_INCLUDES='-I$(GLIBCPP_INCLUDE_DIR)/std -I$(C_INCLUDE_DIR)'
19856   #endif
19857
19858   # Now, export this to all the little Makefiles....
19859
19860
19861
19862
19863
19864
19865
19866
19867   # Optimization flags that are probably a good idea for thrill-seekers. Just
19868   # uncomment the lines below and make, everything else is ready to go...
19869   # OPTIMIZE_CXXFLAGS = -O3 -fstrict-aliasing -fvtable-gc
19870   OPTIMIZE_CXXFLAGS=
19871
19872
19873   WARN_FLAGS='-Wall -Wno-format -W -Wwrite-strings -Winline'
19874
19875
19876
19877 # This should be done by mkincludedir, but hack around it now.
19878 blddir=`pwd`
19879 echo "checking for $blddir/include"
19880
19881 if test ! -d "$blddir/include"; then
19882   mkdir "$blddir/include"
19883 fi
19884
19885 # NB: Multilibs need MULTISUBDIR defined correctly in src/Makefile.am
19886 # so that multilib installs will end up installed in the correct
19887 # place. To work around this not being passed down from config-ml.in
19888 # -> top_srcdir/Makefile.am -> top_srcdir/src/Makefile.am, manually
19889 # append it here.
19890 trap '' 1 2 15
19891 cat > confcache <<\EOF
19892 # This file is a shell script that caches the results of configure
19893 # tests run on this system so they can be shared between configure
19894 # scripts and configure runs.  It is not useful on other systems.
19895 # If it contains results you don't want to keep, you may remove or edit it.
19896 #
19897 # By default, configure uses ./config.cache as the cache file,
19898 # creating it if it does not exist already.  You can give configure
19899 # the --cache-file=FILE option to use a different cache file; that is
19900 # what configure does when it calls configure scripts in
19901 # subdirectories, so they share the cache.
19902 # Giving --cache-file=/dev/null disables caching, for debugging configure.
19903 # config.status only pays attention to the cache file if you give it the
19904 # --recheck option to rerun configure.
19905 #
19906 EOF
19907 # The following way of writing the cache mishandles newlines in values,
19908 # but we know of no workaround that is simple, portable, and efficient.
19909 # So, don't put newlines in cache variables' values.
19910 # Ultrix sh set writes to stderr and can't be redirected directly,
19911 # and sets the high bit in the cache file unless we assign to the vars.
19912 (set) 2>&1 |
19913   case `(ac_space=' '; set | grep ac_space) 2>&1` in
19914   *ac_space=\ *)
19915     # `set' does not quote correctly, so add quotes (double-quote substitution
19916     # turns \\\\ into \\, and sed turns \\ into \).
19917     sed -n \
19918       -e "s/'/'\\\\''/g" \
19919       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
19920     ;;
19921   *)
19922     # `set' quotes correctly as required by POSIX, so do not add quotes.
19923     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
19924     ;;
19925   esac >> confcache
19926 if cmp -s $cache_file confcache; then
19927   :
19928 else
19929   if test -w $cache_file; then
19930     echo "updating cache $cache_file"
19931     cat confcache > $cache_file
19932   else
19933     echo "not updating unwritable cache $cache_file"
19934   fi
19935 fi
19936 rm -f confcache
19937
19938 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
19939
19940 test "x$prefix" = xNONE && prefix=$ac_default_prefix
19941 # Let make expand exec_prefix.
19942 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
19943
19944 # Any assignment to VPATH causes Sun make to only execute
19945 # the first set of double-colon rules, so remove it if not needed.
19946 # If there is a colon in the path, we need to keep it.
19947 if test "x$srcdir" = x.; then
19948   ac_vpsub='/^[         ]*VPATH[        ]*=[^:]*$/d'
19949 fi
19950
19951 trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15
19952
19953 DEFS=-DHAVE_CONFIG_H
19954
19955 # Without the "./", some shells look in PATH for config.status.
19956 : ${CONFIG_STATUS=./config.status}
19957
19958 echo creating $CONFIG_STATUS
19959 rm -f $CONFIG_STATUS
19960 cat > $CONFIG_STATUS <<EOF
19961 #! /bin/sh
19962 # Generated automatically by configure.
19963 # Run this file to recreate the current configuration.
19964 # This directory was configured as follows,
19965 # on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
19966 #
19967 # $0 $ac_configure_args
19968 #
19969 # Compiler output produced by configure, useful for debugging
19970 # configure, is in ./config.log if it exists.
19971
19972 ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
19973 for ac_option
19974 do
19975   case "\$ac_option" in
19976   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
19977     echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
19978     exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
19979   -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
19980     echo "$CONFIG_STATUS generated by autoconf version 2.13"
19981     exit 0 ;;
19982   -help | --help | --hel | --he | --h)
19983     echo "\$ac_cs_usage"; exit 0 ;;
19984   *) echo "\$ac_cs_usage"; exit 1 ;;
19985   esac
19986 done
19987
19988 ac_given_srcdir=$srcdir
19989 ac_given_INSTALL="$INSTALL"
19990
19991 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
19992 EOF
19993 cat >> $CONFIG_STATUS <<EOF
19994
19995 # Protect against being on the right side of a sed subst in config.status.
19996 sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
19997  s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
19998 $ac_vpsub
19999 $extrasub
20000 s%@SHELL@%$SHELL%g
20001 s%@CFLAGS@%$CFLAGS%g
20002 s%@CPPFLAGS@%$CPPFLAGS%g
20003 s%@CXXFLAGS@%$CXXFLAGS%g
20004 s%@FFLAGS@%$FFLAGS%g
20005 s%@DEFS@%$DEFS%g
20006 s%@LDFLAGS@%$LDFLAGS%g
20007 s%@LIBS@%$LIBS%g
20008 s%@exec_prefix@%$exec_prefix%g
20009 s%@prefix@%$prefix%g
20010 s%@program_transform_name@%$program_transform_name%g
20011 s%@bindir@%$bindir%g
20012 s%@sbindir@%$sbindir%g
20013 s%@libexecdir@%$libexecdir%g
20014 s%@datadir@%$datadir%g
20015 s%@sysconfdir@%$sysconfdir%g
20016 s%@sharedstatedir@%$sharedstatedir%g
20017 s%@localstatedir@%$localstatedir%g
20018 s%@libdir@%$libdir%g
20019 s%@includedir@%$includedir%g
20020 s%@oldincludedir@%$oldincludedir%g
20021 s%@infodir@%$infodir%g
20022 s%@mandir@%$mandir%g
20023 s%@host@%$host%g
20024 s%@host_alias@%$host_alias%g
20025 s%@host_cpu@%$host_cpu%g
20026 s%@host_vendor@%$host_vendor%g
20027 s%@host_os@%$host_os%g
20028 s%@target@%$target%g
20029 s%@target_alias@%$target_alias%g
20030 s%@target_cpu@%$target_cpu%g
20031 s%@target_vendor@%$target_vendor%g
20032 s%@target_os@%$target_os%g
20033 s%@build@%$build%g
20034 s%@build_alias@%$build_alias%g
20035 s%@build_cpu@%$build_cpu%g
20036 s%@build_vendor@%$build_vendor%g
20037 s%@build_os@%$build_os%g
20038 s%@glibcpp_basedir@%$glibcpp_basedir%g
20039 s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
20040 s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
20041 s%@INSTALL_DATA@%$INSTALL_DATA%g
20042 s%@PACKAGE@%$PACKAGE%g
20043 s%@VERSION@%$VERSION%g
20044 s%@ACLOCAL@%$ACLOCAL%g
20045 s%@AUTOCONF@%$AUTOCONF%g
20046 s%@AUTOMAKE@%$AUTOMAKE%g
20047 s%@AUTOHEADER@%$AUTOHEADER%g
20048 s%@MAKEINFO@%$MAKEINFO%g
20049 s%@SET_MAKE@%$SET_MAKE%g
20050 s%@CC@%$CC%g
20051 s%@CXX_libstdcxx@%$CXX_libstdcxx%g
20052 s%@CXX@%$CXX%g
20053 s%@AS@%$AS%g
20054 s%@AR@%$AR%g
20055 s%@RANLIB@%$RANLIB%g
20056 s%@MAINTAINER_MODE_TRUE@%$MAINTAINER_MODE_TRUE%g
20057 s%@MAINTAINER_MODE_FALSE@%$MAINTAINER_MODE_FALSE%g
20058 s%@MAINT@%$MAINT%g
20059 s%@EXEEXT@%$EXEEXT%g
20060 s%@GLIBCPP_CFLAGS@%$GLIBCPP_CFLAGS%g
20061 s%@GLIBCPP_CXXFLAGS@%$GLIBCPP_CXXFLAGS%g
20062 s%@LN_S@%$LN_S%g
20063 s%@OBJEXT@%$OBJEXT%g
20064 s%@STRIP@%$STRIP%g
20065 s%@LIBTOOL@%$LIBTOOL%g
20066 s%@CXXCPP@%$CXXCPP%g
20067 s%@enable_shared@%$enable_shared%g
20068 s%@enable_static@%$enable_static%g
20069 s%@ifGNUmake@%$ifGNUmake%g
20070 s%@DEBUG_FLAGS@%$DEBUG_FLAGS%g
20071 s%@CPP@%$CPP%g
20072 s%@GLIBCPP_BUILD_LIBIO_TRUE@%$GLIBCPP_BUILD_LIBIO_TRUE%g
20073 s%@GLIBCPP_BUILD_LIBIO_FALSE@%$GLIBCPP_BUILD_LIBIO_FALSE%g
20074 s%@GLIBCPP_NEED_LIBIO_TRUE@%$GLIBCPP_NEED_LIBIO_TRUE%g
20075 s%@GLIBCPP_NEED_LIBIO_FALSE@%$GLIBCPP_NEED_LIBIO_FALSE%g
20076 s%@GLIBCPP_NEED_WLIBIO_TRUE@%$GLIBCPP_NEED_WLIBIO_TRUE%g
20077 s%@GLIBCPP_NEED_WLIBIO_FALSE@%$GLIBCPP_NEED_WLIBIO_FALSE%g
20078 s%@libio_la@%$libio_la%g
20079 s%@CSHADOW_FLAGS@%$CSHADOW_FLAGS%g
20080 s%@C_INCLUDE_DIR@%$C_INCLUDE_DIR%g
20081 s%@GLIBCPP_USE_CSHADOW_TRUE@%$GLIBCPP_USE_CSHADOW_TRUE%g
20082 s%@GLIBCPP_USE_CSHADOW_FALSE@%$GLIBCPP_USE_CSHADOW_FALSE%g
20083 s%@EXTRA_CXX_FLAGS@%$EXTRA_CXX_FLAGS%g
20084 s%@WFMT_FLAGS@%$WFMT_FLAGS%g
20085 s%@SECTION_FLAGS@%$SECTION_FLAGS%g
20086 s%@SECTION_LDFLAGS@%$SECTION_LDFLAGS%g
20087 s%@OPT_LDFLAGS@%$OPT_LDFLAGS%g
20088 s%@LIBMATHOBJS@%$LIBMATHOBJS%g
20089 s%@USE_COMPLEX_LONG_DOUBLE@%$USE_COMPLEX_LONG_DOUBLE%g
20090 s%@libinst_wstring_la@%$libinst_wstring_la%g
20091 s%@WERROR@%$WERROR%g
20092 s%@NULL_TARGET_TRUE@%$NULL_TARGET_TRUE%g
20093 s%@NULL_TARGET_FALSE@%$NULL_TARGET_FALSE%g
20094 s%@NATIVE_TRUE@%$NATIVE_TRUE%g
20095 s%@NATIVE_FALSE@%$NATIVE_FALSE%g
20096 s%@USE_LIBDIR_TRUE@%$USE_LIBDIR_TRUE%g
20097 s%@USE_LIBDIR_FALSE@%$USE_LIBDIR_FALSE%g
20098 s%@CANADIAN_TRUE@%$CANADIAN_TRUE%g
20099 s%@CANADIAN_FALSE@%$CANADIAN_FALSE%g
20100 s%@libstdcxx_interface@%$libstdcxx_interface%g
20101 s%@gxx_include_dir@%$gxx_include_dir%g
20102 s%@GXX_INCLUDE_DIR_TRUE@%$GXX_INCLUDE_DIR_TRUE%g
20103 s%@GXX_INCLUDE_DIR_FALSE@%$GXX_INCLUDE_DIR_FALSE%g
20104 s%@gcc_version@%$gcc_version%g
20105 s%@VERSION_SPECIFIC_LIBS_TRUE@%$VERSION_SPECIFIC_LIBS_TRUE%g
20106 s%@VERSION_SPECIFIC_LIBS_FALSE@%$VERSION_SPECIFIC_LIBS_FALSE%g
20107 s%@gxx_target_include_dir@%$gxx_target_include_dir%g
20108 s%@GLIBCPP_INCLUDE_DIR@%$GLIBCPP_INCLUDE_DIR%g
20109 s%@TOPLEVEL_INCLUDES@%$TOPLEVEL_INCLUDES%g
20110 s%@LIBMATH_INCLUDES@%$LIBMATH_INCLUDES%g
20111 s%@LIBSUPCXX_INCLUDES@%$LIBSUPCXX_INCLUDES%g
20112 s%@LIBIO_INCLUDES@%$LIBIO_INCLUDES%g
20113 s%@CSHADOW_INCLUDES@%$CSHADOW_INCLUDES%g
20114 s%@OPTIMIZE_CXXFLAGS@%$OPTIMIZE_CXXFLAGS%g
20115 s%@WARN_FLAGS@%$WARN_FLAGS%g
20116
20117 CEOF
20118 EOF
20119
20120 cat >> $CONFIG_STATUS <<\EOF
20121
20122 # Split the substitutions into bite-sized pieces for seds with
20123 # small command number limits, like on Digital OSF/1 and HP-UX.
20124 ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
20125 ac_file=1 # Number of current file.
20126 ac_beg=1 # First line for current file.
20127 ac_end=$ac_max_sed_cmds # Line after last line for current file.
20128 ac_more_lines=:
20129 ac_sed_cmds=""
20130 while $ac_more_lines; do
20131   if test $ac_beg -gt 1; then
20132     sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
20133   else
20134     sed "${ac_end}q" conftest.subs > conftest.s$ac_file
20135   fi
20136   if test ! -s conftest.s$ac_file; then
20137     ac_more_lines=false
20138     rm -f conftest.s$ac_file
20139   else
20140     if test -z "$ac_sed_cmds"; then
20141       ac_sed_cmds="sed -f conftest.s$ac_file"
20142     else
20143       ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
20144     fi
20145     ac_file=`expr $ac_file + 1`
20146     ac_beg=$ac_end
20147     ac_end=`expr $ac_end + $ac_max_sed_cmds`
20148   fi
20149 done
20150 if test -z "$ac_sed_cmds"; then
20151   ac_sed_cmds=cat
20152 fi
20153 EOF
20154
20155 cat >> $CONFIG_STATUS <<EOF
20156
20157 CONFIG_FILES=\${CONFIG_FILES-"tests_flags mkcheck Makefile src/Makefile libmath/Makefile libio/Makefile libsupc++/Makefile"}
20158 EOF
20159 cat >> $CONFIG_STATUS <<\EOF
20160 for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
20161   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
20162   case "$ac_file" in
20163   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
20164        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
20165   *) ac_file_in="${ac_file}.in" ;;
20166   esac
20167
20168   # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.
20169
20170   # Remove last slash and all that follows it.  Not all systems have dirname.
20171   ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
20172   if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
20173     # The file is in a subdirectory.
20174     test ! -d "$ac_dir" && mkdir "$ac_dir"
20175     ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
20176     # A "../" for each directory in $ac_dir_suffix.
20177     ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
20178   else
20179     ac_dir_suffix= ac_dots=
20180   fi
20181
20182   case "$ac_given_srcdir" in
20183   .)  srcdir=.
20184       if test -z "$ac_dots"; then top_srcdir=.
20185       else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
20186   /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
20187   *) # Relative path.
20188     srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
20189     top_srcdir="$ac_dots$ac_given_srcdir" ;;
20190   esac
20191
20192   case "$ac_given_INSTALL" in
20193   [/$]*) INSTALL="$ac_given_INSTALL" ;;
20194   *) INSTALL="$ac_dots$ac_given_INSTALL" ;;
20195   esac
20196
20197   echo creating "$ac_file"
20198   rm -f "$ac_file"
20199   configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
20200   case "$ac_file" in
20201   *Makefile*) ac_comsub="1i\\
20202 # $configure_input" ;;
20203   *) ac_comsub= ;;
20204   esac
20205
20206   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
20207   sed -e "$ac_comsub
20208 s%@configure_input@%$configure_input%g
20209 s%@srcdir@%$srcdir%g
20210 s%@top_srcdir@%$top_srcdir%g
20211 s%@INSTALL@%$INSTALL%g
20212 " $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
20213 fi; done
20214 rm -f conftest.s*
20215
20216 # These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
20217 # NAME is the cpp macro being defined and VALUE is the value it is being given.
20218 #
20219 # ac_d sets the value in "#define NAME VALUE" lines.
20220 ac_dA='s%^\([   ]*\)#\([        ]*define[       ][      ]*\)'
20221 ac_dB='\([      ][      ]*\)[^  ]*%\1#\2'
20222 ac_dC='\3'
20223 ac_dD='%g'
20224 # ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
20225 ac_uA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
20226 ac_uB='\([      ]\)%\1#\2define\3'
20227 ac_uC=' '
20228 ac_uD='\4%g'
20229 # ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
20230 ac_eA='s%^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
20231 ac_eB='$%\1#\2define\3'
20232 ac_eC=' '
20233 ac_eD='%g'
20234
20235 if test "${CONFIG_HEADERS+set}" != set; then
20236 EOF
20237 cat >> $CONFIG_STATUS <<EOF
20238   CONFIG_HEADERS="config.h"
20239 EOF
20240 cat >> $CONFIG_STATUS <<\EOF
20241 fi
20242 for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then
20243   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
20244   case "$ac_file" in
20245   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
20246        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
20247   *) ac_file_in="${ac_file}.in" ;;
20248   esac
20249
20250   echo creating $ac_file
20251
20252   rm -f conftest.frag conftest.in conftest.out
20253   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
20254   cat $ac_file_inputs > conftest.in
20255
20256 EOF
20257
20258 # Transform confdefs.h into a sed script conftest.vals that substitutes
20259 # the proper values into config.h.in to produce config.h.  And first:
20260 # Protect against being on the right side of a sed subst in config.status.
20261 # Protect against being in an unquoted here document in config.status.
20262 rm -f conftest.vals
20263 cat > conftest.hdr <<\EOF
20264 s/[\\&%]/\\&/g
20265 s%[\\$`]%\\&%g
20266 s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp
20267 s%ac_d%ac_u%gp
20268 s%ac_u%ac_e%gp
20269 EOF
20270 sed -n -f conftest.hdr confdefs.h > conftest.vals
20271 rm -f conftest.hdr
20272
20273 # This sed command replaces #undef with comments.  This is necessary, for
20274 # example, in the case of _POSIX_SOURCE, which is predefined and required
20275 # on some systems where configure will not decide to define it.
20276 cat >> conftest.vals <<\EOF
20277 s%^[    ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */%
20278 EOF
20279
20280 # Break up conftest.vals because some shells have a limit on
20281 # the size of here documents, and old seds have small limits too.
20282
20283 rm -f conftest.tail
20284 while :
20285 do
20286   ac_lines=`grep -c . conftest.vals`
20287   # grep -c gives empty output for an empty file on some AIX systems.
20288   if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
20289   # Write a limited-size here document to conftest.frag.
20290   echo '  cat > conftest.frag <<CEOF' >> $CONFIG_STATUS
20291   sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS
20292   echo 'CEOF
20293   sed -f conftest.frag conftest.in > conftest.out
20294   rm -f conftest.in
20295   mv conftest.out conftest.in
20296 ' >> $CONFIG_STATUS
20297   sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail
20298   rm -f conftest.vals
20299   mv conftest.tail conftest.vals
20300 done
20301 rm -f conftest.vals
20302
20303 cat >> $CONFIG_STATUS <<\EOF
20304   rm -f conftest.frag conftest.h
20305   echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
20306   cat conftest.in >> conftest.h
20307   rm -f conftest.in
20308   if cmp -s $ac_file conftest.h 2>/dev/null; then
20309     echo "$ac_file is unchanged"
20310     rm -f conftest.h
20311   else
20312     # Remove last slash and all that follows it.  Not all systems have dirname.
20313       ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
20314       if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
20315       # The file is in a subdirectory.
20316       test ! -d "$ac_dir" && mkdir "$ac_dir"
20317     fi
20318     rm -f $ac_file
20319     mv conftest.h $ac_file
20320   fi
20321 fi; done
20322
20323 EOF
20324
20325 cat >> $CONFIG_STATUS <<EOF
20326 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"
20327 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 \
20328 include/bits/ctype_base.h \
20329 include/bits/ctype_inline.h \
20330 include/bits/ctype_noninline.h"
20331 EOF
20332
20333 cat >> $CONFIG_STATUS <<\EOF
20334 srcdir=$ac_given_srcdir
20335 while test -n "$ac_sources"; do
20336   set $ac_dests; ac_dest=$1; shift; ac_dests=$*
20337   set $ac_sources; ac_source=$1; shift; ac_sources=$*
20338
20339   echo "linking $srcdir/$ac_source to $ac_dest"
20340
20341   if test ! -r $srcdir/$ac_source; then
20342     { echo "configure: error: $srcdir/$ac_source: File not found" 1>&2; exit 1; }
20343   fi
20344   rm -f $ac_dest
20345
20346   # Make relative symlinks.
20347   # Remove last slash and all that follows it.  Not all systems have dirname.
20348   ac_dest_dir=`echo $ac_dest|sed 's%/[^/][^/]*$%%'`
20349   if test "$ac_dest_dir" != "$ac_dest" && test "$ac_dest_dir" != .; then
20350     # The dest file is in a subdirectory.
20351     test ! -d "$ac_dest_dir" && mkdir "$ac_dest_dir"
20352     ac_dest_dir_suffix="/`echo $ac_dest_dir|sed 's%^\./%%'`"
20353     # A "../" for each directory in $ac_dest_dir_suffix.
20354     ac_dots=`echo $ac_dest_dir_suffix|sed 's%/[^/]*%../%g'`
20355   else
20356     ac_dest_dir_suffix= ac_dots=
20357   fi
20358
20359   case "$srcdir" in
20360   [/$]*) ac_rel_source="$srcdir/$ac_source" ;;
20361   *) ac_rel_source="$ac_dots$srcdir/$ac_source" ;;
20362   esac
20363
20364   # Make a symlink if possible; otherwise try a hard link.
20365   if ln -s $ac_rel_source $ac_dest 2>/dev/null ||
20366     ln $srcdir/$ac_source $ac_dest; then :
20367   else
20368     { echo "configure: error: can not link $ac_dest to $srcdir/$ac_source" 1>&2; exit 1; }
20369   fi
20370 done
20371 EOF
20372 cat >> $CONFIG_STATUS <<EOF
20373
20374 srcdir=${srcdir}
20375 host=${host}
20376 target=${target}
20377 with_multisubdir=${with_multisubdir}
20378 ac_configure_args="${multilib_arg} ${ac_configure_args}"
20379 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
20380 glibcpp_basedir=${glibcpp_basedir}
20381 CC="${CC}"
20382 CXX="${CXX}"
20383
20384 EOF
20385 cat >> $CONFIG_STATUS <<\EOF
20386 test -z "$CONFIG_HEADERS" || echo timestamp > stamp-h
20387 if test -n "$CONFIG_FILES"; then
20388   ac_file=Makefile . ${glibcpp_basedir}/../config-ml.in
20389   grep '^MULTISUBDIR =' Makefile >> src/Makefile
20390 fi
20391 chmod +x tests_flags
20392 chmod +x mkcheck
20393
20394 exit 0
20395 EOF
20396 chmod +x $CONFIG_STATUS
20397 rm -fr confdefs* $ac_clean_files
20398 test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
20399
20400
20401
20402 # Generate bits/c++config.h
20403 # NB: This must be the first generated file as others include it. . .
20404 $srcdir/mkc++config $blddir $srcdir
20405
20406 # Generate bits/std_limits.h and src/limitsMEMBERS.cc
20407 if test ! -f stamp-limits; then
20408   $srcdir/mknumeric_limits $blddir $srcdir $xcompiling
20409   if test ! -f include/bits/std_limits.h; then
20410     echo "mknumeric_limits failed to execute properly: exiting"
20411     exit 1
20412   else
20413     touch stamp-limits
20414   fi
20415 fi
20416
20417
20418 # Sanity checking & User-visible messages.
20419 # Checks down here, otherwise they get scrolled off before
20420 # the user will notice.
20421
20422 # Trying to get more people to read documentation.  Possibly remove
20423 # check and warn all the time. There is no "informational" AC_MSG_
20424 # macro, so these are going to be printed even when --quiet/--silent
20425 # is given.
20426 if test ! -f stamp-sanity-warned; then
20427   touch stamp-sanity-warned
20428   echo ""
20429   echo "Please make certain that you read the installation information here:"
20430   echo "  faster => ${srcdir}/docs/install.html"
20431   echo "  slower => <URL:http://sources.redhat.com/libstdc++/install.html>"
20432   echo ""
20433   echo "and the configuration information here:"
20434   echo "  faster => ${srcdir}/docs/configopts.html"
20435   echo "  slower => <URL:http://sources.redhat.com/libstdc++/configopts.html>"
20436   echo ""
20437   echo "before proceeding with ${_cv_gnu_make_command}."
20438   echo ""
20439 fi