#! /bin/sh

# From configure.in 21-Jul-2000  WEB -- Do not hand-edit!
# Guess values for system-dependent variables and create Makefiles.
# Generated automatically using autoconf version 2.13 
# Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
#
# This configure script is free software; the Free Software Foundation
# gives unlimited permission to copy, distribute and modify it.

# Defaults:
ac_help=
ac_default_prefix=/usr/local
# Any additions from configure.in:

# Initialize some variables set by options.
# The variables have the same names as the options, with
# dashes changed to underlines.
build=NONE
cache_file=./config.cache
exec_prefix=NONE
host=NONE
no_create=
nonopt=NONE
no_recursion=
prefix=NONE
program_prefix=NONE
program_suffix=NONE
program_transform_name=s,x,x,
silent=
site=
srcdir=
target=NONE
verbose=
x_includes=NONE
x_libraries=NONE
bindir='${exec_prefix}/bin'
sbindir='${exec_prefix}/sbin'
libexecdir='${exec_prefix}/libexec'
datadir='${prefix}/share'
sysconfdir='${prefix}/etc'
sharedstatedir='${prefix}/com'
localstatedir='${prefix}/var'
libdir='${exec_prefix}/lib'
includedir='${prefix}/include'
oldincludedir='/usr/include'
infodir='${prefix}/info'
mandir='${prefix}/man'

# Initialize some other variables.
subdirs=
MFLAGS= MAKEFLAGS=
SHELL=${CONFIG_SHELL-/bin/sh}
# Maximum number of lines to put in a shell here document.
ac_max_here_lines=12

ac_prev=
for ac_option
do

  # If the previous option needs an argument, assign it.
  if test -n "$ac_prev"; then
    eval "$ac_prev=\$ac_option"
    ac_prev=
    continue
  fi

  case "$ac_option" in
  -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
  *) ac_optarg= ;;
  esac

  # Accept the important Cygnus configure options, so we can diagnose typos.

  case "$ac_option" in

  -bindir | --bindir | --bindi | --bind | --bin | --bi)
    ac_prev=bindir ;;
  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
    bindir="$ac_optarg" ;;

  -build | --build | --buil | --bui | --bu)
    ac_prev=build ;;
  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
    build="$ac_optarg" ;;

  -cache-file | --cache-file | --cache-fil | --cache-fi \
  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
    ac_prev=cache_file ;;
  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
    cache_file="$ac_optarg" ;;

  -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
    ac_prev=datadir ;;
  -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
  | --da=*)
    datadir="$ac_optarg" ;;

  -disable-* | --disable-*)
    ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
    # Reject names that are not valid shell variable names.
    if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
      { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
    fi
    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
    eval "enable_${ac_feature}=no" ;;

  -enable-* | --enable-*)
    ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
    # Reject names that are not valid shell variable names.
    if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
      { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
    fi
    ac_feature=`echo $ac_feature| sed 's/-/_/g'`
    case "$ac_option" in
      *=*) ;;
      *) ac_optarg=yes ;;
    esac
    eval "enable_${ac_feature}='$ac_optarg'" ;;

  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
  | --exec | --exe | --ex)
    ac_prev=exec_prefix ;;
  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
  | --exec=* | --exe=* | --ex=*)
    exec_prefix="$ac_optarg" ;;

  -gas | --gas | --ga | --g)
    # Obsolete; use --with-gas.
    with_gas=yes ;;

  -help | --help | --hel | --he)
    # Omit some internal or obsolete options to make the list less imposing.
    # This message is too long to be a string in the A/UX 3.1 sh.
    cat << EOF
Usage: configure [options] [host]
Options: [defaults in brackets after descriptions]
Configuration:
  --cache-file=FILE       cache test results in FILE
  --help                  print this message
  --no-create             do not create output files
  --quiet, --silent       do not print \`checking...' messages
  --version               print the version of autoconf that created configure
Directory and file names:
  --prefix=PREFIX         install architecture-independent files in PREFIX
                          [$ac_default_prefix]
  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
                          [same as prefix]
  --bindir=DIR            user executables in DIR [EPREFIX/bin]
  --sbindir=DIR           system admin executables in DIR [EPREFIX/sbin]
  --libexecdir=DIR        program executables in DIR [EPREFIX/libexec]
  --datadir=DIR           read-only architecture-independent data in DIR
                          [PREFIX/share]
  --sysconfdir=DIR        read-only single-machine data in DIR [PREFIX/etc]
  --sharedstatedir=DIR    modifiable architecture-independent data in DIR
                          [PREFIX/com]
  --localstatedir=DIR     modifiable single-machine data in DIR [PREFIX/var]
  --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
  --includedir=DIR        C header files in DIR [PREFIX/include]
  --oldincludedir=DIR     C header files for non-gcc in DIR [/usr/include]
  --infodir=DIR           info documentation in DIR [PREFIX/info]
  --mandir=DIR            man documentation in DIR [PREFIX/man]
  --srcdir=DIR            find the sources in DIR [configure dir or ..]
  --program-prefix=PREFIX prepend PREFIX to installed program names
  --program-suffix=SUFFIX append SUFFIX to installed program names
  --program-transform-name=PROGRAM
                          run sed PROGRAM on installed program names
EOF
    cat << EOF
Host type:
  --build=BUILD           configure for building on BUILD [BUILD=HOST]
  --host=HOST             configure for HOST [guessed]
  --target=TARGET         configure for TARGET [TARGET=HOST]
Features and packages:
  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
  --x-includes=DIR        X include files are in DIR
  --x-libraries=DIR       X library files are in DIR
EOF
    if test -n "$ac_help"; then
      echo "--enable and --with options recognized:$ac_help"
    fi
    exit 0 ;;

  -host | --host | --hos | --ho)
    ac_prev=host ;;
  -host=* | --host=* | --hos=* | --ho=*)
    host="$ac_optarg" ;;

  -includedir | --includedir | --includedi | --included | --include \
  | --includ | --inclu | --incl | --inc)
    ac_prev=includedir ;;
  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
  | --includ=* | --inclu=* | --incl=* | --inc=*)
    includedir="$ac_optarg" ;;

  -infodir | --infodir | --infodi | --infod | --info | --inf)
    ac_prev=infodir ;;
  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
    infodir="$ac_optarg" ;;

  -libdir | --libdir | --libdi | --libd)
    ac_prev=libdir ;;
  -libdir=* | --libdir=* | --libdi=* | --libd=*)
    libdir="$ac_optarg" ;;

  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
  | --libexe | --libex | --libe)
    ac_prev=libexecdir ;;
  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
  | --libexe=* | --libex=* | --libe=*)
    libexecdir="$ac_optarg" ;;

  -localstatedir | --localstatedir | --localstatedi | --localstated \
  | --localstate | --localstat | --localsta | --localst \
  | --locals | --local | --loca | --loc | --lo)
    ac_prev=localstatedir ;;
  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
  | --localstate=* | --localstat=* | --localsta=* | --localst=* \
  | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
    localstatedir="$ac_optarg" ;;

  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
    ac_prev=mandir ;;
  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
    mandir="$ac_optarg" ;;

  -nfp | --nfp | --nf)
    # Obsolete; use --without-fp.
    with_fp=no ;;

  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
  | --no-cr | --no-c)
    no_create=yes ;;

  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
    no_recursion=yes ;;

  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
  | --oldin | --oldi | --old | --ol | --o)
    ac_prev=oldincludedir ;;
  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
    oldincludedir="$ac_optarg" ;;

  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
    ac_prev=prefix ;;
  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
    prefix="$ac_optarg" ;;

  -program-prefix | --program-prefix | --program-prefi | --program-pref \
  | --program-pre | --program-pr | --program-p)
    ac_prev=program_prefix ;;
  -program-prefix=* | --program-prefix=* | --program-prefi=* \
  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
    program_prefix="$ac_optarg" ;;

  -program-suffix | --program-suffix | --program-suffi | --program-suff \
  | --program-suf | --program-su | --program-s)
    ac_prev=program_suffix ;;
  -program-suffix=* | --program-suffix=* | --program-suffi=* \
  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
    program_suffix="$ac_optarg" ;;

  -program-transform-name | --program-transform-name \
  | --program-transform-nam | --program-transform-na \
  | --program-transform-n | --program-transform- \
  | --program-transform | --program-transfor \
  | --program-transfo | --program-transf \
  | --program-trans | --program-tran \
  | --progr-tra | --program-tr | --program-t)
    ac_prev=program_transform_name ;;
  -program-transform-name=* | --program-transform-name=* \
  | --program-transform-nam=* | --program-transform-na=* \
  | --program-transform-n=* | --program-transform-=* \
  | --program-transform=* | --program-transfor=* \
  | --program-transfo=* | --program-transf=* \
  | --program-trans=* | --program-tran=* \
  | --progr-tra=* | --program-tr=* | --program-t=*)
    program_transform_name="$ac_optarg" ;;

  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  | -silent | --silent | --silen | --sile | --sil)
    silent=yes ;;

  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
    ac_prev=sbindir ;;
  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
  | --sbi=* | --sb=*)
    sbindir="$ac_optarg" ;;

  -sharedstatedir | --sharedstatedir | --sharedstatedi \
  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
  | --sharedst | --shareds | --shared | --share | --shar \
  | --sha | --sh)
    ac_prev=sharedstatedir ;;
  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
  | --sha=* | --sh=*)
    sharedstatedir="$ac_optarg" ;;

  -site | --site | --sit)
    ac_prev=site ;;
  -site=* | --site=* | --sit=*)
    site="$ac_optarg" ;;

  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
    ac_prev=srcdir ;;
  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
    srcdir="$ac_optarg" ;;

  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
  | --syscon | --sysco | --sysc | --sys | --sy)
    ac_prev=sysconfdir ;;
  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
    sysconfdir="$ac_optarg" ;;

  -target | --target | --targe | --targ | --tar | --ta | --t)
    ac_prev=target ;;
  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
    target="$ac_optarg" ;;

  -v | -verbose | --verbose | --verbos | --verbo | --verb)
    verbose=yes ;;

  -version | --version | --versio | --versi | --vers)
    echo "configure generated by autoconf version 2.13"
    exit 0 ;;

  -with-* | --with-*)
    ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
    # Reject names that are not valid shell variable names.
    if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
      { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
    fi
    ac_package=`echo $ac_package| sed 's/-/_/g'`
    case "$ac_option" in
      *=*) ;;
      *) ac_optarg=yes ;;
    esac
    eval "with_${ac_package}='$ac_optarg'" ;;

  -without-* | --without-*)
    ac_package=`echo $ac_option|sed -e 's/-*without-//'`
    # Reject names that are not valid shell variable names.
    if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
      { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
    fi
    ac_package=`echo $ac_package| sed 's/-/_/g'`
    eval "with_${ac_package}=no" ;;

  --x)
    # Obsolete; use --with-x.
    with_x=yes ;;

  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
  | --x-incl | --x-inc | --x-in | --x-i)
    ac_prev=x_includes ;;
  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
    x_includes="$ac_optarg" ;;

  -x-libraries | --x-libraries | --x-librarie | --x-librari \
  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
    ac_prev=x_libraries ;;
  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
    x_libraries="$ac_optarg" ;;

  -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; }
    ;;

  *)
    if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
      echo "configure: warning: $ac_option: invalid host type" 1>&2
    fi
    if test "x$nonopt" != xNONE; then
      { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; }
    fi
    nonopt="$ac_option"
    ;;

  esac
done

if test -n "$ac_prev"; then
  { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; }
fi

trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15

# File descriptor usage:
# 0 standard input
# 1 file creation
# 2 errors and warnings
# 3 some systems may open it to /dev/tty
# 4 used on the Kubota Titan
# 6 checking for... messages and results
# 5 compiler messages saved in config.log
if test "$silent" = yes; then
  exec 6>/dev/null
else
  exec 6>&1
fi
exec 5>./config.log

echo "\
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.
" 1>&5

# Strip out --no-create and --no-recursion so they do not pile up.
# Also quote any args containing shell metacharacters.
ac_configure_args=
for ac_arg
do
  case "$ac_arg" in
  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
  | --no-cr | --no-c) ;;
  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
  *" "*|*"	"*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
  ac_configure_args="$ac_configure_args '$ac_arg'" ;;
  *) ac_configure_args="$ac_configure_args $ac_arg" ;;
  esac
done

# NLS nuisances.
# Only set these to C if already set.  These must not be set unconditionally
# because not all systems understand e.g. LANG=C (notably SCO).
# Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
# Non-C LC_CTYPE values break the ctype check.
if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi

# confdefs.h avoids OS command line length limits that DEFS can exceed.
rm -rf conftest* confdefs.h
# AIX cpp loses on an empty file, so make sure it contains at least a newline.
echo > confdefs.h

# A filename unique to this package, relative to the directory that
# configure is in, which we can look for to find out if srcdir is correct.
ac_unique_file=

# Find the source files, if location was not specified.
if test -z "$srcdir"; then
  ac_srcdir_defaulted=yes
  # Try the directory containing this script, then its parent.
  ac_prog=$0
  ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
  test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
  srcdir=$ac_confdir
  if test ! -r $srcdir/$ac_unique_file; then
    srcdir=..
  fi
else
  ac_srcdir_defaulted=no
fi
if test ! -r $srcdir/$ac_unique_file; then
  if test "$ac_srcdir_defaulted" = yes; then
    { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; }
  else
    { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; }
  fi
fi
srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`

# Prefer explicitly selected file to automatically selected ones.
if test -z "$CONFIG_SITE"; then
  if test "x$prefix" != xNONE; then
    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
  else
    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
  fi
fi
for ac_site_file in $CONFIG_SITE; do
  if test -r "$ac_site_file"; then
    echo "loading site script $ac_site_file"
    . "$ac_site_file"
  fi
done

ac_ext=c
# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
ac_cpp='$CPP $CPPFLAGS'
ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
cross_compiling=$ac_cv_prog_cc_cross

ac_exeext=
ac_objext=o
if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
  # Stardent Vistra SVR4 grep lacks -e, says ghazi@caip.rutgers.edu.
  if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
    ac_n= ac_c='
' ac_t='	'
  else
    ac_n=-n ac_c= ac_t=
  fi
else
  ac_n= ac_c='\c' ac_t=
fi

# ----------------------------------------------------------------------
# Prepare environment:
# ----------------------------------------------------------------------

# Anticipate success:
ISOcxx_success=yes

printf "\n=====  Prolog:  =====\n" 1>&6
echo "configure:534: =====  Prolog:  =====" >&5

for ac_prog in $CCC c++ g++ gcc CC cxx cc++ cl
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:541: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_CXX'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$CXX"; then
  ac_cv_prog_CXX="$CXX" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$PATH"
  for ac_dir in $ac_dummy; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_prog_CXX="$ac_prog"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
fi
CXX="$ac_cv_prog_CXX"
if test -n "$CXX"; then
  echo "$ac_t""$CXX" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

test -n "$CXX" && break
done
test -n "$CXX" || CXX="gcc"

echo $ac_n "checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) works""... $ac_c" 1>&6
echo "configure:573: checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) works" >&5

ac_ext=C
# CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
cross_compiling=$ac_cv_prog_cxx_cross

cat > conftest.$ac_ext << EOF

#line 584 "configure"
#include "confdefs.h"

int main(){return(0);}
EOF
if { (eval echo configure:589: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  ac_cv_prog_cxx_works=yes
  # If we can't run a trivial program, we are probably using a cross compiler.
  if (./conftest; exit) 2>/dev/null; then
    ac_cv_prog_cxx_cross=no
  else
    ac_cv_prog_cxx_cross=yes
  fi
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  ac_cv_prog_cxx_works=no
fi
rm -fr conftest*
ac_ext=c
# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
ac_cpp='$CPP $CPPFLAGS'
ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
cross_compiling=$ac_cv_prog_cc_cross

echo "$ac_t""$ac_cv_prog_cxx_works" 1>&6
if test $ac_cv_prog_cxx_works = no; then
  { echo "configure: error: installation or configuration problem: C++ compiler cannot create executables." 1>&2; exit 1; }
fi
echo $ac_n "checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
echo "configure:615: checking whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) is a cross-compiler" >&5
echo "$ac_t""$ac_cv_prog_cxx_cross" 1>&6
cross_compiling=$ac_cv_prog_cxx_cross

echo $ac_n "checking whether we are using GNU C++""... $ac_c" 1>&6
echo "configure:620: checking whether we are using GNU C++" >&5
if eval "test \"`echo '$''{'ac_cv_prog_gxx'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.C <<EOF
#ifdef __GNUC__
  yes;
#endif
EOF
if { ac_try='${CXX-g++} -E conftest.C'; { (eval echo configure:629: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
  ac_cv_prog_gxx=yes
else
  ac_cv_prog_gxx=no
fi
fi

echo "$ac_t""$ac_cv_prog_gxx" 1>&6

if test $ac_cv_prog_gxx = yes; then
  GXX=yes
else
  GXX=
fi

ac_test_CXXFLAGS="${CXXFLAGS+set}"
ac_save_CXXFLAGS="$CXXFLAGS"
CXXFLAGS=
echo $ac_n "checking whether ${CXX-g++} accepts -g""... $ac_c" 1>&6
echo "configure:648: checking whether ${CXX-g++} accepts -g" >&5
if eval "test \"`echo '$''{'ac_cv_prog_cxx_g'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  echo 'void f(){}' > conftest.cc
if test -z "`${CXX-g++} -g -c conftest.cc 2>&1`"; then
  ac_cv_prog_cxx_g=yes
else
  ac_cv_prog_cxx_g=no
fi
rm -f conftest*

fi

echo "$ac_t""$ac_cv_prog_cxx_g" 1>&6
if test "$ac_test_CXXFLAGS" = set; then
  CXXFLAGS="$ac_save_CXXFLAGS"
elif test $ac_cv_prog_cxx_g = yes; then
  if test "$GXX" = yes; then
    CXXFLAGS="-g -O2"
  else
    CXXFLAGS="-g"
  fi
else
  if test "$GXX" = yes; then
    CXXFLAGS="-O2"
  else
    CXXFLAGS=
  fi
fi

#AC_PROG_CXXCPP
ac_ext=C
# CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
cross_compiling=$ac_cv_prog_cxx_cross

# Source file suffix '.C' is deadly to MSVC++:  C compilation results!
ac_ext=cc

# Extract the first word of "cygpath -w", so it can be a program name with args.
set dummy cygpath -w; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:694: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_path_filter'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$path_filter"; then
  ac_cv_prog_path_filter="$path_filter" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$PATH"
  for ac_dir in $ac_dummy; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_prog_path_filter="cygpath -w"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
fi
path_filter="$ac_cv_prog_path_filter"
if test -n "$path_filter"; then
  echo "$ac_t""$path_filter" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

# ----------------------------------------------------------------------
# ISOcxx_INCLUDE(FILE-TO-INCLUDE)
# ----------------------------------------------------------------------

# ----------------------------------------------------------------------
# ISOcxx_TRY_COMPILE(PGM-TO-TRY [, SUCCESS-ACTION [, FAILURE-ACTION]]):
# ----------------------------------------------------------------------

# ----------------------------------------------------------------------
# ISOcxx_TRY_LINK(PGM-TO-TRY [, SUCCESS-ACTION [, FAILURE-ACTION]]):
# ----------------------------------------------------------------------

# ----------------------------------------------------------------------
# ISOcxx_TRY_RUN(PGM-TO-TRY [, SUCCESS-ACTION [, FAILURE-ACTION]])
# ----------------------------------------------------------------------

# ----------------------------------------------------------------------
# ISOcxx_TEST_DEFECT(TEXT_DESCRIPTION,
#                    DEFECT_PRESENCE_SYMBOL,DEFECT_ABSENCE-SYMBOL,
#                    LIST-OF-TESTS-TO-SUCCEED,LIST-OF-TESTS-TO-FAIL):
# ----------------------------------------------------------------------

# ----------------------------------------------------------------------
# ISOcxx_TEST_EXTENSION(TEXT_DESCRIPTION,
#                       EXTENSION_PRESENCE_SYMBOL-SYMBOL,
#                       LIST-OF-TESTS-TO-SUCCEED,LIST-OF-TESTS-TO-FAIL):
# ----------------------------------------------------------------------

# ----------------------------------------------------------------------
# ISOcxx_LOCATE_HDR(HDR-TO-LOCATE, LOCATION, NON-PRIMARY, SECONDARY):
# ----------------------------------------------------------------------

# ----------------------------------------------------------------------
# Confirm a prototypical, correct, program successfully compiles & runs:
# ----------------------------------------------------------------------

printf "\n=====  Insure our tests compile and run:  =====\n" 1>&6
echo "configure:779: =====  Insure our tests compile and run:  =====" >&5

echo $ac_n "checking correct compilation via ok.cc""... $ac_c" 1>&6
echo "configure:782: checking correct compilation via ok.cc" >&5

if test -z "${path_filter}" ; then :
  testpgm=""${testdir}ok.cc""
else
  testpgm="`${path_filter} "${testdir}ok.cc"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 790 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:795: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; } ; then :
  status=ok
else
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
echo "$ac_t""${status}" 1>&6
if test "${status}" != "ok" ; then :
  exit 1;
fi

echo $ac_n "checking correct linking via ok.cc""... $ac_c" 1>&6
echo "configure:816: checking correct linking via ok.cc" >&5

if test -z "${path_filter}" ; then :
  testpgm=""${testdir}ok.cc""
else
  testpgm="`${path_filter} "${testdir}ok.cc"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 824 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:829: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} ; then :
  status=ok
else
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
echo "$ac_t""${status}" 1>&6
if test "${status}" != "ok" ; then :
  exit 2;
fi

echo $ac_n "checking correct execution via ok.cc""... $ac_c" 1>&6
echo "configure:850: checking correct execution via ok.cc" >&5

if test -z "${path_filter}" ; then :
  testpgm=""${testdir}ok.cc""
else
  testpgm="`${path_filter} "${testdir}ok.cc"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 858 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:863: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=ok
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
echo "$ac_t""${status}" 1>&6
if test "${status}" != "ok" ; then :
  exit 3;
fi

# ----------------------------------------------------------------------
# Begin seeking compiler extensions:
# ----------------------------------------------------------------------

printf "\n=====  Probe for compiler extensions:  =====\n" 1>&6
echo "configure:892: =====  Probe for compiler extensions:  =====" >&5

# ----------------------------------------------------------------------
# Do we support the (nonstandard) #include_next directive?
# ----------------------------------------------------------------------

pound="#"
  status=ok
  t=0
  # try tests that ought to succeed if extension is supported:
      for T in incnext.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking (nonstandard) ${pound}include_next directive via ${T}""... $ac_c" 1>&6
echo "configure:906: checking (nonstandard) ${pound}include_next directive via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 915 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:920: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status="unsupported; ok"
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail if extension is supported:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define EXTENSION_INCLUDE_NEXT 1
EOF
 EXTENSION_INCLUDE_NEXT=@@; echo "==>  EXTENSION_INCLUDE_NEXT" >&5
  else
    echo "==>  ${status}" >&5
  fi

lquote='"'
rquote='"'

# ----------------------------------------------------------------------
# Do we support the (nonstandard) include_alias pragma?
# ----------------------------------------------------------------------

pound="#"
  status=ok
  t=0
  # try tests that ought to succeed if extension is supported:
      for T in incalias.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking ${pound}pragma include_alias via ${T}""... $ac_c" 1>&6
echo "configure:968: checking ${pound}pragma include_alias via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 977 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:982: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status="unsupported; ok"
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail if extension is supported:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define EXTENSION_INCLUDE_ALIAS 1
EOF
 EXTENSION_INCLUDE_ALIAS=@@; echo "==>  EXTENSION_INCLUDE_ALIAS" >&5
  else
    echo "==>  ${status}" >&5
  fi

lquote='"'
rquote='"'

# ----------------------------------------------------------------------
# Do we support the (nonstandard) long long int type?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed if extension is supported:
      for T in ll.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking (nonstandard) long long int via ${T}""... $ac_c" 1>&6
echo "configure:1029: checking (nonstandard) long long int via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1038 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1043: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status="unsupported; ok"
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail if extension is supported:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define EXTENSION_LONG_LONG 1
EOF
 EXTENSION_LONG_LONG=@@; echo "==>  EXTENSION_LONG_LONG" >&5
  else
    echo "==>  ${status}" >&5
  fi

# ----------------------------------------------------------------------
# Begin seeking compiler defects:
# ----------------------------------------------------------------------

printf "\n=====  Probe for compiler defects:  =====\n" 1>&6
echo "configure:1083: =====  Probe for compiler defects:  =====" >&5

# ----------------------------------------------------------------------
# Test 'bool' and related keywords:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in bool.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking 'bool' and related keywords via ${T}""... $ac_c" 1>&6
echo "configure:1096: checking 'bool' and related keywords via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1105 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1110: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_BOOL 1
EOF
 ISOcxx_HAS_BOOL=@@; echo "==>  ISOcxx_HAS_BOOL" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_BOOL ${t}
EOF
 DEFECT_NO_BOOL=@${t}@; echo "==>  DEFECT_NO_BOOL = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_BOOL"
    status=cured
          for T in bool.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for 'bool' and related keywords defect via ${T}""... $ac_c" 1>&6
echo "configure:1152: checking cure for 'bool' and related keywords defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1160 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1165: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_BOOL"
    fi
  fi

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in booluniq.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking whether 'bool' is a distinct type via ${T}""... $ac_c" 1>&6
echo "configure:1199: checking whether 'bool' is a distinct type via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1208 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1213: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_BOOL_IS_DISTINCT_TYPE 1
EOF
 ISOcxx_BOOL_IS_DISTINCT_TYPE=@@; echo "==>  ISOcxx_BOOL_IS_DISTINCT_TYPE" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_BOOL_NOT_DISTINCT_TYPE ${t}
EOF
 DEFECT_BOOL_NOT_DISTINCT_TYPE=@${t}@; echo "==>  DEFECT_BOOL_NOT_DISTINCT_TYPE = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_BOOL_NOT_DISTINCT_TYPE"
    status=cured
          for T in booluniq.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for whether 'bool' is a distinct type defect via ${T}""... $ac_c" 1>&6
echo "configure:1255: checking cure for whether 'bool' is a distinct type defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1263 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1268: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_BOOL_NOT_DISTINCT_TYPE"
    fi
  fi

# ----------------------------------------------------------------------
# Test operands 2/3 in a conditional expression:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in conditnl.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking operands 2 & 3 in a conditional expression via ${T}""... $ac_c" 1>&6
echo "configure:1307: checking operands 2 & 3 in a conditional expression via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1316 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1321: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_CONDITIONAL 1
EOF
 ISOcxx_CONDITIONAL=@@; echo "==>  ISOcxx_CONDITIONAL" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_CONDITIONAL ${t}
EOF
 DEFECT_CONDITIONAL=@${t}@; echo "==>  DEFECT_CONDITIONAL = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_CONDITIONAL"
    status=cured
          for T in conditnl.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for operands 2 & 3 in a conditional expression defect via ${T}""... $ac_c" 1>&6
echo "configure:1363: checking cure for operands 2 & 3 in a conditional expression defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1371 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1376: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_CONDITIONAL"
    fi
  fi

# ----------------------------------------------------------------------
# Test 'wchar_t' keyword:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in wchart.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking 'wchar_t' keyword via ${T}""... $ac_c" 1>&6
echo "configure:1415: checking 'wchar_t' keyword via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1424 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1429: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_WCHAR_T 1
EOF
 ISOcxx_HAS_WCHAR_T=@@; echo "==>  ISOcxx_HAS_WCHAR_T" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_WCHAR_T ${t}
EOF
 DEFECT_NO_WCHAR_T=@${t}@; echo "==>  DEFECT_NO_WCHAR_T = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_WCHAR_T"
    status=cured
          for T in wchart.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for 'wchar_t' keyword defect via ${T}""... $ac_c" 1>&6
echo "configure:1471: checking cure for 'wchar_t' keyword defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1479 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1484: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_WCHAR_T"
    fi
  fi

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in wchruniq.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking whether 'wchar_t' is a distinct type via ${T}""... $ac_c" 1>&6
echo "configure:1518: checking whether 'wchar_t' is a distinct type via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1527 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1532: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_WCHAR_T_IS_DISTINCT_TYPE 1
EOF
 ISOcxx_WCHAR_T_IS_DISTINCT_TYPE=@@; echo "==>  ISOcxx_WCHAR_T_IS_DISTINCT_TYPE" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_WCHAR_T_NOT_DISTINCT_TYPE ${t}
EOF
 DEFECT_WCHAR_T_NOT_DISTINCT_TYPE=@${t}@; echo "==>  DEFECT_WCHAR_T_NOT_DISTINCT_TYPE = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_WCHAR_T_NOT_DISTINCT_TYPE"
    status=cured
          for T in wchruniq.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for whether 'wchar_t' is a distinct type defect via ${T}""... $ac_c" 1>&6
echo "configure:1574: checking cure for whether 'wchar_t' is a distinct type defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1582 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1587: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_WCHAR_T_NOT_DISTINCT_TYPE"
    fi
  fi

# ----------------------------------------------------------------------
# Test const_cast<> and static_cast<>:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in casts.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking new-style casts via ${T}""... $ac_c" 1>&6
echo "configure:1626: checking new-style casts via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1635 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1640: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_NEW_STYLE_CASTS 1
EOF
 ISOcxx_NEW_STYLE_CASTS=@@; echo "==>  ISOcxx_NEW_STYLE_CASTS" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_OLD_STYLE_CASTS ${t}
EOF
 DEFECT_OLD_STYLE_CASTS=@${t}@; echo "==>  DEFECT_OLD_STYLE_CASTS = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_OLD_STYLE_CASTS"
    status=cured
          for T in casts.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for new-style casts defect via ${T}""... $ac_c" 1>&6
echo "configure:1682: checking cure for new-style casts defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1690 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1695: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_OLD_STYLE_CASTS"
    fi
  fi

# ----------------------------------------------------------------------
# Test for-scoping:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in forok.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking 'for' scoping via ${T}""... $ac_c" 1>&6
echo "configure:1734: checking 'for' scoping via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1743 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1748: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
      for T in forbad.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking 'for' scoping via ${T}""... $ac_c" 1>&6
echo "configure:1773: checking 'for' scoping via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1782 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1787: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; } ; then :
  status=defective
else
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_NEW_FOR_SCOPING 1
EOF
 ISOcxx_NEW_FOR_SCOPING=@@; echo "==>  ISOcxx_NEW_FOR_SCOPING" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_OLD_FOR_SCOPING ${t}
EOF
 DEFECT_OLD_FOR_SCOPING=@${t}@; echo "==>  DEFECT_OLD_FOR_SCOPING = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_OLD_FOR_SCOPING"
    status=cured
          for T in forok.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for 'for' scoping defect via ${T}""... $ac_c" 1>&6
echo "configure:1823: checking cure for 'for' scoping defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1831 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1836: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
          for T in forbad.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for 'for' scoping defect via ${T}""... $ac_c" 1>&6
echo "configure:1859: checking cure for 'for' scoping defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1867 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1872: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; } ; then :
  status=PROBLEM!
else
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=cured
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_OLD_FOR_SCOPING"
    fi
  fi

# ----------------------------------------------------------------------
# Test keyword 'mutable':
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in mutable.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking 'mutable' keyword via ${T}""... $ac_c" 1>&6
echo "configure:1906: checking 'mutable' keyword via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1915 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1920: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_MUTABLE 1
EOF
 ISOcxx_HAS_MUTABLE=@@; echo "==>  ISOcxx_HAS_MUTABLE" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_MUTABLE ${t}
EOF
 DEFECT_NO_MUTABLE=@${t}@; echo "==>  DEFECT_NO_MUTABLE = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_MUTABLE"
    status=cured
          for T in mutable.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for 'mutable' keyword defect via ${T}""... $ac_c" 1>&6
echo "configure:1962: checking cure for 'mutable' keyword defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 1970 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:1975: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_MUTABLE"
    fi
  fi

# ----------------------------------------------------------------------
# Test keyword 'explicit':
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in explicit.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking 'explicit' keyword via ${T}""... $ac_c" 1>&6
echo "configure:2014: checking 'explicit' keyword via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2023 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2028: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_EXPLICIT 1
EOF
 ISOcxx_HAS_EXPLICIT=@@; echo "==>  ISOcxx_HAS_EXPLICIT" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_EXPLICIT ${t}
EOF
 DEFECT_NO_EXPLICIT=@${t}@; echo "==>  DEFECT_NO_EXPLICIT = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_EXPLICIT"
    status=cured
          for T in explicit.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for 'explicit' keyword defect via ${T}""... $ac_c" 1>&6
echo "configure:2070: checking cure for 'explicit' keyword defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2078 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2083: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_EXPLICIT"
    fi
  fi

# ----------------------------------------------------------------------
# Test 'namespace' and related keywords, etc.:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in nmspace.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking 'namespace' support via ${T}""... $ac_c" 1>&6
echo "configure:2122: checking 'namespace' support via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2131 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2136: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_NAMESPACES 1
EOF
 ISOcxx_HAS_NAMESPACES=@@; echo "==>  ISOcxx_HAS_NAMESPACES" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_NAMESPACES ${t}
EOF
 DEFECT_NO_NAMESPACES=@${t}@; echo "==>  DEFECT_NO_NAMESPACES = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_NAMESPACES"
    status=cured
          for T in nmspace.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for 'namespace' support defect via ${T}""... $ac_c" 1>&6
echo "configure:2178: checking cure for 'namespace' support defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2186 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2191: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_NAMESPACES"
    fi
  fi

# ----------------------------------------------------------------------
# Test 'using namespace' behavior:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in using_ns.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking 'using namespace' behavior via ${T}""... $ac_c" 1>&6
echo "configure:2230: checking 'using namespace' behavior via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2239 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2244: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_USING_NAMESPACE_OVERLOAD 1
EOF
 ISOcxx_USING_NAMESPACE_OVERLOAD=@@; echo "==>  ISOcxx_USING_NAMESPACE_OVERLOAD" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_USING_NAMESPACE_OVERLOAD ${t}
EOF
 DEFECT_USING_NAMESPACE_OVERLOAD=@${t}@; echo "==>  DEFECT_USING_NAMESPACE_OVERLOAD = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_USING_NAMESPACE_OVERLOAD"
    status=cured
          for T in using_ns.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for 'using namespace' behavior defect via ${T}""... $ac_c" 1>&6
echo "configure:2286: checking cure for 'using namespace' behavior defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2294 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2299: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_USING_NAMESPACE_OVERLOAD"
    fi
  fi

# ----------------------------------------------------------------------
# Test member using behavior:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in usingmbr.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking member using behavior via ${T}""... $ac_c" 1>&6
echo "configure:2338: checking member using behavior via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2347 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2352: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_MEMBER_USING 1
EOF
 ISOcxx_OK_MEMBER_USING=@@; echo "==>  ISOcxx_OK_MEMBER_USING" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_MEMBER_USING ${t}
EOF
 DEFECT_NO_MEMBER_USING=@${t}@; echo "==>  DEFECT_NO_MEMBER_USING = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_MEMBER_USING"
    status=cured
          for T in usingmbr.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for member using behavior defect via ${T}""... $ac_c" 1>&6
echo "configure:2394: checking cure for member using behavior defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2402 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2407: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_MEMBER_USING"
    fi
  fi

# ----------------------------------------------------------------------
# Test virtual covariance:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in covary.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking virtual covariance via ${T}""... $ac_c" 1>&6
echo "configure:2446: checking virtual covariance via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2455 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2460: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_VIRTUAL_COVARIANCE 1
EOF
 ISOcxx_HAS_VIRTUAL_COVARIANCE=@@; echo "==>  ISOcxx_HAS_VIRTUAL_COVARIANCE" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_VIRTUAL_COVARIANCE ${t}
EOF
 DEFECT_NO_VIRTUAL_COVARIANCE=@${t}@; echo "==>  DEFECT_NO_VIRTUAL_COVARIANCE = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_VIRTUAL_COVARIANCE"
    status=cured
          for T in covary.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for virtual covariance defect via ${T}""... $ac_c" 1>&6
echo "configure:2502: checking cure for virtual covariance defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2510 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2515: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_VIRTUAL_COVARIANCE"
    fi
  fi

# ----------------------------------------------------------------------
# Do we correctly support nested class names?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in nestcls.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking nested class names via ${T}""... $ac_c" 1>&6
echo "configure:2554: checking nested class names via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2563 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2568: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_NESTED_CLASS_ID 1
EOF
 ISOcxx_NESTED_CLASS_ID=@@; echo "==>  ISOcxx_NESTED_CLASS_ID" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NESTED_CLASS_ID ${t}
EOF
 DEFECT_NESTED_CLASS_ID=@${t}@; echo "==>  DEFECT_NESTED_CLASS_ID = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NESTED_CLASS_ID"
    status=cured
          for T in nestcls.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for nested class names defect via ${T}""... $ac_c" 1>&6
echo "configure:2610: checking cure for nested class names defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2618 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2623: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NESTED_CLASS_ID"
    fi
  fi

# ----------------------------------------------------------------------
# Test 'template' keyword:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in template.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking basic template support via ${T}""... $ac_c" 1>&6
echo "configure:2662: checking basic template support via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2671 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2676: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_TEMPLATES 1
EOF
 ISOcxx_HAS_TEMPLATES=@@; echo "==>  ISOcxx_HAS_TEMPLATES" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_TEMPLATES ${t}
EOF
 DEFECT_NO_TEMPLATES=@${t}@; echo "==>  DEFECT_NO_TEMPLATES = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_TEMPLATES"
    status=cured
          for T in template.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for basic template support defect via ${T}""... $ac_c" 1>&6
echo "configure:2718: checking cure for basic template support defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2726 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2731: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_TEMPLATES"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support default template parameters?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in default.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking default template parameters via ${T}""... $ac_c" 1>&6
echo "configure:2770: checking default template parameters via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2779 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2784: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_DEFAULT_TEMPLATE_PARAMETERS 1
EOF
 ISOcxx_HAS_DEFAULT_TEMPLATE_PARAMETERS=@@; echo "==>  ISOcxx_HAS_DEFAULT_TEMPLATE_PARAMETERS" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_DEFAULT_TEMPLATE_PARAMETERS ${t}
EOF
 DEFECT_NO_DEFAULT_TEMPLATE_PARAMETERS=@${t}@; echo "==>  DEFECT_NO_DEFAULT_TEMPLATE_PARAMETERS = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_DEFAULT_TEMPLATE_PARAMETERS"
    status=cured
          for T in default.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for default template parameters defect via ${T}""... $ac_c" 1>&6
echo "configure:2826: checking cure for default template parameters defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2834 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2839: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_DEFAULT_TEMPLATE_PARAMETERS"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support templates as template parameters?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in tmpltmpl.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking template template parameters via ${T}""... $ac_c" 1>&6
echo "configure:2878: checking template template parameters via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2887 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2892: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_TEMPLATES_AS_TEMPLATE_PARAMETERS 1
EOF
 ISOcxx_HAS_TEMPLATES_AS_TEMPLATE_PARAMETERS=@@; echo "==>  ISOcxx_HAS_TEMPLATES_AS_TEMPLATE_PARAMETERS" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_TEMPLATES_AS_TEMPLATE_PARAMETERS ${t}
EOF
 DEFECT_NO_TEMPLATES_AS_TEMPLATE_PARAMETERS=@${t}@; echo "==>  DEFECT_NO_TEMPLATES_AS_TEMPLATE_PARAMETERS = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_TEMPLATES_AS_TEMPLATE_PARAMETERS"
    status=cured
          for T in tmpltmpl.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for template template parameters defect via ${T}""... $ac_c" 1>&6
echo "configure:2934: checking cure for template template parameters defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2942 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:2947: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_TEMPLATES_AS_TEMPLATE_PARAMETERS"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support template partial specialization?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in partspec.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking partial specialization via ${T}""... $ac_c" 1>&6
echo "configure:2986: checking partial specialization via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 2995 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3000: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_PARTIAL_SPECIALIZATION 1
EOF
 ISOcxx_HAS_PARTIAL_SPECIALIZATION=@@; echo "==>  ISOcxx_HAS_PARTIAL_SPECIALIZATION" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_PARTIAL_SPECIALIZATION ${t}
EOF
 DEFECT_NO_PARTIAL_SPECIALIZATION=@${t}@; echo "==>  DEFECT_NO_PARTIAL_SPECIALIZATION = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_PARTIAL_SPECIALIZATION"
    status=cured
          for T in partspec.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for partial specialization defect via ${T}""... $ac_c" 1>&6
echo "configure:3042: checking cure for partial specialization defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3050 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3055: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_PARTIAL_SPECIALIZATION"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support template methods' specialization?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in methspec.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking method specialization via ${T}""... $ac_c" 1>&6
echo "configure:3094: checking method specialization via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3103 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3108: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_METHOD_SPECIALIZATION 1
EOF
 ISOcxx_HAS_METHOD_SPECIALIZATION=@@; echo "==>  ISOcxx_HAS_METHOD_SPECIALIZATION" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_METHOD_SPECIALIZATION ${t}
EOF
 DEFECT_NO_METHOD_SPECIALIZATION=@${t}@; echo "==>  DEFECT_NO_METHOD_SPECIALIZATION = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_METHOD_SPECIALIZATION"
    status=cured
          for T in methspec.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for method specialization defect via ${T}""... $ac_c" 1>&6
echo "configure:3150: checking cure for method specialization defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3158 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3163: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_METHOD_SPECIALIZATION"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support template functions partial ordering?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in porder.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking partial ordering via ${T}""... $ac_c" 1>&6
echo "configure:3202: checking partial ordering via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3211 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3216: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_FUNCTMPL_PARTIAL_ORDERING 1
EOF
 ISOcxx_HAS_FUNCTMPL_PARTIAL_ORDERING=@@; echo "==>  ISOcxx_HAS_FUNCTMPL_PARTIAL_ORDERING" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_FUNCTMPL_PARTIAL_ORDERING ${t}
EOF
 DEFECT_NO_FUNCTMPL_PARTIAL_ORDERING=@${t}@; echo "==>  DEFECT_NO_FUNCTMPL_PARTIAL_ORDERING = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_FUNCTMPL_PARTIAL_ORDERING"
    status=cured
          for T in porder.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for partial ordering defect via ${T}""... $ac_c" 1>&6
echo "configure:3258: checking cure for partial ordering defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3266 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3271: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_FUNCTMPL_PARTIAL_ORDERING"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support complete (full) template specialization?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in fullspec.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking full specialization via ${T}""... $ac_c" 1>&6
echo "configure:3310: checking full specialization via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3319 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3324: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_FULL_SPECIALIZATION_SYNTAX 1
EOF
 ISOcxx_HAS_FULL_SPECIALIZATION_SYNTAX=@@; echo "==>  ISOcxx_HAS_FULL_SPECIALIZATION_SYNTAX" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_FULL_SPECIALIZATION_SYNTAX ${t}
EOF
 DEFECT_NO_FULL_SPECIALIZATION_SYNTAX=@${t}@; echo "==>  DEFECT_NO_FULL_SPECIALIZATION_SYNTAX = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_FULL_SPECIALIZATION_SYNTAX"
    status=cured
          for T in fullspec.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for full specialization defect via ${T}""... $ac_c" 1>&6
echo "configure:3366: checking cure for full specialization defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3374 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3379: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_FULL_SPECIALIZATION_SYNTAX"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support forward declaration of template member functions?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in membrfwd.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking template member forward declarations via ${T}""... $ac_c" 1>&6
echo "configure:3418: checking template member forward declarations via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3427 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3432: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_TEMPLATE_MEMBER_FWDDECL 1
EOF
 ISOcxx_HAS_TEMPLATE_MEMBER_FWDDECL=@@; echo "==>  ISOcxx_HAS_TEMPLATE_MEMBER_FWDDECL" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_TEMPLATE_MEMBER_FWDDECL ${t}
EOF
 DEFECT_NO_TEMPLATE_MEMBER_FWDDECL=@${t}@; echo "==>  DEFECT_NO_TEMPLATE_MEMBER_FWDDECL = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_TEMPLATE_MEMBER_FWDDECL"
    status=cured
          for T in membrfwd.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for template member forward declarations defect via ${T}""... $ac_c" 1>&6
echo "configure:3474: checking cure for template member forward declarations defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3482 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3487: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_TEMPLATE_MEMBER_FWDDECL"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support forward declaration of member functions of a
# class nested within a templated class?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in nestfwd.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking template member nested forward declarations via ${T}""... $ac_c" 1>&6
echo "configure:3527: checking template member nested forward declarations via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3536 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3541: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_TEMPLATE_NESTEDCLASS_FWDDECL 1
EOF
 ISOcxx_HAS_TEMPLATE_NESTEDCLASS_FWDDECL=@@; echo "==>  ISOcxx_HAS_TEMPLATE_NESTEDCLASS_FWDDECL" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_TEMPLATE_NESTEDCLASS_FWDDECL ${t}
EOF
 DEFECT_NO_TEMPLATE_NESTEDCLASS_FWDDECL=@${t}@; echo "==>  DEFECT_NO_TEMPLATE_NESTEDCLASS_FWDDECL = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_TEMPLATE_NESTEDCLASS_FWDDECL"
    status=cured
          for T in nestfwd.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for template member nested forward declarations defect via ${T}""... $ac_c" 1>&6
echo "configure:3583: checking cure for template member nested forward declarations defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3591 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3596: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_TEMPLATE_NESTEDCLASS_FWDDECL"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support members that are templates?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in tmplmbr.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking member templates via ${T}""... $ac_c" 1>&6
echo "configure:3635: checking member templates via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3644 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3649: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_MEMBER_TEMPLATES 1
EOF
 ISOcxx_HAS_MEMBER_TEMPLATES=@@; echo "==>  ISOcxx_HAS_MEMBER_TEMPLATES" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_MEMBER_TEMPLATES ${t}
EOF
 DEFECT_NO_MEMBER_TEMPLATES=@${t}@; echo "==>  DEFECT_NO_MEMBER_TEMPLATES = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_MEMBER_TEMPLATES"
    status=cured
          for T in tmplmbr.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for member templates defect via ${T}""... $ac_c" 1>&6
echo "configure:3691: checking cure for member templates defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3699 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3704: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_MEMBER_TEMPLATES"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support friends that are templates?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in tmplfrnd.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking friend templates via ${T}""... $ac_c" 1>&6
echo "configure:3743: checking friend templates via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3752 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3757: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_FRIEND_TEMPLATES 1
EOF
 ISOcxx_HAS_FRIEND_TEMPLATES=@@; echo "==>  ISOcxx_HAS_FRIEND_TEMPLATES" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_FRIEND_TEMPLATES ${t}
EOF
 DEFECT_NO_FRIEND_TEMPLATES=@${t}@; echo "==>  DEFECT_NO_FRIEND_TEMPLATES = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_FRIEND_TEMPLATES"
    status=cured
          for T in tmplfrnd.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for friend templates defect via ${T}""... $ac_c" 1>&6
echo "configure:3799: checking cure for friend templates defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3807 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3812: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_FRIEND_TEMPLATES"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support static template members?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in tmplstat.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking static template members via ${T}""... $ac_c" 1>&6
echo "configure:3851: checking static template members via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3860 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3865: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_STATIC_TEMPLATE_DATA 1
EOF
 ISOcxx_HAS_STATIC_TEMPLATE_DATA=@@; echo "==>  ISOcxx_HAS_STATIC_TEMPLATE_DATA" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_STATIC_TEMPLATE_DATA ${t}
EOF
 DEFECT_NO_STATIC_TEMPLATE_DATA=@${t}@; echo "==>  DEFECT_NO_STATIC_TEMPLATE_DATA = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_STATIC_TEMPLATE_DATA"
    status=cured
          for T in tmplstat.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for static template members defect via ${T}""... $ac_c" 1>&6
echo "configure:3907: checking cure for static template members defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3915 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3920: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_STATIC_TEMPLATE_DATA"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support const static inline initialization?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in tmplinit.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking const static inline init via ${T}""... $ac_c" 1>&6
echo "configure:3959: checking const static inline init via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 3968 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:3973: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_STATIC_CONST_INIT 1
EOF
 ISOcxx_HAS_STATIC_CONST_INIT=@@; echo "==>  ISOcxx_HAS_STATIC_CONST_INIT" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_STATIC_CONST_INIT ${t}
EOF
 DEFECT_NO_STATIC_CONST_INIT=@${t}@; echo "==>  DEFECT_NO_STATIC_CONST_INIT = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_STATIC_CONST_INIT"
    status=cured
          for T in tmplinit.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for const static inline init defect via ${T}""... $ac_c" 1>&6
echo "configure:4015: checking cure for const static inline init defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4023 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4028: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_STATIC_CONST_INIT"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support overloading a virtual function in a derived class?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in virtovrd.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking overloading a virtual function in a derived class via ${T}""... $ac_c" 1>&6
echo "configure:4067: checking overloading a virtual function in a derived class via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4076 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4081: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_VIRTUAL_OVERRIDE 1
EOF
 ISOcxx_HAS_VIRTUAL_OVERRIDE=@@; echo "==>  ISOcxx_HAS_VIRTUAL_OVERRIDE" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_VIRTUAL_OVERRIDE ${t}
EOF
 DEFECT_NO_VIRTUAL_OVERRIDE=@${t}@; echo "==>  DEFECT_NO_VIRTUAL_OVERRIDE = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_VIRTUAL_OVERRIDE"
    status=cured
          for T in virtovrd.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for overloading a virtual function in a derived class defect via ${T}""... $ac_c" 1>&6
echo "configure:4123: checking cure for overloading a virtual function in a derived class defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4131 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4136: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_VIRTUAL_OVERRIDE"
    fi
  fi

# ----------------------------------------------------------------------
# Test 'typename' keyword:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in typename.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking 'typename' keyword via ${T}""... $ac_c" 1>&6
echo "configure:4175: checking 'typename' keyword via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4184 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4189: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_TYPENAME 1
EOF
 ISOcxx_HAS_TYPENAME=@@; echo "==>  ISOcxx_HAS_TYPENAME" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_TYPENAME ${t}
EOF
 DEFECT_NO_TYPENAME=@${t}@; echo "==>  DEFECT_NO_TYPENAME = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_TYPENAME"
    status=cured
          for T in typename.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for 'typename' keyword defect via ${T}""... $ac_c" 1>&6
echo "configure:4231: checking cure for 'typename' keyword defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4239 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4244: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_TYPENAME"
    fi
  fi

# ----------------------------------------------------------------------
# Test behavior of large enum values:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in bigenum.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking large enum values via ${T}""... $ac_c" 1>&6
echo "configure:4283: checking large enum values via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4292 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4297: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_UNSIGNED_ENUM 1
EOF
 ISOcxx_HAS_UNSIGNED_ENUM=@@; echo "==>  ISOcxx_HAS_UNSIGNED_ENUM" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_UNSIGNED_ENUM ${t}
EOF
 DEFECT_NO_UNSIGNED_ENUM=@${t}@; echo "==>  DEFECT_NO_UNSIGNED_ENUM = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_UNSIGNED_ENUM"
    status=cured
          for T in bigenum.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for large enum values defect via ${T}""... $ac_c" 1>&6
echo "configure:4339: checking cure for large enum values defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4347 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4352: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_UNSIGNED_ENUM"
    fi
  fi

# ----------------------------------------------------------------------
# Do we permit dynamic allocation of const objects?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in newconst.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking allocation of const objects via ${T}""... $ac_c" 1>&6
echo "configure:4391: checking allocation of const objects via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4400 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4405: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_NEW_CONST 1
EOF
 ISOcxx_HAS_NEW_CONST=@@; echo "==>  ISOcxx_HAS_NEW_CONST" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_NEW_CONST ${t}
EOF
 DEFECT_NO_NEW_CONST=@${t}@; echo "==>  DEFECT_NO_NEW_CONST = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_NEW_CONST"
    status=cured
          for T in newconst.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for allocation of const objects defect via ${T}""... $ac_c" 1>&6
echo "configure:4447: checking cure for allocation of const objects defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4455 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4460: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_NEW_CONST"
    fi
  fi

# ----------------------------------------------------------------------
# Do we permit deletion via pointer-to-const?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in delconst.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking deletion via pointer-to-const via ${T}""... $ac_c" 1>&6
echo "configure:4499: checking deletion via pointer-to-const via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4508 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4513: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_DELETE_CONST 1
EOF
 ISOcxx_HAS_DELETE_CONST=@@; echo "==>  ISOcxx_HAS_DELETE_CONST" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_DELETE_CONST ${t}
EOF
 DEFECT_NO_DELETE_CONST=@${t}@; echo "==>  DEFECT_NO_DELETE_CONST = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_DELETE_CONST"
    status=cured
          for T in delconst.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for deletion via pointer-to-const defect via ${T}""... $ac_c" 1>&6
echo "configure:4555: checking cure for deletion via pointer-to-const defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4563 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4568: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_DELETE_CONST"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support exceptions?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in except.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking exception-handling via ${T}""... $ac_c" 1>&6
echo "configure:4607: checking exception-handling via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4616 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4621: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_EXCEPTIONS 1
EOF
 ISOcxx_HAS_EXCEPTIONS=@@; echo "==>  ISOcxx_HAS_EXCEPTIONS" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_EXCEPTIONS ${t}
EOF
 DEFECT_NO_EXCEPTIONS=@${t}@; echo "==>  DEFECT_NO_EXCEPTIONS = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_EXCEPTIONS"
    status=cured
          for T in except.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for exception-handling defect via ${T}""... $ac_c" 1>&6
echo "configure:4663: checking cure for exception-handling defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4671 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4676: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_EXCEPTIONS"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support function try blocks?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in fctntry.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking function try blocks via ${T}""... $ac_c" 1>&6
echo "configure:4715: checking function try blocks via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4724 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4729: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_FUNCTION_TRY_BLOCKS 1
EOF
 ISOcxx_OK_FUNCTION_TRY_BLOCKS=@@; echo "==>  ISOcxx_OK_FUNCTION_TRY_BLOCKS" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_FUNCTION_TRY_BLOCKS ${t}
EOF
 DEFECT_NO_FUNCTION_TRY_BLOCKS=@${t}@; echo "==>  DEFECT_NO_FUNCTION_TRY_BLOCKS = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_FUNCTION_TRY_BLOCKS"
    status=cured
          for T in fctntry.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for function try blocks defect via ${T}""... $ac_c" 1>&6
echo "configure:4771: checking cure for function try blocks defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4779 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4784: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_FUNCTION_TRY_BLOCKS"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support virtual inheritance from an abstract base?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in absvbase.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking virtual inheritance from abstract base via ${T}""... $ac_c" 1>&6
echo "configure:4823: checking virtual inheritance from abstract base via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4832 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4837: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_ABSTRACT_VIRTUAL_BASE 1
EOF
 ISOcxx_ABSTRACT_VIRTUAL_BASE=@@; echo "==>  ISOcxx_ABSTRACT_VIRTUAL_BASE" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_ABSTRACT_VIRTUAL_BASE ${t}
EOF
 DEFECT_ABSTRACT_VIRTUAL_BASE=@${t}@; echo "==>  DEFECT_ABSTRACT_VIRTUAL_BASE = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_ABSTRACT_VIRTUAL_BASE"
    status=cured
          for T in absvbase.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for virtual inheritance from abstract base defect via ${T}""... $ac_c" 1>&6
echo "configure:4879: checking cure for virtual inheritance from abstract base defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4887 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4892: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_ABSTRACT_VIRTUAL_BASE"
    fi
  fi

# ----------------------------------------------------------------------
# Is "pascal" a keyword?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in pascal.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking erroneous pascal keyword via ${T}""... $ac_c" 1>&6
echo "configure:4931: checking erroneous pascal keyword via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4940 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:4945: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_PASCAL_NOT_KEYWORD 1
EOF
 ISOcxx_PASCAL_NOT_KEYWORD=@@; echo "==>  ISOcxx_PASCAL_NOT_KEYWORD" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_PASCAL_IS_KEYWORD ${t}
EOF
 DEFECT_PASCAL_IS_KEYWORD=@${t}@; echo "==>  DEFECT_PASCAL_IS_KEYWORD = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_PASCAL_IS_KEYWORD"
    status=cured
          for T in pascal.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for erroneous pascal keyword defect via ${T}""... $ac_c" 1>&6
echo "configure:4987: checking cure for erroneous pascal keyword defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 4995 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:5000: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_PASCAL_IS_KEYWORD"
    fi
  fi

# ----------------------------------------------------------------------
# Do we permit member constant definitions?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in mbrconst.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking member constant definitions via ${T}""... $ac_c" 1>&6
echo "configure:5039: checking member constant definitions via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 5048 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:5053: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_MEMBER_CONSTANTS 1
EOF
 ISOcxx_HAS_MEMBER_CONSTANTS=@@; echo "==>  ISOcxx_HAS_MEMBER_CONSTANTS" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_MEMBER_CONSTANTS ${t}
EOF
 DEFECT_NO_MEMBER_CONSTANTS=@${t}@; echo "==>  DEFECT_NO_MEMBER_CONSTANTS = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_MEMBER_CONSTANTS"
    status=cured
          for T in mbrconst.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for member constant definitions defect via ${T}""... $ac_c" 1>&6
echo "configure:5095: checking cure for member constant definitions defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 5103 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:5108: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_MEMBER_CONSTANTS"
    fi
  fi

# ----------------------------------------------------------------------
# Begin locating the required headers:
# ----------------------------------------------------------------------

printf "\n=====  Locate required header files:  =====\n" 1>&6
echo "configure:5142: =====  Locate required header files:  =====" >&5

# ----------------------------------------------------------------------
# Where are the native C++ library headers located?
# ----------------------------------------------------------------------

  echo $ac_n "checking for library header <algorithm>""... $ac_c" 1>&6
echo "configure:5150: checking for library header <algorithm>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}algorithm ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}algorithm${rquote}"
      else
        location="${lquote}`${path_filter} ${D}algorithm`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_ALGORITHM_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_ALGORITHM_HEADER=@${location}@; echo "==>  ISOcxx_ALGORITHM_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_ALGORITHM_HEADER 999
EOF
 DEFECT_NO_ALGORITHM_HEADER=@999@; echo "==>  DEFECT_NO_ALGORITHM_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}algorithm.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}algorithm.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}algorithm.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_ALGORITHM_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_ALGORITHM_HEADER=@${location2}@; echo "==>  ISOcxx_ALGORITHM_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_ALGORITHM_H ${location2}
EOF

        DEFECT_ALGORITHM_H=@${location2}@; echo "==>  DEFECT_ALGORITHM_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <algorithm> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_ALGORITHM_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <bitset>""... $ac_c" 1>&6
echo "configure:5214: checking for library header <bitset>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}bitset ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}bitset${rquote}"
      else
        location="${lquote}`${path_filter} ${D}bitset`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_BITSET_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_BITSET_HEADER=@${location}@; echo "==>  ISOcxx_BITSET_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_BITSET_HEADER 999
EOF
 DEFECT_NO_BITSET_HEADER=@999@; echo "==>  DEFECT_NO_BITSET_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}bitset.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}bitset.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}bitset.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_BITSET_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_BITSET_HEADER=@${location2}@; echo "==>  ISOcxx_BITSET_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_BITSET_H ${location2}
EOF

        DEFECT_BITSET_H=@${location2}@; echo "==>  DEFECT_BITSET_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <bitset> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_BITSET_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <complex>""... $ac_c" 1>&6
echo "configure:5278: checking for library header <complex>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}complex ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}complex${rquote}"
      else
        location="${lquote}`${path_filter} ${D}complex`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_COMPLEX_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_COMPLEX_HEADER=@${location}@; echo "==>  ISOcxx_COMPLEX_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_COMPLEX_HEADER 999
EOF
 DEFECT_NO_COMPLEX_HEADER=@999@; echo "==>  DEFECT_NO_COMPLEX_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}complex.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}complex.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}complex.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_COMPLEX_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_COMPLEX_HEADER=@${location2}@; echo "==>  ISOcxx_COMPLEX_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_COMPLEX_H ${location2}
EOF

        DEFECT_COMPLEX_H=@${location2}@; echo "==>  DEFECT_COMPLEX_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <complex> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_COMPLEX_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <deque>""... $ac_c" 1>&6
echo "configure:5342: checking for library header <deque>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}deque ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}deque${rquote}"
      else
        location="${lquote}`${path_filter} ${D}deque`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_DEQUE_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_DEQUE_HEADER=@${location}@; echo "==>  ISOcxx_DEQUE_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_DEQUE_HEADER 999
EOF
 DEFECT_NO_DEQUE_HEADER=@999@; echo "==>  DEFECT_NO_DEQUE_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}deque.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}deque.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}deque.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_DEQUE_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_DEQUE_HEADER=@${location2}@; echo "==>  ISOcxx_DEQUE_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_DEQUE_H ${location2}
EOF

        DEFECT_DEQUE_H=@${location2}@; echo "==>  DEFECT_DEQUE_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <deque> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_DEQUE_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <exception>""... $ac_c" 1>&6
echo "configure:5406: checking for library header <exception>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}exception ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}exception${rquote}"
      else
        location="${lquote}`${path_filter} ${D}exception`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_EXCEPTION_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_EXCEPTION_HEADER=@${location}@; echo "==>  ISOcxx_EXCEPTION_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_EXCEPTION_HEADER 999
EOF
 DEFECT_NO_EXCEPTION_HEADER=@999@; echo "==>  DEFECT_NO_EXCEPTION_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}exception.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}exception.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}exception.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_EXCEPTION_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_EXCEPTION_HEADER=@${location2}@; echo "==>  ISOcxx_EXCEPTION_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_EXCEPTION_H ${location2}
EOF

        DEFECT_EXCEPTION_H=@${location2}@; echo "==>  DEFECT_EXCEPTION_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <exception> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_EXCEPTION_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <fstream>""... $ac_c" 1>&6
echo "configure:5470: checking for library header <fstream>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}fstream ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}fstream${rquote}"
      else
        location="${lquote}`${path_filter} ${D}fstream`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_FSTREAM_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_FSTREAM_HEADER=@${location}@; echo "==>  ISOcxx_FSTREAM_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_FSTREAM_HEADER 999
EOF
 DEFECT_NO_FSTREAM_HEADER=@999@; echo "==>  DEFECT_NO_FSTREAM_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}fstream.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}fstream.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}fstream.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_FSTREAM_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_FSTREAM_HEADER=@${location2}@; echo "==>  ISOcxx_FSTREAM_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_FSTREAM_H ${location2}
EOF

        DEFECT_FSTREAM_H=@${location2}@; echo "==>  DEFECT_FSTREAM_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <fstream> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_FSTREAM_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <functional>""... $ac_c" 1>&6
echo "configure:5534: checking for library header <functional>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}functional ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}functional${rquote}"
      else
        location="${lquote}`${path_filter} ${D}functional`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_FUNCTIONAL_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_FUNCTIONAL_HEADER=@${location}@; echo "==>  ISOcxx_FUNCTIONAL_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_FUNCTIONAL_HEADER 999
EOF
 DEFECT_NO_FUNCTIONAL_HEADER=@999@; echo "==>  DEFECT_NO_FUNCTIONAL_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}functional.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}functional.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}functional.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_FUNCTIONAL_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_FUNCTIONAL_HEADER=@${location2}@; echo "==>  ISOcxx_FUNCTIONAL_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_FUNCTIONAL_H ${location2}
EOF

        DEFECT_FUNCTIONAL_H=@${location2}@; echo "==>  DEFECT_FUNCTIONAL_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <functional> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_FUNCTIONAL_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <iomanip>""... $ac_c" 1>&6
echo "configure:5598: checking for library header <iomanip>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}iomanip ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}iomanip${rquote}"
      else
        location="${lquote}`${path_filter} ${D}iomanip`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_IOMANIP_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_IOMANIP_HEADER=@${location}@; echo "==>  ISOcxx_IOMANIP_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_IOMANIP_HEADER 999
EOF
 DEFECT_NO_IOMANIP_HEADER=@999@; echo "==>  DEFECT_NO_IOMANIP_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}iomanip.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}iomanip.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}iomanip.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_IOMANIP_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_IOMANIP_HEADER=@${location2}@; echo "==>  ISOcxx_IOMANIP_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_IOMANIP_H ${location2}
EOF

        DEFECT_IOMANIP_H=@${location2}@; echo "==>  DEFECT_IOMANIP_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <iomanip> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_IOMANIP_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <ios>""... $ac_c" 1>&6
echo "configure:5662: checking for library header <ios>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}ios ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}ios${rquote}"
      else
        location="${lquote}`${path_filter} ${D}ios`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_IOS_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_IOS_HEADER=@${location}@; echo "==>  ISOcxx_IOS_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_IOS_HEADER 999
EOF
 DEFECT_NO_IOS_HEADER=@999@; echo "==>  DEFECT_NO_IOS_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}ios.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}ios.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}ios.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_IOS_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_IOS_HEADER=@${location2}@; echo "==>  ISOcxx_IOS_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_IOS_H ${location2}
EOF

        DEFECT_IOS_H=@${location2}@; echo "==>  DEFECT_IOS_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <ios> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_IOS_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <iosfwd>""... $ac_c" 1>&6
echo "configure:5726: checking for library header <iosfwd>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}iosfwd ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}iosfwd${rquote}"
      else
        location="${lquote}`${path_filter} ${D}iosfwd`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_IOSFWD_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_IOSFWD_HEADER=@${location}@; echo "==>  ISOcxx_IOSFWD_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_IOSFWD_HEADER 999
EOF
 DEFECT_NO_IOSFWD_HEADER=@999@; echo "==>  DEFECT_NO_IOSFWD_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}iosfwd.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}iosfwd.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}iosfwd.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_IOSFWD_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_IOSFWD_HEADER=@${location2}@; echo "==>  ISOcxx_IOSFWD_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_IOSFWD_H ${location2}
EOF

        DEFECT_IOSFWD_H=@${location2}@; echo "==>  DEFECT_IOSFWD_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <iosfwd> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_IOSFWD_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <iostream>""... $ac_c" 1>&6
echo "configure:5790: checking for library header <iostream>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}iostream ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}iostream${rquote}"
      else
        location="${lquote}`${path_filter} ${D}iostream`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_IOSTREAM_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_IOSTREAM_HEADER=@${location}@; echo "==>  ISOcxx_IOSTREAM_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_IOSTREAM_HEADER 999
EOF
 DEFECT_NO_IOSTREAM_HEADER=@999@; echo "==>  DEFECT_NO_IOSTREAM_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}iostream.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}iostream.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}iostream.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_IOSTREAM_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_IOSTREAM_HEADER=@${location2}@; echo "==>  ISOcxx_IOSTREAM_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_IOSTREAM_H ${location2}
EOF

        DEFECT_IOSTREAM_H=@${location2}@; echo "==>  DEFECT_IOSTREAM_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <iostream> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_IOSTREAM_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <istream>""... $ac_c" 1>&6
echo "configure:5854: checking for library header <istream>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}istream ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}istream${rquote}"
      else
        location="${lquote}`${path_filter} ${D}istream`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_ISTREAM_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_ISTREAM_HEADER=@${location}@; echo "==>  ISOcxx_ISTREAM_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_ISTREAM_HEADER 999
EOF
 DEFECT_NO_ISTREAM_HEADER=@999@; echo "==>  DEFECT_NO_ISTREAM_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}istream.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}istream.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}istream.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_ISTREAM_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_ISTREAM_HEADER=@${location2}@; echo "==>  ISOcxx_ISTREAM_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_ISTREAM_H ${location2}
EOF

        DEFECT_ISTREAM_H=@${location2}@; echo "==>  DEFECT_ISTREAM_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <istream> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_ISTREAM_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <iterator>""... $ac_c" 1>&6
echo "configure:5918: checking for library header <iterator>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}iterator ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}iterator${rquote}"
      else
        location="${lquote}`${path_filter} ${D}iterator`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_ITERATOR_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_ITERATOR_HEADER=@${location}@; echo "==>  ISOcxx_ITERATOR_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_ITERATOR_HEADER 999
EOF
 DEFECT_NO_ITERATOR_HEADER=@999@; echo "==>  DEFECT_NO_ITERATOR_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}iterator.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}iterator.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}iterator.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_ITERATOR_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_ITERATOR_HEADER=@${location2}@; echo "==>  ISOcxx_ITERATOR_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_ITERATOR_H ${location2}
EOF

        DEFECT_ITERATOR_H=@${location2}@; echo "==>  DEFECT_ITERATOR_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <iterator> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_ITERATOR_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <limits>""... $ac_c" 1>&6
echo "configure:5982: checking for library header <limits>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}limits ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}limits${rquote}"
      else
        location="${lquote}`${path_filter} ${D}limits`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_LIMITS_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_LIMITS_HEADER=@${location}@; echo "==>  ISOcxx_LIMITS_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_LIMITS_HEADER 999
EOF
 DEFECT_NO_LIMITS_HEADER=@999@; echo "==>  DEFECT_NO_LIMITS_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <limits> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_LIMITS_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <list>""... $ac_c" 1>&6
echo "configure:6022: checking for library header <list>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}list ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}list${rquote}"
      else
        location="${lquote}`${path_filter} ${D}list`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_LIST_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_LIST_HEADER=@${location}@; echo "==>  ISOcxx_LIST_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_LIST_HEADER 999
EOF
 DEFECT_NO_LIST_HEADER=@999@; echo "==>  DEFECT_NO_LIST_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}list.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}list.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}list.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_LIST_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_LIST_HEADER=@${location2}@; echo "==>  ISOcxx_LIST_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_LIST_H ${location2}
EOF

        DEFECT_LIST_H=@${location2}@; echo "==>  DEFECT_LIST_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <list> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_LIST_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <locale>""... $ac_c" 1>&6
echo "configure:6086: checking for library header <locale>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}locale ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}locale${rquote}"
      else
        location="${lquote}`${path_filter} ${D}locale`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_LOCALE_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_LOCALE_HEADER=@${location}@; echo "==>  ISOcxx_LOCALE_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_LOCALE_HEADER 999
EOF
 DEFECT_NO_LOCALE_HEADER=@999@; echo "==>  DEFECT_NO_LOCALE_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <locale> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_LOCALE_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <map>""... $ac_c" 1>&6
echo "configure:6126: checking for library header <map>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}map ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}map${rquote}"
      else
        location="${lquote}`${path_filter} ${D}map`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_MAP_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_MAP_HEADER=@${location}@; echo "==>  ISOcxx_MAP_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_MAP_HEADER 999
EOF
 DEFECT_NO_MAP_HEADER=@999@; echo "==>  DEFECT_NO_MAP_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}map.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}map.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}map.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_MAP_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_MAP_HEADER=@${location2}@; echo "==>  ISOcxx_MAP_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_MAP_H ${location2}
EOF

        DEFECT_MAP_H=@${location2}@; echo "==>  DEFECT_MAP_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <map> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_MAP_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <memory>""... $ac_c" 1>&6
echo "configure:6190: checking for library header <memory>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}memory ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}memory${rquote}"
      else
        location="${lquote}`${path_filter} ${D}memory`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_MEMORY_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_MEMORY_HEADER=@${location}@; echo "==>  ISOcxx_MEMORY_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_MEMORY_HEADER 999
EOF
 DEFECT_NO_MEMORY_HEADER=@999@; echo "==>  DEFECT_NO_MEMORY_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}memory.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}memory.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}memory.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_MEMORY_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_MEMORY_HEADER=@${location2}@; echo "==>  ISOcxx_MEMORY_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_MEMORY_H ${location2}
EOF

        DEFECT_MEMORY_H=@${location2}@; echo "==>  DEFECT_MEMORY_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <memory> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_MEMORY_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <new>""... $ac_c" 1>&6
echo "configure:6254: checking for library header <new>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}new ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}new${rquote}"
      else
        location="${lquote}`${path_filter} ${D}new`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_NEW_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_NEW_HEADER=@${location}@; echo "==>  ISOcxx_NEW_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_NEW_HEADER 999
EOF
 DEFECT_NO_NEW_HEADER=@999@; echo "==>  DEFECT_NO_NEW_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}new.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}new.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}new.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_NEW_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_NEW_HEADER=@${location2}@; echo "==>  ISOcxx_NEW_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_NEW_H ${location2}
EOF

        DEFECT_NEW_H=@${location2}@; echo "==>  DEFECT_NEW_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <new> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_NEW_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <numeric>""... $ac_c" 1>&6
echo "configure:6318: checking for library header <numeric>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}numeric ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}numeric${rquote}"
      else
        location="${lquote}`${path_filter} ${D}numeric`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_NUMERIC_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_NUMERIC_HEADER=@${location}@; echo "==>  ISOcxx_NUMERIC_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_NUMERIC_HEADER 999
EOF
 DEFECT_NO_NUMERIC_HEADER=@999@; echo "==>  DEFECT_NO_NUMERIC_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}numeric.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}numeric.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}numeric.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_NUMERIC_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_NUMERIC_HEADER=@${location2}@; echo "==>  ISOcxx_NUMERIC_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_NUMERIC_H ${location2}
EOF

        DEFECT_NUMERIC_H=@${location2}@; echo "==>  DEFECT_NUMERIC_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <numeric> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_NUMERIC_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <ostream>""... $ac_c" 1>&6
echo "configure:6382: checking for library header <ostream>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}ostream ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}ostream${rquote}"
      else
        location="${lquote}`${path_filter} ${D}ostream`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_OSTREAM_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_OSTREAM_HEADER=@${location}@; echo "==>  ISOcxx_OSTREAM_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_OSTREAM_HEADER 999
EOF
 DEFECT_NO_OSTREAM_HEADER=@999@; echo "==>  DEFECT_NO_OSTREAM_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}ostream.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}ostream.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}ostream.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_OSTREAM_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_OSTREAM_HEADER=@${location2}@; echo "==>  ISOcxx_OSTREAM_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_OSTREAM_H ${location2}
EOF

        DEFECT_OSTREAM_H=@${location2}@; echo "==>  DEFECT_OSTREAM_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <ostream> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_OSTREAM_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <queue>""... $ac_c" 1>&6
echo "configure:6446: checking for library header <queue>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}queue ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}queue${rquote}"
      else
        location="${lquote}`${path_filter} ${D}queue`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_QUEUE_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_QUEUE_HEADER=@${location}@; echo "==>  ISOcxx_QUEUE_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_QUEUE_HEADER 999
EOF
 DEFECT_NO_QUEUE_HEADER=@999@; echo "==>  DEFECT_NO_QUEUE_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}queue.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}queue.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}queue.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_QUEUE_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_QUEUE_HEADER=@${location2}@; echo "==>  ISOcxx_QUEUE_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_QUEUE_H ${location2}
EOF

        DEFECT_QUEUE_H=@${location2}@; echo "==>  DEFECT_QUEUE_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <queue> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_QUEUE_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <set>""... $ac_c" 1>&6
echo "configure:6510: checking for library header <set>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}set ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}set${rquote}"
      else
        location="${lquote}`${path_filter} ${D}set`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_SET_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_SET_HEADER=@${location}@; echo "==>  ISOcxx_SET_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_SET_HEADER 999
EOF
 DEFECT_NO_SET_HEADER=@999@; echo "==>  DEFECT_NO_SET_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}set.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}set.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}set.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_SET_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_SET_HEADER=@${location2}@; echo "==>  ISOcxx_SET_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_SET_H ${location2}
EOF

        DEFECT_SET_H=@${location2}@; echo "==>  DEFECT_SET_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <set> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_SET_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <sstream>""... $ac_c" 1>&6
echo "configure:6574: checking for library header <sstream>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}sstream ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}sstream${rquote}"
      else
        location="${lquote}`${path_filter} ${D}sstream`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_SSTREAM_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_SSTREAM_HEADER=@${location}@; echo "==>  ISOcxx_SSTREAM_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_SSTREAM_HEADER 999
EOF
 DEFECT_NO_SSTREAM_HEADER=@999@; echo "==>  DEFECT_NO_SSTREAM_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}sstream.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}sstream.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}sstream.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_SSTREAM_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_SSTREAM_HEADER=@${location2}@; echo "==>  ISOcxx_SSTREAM_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_SSTREAM_H ${location2}
EOF

        DEFECT_SSTREAM_H=@${location2}@; echo "==>  DEFECT_SSTREAM_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <sstream> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_SSTREAM_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <stack>""... $ac_c" 1>&6
echo "configure:6638: checking for library header <stack>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}stack ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}stack${rquote}"
      else
        location="${lquote}`${path_filter} ${D}stack`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_STACK_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_STACK_HEADER=@${location}@; echo "==>  ISOcxx_STACK_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_STACK_HEADER 999
EOF
 DEFECT_NO_STACK_HEADER=@999@; echo "==>  DEFECT_NO_STACK_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}stack.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}stack.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}stack.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_STACK_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_STACK_HEADER=@${location2}@; echo "==>  ISOcxx_STACK_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_STACK_H ${location2}
EOF

        DEFECT_STACK_H=@${location2}@; echo "==>  DEFECT_STACK_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <stack> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_STACK_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <stdexcept>""... $ac_c" 1>&6
echo "configure:6702: checking for library header <stdexcept>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}stdexcept ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}stdexcept${rquote}"
      else
        location="${lquote}`${path_filter} ${D}stdexcept`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_STDEXCEPT_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_STDEXCEPT_HEADER=@${location}@; echo "==>  ISOcxx_STDEXCEPT_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_STDEXCEPT_HEADER 999
EOF
 DEFECT_NO_STDEXCEPT_HEADER=@999@; echo "==>  DEFECT_NO_STDEXCEPT_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}stdexcept.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}stdexcept.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}stdexcept.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_STDEXCEPT_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_STDEXCEPT_HEADER=@${location2}@; echo "==>  ISOcxx_STDEXCEPT_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_STDEXCEPT_H ${location2}
EOF

        DEFECT_STDEXCEPT_H=@${location2}@; echo "==>  DEFECT_STDEXCEPT_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <stdexcept> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_STDEXCEPT_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <streambuf>""... $ac_c" 1>&6
echo "configure:6766: checking for library header <streambuf>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}streambuf ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}streambuf${rquote}"
      else
        location="${lquote}`${path_filter} ${D}streambuf`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_STREAMBUF_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_STREAMBUF_HEADER=@${location}@; echo "==>  ISOcxx_STREAMBUF_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_STREAMBUF_HEADER 999
EOF
 DEFECT_NO_STREAMBUF_HEADER=@999@; echo "==>  DEFECT_NO_STREAMBUF_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}streambuf.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}streambuf.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}streambuf.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_STREAMBUF_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_STREAMBUF_HEADER=@${location2}@; echo "==>  ISOcxx_STREAMBUF_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_STREAMBUF_H ${location2}
EOF

        DEFECT_STREAMBUF_H=@${location2}@; echo "==>  DEFECT_STREAMBUF_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <streambuf> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_STREAMBUF_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <string>""... $ac_c" 1>&6
echo "configure:6830: checking for library header <string>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}string ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}string${rquote}"
      else
        location="${lquote}`${path_filter} ${D}string`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_STRING_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_STRING_HEADER=@${location}@; echo "==>  ISOcxx_STRING_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_STRING_HEADER 999
EOF
 DEFECT_NO_STRING_HEADER=@999@; echo "==>  DEFECT_NO_STRING_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <string> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_STRING_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <strstream>""... $ac_c" 1>&6
echo "configure:6870: checking for library header <strstream>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}strstream ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}strstream${rquote}"
      else
        location="${lquote}`${path_filter} ${D}strstream`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_STRSTREAM_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_STRSTREAM_HEADER=@${location}@; echo "==>  ISOcxx_STRSTREAM_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_STRSTREAM_HEADER 999
EOF
 DEFECT_NO_STRSTREAM_HEADER=@999@; echo "==>  DEFECT_NO_STRSTREAM_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}strstream.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}strstream.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}strstream.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_STRSTREAM_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_STRSTREAM_HEADER=@${location2}@; echo "==>  ISOcxx_STRSTREAM_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_STRSTREAM_H ${location2}
EOF

        DEFECT_STRSTREAM_H=@${location2}@; echo "==>  DEFECT_STRSTREAM_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <strstream> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_STRSTREAM_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <typeinfo>""... $ac_c" 1>&6
echo "configure:6934: checking for library header <typeinfo>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}typeinfo ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}typeinfo${rquote}"
      else
        location="${lquote}`${path_filter} ${D}typeinfo`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_TYPEINFO_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_TYPEINFO_HEADER=@${location}@; echo "==>  ISOcxx_TYPEINFO_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_TYPEINFO_HEADER 999
EOF
 DEFECT_NO_TYPEINFO_HEADER=@999@; echo "==>  DEFECT_NO_TYPEINFO_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}typeinfo.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}typeinfo.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}typeinfo.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_TYPEINFO_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_TYPEINFO_HEADER=@${location2}@; echo "==>  ISOcxx_TYPEINFO_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_TYPEINFO_H ${location2}
EOF

        DEFECT_TYPEINFO_H=@${location2}@; echo "==>  DEFECT_TYPEINFO_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <typeinfo> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_TYPEINFO_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <utility>""... $ac_c" 1>&6
echo "configure:6998: checking for library header <utility>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}utility ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}utility${rquote}"
      else
        location="${lquote}`${path_filter} ${D}utility`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_UTILITY_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_UTILITY_HEADER=@${location}@; echo "==>  ISOcxx_UTILITY_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_UTILITY_HEADER 999
EOF
 DEFECT_NO_UTILITY_HEADER=@999@; echo "==>  DEFECT_NO_UTILITY_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}utility.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}utility.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}utility.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_UTILITY_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_UTILITY_HEADER=@${location2}@; echo "==>  ISOcxx_UTILITY_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_UTILITY_H ${location2}
EOF

        DEFECT_UTILITY_H=@${location2}@; echo "==>  DEFECT_UTILITY_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <utility> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_UTILITY_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <valarray>""... $ac_c" 1>&6
echo "configure:7062: checking for library header <valarray>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}valarray ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}valarray${rquote}"
      else
        location="${lquote}`${path_filter} ${D}valarray`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_VALARRAY_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_VALARRAY_HEADER=@${location}@; echo "==>  ISOcxx_VALARRAY_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_VALARRAY_HEADER 999
EOF
 DEFECT_NO_VALARRAY_HEADER=@999@; echo "==>  DEFECT_NO_VALARRAY_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}valarray.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}valarray.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}valarray.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_VALARRAY_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_VALARRAY_HEADER=@${location2}@; echo "==>  ISOcxx_VALARRAY_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_VALARRAY_H ${location2}
EOF

        DEFECT_VALARRAY_H=@${location2}@; echo "==>  DEFECT_VALARRAY_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <valarray> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_VALARRAY_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <vector>""... $ac_c" 1>&6
echo "configure:7126: checking for library header <vector>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}vector ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}vector${rquote}"
      else
        location="${lquote}`${path_filter} ${D}vector`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_VECTOR_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_VECTOR_HEADER=@${location}@; echo "==>  ISOcxx_VECTOR_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_VECTOR_HEADER 999
EOF
 DEFECT_NO_VECTOR_HEADER=@999@; echo "==>  DEFECT_NO_VECTOR_HEADER = 999" >&5
  fi

  unset location2
  
    for D in ${hdrpath} ; do
      if test -d ${D} -a -f ${D}vector.h ; then :
	if test -z "${path_filter}" ; then :
	  location2="${lquote}${D}vector.h${rquote}"
	else
	  location2="${lquote}`${path_filter} ${D}vector.h`${rquote}"
	fi
	if test -z "${location}" ; then :
	  cat >> confdefs.h <<EOF
#define ISOcxx_VECTOR_HEADER ${location2}
EOF

	  echo "$ac_t""ok" 1>&6
          ISOcxx_VECTOR_HEADER=@${location2}@; echo "==>  ISOcxx_VECTOR_HEADER = ${location2}" >&5
	fi
	cat >> confdefs.h <<EOF
#define DEFECT_VECTOR_H ${location2}
EOF

        DEFECT_VECTOR_H=@${location2}@; echo "==>  DEFECT_VECTOR_H = ${location2}" >&5
	break
      fi
    done
  

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <vector> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_VECTOR_HEADER"
  fi

  echo "" >&5

# ----------------------------------------------------------------------
# Where are the native C++-style C library headers located?
# ----------------------------------------------------------------------

  echo $ac_n "checking for library header <cassert>""... $ac_c" 1>&6
echo "configure:7196: checking for library header <cassert>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}cassert ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}cassert${rquote}"
      else
        location="${lquote}`${path_filter} ${D}cassert`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CASSERT_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CASSERT_HEADER=@${location}@; echo "==>  ISOcxx_CASSERT_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CASSERT_HEADER 999
EOF
 DEFECT_NO_CASSERT_HEADER=@999@; echo "==>  DEFECT_NO_CASSERT_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <cassert> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CASSERT_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <cctype>""... $ac_c" 1>&6
echo "configure:7236: checking for library header <cctype>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}cctype ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}cctype${rquote}"
      else
        location="${lquote}`${path_filter} ${D}cctype`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CCTYPE_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CCTYPE_HEADER=@${location}@; echo "==>  ISOcxx_CCTYPE_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CCTYPE_HEADER 999
EOF
 DEFECT_NO_CCTYPE_HEADER=@999@; echo "==>  DEFECT_NO_CCTYPE_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <cctype> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CCTYPE_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <cerrno>""... $ac_c" 1>&6
echo "configure:7276: checking for library header <cerrno>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}cerrno ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}cerrno${rquote}"
      else
        location="${lquote}`${path_filter} ${D}cerrno`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CERRNO_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CERRNO_HEADER=@${location}@; echo "==>  ISOcxx_CERRNO_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CERRNO_HEADER 999
EOF
 DEFECT_NO_CERRNO_HEADER=@999@; echo "==>  DEFECT_NO_CERRNO_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <cerrno> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CERRNO_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <cfloat>""... $ac_c" 1>&6
echo "configure:7316: checking for library header <cfloat>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}cfloat ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}cfloat${rquote}"
      else
        location="${lquote}`${path_filter} ${D}cfloat`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CFLOAT_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CFLOAT_HEADER=@${location}@; echo "==>  ISOcxx_CFLOAT_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CFLOAT_HEADER 999
EOF
 DEFECT_NO_CFLOAT_HEADER=@999@; echo "==>  DEFECT_NO_CFLOAT_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <cfloat> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CFLOAT_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <ciso646>""... $ac_c" 1>&6
echo "configure:7356: checking for library header <ciso646>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}ciso646 ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}ciso646${rquote}"
      else
        location="${lquote}`${path_filter} ${D}ciso646`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CISO646_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CISO646_HEADER=@${location}@; echo "==>  ISOcxx_CISO646_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CISO646_HEADER 999
EOF
 DEFECT_NO_CISO646_HEADER=@999@; echo "==>  DEFECT_NO_CISO646_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <ciso646> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CISO646_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <climits>""... $ac_c" 1>&6
echo "configure:7396: checking for library header <climits>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}climits ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}climits${rquote}"
      else
        location="${lquote}`${path_filter} ${D}climits`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CLIMITS_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CLIMITS_HEADER=@${location}@; echo "==>  ISOcxx_CLIMITS_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CLIMITS_HEADER 999
EOF
 DEFECT_NO_CLIMITS_HEADER=@999@; echo "==>  DEFECT_NO_CLIMITS_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <climits> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CLIMITS_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <clocale>""... $ac_c" 1>&6
echo "configure:7436: checking for library header <clocale>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}clocale ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}clocale${rquote}"
      else
        location="${lquote}`${path_filter} ${D}clocale`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CLOCALE_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CLOCALE_HEADER=@${location}@; echo "==>  ISOcxx_CLOCALE_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CLOCALE_HEADER 999
EOF
 DEFECT_NO_CLOCALE_HEADER=@999@; echo "==>  DEFECT_NO_CLOCALE_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <clocale> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CLOCALE_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <cmath>""... $ac_c" 1>&6
echo "configure:7476: checking for library header <cmath>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}cmath ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}cmath${rquote}"
      else
        location="${lquote}`${path_filter} ${D}cmath`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CMATH_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CMATH_HEADER=@${location}@; echo "==>  ISOcxx_CMATH_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CMATH_HEADER 999
EOF
 DEFECT_NO_CMATH_HEADER=@999@; echo "==>  DEFECT_NO_CMATH_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <cmath> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CMATH_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <csetjmp>""... $ac_c" 1>&6
echo "configure:7516: checking for library header <csetjmp>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}csetjmp ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}csetjmp${rquote}"
      else
        location="${lquote}`${path_filter} ${D}csetjmp`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CSETJMP_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CSETJMP_HEADER=@${location}@; echo "==>  ISOcxx_CSETJMP_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CSETJMP_HEADER 999
EOF
 DEFECT_NO_CSETJMP_HEADER=@999@; echo "==>  DEFECT_NO_CSETJMP_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <csetjmp> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CSETJMP_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <csignal>""... $ac_c" 1>&6
echo "configure:7556: checking for library header <csignal>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}csignal ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}csignal${rquote}"
      else
        location="${lquote}`${path_filter} ${D}csignal`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CSIGNAL_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CSIGNAL_HEADER=@${location}@; echo "==>  ISOcxx_CSIGNAL_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CSIGNAL_HEADER 999
EOF
 DEFECT_NO_CSIGNAL_HEADER=@999@; echo "==>  DEFECT_NO_CSIGNAL_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <csignal> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CSIGNAL_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <cstdarg>""... $ac_c" 1>&6
echo "configure:7596: checking for library header <cstdarg>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}cstdarg ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}cstdarg${rquote}"
      else
        location="${lquote}`${path_filter} ${D}cstdarg`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CSTDARG_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CSTDARG_HEADER=@${location}@; echo "==>  ISOcxx_CSTDARG_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CSTDARG_HEADER 999
EOF
 DEFECT_NO_CSTDARG_HEADER=@999@; echo "==>  DEFECT_NO_CSTDARG_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <cstdarg> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CSTDARG_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <cstddef>""... $ac_c" 1>&6
echo "configure:7636: checking for library header <cstddef>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}cstddef ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}cstddef${rquote}"
      else
        location="${lquote}`${path_filter} ${D}cstddef`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CSTDDEF_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CSTDDEF_HEADER=@${location}@; echo "==>  ISOcxx_CSTDDEF_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CSTDDEF_HEADER 999
EOF
 DEFECT_NO_CSTDDEF_HEADER=@999@; echo "==>  DEFECT_NO_CSTDDEF_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <cstddef> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CSTDDEF_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <cstdio>""... $ac_c" 1>&6
echo "configure:7676: checking for library header <cstdio>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}cstdio ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}cstdio${rquote}"
      else
        location="${lquote}`${path_filter} ${D}cstdio`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CSTDIO_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CSTDIO_HEADER=@${location}@; echo "==>  ISOcxx_CSTDIO_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CSTDIO_HEADER 999
EOF
 DEFECT_NO_CSTDIO_HEADER=@999@; echo "==>  DEFECT_NO_CSTDIO_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <cstdio> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CSTDIO_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <cstdlib>""... $ac_c" 1>&6
echo "configure:7716: checking for library header <cstdlib>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}cstdlib ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}cstdlib${rquote}"
      else
        location="${lquote}`${path_filter} ${D}cstdlib`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CSTDLIB_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CSTDLIB_HEADER=@${location}@; echo "==>  ISOcxx_CSTDLIB_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CSTDLIB_HEADER 999
EOF
 DEFECT_NO_CSTDLIB_HEADER=@999@; echo "==>  DEFECT_NO_CSTDLIB_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <cstdlib> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CSTDLIB_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <cstring>""... $ac_c" 1>&6
echo "configure:7756: checking for library header <cstring>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}cstring ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}cstring${rquote}"
      else
        location="${lquote}`${path_filter} ${D}cstring`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CSTRING_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CSTRING_HEADER=@${location}@; echo "==>  ISOcxx_CSTRING_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CSTRING_HEADER 999
EOF
 DEFECT_NO_CSTRING_HEADER=@999@; echo "==>  DEFECT_NO_CSTRING_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <cstring> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CSTRING_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <ctime>""... $ac_c" 1>&6
echo "configure:7796: checking for library header <ctime>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}ctime ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}ctime${rquote}"
      else
        location="${lquote}`${path_filter} ${D}ctime`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CTIME_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CTIME_HEADER=@${location}@; echo "==>  ISOcxx_CTIME_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CTIME_HEADER 999
EOF
 DEFECT_NO_CTIME_HEADER=@999@; echo "==>  DEFECT_NO_CTIME_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <ctime> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CTIME_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <cwchar>""... $ac_c" 1>&6
echo "configure:7836: checking for library header <cwchar>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}cwchar ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}cwchar${rquote}"
      else
        location="${lquote}`${path_filter} ${D}cwchar`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CWCHAR_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CWCHAR_HEADER=@${location}@; echo "==>  ISOcxx_CWCHAR_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CWCHAR_HEADER 999
EOF
 DEFECT_NO_CWCHAR_HEADER=@999@; echo "==>  DEFECT_NO_CWCHAR_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <cwchar> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CWCHAR_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <cwctype>""... $ac_c" 1>&6
echo "configure:7876: checking for library header <cwctype>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}cwctype ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}cwctype${rquote}"
      else
        location="${lquote}`${path_filter} ${D}cwctype`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CWCTYPE_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CWCTYPE_HEADER=@${location}@; echo "==>  ISOcxx_CWCTYPE_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CWCTYPE_HEADER 999
EOF
 DEFECT_NO_CWCTYPE_HEADER=@999@; echo "==>  DEFECT_NO_CWCTYPE_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <cwctype> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CWCTYPE_HEADER"
  fi

  echo "" >&5

# ----------------------------------------------------------------------
# Where are the native C library headers located?
# ----------------------------------------------------------------------

  echo $ac_n "checking for library header <assert.h>""... $ac_c" 1>&6
echo "configure:7922: checking for library header <assert.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}assert.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}assert.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}assert.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_ASSERT_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_ASSERT_H_HEADER=@${location}@; echo "==>  ISOcxx_ASSERT_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_ASSERT_H_HEADER 999
EOF
 DEFECT_NO_ASSERT_H_HEADER=@999@; echo "==>  DEFECT_NO_ASSERT_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <assert.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_ASSERT_H_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <ctype.h>""... $ac_c" 1>&6
echo "configure:7962: checking for library header <ctype.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}ctype.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}ctype.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}ctype.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_CTYPE_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_CTYPE_H_HEADER=@${location}@; echo "==>  ISOcxx_CTYPE_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CTYPE_H_HEADER 999
EOF
 DEFECT_NO_CTYPE_H_HEADER=@999@; echo "==>  DEFECT_NO_CTYPE_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <ctype.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_CTYPE_H_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <errno.h>""... $ac_c" 1>&6
echo "configure:8002: checking for library header <errno.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}errno.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}errno.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}errno.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_ERRNO_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_ERRNO_H_HEADER=@${location}@; echo "==>  ISOcxx_ERRNO_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_ERRNO_H_HEADER 999
EOF
 DEFECT_NO_ERRNO_H_HEADER=@999@; echo "==>  DEFECT_NO_ERRNO_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <errno.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_ERRNO_H_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <float.h>""... $ac_c" 1>&6
echo "configure:8042: checking for library header <float.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}float.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}float.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}float.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_FLOAT_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_FLOAT_H_HEADER=@${location}@; echo "==>  ISOcxx_FLOAT_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_FLOAT_H_HEADER 999
EOF
 DEFECT_NO_FLOAT_H_HEADER=@999@; echo "==>  DEFECT_NO_FLOAT_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <float.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_FLOAT_H_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <iso646.h>""... $ac_c" 1>&6
echo "configure:8082: checking for library header <iso646.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}iso646.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}iso646.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}iso646.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_ISO646_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_ISO646_H_HEADER=@${location}@; echo "==>  ISOcxx_ISO646_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_ISO646_H_HEADER 999
EOF
 DEFECT_NO_ISO646_H_HEADER=@999@; echo "==>  DEFECT_NO_ISO646_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <iso646.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_ISO646_H_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <limits.h>""... $ac_c" 1>&6
echo "configure:8122: checking for library header <limits.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}limits.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}limits.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}limits.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_LIMITS_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_LIMITS_H_HEADER=@${location}@; echo "==>  ISOcxx_LIMITS_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_LIMITS_H_HEADER 999
EOF
 DEFECT_NO_LIMITS_H_HEADER=@999@; echo "==>  DEFECT_NO_LIMITS_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <limits.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_LIMITS_H_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <locale.h>""... $ac_c" 1>&6
echo "configure:8162: checking for library header <locale.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}locale.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}locale.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}locale.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_LOCALE_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_LOCALE_H_HEADER=@${location}@; echo "==>  ISOcxx_LOCALE_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_LOCALE_H_HEADER 999
EOF
 DEFECT_NO_LOCALE_H_HEADER=@999@; echo "==>  DEFECT_NO_LOCALE_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <locale.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_LOCALE_H_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <math.h>""... $ac_c" 1>&6
echo "configure:8202: checking for library header <math.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}math.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}math.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}math.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_MATH_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_MATH_H_HEADER=@${location}@; echo "==>  ISOcxx_MATH_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_MATH_H_HEADER 999
EOF
 DEFECT_NO_MATH_H_HEADER=@999@; echo "==>  DEFECT_NO_MATH_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <math.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_MATH_H_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <setjmp.h>""... $ac_c" 1>&6
echo "configure:8242: checking for library header <setjmp.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}setjmp.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}setjmp.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}setjmp.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_SETJMP_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_SETJMP_H_HEADER=@${location}@; echo "==>  ISOcxx_SETJMP_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_SETJMP_H_HEADER 999
EOF
 DEFECT_NO_SETJMP_H_HEADER=@999@; echo "==>  DEFECT_NO_SETJMP_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <setjmp.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_SETJMP_H_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <signal.h>""... $ac_c" 1>&6
echo "configure:8282: checking for library header <signal.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}signal.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}signal.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}signal.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_SIGNAL_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_SIGNAL_H_HEADER=@${location}@; echo "==>  ISOcxx_SIGNAL_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_SIGNAL_H_HEADER 999
EOF
 DEFECT_NO_SIGNAL_H_HEADER=@999@; echo "==>  DEFECT_NO_SIGNAL_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <signal.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_SIGNAL_H_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <stdarg.h>""... $ac_c" 1>&6
echo "configure:8322: checking for library header <stdarg.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}stdarg.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}stdarg.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}stdarg.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_STDARG_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_STDARG_H_HEADER=@${location}@; echo "==>  ISOcxx_STDARG_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_STDARG_H_HEADER 999
EOF
 DEFECT_NO_STDARG_H_HEADER=@999@; echo "==>  DEFECT_NO_STDARG_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <stdarg.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_STDARG_H_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <stddef.h>""... $ac_c" 1>&6
echo "configure:8362: checking for library header <stddef.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}stddef.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}stddef.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}stddef.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_STDDEF_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_STDDEF_H_HEADER=@${location}@; echo "==>  ISOcxx_STDDEF_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_STDDEF_H_HEADER 999
EOF
 DEFECT_NO_STDDEF_H_HEADER=@999@; echo "==>  DEFECT_NO_STDDEF_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <stddef.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_STDDEF_H_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <stdio.h>""... $ac_c" 1>&6
echo "configure:8402: checking for library header <stdio.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}stdio.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}stdio.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}stdio.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_STDIO_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_STDIO_H_HEADER=@${location}@; echo "==>  ISOcxx_STDIO_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_STDIO_H_HEADER 999
EOF
 DEFECT_NO_STDIO_H_HEADER=@999@; echo "==>  DEFECT_NO_STDIO_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <stdio.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_STDIO_H_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <stdlib.h>""... $ac_c" 1>&6
echo "configure:8442: checking for library header <stdlib.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}stdlib.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}stdlib.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}stdlib.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_STDLIB_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_STDLIB_H_HEADER=@${location}@; echo "==>  ISOcxx_STDLIB_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_STDLIB_H_HEADER 999
EOF
 DEFECT_NO_STDLIB_H_HEADER=@999@; echo "==>  DEFECT_NO_STDLIB_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <stdlib.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_STDLIB_H_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <string.h>""... $ac_c" 1>&6
echo "configure:8482: checking for library header <string.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}string.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}string.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}string.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_STRING_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_STRING_H_HEADER=@${location}@; echo "==>  ISOcxx_STRING_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_STRING_H_HEADER 999
EOF
 DEFECT_NO_STRING_H_HEADER=@999@; echo "==>  DEFECT_NO_STRING_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <string.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_STRING_H_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <time.h>""... $ac_c" 1>&6
echo "configure:8522: checking for library header <time.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}time.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}time.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}time.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_TIME_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_TIME_H_HEADER=@${location}@; echo "==>  ISOcxx_TIME_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_TIME_H_HEADER 999
EOF
 DEFECT_NO_TIME_H_HEADER=@999@; echo "==>  DEFECT_NO_TIME_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <time.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_TIME_H_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <wchar.h>""... $ac_c" 1>&6
echo "configure:8562: checking for library header <wchar.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}wchar.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}wchar.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}wchar.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_WCHAR_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_WCHAR_H_HEADER=@${location}@; echo "==>  ISOcxx_WCHAR_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_WCHAR_H_HEADER 999
EOF
 DEFECT_NO_WCHAR_H_HEADER=@999@; echo "==>  DEFECT_NO_WCHAR_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <wchar.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_WCHAR_H_HEADER"
  fi

  echo "" >&5

  echo $ac_n "checking for library header <wctype.h>""... $ac_c" 1>&6
echo "configure:8602: checking for library header <wctype.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}wctype.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}wctype.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}wctype.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_WCTYPE_H_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_WCTYPE_H_HEADER=@${location}@; echo "==>  ISOcxx_WCTYPE_H_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    cat >> confdefs.h <<EOF
#define DEFECT_NO_WCTYPE_H_HEADER 999
EOF
 DEFECT_NO_WCTYPE_H_HEADER=@999@; echo "==>  DEFECT_NO_WCTYPE_H_HEADER = 999" >&5
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <wctype.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\tDEFECT_NO_WCTYPE_H_HEADER"
  fi

  echo "" >&5

# ----------------------------------------------------------------------
# Were some of the native headers in alternate locations?
# ----------------------------------------------------------------------

if test -n "${DEFECT_NO_FSTREAM_HEADER}"	\
    -o  -n "${DEFECT_NO_IOMANIP_HEADER}"	\
    -o  -n "${DEFECT_NO_IOS_HEADER}"		\
    -o  -n "${DEFECT_NO_IOSTREAM_HEADER}"	\
    -o  -n "${DEFECT_NO_ISTREAM_HEADER}"	\
    -o  -n "${DEFECT_NO_OSTREAM_HEADER}"	\
    -o  -n "${DEFECT_NO_STREAMBUF_HEADER}"	\
    -o  -n "${DEFECT_NO_STRSTREAM_HEADER}"	\
; then :
  cat >> confdefs.h <<EOF
#define DEFECT_OLD_IOSTREAM_HEADERS 1
EOF

else
  cat >> confdefs.h <<EOF
#define ISOcxx_NEW_IOSTREAM_HEADERS 1
EOF

fi

if test -n "${DEFECT_NO_ASSERT_HEADER}"		\
    -o  -n "${DEFECT_NO_CTYPE_HEADER}"		\
    -o  -n "${DEFECT_NO_CERRNO_HEADER}"		\
    -o  -n "${DEFECT_NO_CFLOAT_HEADER}"		\
    -o  -n "${DEFECT_NO_CISO646_HEADER}"	\
    -o  -n "${DEFECT_NO_CLIMITS_HEADER}"	\
    -o  -n "${DEFECT_NO_CLOCALE_HEADER}"	\
    -o  -n "${DEFECT_NO_CMATH_HEADER}"		\
    -o  -n "${DEFECT_NO_CSETJMP_HEADER}"	\
    -o  -n "${DEFECT_NO_CSIGNAL_HEADER}"	\
    -o  -n "${DEFECT_NO_CSTDRG_HEADER}"		\
    -o  -n "${DEFECT_NO_CSTDDEF_HEADER}"	\
    -o  -n "${DEFECT_NO_CSTDIO_HEADER}"		\
    -o  -n "${DEFECT_NO_CSTDLIB_HEADER}"	\
    -o  -n "${DEFECT_NO_CSTRING_HEADER}"	\
    -o  -n "${DEFECT_NO_CCTIME_HEADER}"		\
    -o  -n "${DEFECT_NO_CWCHAR_HEADER}"		\
    -o  -n "${DEFECT_NO_CWCTYPE_HEADER}"	\
; then :
  cat >> confdefs.h <<EOF
#define DEFECT_OLD_STDC_HEADERS 1
EOF

else
  cat >> confdefs.h <<EOF
#define ISOcxx_NEW_STDC_HEADERS 1
EOF

fi

if test -n "${DEFECT_NO_ALGORITHM_HEADER}"	\
    -o  -n "${DEFECT_NO_DEQUE_HEADER}"		\
    -o  -n "${DEFECT_NO_FUNCTIONAL_HEADER}"	\
    -o  -n "${DEFECT_NO_ITERATOR_HEADER}"	\
    -o  -n "${DEFECT_NO_LIST_HEADER}"		\
    -o  -n "${DEFECT_NO_MAP_HEADER}"		\
    -o  -n "${DEFECT_NO_MEMORY_HEADER}"		\
    -o  -n "${DEFECT_NO_NUMERIC_HEADER}"	\
    -o  -n "${DEFECT_NO_QUEUE_HEADER}"		\
    -o  -n "${DEFECT_NO_SET_HEADER}"		\
    -o  -n "${DEFECT_NO_STACK_HEADER}"		\
    -o  -n "${DEFECT_NO_UTILITY_HEADER}"	\
    -o  -n "${DEFECT_NO_VECTOR_HEADER}"		\
; then :
  cat >> confdefs.h <<EOF
#define DEFECT_OLD_STL_HEADERS 1
EOF

else
  cat >> confdefs.h <<EOF
#define ISOcxx_NEW_STL_HEADERS 1
EOF

fi

# ----------------------------------------------------------------------
# Seek substitute headers in alternate locations:
# ----------------------------------------------------------------------

if test -n "${DEFECT_NO_ALGORITHM_HEADER}"	\
    -a  -z "${ISOcxx_ALGORITHM_HEADER}"		\
; then :
    echo $ac_n "checking for library header <algo.h>""... $ac_c" 1>&6
echo "configure:8731: checking for library header <algo.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}algo.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}algo.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}algo.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_ALGORITHM_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_ALGORITHM_HEADER=@${location}@; echo "==>  ISOcxx_ALGORITHM_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    :
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <algo.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\t"
  fi

  echo "" >&5

    echo $ac_n "checking for library header <algobase.h>""... $ac_c" 1>&6
echo "configure:8768: checking for library header <algobase.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}algobase.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}algobase.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}algobase.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_ALGORITHM_HEADER2 ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_ALGORITHM_HEADER2=@${location}@; echo "==>  ISOcxx_ALGORITHM_HEADER2 = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    :
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <algobase.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\t"
  fi

  echo "" >&5

fi

if test -n "${DEFECT_NO_IOS_HEADER}"		\
    -a  -z "${DEFECT_NO_IOSTREAM_HEADER}"	\
; then :
    echo $ac_n "checking for library header <iostream>""... $ac_c" 1>&6
echo "configure:8810: checking for library header <iostream>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}iostream ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}iostream${rquote}"
      else
        location="${lquote}`${path_filter} ${D}iostream`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_IOS_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_IOS_HEADER=@${location}@; echo "==>  ISOcxx_IOS_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    :
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <iostream> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\t"
  fi

  echo "" >&5

fi

if test -n "${DEFECT_NO_NUMERIC_HEADER}"\
    -a  -z "${ISOcxx_NUMERIC_HEADER}"	\
; then :
    echo $ac_n "checking for library header <algo.h>""... $ac_c" 1>&6
echo "configure:8852: checking for library header <algo.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}algo.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}algo.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}algo.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_NUMERIC_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_NUMERIC_HEADER=@${location}@; echo "==>  ISOcxx_NUMERIC_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    :
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <algo.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\t"
  fi

  echo "" >&5

    echo $ac_n "checking for library header <algobase.h>""... $ac_c" 1>&6
echo "configure:8889: checking for library header <algobase.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}algobase.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}algobase.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}algobase.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_NUMERIC_HEADER2 ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_NUMERIC_HEADER2=@${location}@; echo "==>  ISOcxx_NUMERIC_HEADER2 = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    :
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <algobase.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\t"
  fi

  echo "" >&5

fi

if test -n "${DEFECT_NO_STRING_HEADER}"	\
    -a  -z "${ISOcxx_STRING_HEADER}"	\
; then :
  cat >> confdefs.h <<EOF
#define DEFECT_SGICC_STRING_HEADER 1
EOF

    echo $ac_n "checking for library header <mstring.h>""... $ac_c" 1>&6
echo "configure:8935: checking for library header <mstring.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}mstring.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}mstring.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}mstring.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_STRING_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_STRING_HEADER=@${location}@; echo "==>  ISOcxx_STRING_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    :
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <mstring.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\t"
  fi

  echo "" >&5

else
  cat >> confdefs.h <<EOF
#define ISOcxx_OK_STRING_HEADER 1
EOF

fi

if test -n "${DEFECT_NO_UTILITY_HEADER}"\
    -a  -z "${ISOcxx_UTILITY_HEADER}"	\
; then :
    echo $ac_n "checking for library header <function.h>""... $ac_c" 1>&6
echo "configure:8982: checking for library header <function.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}function.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}function.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}function.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_UTILITY_HEADER ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_UTILITY_HEADER=@${location}@; echo "==>  ISOcxx_UTILITY_HEADER = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    :
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <function.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\t"
  fi

  echo "" >&5

    echo $ac_n "checking for library header <pair.h>""... $ac_c" 1>&6
echo "configure:9019: checking for library header <pair.h>" >&5
  unset location
  for D in ${hdrpath} ; do
    if test -d ${D} -a -f ${D}pair.h ; then :
      if test -z "${path_filter}" ; then :
        location="${lquote}${D}pair.h${rquote}"
      else
        location="${lquote}`${path_filter} ${D}pair.h`${rquote}"
      fi
      cat >> confdefs.h <<EOF
#define ISOcxx_UTILITY_HEADER2 ${location}
EOF

      echo "$ac_t""ok" 1>&6
      ISOcxx_UTILITY_HEADER2=@${location}@; echo "==>  ISOcxx_UTILITY_HEADER2 = ${location}" >&5
      break
    fi
  done
  if test -z "${location}" ; then :
    :
  fi

  unset location2
  :

  if test -z "${location}"  -a -z "${location2}"; then :
    echo "configure: failed to locate usable <pair.h> header in any of" >&5
    for D in ${hdrpath} ; do
      echo "  "${D} >&5
    done
    echo "$ac_t""unavailable" 1>&6
    defect_list="${defect_list}\\n\\t"
  fi

  echo "" >&5

fi

# ----------------------------------------------------------------------
# Assure we know about <sstream>, if available:
# ----------------------------------------------------------------------

if test -n "${DEFECT_NO_SSTREAM_HEADER}"\
    -a  -z "${ISOcxx_SSTREAM_HEADER}"	\
; then :
  cat >> confdefs.h <<EOF
#define DEFECT_NO_SSTREAM 1
EOF

  cat >> confdefs.h <<EOF
#define DEFECT_OLD_STRINGSTREAM 1
EOF

else
  cat >> confdefs.h <<EOF
#define ISOcxx_HAS_SSTREAM 1
EOF

  cat >> confdefs.h <<EOF
#define ISOcxx_NEW_STRINGSTREAM 1
EOF

fi

# ----------------------------------------------------------------------
# Begin seeking library defects:
# ----------------------------------------------------------------------

printf "\n=====  Probe for general library defects:  =====\n" 1>&6
echo "configure:9090: =====  Probe for general library defects:  =====" >&5

# ----------------------------------------------------------------------
# Early tests (none unless debugging):
# ----------------------------------------------------------------------

# ----------------------------------------------------------------------
# Confirm correctness of ISOcxxDepth:
# ----------------------------------------------------------------------

#AC_MSG_CHECKING([ISOcxxDepth])
#ISOcxx_TRY_RUN(["${testdir}oldhdrs.cc"], status=PROBLEM!, status=ok)
#AC_MSG_RESULT(${status})

# ----------------------------------------------------------------------
# Does <cmath> have all the std::abs()'s?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in abs_dbl.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking abs(double) via ${T}""... $ac_c" 1>&6
echo "configure:9117: checking abs(double) via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 9126 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:9131: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_ABS_DOUBLE 1
EOF
 ISOcxx_HAS_ABS_DOUBLE=@@; echo "==>  ISOcxx_HAS_ABS_DOUBLE" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_ABS_DOUBLE ${t}
EOF
 DEFECT_NO_ABS_DOUBLE=@${t}@; echo "==>  DEFECT_NO_ABS_DOUBLE = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_ABS_DOUBLE"
    status=cured
          for T in abs_dbl.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for abs(double) defect via ${T}""... $ac_c" 1>&6
echo "configure:9173: checking cure for abs(double) defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 9181 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:9186: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_ABS_DOUBLE"
    fi
  fi

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in abs_flt.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking abs(float) via ${T}""... $ac_c" 1>&6
echo "configure:9220: checking abs(float) via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 9229 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:9234: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_ABS_FLOAT 1
EOF
 ISOcxx_HAS_ABS_FLOAT=@@; echo "==>  ISOcxx_HAS_ABS_FLOAT" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_ABS_FLOAT ${t}
EOF
 DEFECT_NO_ABS_FLOAT=@${t}@; echo "==>  DEFECT_NO_ABS_FLOAT = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_ABS_FLOAT"
    status=cured
          for T in abs_flt.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for abs(float) defect via ${T}""... $ac_c" 1>&6
echo "configure:9276: checking cure for abs(float) defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 9284 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:9289: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_ABS_FLOAT"
    fi
  fi

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in abs_ldbl.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking abs(long double) via ${T}""... $ac_c" 1>&6
echo "configure:9323: checking abs(long double) via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 9332 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:9337: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_ABS_LONG_DOUBLE 1
EOF
 ISOcxx_HAS_ABS_LONG_DOUBLE=@@; echo "==>  ISOcxx_HAS_ABS_LONG_DOUBLE" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_ABS_LONG_DOUBLE ${t}
EOF
 DEFECT_NO_ABS_LONG_DOUBLE=@${t}@; echo "==>  DEFECT_NO_ABS_LONG_DOUBLE = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_ABS_LONG_DOUBLE"
    status=cured
          for T in abs_ldbl.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for abs(long double) defect via ${T}""... $ac_c" 1>&6
echo "configure:9379: checking cure for abs(long double) defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 9387 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:9392: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_ABS_LONG_DOUBLE"
    fi
  fi

# ----------------------------------------------------------------------
# Test for std::<cmath>:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in cmathstd.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking <cmath>'s namespace via ${T}""... $ac_c" 1>&6
echo "configure:9431: checking <cmath>'s namespace via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 9440 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:9445: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_CMATH_IN_STD 1
EOF
 ISOcxx_CMATH_IN_STD=@@; echo "==>  ISOcxx_CMATH_IN_STD" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_CMATH_NOT_STD ${t}
EOF
 DEFECT_CMATH_NOT_STD=@${t}@; echo "==>  DEFECT_CMATH_NOT_STD = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_CMATH_NOT_STD"
    status=cured
          for T in cmathstd.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for <cmath>'s namespace defect via ${T}""... $ac_c" 1>&6
echo "configure:9487: checking cure for <cmath>'s namespace defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 9495 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:9500: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_CMATH_NOT_STD"
    fi
  fi

# ----------------------------------------------------------------------
# Test for all required versions of <cmath>'s functions:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in cmathver.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking full <cmath> functionality via ${T}""... $ac_c" 1>&6
echo "configure:9539: checking full <cmath> functionality via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 9548 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:9553: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_CMATH_ALL_VERSIONS 1
EOF
 ISOcxx_CMATH_ALL_VERSIONS=@@; echo "==>  ISOcxx_CMATH_ALL_VERSIONS" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_CMATH_DOUBLE_VERSIONS ${t}
EOF
 DEFECT_CMATH_DOUBLE_VERSIONS=@${t}@; echo "==>  DEFECT_CMATH_DOUBLE_VERSIONS = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_CMATH_DOUBLE_VERSIONS"
    status=cured
          for T in cmathver.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for full <cmath> functionality defect via ${T}""... $ac_c" 1>&6
echo "configure:9595: checking cure for full <cmath> functionality defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 9603 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:9608: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_CMATH_DOUBLE_VERSIONS"
    fi
  fi

# ----------------------------------------------------------------------
# Test for std::<cstddef>:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in cstdfstd.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking <cstddef>'s namespace via ${T}""... $ac_c" 1>&6
echo "configure:9647: checking <cstddef>'s namespace via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 9656 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:9661: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_CSTDDEF_IN_STD 1
EOF
 ISOcxx_CSTDDEF_IN_STD=@@; echo "==>  ISOcxx_CSTDDEF_IN_STD" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_CSTDDEF_NOT_STD ${t}
EOF
 DEFECT_CSTDDEF_NOT_STD=@${t}@; echo "==>  DEFECT_CSTDDEF_NOT_STD = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_CSTDDEF_NOT_STD"
    status=cured
          for T in cstdfstd.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for <cstddef>'s namespace defect via ${T}""... $ac_c" 1>&6
echo "configure:9703: checking cure for <cstddef>'s namespace defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 9711 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:9716: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_CSTDDEF_NOT_STD"
    fi
  fi

# ----------------------------------------------------------------------
# Does <stdlib.h> have ::abs(int)?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in abs_int.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking abs(int) via ${T}""... $ac_c" 1>&6
echo "configure:9755: checking abs(int) via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 9764 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:9769: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_ABS 1
EOF
 ISOcxx_HAS_ABS=@@; echo "==>  ISOcxx_HAS_ABS" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_ABS ${t}
EOF
 DEFECT_NO_ABS=@${t}@; echo "==>  DEFECT_NO_ABS = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_ABS"
    status=cured
          for T in abs_int.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for abs(int) defect via ${T}""... $ac_c" 1>&6
echo "configure:9811: checking cure for abs(int) defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 9819 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:9824: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_ABS"
    fi
  fi

# ----------------------------------------------------------------------
# Does <cstdlib> have std::abs(long)?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in abs_long.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking abs(long) via ${T}""... $ac_c" 1>&6
echo "configure:9863: checking abs(long) via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 9872 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:9877: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_ABS_LONG 1
EOF
 ISOcxx_HAS_ABS_LONG=@@; echo "==>  ISOcxx_HAS_ABS_LONG" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_ABS_LONG ${t}
EOF
 DEFECT_NO_ABS_LONG=@${t}@; echo "==>  DEFECT_NO_ABS_LONG = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_ABS_LONG"
    status=cured
          for T in abs_long.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for abs(long) defect via ${T}""... $ac_c" 1>&6
echo "configure:9919: checking cure for abs(long) defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 9927 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:9932: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_ABS_LONG"
    fi
  fi

# ----------------------------------------------------------------------
# Does <cstdlib> have the div(long,long) function?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in div_l_l.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking div(long,long) via ${T}""... $ac_c" 1>&6
echo "configure:9971: checking div(long,long) via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 9980 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:9985: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_DIV_LONG_LONG 1
EOF
 ISOcxx_HAS_DIV_LONG_LONG=@@; echo "==>  ISOcxx_HAS_DIV_LONG_LONG" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_DIV_LONG_LONG ${t}
EOF
 DEFECT_NO_DIV_LONG_LONG=@${t}@; echo "==>  DEFECT_NO_DIV_LONG_LONG = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_DIV_LONG_LONG"
    status=cured
          for T in div_l_l.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for div(long,long) defect via ${T}""... $ac_c" 1>&6
echo "configure:10027: checking cure for div(long,long) defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10035 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10040: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_DIV_LONG_LONG"
    fi
  fi

# ----------------------------------------------------------------------
# Does <cstdlib> have the wchar functions?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in multibyt.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking wchar functions via ${T}""... $ac_c" 1>&6
echo "configure:10079: checking wchar functions via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10088 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10093: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_WCHAR_FUNCTIONS 1
EOF
 ISOcxx_HAS_WCHAR_FUNCTIONS=@@; echo "==>  ISOcxx_HAS_WCHAR_FUNCTIONS" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_WCHAR_FUNCTIONS ${t}
EOF
 DEFECT_NO_WCHAR_FUNCTIONS=@${t}@; echo "==>  DEFECT_NO_WCHAR_FUNCTIONS = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_WCHAR_FUNCTIONS"
    status=cured
          for T in multibyt.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for wchar functions defect via ${T}""... $ac_c" 1>&6
echo "configure:10135: checking cure for wchar functions defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10143 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10148: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_WCHAR_FUNCTIONS"
    fi
  fi

# ----------------------------------------------------------------------
# Test for std::<cstdlib>:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in cstlbstd.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking <cstdlib>'s namespace via ${T}""... $ac_c" 1>&6
echo "configure:10187: checking <cstdlib>'s namespace via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10196 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10201: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_CSTDLIB_IN_STD 1
EOF
 ISOcxx_CSTDLIB_IN_STD=@@; echo "==>  ISOcxx_CSTDLIB_IN_STD" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_CSTDLIB_NOT_STD ${t}
EOF
 DEFECT_CSTDLIB_NOT_STD=@${t}@; echo "==>  DEFECT_CSTDLIB_NOT_STD = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_CSTDLIB_NOT_STD"
    status=cured
          for T in cstlbstd.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for <cstdlib>'s namespace defect via ${T}""... $ac_c" 1>&6
echo "configure:10243: checking cure for <cstdlib>'s namespace defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10251 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10256: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_CSTDLIB_NOT_STD"
    fi
  fi

# ----------------------------------------------------------------------
# Test for std::<cstring>:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in cstrgstd.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking <cstring>'s namespace via ${T}""... $ac_c" 1>&6
echo "configure:10295: checking <cstring>'s namespace via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10304 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10309: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_CSTRING_IN_STD 1
EOF
 ISOcxx_CSTRING_IN_STD=@@; echo "==>  ISOcxx_CSTRING_IN_STD" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_CSTRING_NOT_STD ${t}
EOF
 DEFECT_CSTRING_NOT_STD=@${t}@; echo "==>  DEFECT_CSTRING_NOT_STD = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_CSTRING_NOT_STD"
    status=cured
          for T in cstrgstd.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for <cstring>'s namespace defect via ${T}""... $ac_c" 1>&6
echo "configure:10351: checking cure for <cstring>'s namespace defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10359 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10364: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_CSTRING_NOT_STD"
    fi
  fi

# ----------------------------------------------------------------------
# Does <algorithm> have std::min() and std::max()?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in min_max.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking min() and max() via ${T}""... $ac_c" 1>&6
echo "configure:10403: checking min() and max() via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10412 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10417: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_MIN_MAX 1
EOF
 ISOcxx_HAS_MIN_MAX=@@; echo "==>  ISOcxx_HAS_MIN_MAX" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_MIN_MAX ${t}
EOF
 DEFECT_NO_MIN_MAX=@${t}@; echo "==>  DEFECT_NO_MIN_MAX = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_MIN_MAX"
    status=cured
          for T in min_max.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for min() and max() defect via ${T}""... $ac_c" 1>&6
echo "configure:10459: checking cure for min() and max() defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10467 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10472: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_MIN_MAX"
    fi
  fi

# ----------------------------------------------------------------------
# Test for old count() signature in <algorithm>:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in countok.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking count()'s signature via ${T}""... $ac_c" 1>&6
echo "configure:10511: checking count()'s signature via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10520 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10525: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_NEW_STL_COUNT 1
EOF
 ISOcxx_NEW_STL_COUNT=@@; echo "==>  ISOcxx_NEW_STL_COUNT" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_OLD_STL_COUNT ${t}
EOF
 DEFECT_OLD_STL_COUNT=@${t}@; echo "==>  DEFECT_OLD_STL_COUNT = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_OLD_STL_COUNT"
    status=cured
          for T in countok.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for count()'s signature defect via ${T}""... $ac_c" 1>&6
echo "configure:10567: checking cure for count()'s signature defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10575 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10580: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_OLD_STL_COUNT"
    fi
  fi
#, countbad.cc)

# ----------------------------------------------------------------------
# Does <functional> have const_mem_fun1_t<>?
# MUST PRECEDE DEFECT_MEM_FUN1
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in cmf1t.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking <functional> for const_mem_fun1_t via ${T}""... $ac_c" 1>&6
echo "configure:10620: checking <functional> for const_mem_fun1_t via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10629 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10634: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_CONST_MEM_FUN1_T 1
EOF
 ISOcxx_HAS_CONST_MEM_FUN1_T=@@; echo "==>  ISOcxx_HAS_CONST_MEM_FUN1_T" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_CONST_MEM_FUN1_T ${t}
EOF
 DEFECT_NO_CONST_MEM_FUN1_T=@${t}@; echo "==>  DEFECT_NO_CONST_MEM_FUN1_T = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_CONST_MEM_FUN1_T"
    status=cured
          for T in cmf1t.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for <functional> for const_mem_fun1_t defect via ${T}""... $ac_c" 1>&6
echo "configure:10676: checking cure for <functional> for const_mem_fun1_t defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10684 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10689: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_CONST_MEM_FUN1_T"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support the 3-arg forms of mem_fun & mem_fun_ref?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in mem_fun1.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking 3-arg forms of mem_fun & mem_fun_ref via ${T}""... $ac_c" 1>&6
echo "configure:10728: checking 3-arg forms of mem_fun & mem_fun_ref via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10737 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10742: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_MEM_FUN1 1
EOF
 ISOcxx_MEM_FUN1=@@; echo "==>  ISOcxx_MEM_FUN1" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_MEM_FUN1 ${t}
EOF
 DEFECT_MEM_FUN1=@${t}@; echo "==>  DEFECT_MEM_FUN1 = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_MEM_FUN1"
    status=cured
          for T in mem_fun1.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for 3-arg forms of mem_fun & mem_fun_ref defect via ${T}""... $ac_c" 1>&6
echo "configure:10784: checking cure for 3-arg forms of mem_fun & mem_fun_ref defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10792 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10797: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_MEM_FUN1"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support auto_ptr<>?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in autoptr.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking <memory> for auto_ptr<> via ${T}""... $ac_c" 1>&6
echo "configure:10836: checking <memory> for auto_ptr<> via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10845 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10850: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_AUTO_PTR 1
EOF
 ISOcxx_HAS_AUTO_PTR=@@; echo "==>  ISOcxx_HAS_AUTO_PTR" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_AUTO_PTR ${t}
EOF
 DEFECT_NO_AUTO_PTR=@${t}@; echo "==>  DEFECT_NO_AUTO_PTR = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_AUTO_PTR"
    status=cured
          for T in autoptr.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for <memory> for auto_ptr<> defect via ${T}""... $ac_c" 1>&6
echo "configure:10892: checking cure for <memory> for auto_ptr<> defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10900 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10905: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_AUTO_PTR"
    fi
  fi

# ----------------------------------------------------------------------
# Does the long double infinity() work properly?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in inf_ldbl.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking numeric_limits<long double>infinity() via ${T}""... $ac_c" 1>&6
echo "configure:10944: checking numeric_limits<long double>infinity() via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 10953 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:10958: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_INF_LONG_DOUBLE 1
EOF
 ISOcxx_INF_LONG_DOUBLE=@@; echo "==>  ISOcxx_INF_LONG_DOUBLE" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_INF_LONG_DOUBLE ${t}
EOF
 DEFECT_INF_LONG_DOUBLE=@${t}@; echo "==>  DEFECT_INF_LONG_DOUBLE = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_INF_LONG_DOUBLE"
    status=cured
          for T in inf_ldbl.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for numeric_limits<long double>infinity() defect via ${T}""... $ac_c" 1>&6
echo "configure:11000: checking cure for numeric_limits<long double>infinity() defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11008 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11013: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_INF_LONG_DOUBLE"
    fi
  fi

# ----------------------------------------------------------------------
# Do we support user placement delete parameters?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in placedel.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking user placement delete parameters via ${T}""... $ac_c" 1>&6
echo "configure:11052: checking user placement delete parameters via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11061 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11066: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_USER_PLACEMENT_DELETE 1
EOF
 ISOcxx_HAS_USER_PLACEMENT_DELETE=@@; echo "==>  ISOcxx_HAS_USER_PLACEMENT_DELETE" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_USER_PLACEMENT_DELETE ${t}
EOF
 DEFECT_NO_USER_PLACEMENT_DELETE=@${t}@; echo "==>  DEFECT_NO_USER_PLACEMENT_DELETE = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_USER_PLACEMENT_DELETE"
    status=cured
          for T in placedel.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for user placement delete parameters defect via ${T}""... $ac_c" 1>&6
echo "configure:11108: checking cure for user placement delete parameters defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11116 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11121: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_USER_PLACEMENT_DELETE"
    fi
  fi

# ----------------------------------------------------------------------
# Is allocator a template?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in alloc.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking <memory> allocator's templatization via ${T}""... $ac_c" 1>&6
echo "configure:11160: checking <memory> allocator's templatization via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11169 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11174: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_ALLOCATOR_IS_TEMPLATE 1
EOF
 ISOcxx_ALLOCATOR_IS_TEMPLATE=@@; echo "==>  ISOcxx_ALLOCATOR_IS_TEMPLATE" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_ALLOCATOR_NOT_TEMPLATE ${t}
EOF
 DEFECT_ALLOCATOR_NOT_TEMPLATE=@${t}@; echo "==>  DEFECT_ALLOCATOR_NOT_TEMPLATE = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_ALLOCATOR_NOT_TEMPLATE"
    status=cured
          for T in alloc.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for <memory> allocator's templatization defect via ${T}""... $ac_c" 1>&6
echo "configure:11216: checking cure for <memory> allocator's templatization defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11224 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11229: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_ALLOCATOR_NOT_TEMPLATE"
    fi
  fi

# ----------------------------------------------------------------------
# Test <wctype.h> vulnerability to DEFECT_NO_UNSIGNED_ENUM:
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in wctype.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking <wctype.h> vulnerability via ${T}""... $ac_c" 1>&6
echo "configure:11268: checking <wctype.h> vulnerability via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11277 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11282: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_WCTYPE_H_OK 1
EOF
 ISOcxx_WCTYPE_H_OK=@@; echo "==>  ISOcxx_WCTYPE_H_OK" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_WCTYPE_H_NEEDS_UNSIGNED_ENUM ${t}
EOF
 DEFECT_WCTYPE_H_NEEDS_UNSIGNED_ENUM=@${t}@; echo "==>  DEFECT_WCTYPE_H_NEEDS_UNSIGNED_ENUM = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_WCTYPE_H_NEEDS_UNSIGNED_ENUM"
    status=cured
          for T in wctype.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for <wctype.h> vulnerability defect via ${T}""... $ac_c" 1>&6
echo "configure:11324: checking cure for <wctype.h> vulnerability defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11332 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11337: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_WCTYPE_H_NEEDS_UNSIGNED_ENUM"
    fi
  fi

# ----------------------------------------------------------------------
# Begin seeking library i/o-related defects:
# ----------------------------------------------------------------------

printf "\n=====  Probe for library i/o-related defects:  =====\n" 1>&6
echo "configure:11371: =====  Probe for library i/o-related defects:  =====" >&5

# ----------------------------------------------------------------------
# <ios>:
# ----------------------------------------------------------------------

# Do we have class std::ios_base?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in iosbase.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking class std::ios_base via ${T}""... $ac_c" 1>&6
echo "configure:11385: checking class std::ios_base via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11394 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11399: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_IOS_BASE 1
EOF
 ISOcxx_HAS_IOS_BASE=@@; echo "==>  ISOcxx_HAS_IOS_BASE" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_IOS_BASE ${t}
EOF
 DEFECT_NO_IOS_BASE=@${t}@; echo "==>  DEFECT_NO_IOS_BASE = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_IOS_BASE"
    status=cured
          for T in iosbase.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for class std::ios_base defect via ${T}""... $ac_c" 1>&6
echo "configure:11441: checking cure for class std::ios_base defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11449 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11454: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_IOS_BASE"
    fi
  fi

# Do we have manipulators?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in iosmanip.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking <ios> manipulators via ${T}""... $ac_c" 1>&6
echo "configure:11489: checking <ios> manipulators via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11498 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11503: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_IOS_MANIPULATORS 1
EOF
 ISOcxx_HAS_IOS_MANIPULATORS=@@; echo "==>  ISOcxx_HAS_IOS_MANIPULATORS" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_IOS_MANIPULATORS ${t}
EOF
 DEFECT_NO_IOS_MANIPULATORS=@${t}@; echo "==>  DEFECT_NO_IOS_MANIPULATORS = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_IOS_MANIPULATORS"
    status=cured
          for T in iosmanip.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for <ios> manipulators defect via ${T}""... $ac_c" 1>&6
echo "configure:11545: checking cure for <ios> manipulators defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11553 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11558: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_IOS_MANIPULATORS"
    fi
  fi

# ----------------------------------------------------------------------
# Does an istream's eof() behave properly?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed:
      for T in eof.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking eof() via ${T}""... $ac_c" 1>&6
echo "configure:11597: checking eof() via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11606 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11611: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_EOF 1
EOF
 ISOcxx_OK_EOF=@@; echo "==>  ISOcxx_OK_EOF" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_EOF ${t}
EOF
 DEFECT_EOF=@${t}@; echo "==>  DEFECT_EOF = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_EOF"
    status=cured
          for T in eof.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for eof() defect via ${T}""... $ac_c" 1>&6
echo "configure:11653: checking cure for eof() defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11661 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11666: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_EOF"
    fi
  fi

# ----------------------------------------------------------------------
# Begin seeking library container-related defects:
# ----------------------------------------------------------------------

printf "\n=====  Probe for library container-related defects:  =====\n" 1>&6
echo "configure:11700: =====  Probe for library container-related defects:  =====" >&5

# ----------------------------------------------------------------------
# iterator<>s:
# ----------------------------------------------------------------------

# Do iterator<>s have all template arguments?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in iter8or.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking iterator<> template arguments via ${T}""... $ac_c" 1>&6
echo "configure:11714: checking iterator<> template arguments via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11723 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11728: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_ITERATOR_ARGS 1
EOF
 ISOcxx_OK_ITERATOR_ARGS=@@; echo "==>  ISOcxx_OK_ITERATOR_ARGS" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_BAD_ITERATOR_ARGS ${t}
EOF
 DEFECT_BAD_ITERATOR_ARGS=@${t}@; echo "==>  DEFECT_BAD_ITERATOR_ARGS = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_BAD_ITERATOR_ARGS"
    status=cured
          for T in iter8or.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for iterator<> template arguments defect via ${T}""... $ac_c" 1>&6
echo "configure:11770: checking cure for iterator<> template arguments defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11778 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11783: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_BAD_ITERATOR_ARGS"
    fi
  fi

# Do reverse_iterator<>s have the right number of template arguments?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in reviter.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking reverse_iterator<> template arguments via ${T}""... $ac_c" 1>&6
echo "configure:11818: checking reverse_iterator<> template arguments via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11827 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11832: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_REVERSE_ITERATOR 1
EOF
 ISOcxx_OK_REVERSE_ITERATOR=@@; echo "==>  ISOcxx_OK_REVERSE_ITERATOR" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_OLD_REVERSE_ITERATOR ${t}
EOF
 DEFECT_OLD_REVERSE_ITERATOR=@${t}@; echo "==>  DEFECT_OLD_REVERSE_ITERATOR = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_OLD_REVERSE_ITERATOR"
    status=cured
          for T in reviter.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for reverse_iterator<> template arguments defect via ${T}""... $ac_c" 1>&6
echo "configure:11874: checking cure for reverse_iterator<> template arguments defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11882 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11887: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_OLD_REVERSE_ITERATOR"
    fi
  fi

# ----------------------------------------------------------------------
# string<>s:
# ----------------------------------------------------------------------

# Do string<>s have clear()?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in clearstr.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking <string> clear() via ${T}""... $ac_c" 1>&6
echo "configure:11927: checking <string> clear() via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11936 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11941: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_STRING_CLEAR 1
EOF
 ISOcxx_HAS_STRING_CLEAR=@@; echo "==>  ISOcxx_HAS_STRING_CLEAR" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_STRING_CLEAR ${t}
EOF
 DEFECT_NO_STRING_CLEAR=@${t}@; echo "==>  DEFECT_NO_STRING_CLEAR = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_STRING_CLEAR"
    status=cured
          for T in clearstr.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for <string> clear() defect via ${T}""... $ac_c" 1>&6
echo "configure:11983: checking cure for <string> clear() defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 11991 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:11996: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_STRING_CLEAR"
    fi
  fi

# ----------------------------------------------------------------------
# deque<>s:
# ----------------------------------------------------------------------

# Do deque<>s support custom allocators?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in allocdeq.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking <deque> allocator option via ${T}""... $ac_c" 1>&6
echo "configure:12036: checking <deque> allocator option via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12045 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12050: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_DEQUE_ALLOCATOR 1
EOF
 ISOcxx_OK_DEQUE_ALLOCATOR=@@; echo "==>  ISOcxx_OK_DEQUE_ALLOCATOR" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_DEQUE_ALLOCATOR ${t}
EOF
 DEFECT_NO_DEQUE_ALLOCATOR=@${t}@; echo "==>  DEFECT_NO_DEQUE_ALLOCATOR = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_DEQUE_ALLOCATOR"
    status=cured
          for T in allocdeq.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for <deque> allocator option defect via ${T}""... $ac_c" 1>&6
echo "configure:12092: checking cure for <deque> allocator option defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12100 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12105: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_DEQUE_ALLOCATOR"
    fi
  fi

# Do deque<>s support at()?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in atdeq.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking <deque> at() via ${T}""... $ac_c" 1>&6
echo "configure:12140: checking <deque> at() via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12149 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12154: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_DEQUE_AT 1
EOF
 ISOcxx_HAS_DEQUE_AT=@@; echo "==>  ISOcxx_HAS_DEQUE_AT" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_DEQUE_AT ${t}
EOF
 DEFECT_NO_DEQUE_AT=@${t}@; echo "==>  DEFECT_NO_DEQUE_AT = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_DEQUE_AT"
    status=cured
          for T in atdeq.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for <deque> at() defect via ${T}""... $ac_c" 1>&6
echo "configure:12196: checking cure for <deque> at() defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12204 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12209: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_DEQUE_AT"
    fi
  fi

# ----------------------------------------------------------------------
# list<>s:
# ----------------------------------------------------------------------

# Do list<>s support custom allocators?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in alloclst.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking <list> allocator option via ${T}""... $ac_c" 1>&6
echo "configure:12249: checking <list> allocator option via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12258 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12263: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_LIST_ALLOCATOR 1
EOF
 ISOcxx_OK_LIST_ALLOCATOR=@@; echo "==>  ISOcxx_OK_LIST_ALLOCATOR" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_LIST_ALLOCATOR ${t}
EOF
 DEFECT_NO_LIST_ALLOCATOR=@${t}@; echo "==>  DEFECT_NO_LIST_ALLOCATOR = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_LIST_ALLOCATOR"
    status=cured
          for T in alloclst.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for <list> allocator option defect via ${T}""... $ac_c" 1>&6
echo "configure:12305: checking cure for <list> allocator option defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12313 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12318: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_LIST_ALLOCATOR"
    fi
  fi

# Does list<>'s splice() work correctly?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in splice.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking <list>'s splice() via ${T}""... $ac_c" 1>&6
echo "configure:12353: checking <list>'s splice() via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12362 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12367: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_LIST_SPLICE 1
EOF
 ISOcxx_OK_LIST_SPLICE=@@; echo "==>  ISOcxx_OK_LIST_SPLICE" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_BAD_LIST_SPLICE ${t}
EOF
 DEFECT_BAD_LIST_SPLICE=@${t}@; echo "==>  DEFECT_BAD_LIST_SPLICE = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_BAD_LIST_SPLICE"
    status=cured
          for T in splice.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for <list>'s splice() defect via ${T}""... $ac_c" 1>&6
echo "configure:12409: checking cure for <list>'s splice() defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12417 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12422: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_BAD_LIST_SPLICE"
    fi
  fi

# ----------------------------------------------------------------------
# vector<>s:
# ----------------------------------------------------------------------

# Do vector<>s support custom allocators?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in allocvec.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking <vector> allocator option via ${T}""... $ac_c" 1>&6
echo "configure:12462: checking <vector> allocator option via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12471 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12476: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_VECTOR_ALLOCATOR 1
EOF
 ISOcxx_OK_VECTOR_ALLOCATOR=@@; echo "==>  ISOcxx_OK_VECTOR_ALLOCATOR" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_VECTOR_ALLOCATOR ${t}
EOF
 DEFECT_NO_VECTOR_ALLOCATOR=@${t}@; echo "==>  DEFECT_NO_VECTOR_ALLOCATOR = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_VECTOR_ALLOCATOR"
    status=cured
          for T in allocvec.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for <vector> allocator option defect via ${T}""... $ac_c" 1>&6
echo "configure:12518: checking cure for <vector> allocator option defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12526 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12531: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_VECTOR_ALLOCATOR"
    fi
  fi

# Do vector<>s support at()?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in atvec.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking <vector> at() via ${T}""... $ac_c" 1>&6
echo "configure:12566: checking <vector> at() via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12575 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12580: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_VECTOR_AT 1
EOF
 ISOcxx_HAS_VECTOR_AT=@@; echo "==>  ISOcxx_HAS_VECTOR_AT" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_VECTOR_AT ${t}
EOF
 DEFECT_NO_VECTOR_AT=@${t}@; echo "==>  DEFECT_NO_VECTOR_AT = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_VECTOR_AT"
    status=cured
          for T in atvec.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for <vector> at() defect via ${T}""... $ac_c" 1>&6
echo "configure:12622: checking cure for <vector> at() defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12630 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12635: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_VECTOR_AT"
    fi
  fi

# ----------------------------------------------------------------------
# queue<>s:
# ----------------------------------------------------------------------

# Do <queue>s have the container_type typedef?
# MUST PRECEDE OTHER queue<> tests
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in conttque.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking queue<> container_type via ${T}""... $ac_c" 1>&6
echo "configure:12676: checking queue<> container_type via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12685 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12690: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_QUEUE_CONTAINER_TYPE 1
EOF
 ISOcxx_HAS_QUEUE_CONTAINER_TYPE=@@; echo "==>  ISOcxx_HAS_QUEUE_CONTAINER_TYPE" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_QUEUE_CONTAINER_TYPE ${t}
EOF
 DEFECT_NO_QUEUE_CONTAINER_TYPE=@${t}@; echo "==>  DEFECT_NO_QUEUE_CONTAINER_TYPE = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_QUEUE_CONTAINER_TYPE"
    status=cured
          for T in conttque.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for queue<> container_type defect via ${T}""... $ac_c" 1>&6
echo "configure:12732: checking cure for queue<> container_type defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12740 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12745: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_QUEUE_CONTAINER_TYPE"
    fi
  fi

# Do queue<>s have the correct Container default?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in defque.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking queue<>'s Container default via ${T}""... $ac_c" 1>&6
echo "configure:12780: checking queue<>'s Container default via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12789 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12794: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_QUEUE_DEFAULT_CONTAINER 1
EOF
 ISOcxx_OK_QUEUE_DEFAULT_CONTAINER=@@; echo "==>  ISOcxx_OK_QUEUE_DEFAULT_CONTAINER" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_BAD_QUEUE_DEFAULT_CONTAINER ${t}
EOF
 DEFECT_BAD_QUEUE_DEFAULT_CONTAINER=@${t}@; echo "==>  DEFECT_BAD_QUEUE_DEFAULT_CONTAINER = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_BAD_QUEUE_DEFAULT_CONTAINER"
    status=cured
          for T in defque.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for queue<>'s Container default defect via ${T}""... $ac_c" 1>&6
echo "configure:12836: checking cure for queue<>'s Container default defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12844 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12849: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_BAD_QUEUE_DEFAULT_CONTAINER"
    fi
  fi

# Do queue<>s support custom underlying containers?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in contque.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking queue<> custom container via ${T}""... $ac_c" 1>&6
echo "configure:12884: checking queue<> custom container via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12893 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12898: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_QUEUE_CONTAINER 1
EOF
 ISOcxx_OK_QUEUE_CONTAINER=@@; echo "==>  ISOcxx_OK_QUEUE_CONTAINER" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_QUEUE_CONTAINER ${t}
EOF
 DEFECT_NO_QUEUE_CONTAINER=@${t}@; echo "==>  DEFECT_NO_QUEUE_CONTAINER = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_QUEUE_CONTAINER"
    status=cured
          for T in contque.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for queue<> custom container defect via ${T}""... $ac_c" 1>&6
echo "configure:12940: checking cure for queue<> custom container defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 12948 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:12953: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_QUEUE_CONTAINER"
    fi
  fi

# ----------------------------------------------------------------------
# priority_queue<>s:
# ----------------------------------------------------------------------

# Do priority_queue<>s have the correct Container default?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in defpriq.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking priority_queue<>'s Container default via ${T}""... $ac_c" 1>&6
echo "configure:12993: checking priority_queue<>'s Container default via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13002 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13007: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_PRIQ_DEFAULT_CONTAINER 1
EOF
 ISOcxx_OK_PRIQ_DEFAULT_CONTAINER=@@; echo "==>  ISOcxx_OK_PRIQ_DEFAULT_CONTAINER" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_BAD_PRIQ_DEFAULT_CONTAINER ${t}
EOF
 DEFECT_BAD_PRIQ_DEFAULT_CONTAINER=@${t}@; echo "==>  DEFECT_BAD_PRIQ_DEFAULT_CONTAINER = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_BAD_PRIQ_DEFAULT_CONTAINER"
    status=cured
          for T in defpriq.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for priority_queue<>'s Container default defect via ${T}""... $ac_c" 1>&6
echo "configure:13049: checking cure for priority_queue<>'s Container default defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13057 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13062: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_BAD_PRIQ_DEFAULT_CONTAINER"
    fi
  fi

# Do priority_queue<>s support custom underlying containers?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in contpriq.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking priority_queue<> custom container via ${T}""... $ac_c" 1>&6
echo "configure:13097: checking priority_queue<> custom container via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13106 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13111: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_PRIQ_CONTAINER 1
EOF
 ISOcxx_OK_PRIQ_CONTAINER=@@; echo "==>  ISOcxx_OK_PRIQ_CONTAINER" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_PRIQ_CONTAINER ${t}
EOF
 DEFECT_NO_PRIQ_CONTAINER=@${t}@; echo "==>  DEFECT_NO_PRIQ_CONTAINER = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_PRIQ_CONTAINER"
    status=cured
          for T in contpriq.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for priority_queue<> custom container defect via ${T}""... $ac_c" 1>&6
echo "configure:13153: checking cure for priority_queue<> custom container defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13161 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13166: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_PRIQ_CONTAINER"
    fi
  fi

# Do priority_queue<>s support custom comparators?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in comppriq.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking priority_queue<> custom comparator via ${T}""... $ac_c" 1>&6
echo "configure:13201: checking priority_queue<> custom comparator via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13210 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13215: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_PRIQ_COMPARATOR 1
EOF
 ISOcxx_OK_PRIQ_COMPARATOR=@@; echo "==>  ISOcxx_OK_PRIQ_COMPARATOR" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_PRIQ_COMPARATOR ${t}
EOF
 DEFECT_NO_PRIQ_COMPARATOR=@${t}@; echo "==>  DEFECT_NO_PRIQ_COMPARATOR = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_PRIQ_COMPARATOR"
    status=cured
          for T in comppriq.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for priority_queue<> custom comparator defect via ${T}""... $ac_c" 1>&6
echo "configure:13257: checking cure for priority_queue<> custom comparator defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13265 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13270: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_PRIQ_COMPARATOR"
    fi
  fi

# ----------------------------------------------------------------------
# stack<>s:
# ----------------------------------------------------------------------

# Do <stack>s have the container_type typedef?
# MUST PRECEDE OTHER stack<> tests
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in conttstk.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking stack<> container_type via ${T}""... $ac_c" 1>&6
echo "configure:13311: checking stack<> container_type via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13320 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13325: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_HAS_STACK_CONTAINER_TYPE 1
EOF
 ISOcxx_HAS_STACK_CONTAINER_TYPE=@@; echo "==>  ISOcxx_HAS_STACK_CONTAINER_TYPE" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_STACK_CONTAINER_TYPE ${t}
EOF
 DEFECT_NO_STACK_CONTAINER_TYPE=@${t}@; echo "==>  DEFECT_NO_STACK_CONTAINER_TYPE = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_STACK_CONTAINER_TYPE"
    status=cured
          for T in conttstk.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for stack<> container_type defect via ${T}""... $ac_c" 1>&6
echo "configure:13367: checking cure for stack<> container_type defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13375 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13380: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_STACK_CONTAINER_TYPE"
    fi
  fi

# Do stack<>s have the correct Container default?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in defstk.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking stack<>'s Container default via ${T}""... $ac_c" 1>&6
echo "configure:13415: checking stack<>'s Container default via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13424 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13429: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_STACK_DEFAULT_CONTAINER 1
EOF
 ISOcxx_OK_STACK_DEFAULT_CONTAINER=@@; echo "==>  ISOcxx_OK_STACK_DEFAULT_CONTAINER" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_BAD_STACK_DEFAULT_CONTAINER ${t}
EOF
 DEFECT_BAD_STACK_DEFAULT_CONTAINER=@${t}@; echo "==>  DEFECT_BAD_STACK_DEFAULT_CONTAINER = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_BAD_STACK_DEFAULT_CONTAINER"
    status=cured
          for T in defstk.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for stack<>'s Container default defect via ${T}""... $ac_c" 1>&6
echo "configure:13471: checking cure for stack<>'s Container default defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13479 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13484: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_BAD_STACK_DEFAULT_CONTAINER"
    fi
  fi

# Do stack<>s support custom underlying containers?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in contstk.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking stack<> custom container via ${T}""... $ac_c" 1>&6
echo "configure:13519: checking stack<> custom container via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13528 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13533: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_STACK_CONTAINER 1
EOF
 ISOcxx_OK_STACK_CONTAINER=@@; echo "==>  ISOcxx_OK_STACK_CONTAINER" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_STACK_CONTAINER ${t}
EOF
 DEFECT_NO_STACK_CONTAINER=@${t}@; echo "==>  DEFECT_NO_STACK_CONTAINER = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_STACK_CONTAINER"
    status=cured
          for T in contstk.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for stack<> custom container defect via ${T}""... $ac_c" 1>&6
echo "configure:13575: checking cure for stack<> custom container defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13583 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13588: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_STACK_CONTAINER"
    fi
  fi

# ----------------------------------------------------------------------
# map<>s:
# ----------------------------------------------------------------------

# Do map<>s support custom comparators?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in compmap.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking map<> custom comparator via ${T}""... $ac_c" 1>&6
echo "configure:13628: checking map<> custom comparator via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13637 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13642: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_MAP_COMPARATOR 1
EOF
 ISOcxx_OK_MAP_COMPARATOR=@@; echo "==>  ISOcxx_OK_MAP_COMPARATOR" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_MAP_COMPARATOR ${t}
EOF
 DEFECT_NO_MAP_COMPARATOR=@${t}@; echo "==>  DEFECT_NO_MAP_COMPARATOR = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_MAP_COMPARATOR"
    status=cured
          for T in compmap.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for map<> custom comparator defect via ${T}""... $ac_c" 1>&6
echo "configure:13684: checking cure for map<> custom comparator defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13692 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13697: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_MAP_COMPARATOR"
    fi
  fi

# Do map<>s have the correct default allocators?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in defmapal.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking map<> default allocator via ${T}""... $ac_c" 1>&6
echo "configure:13732: checking map<> default allocator via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13741 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13746: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_MAP_DEFAULT_ALLOCATOR 1
EOF
 ISOcxx_OK_MAP_DEFAULT_ALLOCATOR=@@; echo "==>  ISOcxx_OK_MAP_DEFAULT_ALLOCATOR" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_BAD_MAP_DEFAULT_ALLOCATOR ${t}
EOF
 DEFECT_BAD_MAP_DEFAULT_ALLOCATOR=@${t}@; echo "==>  DEFECT_BAD_MAP_DEFAULT_ALLOCATOR = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_BAD_MAP_DEFAULT_ALLOCATOR"
    status=cured
          for T in defmapal.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for map<> default allocator defect via ${T}""... $ac_c" 1>&6
echo "configure:13788: checking cure for map<> default allocator defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13796 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13801: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_BAD_MAP_DEFAULT_ALLOCATOR"
    fi
  fi

# Do map<>s support custom allocators?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in allocmap.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking map<> custom allocator via ${T}""... $ac_c" 1>&6
echo "configure:13836: checking map<> custom allocator via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13845 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13850: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_MAP_ALLOCATOR 1
EOF
 ISOcxx_OK_MAP_ALLOCATOR=@@; echo "==>  ISOcxx_OK_MAP_ALLOCATOR" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_MAP_ALLOCATOR ${t}
EOF
 DEFECT_NO_MAP_ALLOCATOR=@${t}@; echo "==>  DEFECT_NO_MAP_ALLOCATOR = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_MAP_ALLOCATOR"
    status=cured
          for T in allocmap.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for map<> custom allocator defect via ${T}""... $ac_c" 1>&6
echo "configure:13892: checking cure for map<> custom allocator defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13900 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13905: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_MAP_ALLOCATOR"
    fi
  fi

# ----------------------------------------------------------------------
# set<>s:
# ----------------------------------------------------------------------

# Do set<>s support custom comparators?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in compset.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking set<> custom comparator via ${T}""... $ac_c" 1>&6
echo "configure:13945: checking set<> custom comparator via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 13954 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:13959: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_SET_COMPARATOR 1
EOF
 ISOcxx_OK_SET_COMPARATOR=@@; echo "==>  ISOcxx_OK_SET_COMPARATOR" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_SET_COMPARATOR ${t}
EOF
 DEFECT_NO_SET_COMPARATOR=@${t}@; echo "==>  DEFECT_NO_SET_COMPARATOR = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_SET_COMPARATOR"
    status=cured
          for T in compset.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for set<> custom comparator defect via ${T}""... $ac_c" 1>&6
echo "configure:14001: checking cure for set<> custom comparator defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 14009 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:14014: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_SET_COMPARATOR"
    fi
  fi

# Do set<>s support custom allocators?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in allocset.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking set<> custom allocator via ${T}""... $ac_c" 1>&6
echo "configure:14049: checking set<> custom allocator via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 14058 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:14063: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_SET_ALLOCATOR 1
EOF
 ISOcxx_OK_SET_ALLOCATOR=@@; echo "==>  ISOcxx_OK_SET_ALLOCATOR" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_SET_ALLOCATOR ${t}
EOF
 DEFECT_NO_SET_ALLOCATOR=@${t}@; echo "==>  DEFECT_NO_SET_ALLOCATOR = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_SET_ALLOCATOR"
    status=cured
          for T in allocset.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for set<> custom allocator defect via ${T}""... $ac_c" 1>&6
echo "configure:14105: checking cure for set<> custom allocator defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 14113 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:14118: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_SET_ALLOCATOR"
    fi
  fi

# ----------------------------------------------------------------------
# multimap<>s:
# ----------------------------------------------------------------------

# Do multimap<>s support custom comparators?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in compmmap.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking multimap<> custom comparator via ${T}""... $ac_c" 1>&6
echo "configure:14158: checking multimap<> custom comparator via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 14167 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:14172: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_MULTIMAP_COMPARATOR 1
EOF
 ISOcxx_OK_MULTIMAP_COMPARATOR=@@; echo "==>  ISOcxx_OK_MULTIMAP_COMPARATOR" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_MULTIMAP_COMPARATOR ${t}
EOF
 DEFECT_NO_MULTIMAP_COMPARATOR=@${t}@; echo "==>  DEFECT_NO_MULTIMAP_COMPARATOR = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_MULTIMAP_COMPARATOR"
    status=cured
          for T in compmmap.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for multimap<> custom comparator defect via ${T}""... $ac_c" 1>&6
echo "configure:14214: checking cure for multimap<> custom comparator defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 14222 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:14227: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_MULTIMAP_COMPARATOR"
    fi
  fi

# Do multimap<>s support custom allocators?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in allocmmp.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking multimap<> custom allocator via ${T}""... $ac_c" 1>&6
echo "configure:14262: checking multimap<> custom allocator via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 14271 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:14276: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_MULTIMAP_ALLOCATOR 1
EOF
 ISOcxx_OK_MULTIMAP_ALLOCATOR=@@; echo "==>  ISOcxx_OK_MULTIMAP_ALLOCATOR" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_MULTIMAP_ALLOCATOR ${t}
EOF
 DEFECT_NO_MULTIMAP_ALLOCATOR=@${t}@; echo "==>  DEFECT_NO_MULTIMAP_ALLOCATOR = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_MULTIMAP_ALLOCATOR"
    status=cured
          for T in allocmmp.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for multimap<> custom allocator defect via ${T}""... $ac_c" 1>&6
echo "configure:14318: checking cure for multimap<> custom allocator defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 14326 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:14331: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_MULTIMAP_ALLOCATOR"
    fi
  fi

# ----------------------------------------------------------------------
# multiset<>s:
# ----------------------------------------------------------------------

# Do multiset<>s support custom comparators?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in compmset.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking multiset<> custom comparator via ${T}""... $ac_c" 1>&6
echo "configure:14371: checking multiset<> custom comparator via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 14380 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:14385: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_MULTISET_COMPARATOR 1
EOF
 ISOcxx_OK_MULTISET_COMPARATOR=@@; echo "==>  ISOcxx_OK_MULTISET_COMPARATOR" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_MULTISET_COMPARATOR ${t}
EOF
 DEFECT_NO_MULTISET_COMPARATOR=@${t}@; echo "==>  DEFECT_NO_MULTISET_COMPARATOR = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_MULTISET_COMPARATOR"
    status=cured
          for T in compmset.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for multiset<> custom comparator defect via ${T}""... $ac_c" 1>&6
echo "configure:14427: checking cure for multiset<> custom comparator defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 14435 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:14440: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_MULTISET_COMPARATOR"
    fi
  fi

# Do multiset<>s support custom allocators?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in allocmst.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking multiset<> custom allocator via ${T}""... $ac_c" 1>&6
echo "configure:14475: checking multiset<> custom allocator via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 14484 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:14489: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_MULTISET_ALLOCATOR 1
EOF
 ISOcxx_OK_MULTISET_ALLOCATOR=@@; echo "==>  ISOcxx_OK_MULTISET_ALLOCATOR" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_NO_MULTISET_ALLOCATOR ${t}
EOF
 DEFECT_NO_MULTISET_ALLOCATOR=@${t}@; echo "==>  DEFECT_NO_MULTISET_ALLOCATOR = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_NO_MULTISET_ALLOCATOR"
    status=cured
          for T in allocmst.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for multiset<> custom allocator defect via ${T}""... $ac_c" 1>&6
echo "configure:14531: checking cure for multiset<> custom allocator defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 14539 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:14544: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_NO_MULTISET_ALLOCATOR"
    fi
  fi

# ----------------------------------------------------------------------
# bitset<>s:
# ----------------------------------------------------------------------

# Do we have basic bitset<> support?
  status=ok
  t=0
  # try tests that ought to succeed:
      for T in bitset.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking basic bitset<> support via ${T}""... $ac_c" 1>&6
echo "configure:14584: checking basic bitset<> support via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 14593 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:14598: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=defective
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define ISOcxx_OK_BITSET_SUPPORT 1
EOF
 ISOcxx_OK_BITSET_SUPPORT=@@; echo "==>  ISOcxx_OK_BITSET_SUPPORT" >&5
  else
    cat >> confdefs.h <<EOF
#define DEFECT_BAD_BITSET_SUPPORT ${t}
EOF
 DEFECT_BAD_BITSET_SUPPORT=@${t}@; echo "==>  DEFECT_BAD_BITSET_SUPPORT = ${t}" >&5
  fi
  # validate fix:
  if test "${status}" = "defective" ; then :
    defect_list="${defect_list}\\n\\tDEFECT_BAD_BITSET_SUPPORT"
    status=cured
          for T in bitset.cc ; do
        if test "${status}" != "cured" ; then break ; fi
        echo $ac_n "checking cure for basic bitset<> support defect via ${T}""... $ac_c" 1>&6
echo "configure:14640: checking cure for basic bitset<> support defect via ${T}" >&5
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 14648 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:14653: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=cured
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      done
    :
    if test "${status}" = "PROBLEM!" ; then
      ISOcxx_success=no
      problem_list="${problem_list}\\n\\tDEFECT_BAD_BITSET_SUPPORT"
    fi
  fi

# ----------------------------------------------------------------------
# Begin seeking library extensions:
# ----------------------------------------------------------------------

printf "\n=====  Probe for library extensions:  =====\n" 1>&6
echo "configure:14687: =====  Probe for library extensions:  =====" >&5

# ----------------------------------------------------------------------
# Do we support (nonstandard) long long streaming?
# ----------------------------------------------------------------------

  status=ok
  t=0
  # try tests that ought to succeed if extension is supported:
      for T in llio.cc ; do
      if test "${status}" = "ok" ; then :
        echo $ac_n "checking (nonstandard) long long streaming via ${T}""... $ac_c" 1>&6
echo "configure:14700: checking (nonstandard) long long streaming via ${T}" >&5
        t=`expr \( ${t} + 1 \)`
        
if test -z "${path_filter}" ; then :
  testpgm=""${testdir}${T}""
else
  testpgm="`${path_filter} "${testdir}${T}"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 14709 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:14714: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status="unsupported; ok"
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
        echo "$ac_t""${status}" 1>&6
      fi
    done
  # try tests that ought to fail if extension is supported:
  :
  # set final status:
  if test "${status}" = "ok" ; then
    cat >> confdefs.h <<EOF
#define EXTENSION_LONG_LONG_STREAM_OPERATOR 1
EOF
 EXTENSION_LONG_LONG_STREAM_OPERATOR=@@; echo "==>  EXTENSION_LONG_LONG_STREAM_OPERATOR" >&5
  else
    echo "==>  ${status}" >&5
  fi

# ----------------------------------------------------------------------
# Final check:
# ----------------------------------------------------------------------

printf "\n=====  Epilog:  =====\n" 1>&6
echo "configure:14754: =====  Epilog:  =====" >&5

# ----------------------------------------------------------------------
# Test all library headers' accessibility:
# ----------------------------------------------------------------------

echo $ac_n "checking library accessibility via library.cc""... $ac_c" 1>&6
echo "configure:14762: checking library accessibility via library.cc" >&5

if test -z "${path_filter}" ; then :
  testpgm=""${testdir}library.cc""
else
  testpgm="`${path_filter} "${testdir}library.cc"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 14770 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:14775: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=ok
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
echo "$ac_t""${status}" 1>&6

# ----------------------------------------------------------------------
# Final test for ISOcxx internal consistency:
# ----------------------------------------------------------------------

echo $ac_n "checking ISOcxx internal consistency via final.cc""... $ac_c" 1>&6
echo "configure:14801: checking ISOcxx internal consistency via final.cc" >&5

if test -z "${path_filter}" ; then :
  testpgm=""${testdir}final.cc""
else
  testpgm="`${path_filter} "${testdir}final.cc"`"
fi
cat > conftest.${ac_ext} <<EOF
#line 14809 "configure"
#include "confdefs.h"
#include "${testpgm}"
EOF
unset testpgm
if { (eval echo configure:14814: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest ; exit) 2>/dev/null ; then :
  status=ok
else
  if test -s conftest${ac_exeext} ; then :
    ./conftest 2> /dev/null
    echo "configure: program's exit status was:" $? >&5
  fi
  echo "configure: failed program was:" >&5
  cat conftest.${ac_ext} >&5
  echo "configure: after preprocessing, failed program was:" >&5
  ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\
  | tr -d '\015'\
  | sed -n -e 's/  *$//' -e '/^./p'\
  ) >&5 2>&5
  status=PROBLEM!
fi
echo "" >&5
rm -rf `find . -name 'conftest*'`
echo "$ac_t""${status}" 1>&6

# ----------------------------------------------------------------------
# Done; produce output file, summary information, and validate success:
# ----------------------------------------------------------------------

trap '' 1 2 15

trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15

test "x$prefix" = xNONE && prefix=$ac_default_prefix
# Let make expand exec_prefix.
test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'

# Any assignment to VPATH causes Sun make to only execute
# the first set of double-colon rules, so remove it if not needed.
# If there is a colon in the path, we need to keep it.
if test "x$srcdir" = x.; then
  ac_vpsub='/^[ 	]*VPATH[ 	]*=[^:]*$/d'
fi

trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15

DEFS=-DHAVE_CONFIG_H

# Without the "./", some shells look in PATH for config.status.
: ${CONFIG_STATUS=./config.status}

echo creating $CONFIG_STATUS
rm -f $CONFIG_STATUS
cat > $CONFIG_STATUS <<EOF
#! /bin/sh
# Generated automatically by configure.
# Run this file to recreate the current configuration.
# This directory was configured as follows,
# on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
#
# $0 $ac_configure_args
#
# Compiler output produced by configure, useful for debugging
# configure, is in ./config.log if it exists.

ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
for ac_option
do
  case "\$ac_option" in
  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
    echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
    exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
  -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
    echo "$CONFIG_STATUS generated by autoconf version 2.13"
    exit 0 ;;
  -help | --help | --hel | --he | --h)
    echo "\$ac_cs_usage"; exit 0 ;;
  *) echo "\$ac_cs_usage"; exit 1 ;;
  esac
done

ac_given_srcdir=$srcdir

trap 'rm -fr `echo " ISOcxx.h" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
EOF
cat >> $CONFIG_STATUS <<EOF

# Protect against being on the right side of a sed subst in config.status.
sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
 s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
$ac_vpsub
$extrasub
s%@SHELL@%$SHELL%g
s%@CFLAGS@%$CFLAGS%g
s%@CPPFLAGS@%$CPPFLAGS%g
s%@CXXFLAGS@%$CXXFLAGS%g
s%@FFLAGS@%$FFLAGS%g
s%@DEFS@%$DEFS%g
s%@LDFLAGS@%$LDFLAGS%g
s%@LIBS@%$LIBS%g
s%@exec_prefix@%$exec_prefix%g
s%@prefix@%$prefix%g
s%@program_transform_name@%$program_transform_name%g
s%@bindir@%$bindir%g
s%@sbindir@%$sbindir%g
s%@libexecdir@%$libexecdir%g
s%@datadir@%$datadir%g
s%@sysconfdir@%$sysconfdir%g
s%@sharedstatedir@%$sharedstatedir%g
s%@localstatedir@%$localstatedir%g
s%@libdir@%$libdir%g
s%@includedir@%$includedir%g
s%@oldincludedir@%$oldincludedir%g
s%@infodir@%$infodir%g
s%@mandir@%$mandir%g
s%@CXX@%$CXX%g
s%@path_filter@%$path_filter%g

CEOF
EOF

cat >> $CONFIG_STATUS <<\EOF

# Split the substitutions into bite-sized pieces for seds with
# small command number limits, like on Digital OSF/1 and HP-UX.
ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
ac_file=1 # Number of current file.
ac_beg=1 # First line for current file.
ac_end=$ac_max_sed_cmds # Line after last line for current file.
ac_more_lines=:
ac_sed_cmds=""
while $ac_more_lines; do
  if test $ac_beg -gt 1; then
    sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
  else
    sed "${ac_end}q" conftest.subs > conftest.s$ac_file
  fi
  if test ! -s conftest.s$ac_file; then
    ac_more_lines=false
    rm -f conftest.s$ac_file
  else
    if test -z "$ac_sed_cmds"; then
      ac_sed_cmds="sed -f conftest.s$ac_file"
    else
      ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
    fi
    ac_file=`expr $ac_file + 1`
    ac_beg=$ac_end
    ac_end=`expr $ac_end + $ac_max_sed_cmds`
  fi
done
if test -z "$ac_sed_cmds"; then
  ac_sed_cmds=cat
fi
EOF

cat >> $CONFIG_STATUS <<EOF

CONFIG_FILES=\${CONFIG_FILES-""}
EOF
cat >> $CONFIG_STATUS <<\EOF
for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
  case "$ac_file" in
  *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
       ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
  *) ac_file_in="${ac_file}.in" ;;
  esac

  # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.

  # Remove last slash and all that follows it.  Not all systems have dirname.
  ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
  if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
    # The file is in a subdirectory.
    test ! -d "$ac_dir" && mkdir "$ac_dir"
    ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
    # A "../" for each directory in $ac_dir_suffix.
    ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
  else
    ac_dir_suffix= ac_dots=
  fi

  case "$ac_given_srcdir" in
  .)  srcdir=.
      if test -z "$ac_dots"; then top_srcdir=.
      else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
  /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
  *) # Relative path.
    srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
    top_srcdir="$ac_dots$ac_given_srcdir" ;;
  esac

  echo creating "$ac_file"
  rm -f "$ac_file"
  configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
  case "$ac_file" in
  *Makefile*) ac_comsub="1i\\
# $configure_input" ;;
  *) ac_comsub= ;;
  esac

  ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
  sed -e "$ac_comsub
s%@configure_input@%$configure_input%g
s%@srcdir@%$srcdir%g
s%@top_srcdir@%$top_srcdir%g
" $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
fi; done
rm -f conftest.s*

# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where
# NAME is the cpp macro being defined and VALUE is the value it is being given.
#
# ac_d sets the value in "#define NAME VALUE" lines.
ac_dA='s%^\([ 	]*\)#\([ 	]*define[ 	][ 	]*\)'
ac_dB='\([ 	][ 	]*\)[^ 	]*%\1#\2'
ac_dC='\3'
ac_dD='%g'
# ac_u turns "#undef NAME" with trailing blanks into "#define NAME VALUE".
ac_uA='s%^\([ 	]*\)#\([ 	]*\)undef\([ 	][ 	]*\)'
ac_uB='\([ 	]\)%\1#\2define\3'
ac_uC=' '
ac_uD='\4%g'
# ac_e turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
ac_eA='s%^\([ 	]*\)#\([ 	]*\)undef\([ 	][ 	]*\)'
ac_eB='$%\1#\2define\3'
ac_eC=' '
ac_eD='%g'

if test "${CONFIG_HEADERS+set}" != set; then
EOF
cat >> $CONFIG_STATUS <<EOF
  CONFIG_HEADERS="ISOcxx.h"
EOF
cat >> $CONFIG_STATUS <<\EOF
fi
for ac_file in .. $CONFIG_HEADERS; do if test "x$ac_file" != x..; then
  # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
  case "$ac_file" in
  *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
       ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
  *) ac_file_in="${ac_file}.in" ;;
  esac

  echo creating $ac_file

  rm -f conftest.frag conftest.in conftest.out
  ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
  cat $ac_file_inputs > conftest.in

EOF

# Transform confdefs.h into a sed script conftest.vals that substitutes
# the proper values into config.h.in to produce config.h.  And first:
# Protect against being on the right side of a sed subst in config.status.
# Protect against being in an unquoted here document in config.status.
rm -f conftest.vals
cat > conftest.hdr <<\EOF
s/[\\&%]/\\&/g
s%[\\$`]%\\&%g
s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD}%gp
s%ac_d%ac_u%gp
s%ac_u%ac_e%gp
EOF
sed -n -f conftest.hdr confdefs.h > conftest.vals
rm -f conftest.hdr

# This sed command replaces #undef with comments.  This is necessary, for
# example, in the case of _POSIX_SOURCE, which is predefined and required
# on some systems where configure will not decide to define it.
cat >> conftest.vals <<\EOF
s%^[ 	]*#[ 	]*undef[ 	][ 	]*[a-zA-Z_][a-zA-Z_0-9]*%/* & */%
EOF

# Break up conftest.vals because some shells have a limit on
# the size of here documents, and old seds have small limits too.

rm -f conftest.tail
while :
do
  ac_lines=`grep -c . conftest.vals`
  # grep -c gives empty output for an empty file on some AIX systems.
  if test -z "$ac_lines" || test "$ac_lines" -eq 0; then break; fi
  # Write a limited-size here document to conftest.frag.
  echo '  cat > conftest.frag <<CEOF' >> $CONFIG_STATUS
  sed ${ac_max_here_lines}q conftest.vals >> $CONFIG_STATUS
  echo 'CEOF
  sed -f conftest.frag conftest.in > conftest.out
  rm -f conftest.in
  mv conftest.out conftest.in
' >> $CONFIG_STATUS
  sed 1,${ac_max_here_lines}d conftest.vals > conftest.tail
  rm -f conftest.vals
  mv conftest.tail conftest.vals
done
rm -f conftest.vals

cat >> $CONFIG_STATUS <<\EOF
  rm -f conftest.frag conftest.h
  echo "/* $ac_file.  Generated automatically by configure.  */" > conftest.h
  cat conftest.in >> conftest.h
  rm -f conftest.in
  if cmp -s $ac_file conftest.h 2>/dev/null; then
    echo "$ac_file is unchanged"
    rm -f conftest.h
  else
    # Remove last slash and all that follows it.  Not all systems have dirname.
      ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
      if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
      # The file is in a subdirectory.
      test ! -d "$ac_dir" && mkdir "$ac_dir"
    fi
    rm -f $ac_file
    mv conftest.h $ac_file
  fi
fi; done

EOF
cat >> $CONFIG_STATUS <<EOF

EOF
cat >> $CONFIG_STATUS <<\EOF

exit 0
EOF
chmod +x $CONFIG_STATUS
rm -fr confdefs* $ac_clean_files
test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1

if test "$defect_list" = "" ; then
  printf "\n=====  No defects detected!  =====\n" 1>&6
echo "configure:15144: =====  No defects detected!  =====" >&5
else
  printf "\n=====  Summary of defects detected:  ${defect_list}\\n  =====\n" 1>&6
echo "configure:15147: =====  Summary of defects detected:  ${defect_list}\\n  =====" >&5
fi

if test "$problem_list" != "" ; then
  printf "\n=====  Summary of PROBLEMs needing attention:  ${problem_list}\\n  =====\n" 1>&6
echo "configure:15152: =====  Summary of PROBLEMs needing attention:  ${problem_list}\\n  =====" >&5
fi

test "${ISOcxx_success}" = yes || exit 9