# ====================================================================== # This is the ISOcxx configuration input file # ====================================================================== # ---------------------------------------------------------------------- # Disable autoconf caching: # ---------------------------------------------------------------------- define([AC_CACHE_LOAD],)dnl define([AC_CACHE_SAVE],)dnl # ---------------------------------------------------------------------- # Identify the header file we are intended to produce: # ---------------------------------------------------------------------- AC_PREREQ(2.13) AC_REVISION([21-Jul-2000 WEB -- Do not hand-edit!]) AC_INIT() AC_CONFIG_HEADER(ISOcxx.h) # ---------------------------------------------------------------------- # Prepare environment: # ---------------------------------------------------------------------- dnl autoconf 2.13 version is buggy pushdef('AC_PROG_CXXCPP', '[AC_MSG_CHECKING(how to run the local C++ preprocessor) if test -z "${CXXCPP}"; then AC_CACHE_VAL(ac_cv_prog_CXXCPP, [AC_LANG_SAVE[]dnl AC_LANG_CPLUSPLUS[]dnl CXXCPP="${CXX-g++} -E" AC_TRY_CPP([#include ], , CXXCPP=/lib/cpp) ac_cv_prog_CXXCPP="${CXXCPP}" AC_LANG_RESTORE[]dnl ])dnl fi AC_MSG_RESULT(${CXXCPP}) AC_SUBST(CXXCPP)dnl ]') # Anticipate success: ISOcxx_success=yes dnl ISOcxx_MSG(TEXT) define(ISOcxx_MSG, [printf "\n===== $1 =====\n" 1>&AC_FD_MSG echo "configure:__oline__: ===== $1 =====" >&AC_FD_CC]) ISOcxx_MSG(Prolog:) AC_PROG_CXX #AC_PROG_CXXCPP AC_LANG_CPLUSPLUS AC_REQUIRE_CPP # Source file suffix '.C' is deadly to MSVC++: C compilation results! ac_ext=cc AC_CHECK_PROG(path_filter, cygpath -w, cygpath -w) # ---------------------------------------------------------------------- # ISOcxx_INCLUDE(FILE-TO-INCLUDE) # ---------------------------------------------------------------------- AC_DEFUN(ISOcxx_INCLUDE, [ifelse($1, [], [], [dnl esyscmd([for file in $1 ; do echo "builtin(include,${file})dnl" ; done]) ])]) # ---------------------------------------------------------------------- # ISOcxx_TRY_COMPILE(PGM-TO-TRY [, SUCCESS-ACTION [, FAILURE-ACTION]]): # ---------------------------------------------------------------------- AC_DEFUN(ISOcxx_TRY_COMPILE, [ if test -z "${path_filter}" ; then : testpgm="$1" else testpgm="`${path_filter} $1`" fi cat > conftest.${ac_ext} <&AC_FD_CC cat conftest.${ac_ext} >&AC_FD_CC [echo "configure: after preprocessing, failed program was:" >&AC_FD_CC] ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\ | tr -d '\015'\ | sed -n -e 's/ *$//' -e '/^./p'\ ) >&AC_FD_CC 2>&AC_FD_CC ifelse([$3], [], :, [$3]) fi echo "" >&AC_FD_CC rm -rf `find . -name 'conftest*'`) # ---------------------------------------------------------------------- # ISOcxx_TRY_LINK(PGM-TO-TRY [, SUCCESS-ACTION [, FAILURE-ACTION]]): # ---------------------------------------------------------------------- AC_DEFUN(ISOcxx_TRY_LINK, [ if test -z "${path_filter}" ; then : testpgm="$1" else testpgm="`${path_filter} $1`" fi cat > conftest.${ac_ext} <&AC_FD_CC cat conftest.${ac_ext} >&AC_FD_CC [echo "configure: after preprocessing, failed program was:" >&AC_FD_CC] ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\ | tr -d '\015'\ | sed -n -e 's/ *$//' -e '/^./p'\ ) >&AC_FD_CC 2>&AC_FD_CC ifelse([$3], [], :, [$3]) fi echo "" >&AC_FD_CC rm -rf `find . -name 'conftest*'`) # ---------------------------------------------------------------------- # ISOcxx_TRY_RUN(PGM-TO-TRY [, SUCCESS-ACTION [, FAILURE-ACTION]]) # ---------------------------------------------------------------------- AC_DEFUN(ISOcxx_TRY_RUN, [ if test -z "${path_filter}" ; then : testpgm="$1" else testpgm="`${path_filter} $1`" fi cat > conftest.${ac_ext} </dev/null ; then : ifelse([$2], [], :, [$2]) else if test -s conftest${ac_exeext} ; then : ./conftest 2> /dev/null echo "configure: program's exit status was:" $? >&AC_FD_CC fi echo "configure: failed program was:" >&AC_FD_CC cat conftest.${ac_ext} >&AC_FD_CC [echo "configure: after preprocessing, failed program was:" >&AC_FD_CC] ( ${CXXCPP} ${CPPFLAGS} conftest.${ac_ext}\ | tr -d '\015'\ | sed -n -e 's/ *$//' -e '/^./p'\ ) >&AC_FD_CC 2>&AC_FD_CC ifelse([$3], [], :, [$3]) fi echo "" >&AC_FD_CC rm -rf `find . -name 'conftest*'`) # ---------------------------------------------------------------------- # ISOcxx_TEST_DEFECT(TEXT_DESCRIPTION, # DEFECT_PRESENCE_SYMBOL,DEFECT_ABSENCE-SYMBOL, # LIST-OF-TESTS-TO-SUCCEED,LIST-OF-TESTS-TO-FAIL): # ---------------------------------------------------------------------- AC_DEFUN(ISOcxx_TEST_DEFECT, [dnl status=ok t=0 [#] try tests that ought to succeed: ifelse([$4], [], :,[dnl for T in $4 ; do if test "${status}" = "ok" ; then : AC_MSG_CHECKING([$1 via ${T}]) t=`expr \( ${t} + 1 \)` ISOcxx_TRY_RUN(["${testdir}${T}"], [], status=defective) AC_MSG_RESULT(${status}) fi done]) [#] try tests that ought to fail: ifelse([$5], [], :,[dnl for T in $5 ; do if test "${status}" = "ok" ; then : AC_MSG_CHECKING([$1 via ${T}]) t=`expr \( ${t} + 1 \)` ISOcxx_TRY_COMPILE(["${testdir}${T}"], status=defective) AC_MSG_RESULT(${status}) fi done]) [#] set final status: if test "${status}" = "ok" ; then AC_DEFINE_UNQUOTED($3) $3=@@; echo "==> $3" >&AC_FD_CC else AC_DEFINE_UNQUOTED($2,${t}) $2=@${t}@; echo "==> $2 = ${t}" >&AC_FD_CC fi [#] validate fix: if test "${status}" = "defective" ; then : defect_list="${defect_list}\\n\\t$2" status=cured ifelse([$4], [], :,[dnl for T in $4 ; do if test "${status}" != "cured" ; then break ; fi AC_MSG_CHECKING([cure for $1 defect via ${T}]) ISOcxx_TRY_RUN(["${testdir}${T}"],status=cured,status=PROBLEM!) AC_MSG_RESULT(${status}) done]) ifelse([$5], [], :,[dnl for T in $5 ; do if test "${status}" != "cured" ; then break ; fi AC_MSG_CHECKING([cure for $1 defect via ${T}]) ISOcxx_TRY_COMPILE(["${testdir}${T}"],status=PROBLEM!,status=cured) AC_MSG_RESULT(${status}) done]) if test "${status}" = "PROBLEM!" ; then ISOcxx_success=no problem_list="${problem_list}\\n\\t$2" fi fi ]) # ---------------------------------------------------------------------- # ISOcxx_TEST_EXTENSION(TEXT_DESCRIPTION, # EXTENSION_PRESENCE_SYMBOL-SYMBOL, # LIST-OF-TESTS-TO-SUCCEED,LIST-OF-TESTS-TO-FAIL): # ---------------------------------------------------------------------- AC_DEFUN(ISOcxx_TEST_EXTENSION, [dnl status=ok t=0 [#] try tests that ought to succeed if extension is supported: ifelse([$3], [], :,[dnl for T in $3 ; do if test "${status}" = "ok" ; then : AC_MSG_CHECKING([$1 via ${T}]) t=`expr \( ${t} + 1 \)` ISOcxx_TRY_RUN(["${testdir}${T}"], [], status="unsupported; ok") AC_MSG_RESULT(${status}) fi done]) [#] try tests that ought to fail if extension is supported: ifelse([$4], [], :,[dnl for T in $4 ; do if test "${status}" = "ok" ; then : AC_MSG_CHECKING([$1 via ${T}]) t=`expr \( ${t} + 1 \)` ISOcxx_TRY_COMPILE(["${testdir}${T}"], status="unsupported; ok") AC_MSG_RESULT(${status}) fi done]) [#] set final status: if test "${status}" = "ok" ; then AC_DEFINE_UNQUOTED($2) $2=@@; echo "==> $2" >&AC_FD_CC else echo "==> ${status}" >&AC_FD_CC fi ]) # ---------------------------------------------------------------------- # ISOcxx_LOCATE_HDR(HDR-TO-LOCATE, LOCATION, NON-PRIMARY, SECONDARY): # ---------------------------------------------------------------------- AC_DEFUN(ISOcxx_LOCATE_HDR, [dnl AC_MSG_CHECKING(for library header <$1>) unset location for D in ${hdrpath} ; do if test -d ${D} -a -f ${D}$1 ; then : if test -z "${path_filter}" ; then : location="${lquote}${D}$1${rquote}" else location="${lquote}`${path_filter} ${D}$1`${rquote}" fi AC_DEFINE_UNQUOTED($2,${location}) AC_MSG_RESULT(ok) $2=@${location}@; echo "==> $2 = ${location}" >&AC_FD_CC break fi done if test -z "${location}" ; then : ifelse([$3], [], :, [AC_DEFINE_UNQUOTED($3,999) $3=@999@; echo "==> $3 = 999" >&AC_FD_CC]) fi unset location2 ifelse([$4], [], :, [ for D in ${hdrpath} ; do if test -d ${D} -a -f ${D}$1.h ; then : if test -z "${path_filter}" ; then : location2="${lquote}${D}$1.h${rquote}" else location2="${lquote}`${path_filter} ${D}$1.h`${rquote}" fi if test -z "${location}" ; then : AC_DEFINE_UNQUOTED($2,${location2}) AC_MSG_RESULT(ok) $2=@${location2}@; echo "==> $2 = ${location2}" >&AC_FD_CC fi AC_DEFINE_UNQUOTED($4,${location2}) $4=@${location2}@; echo "==> $4 = ${location2}" >&AC_FD_CC break fi done ]) if test -z "${location}" -a -z "${location2}"; then : echo "configure: failed to locate usable <$1> header in any of" >&AC_FD_CC for D in ${hdrpath} ; do echo " "${D} >&AC_FD_CC done AC_MSG_RESULT([unavailable]) defect_list="${defect_list}\\n\\t$3" fi echo "" >&AC_FD_CC ]) # ---------------------------------------------------------------------- # Confirm a prototypical, correct, program successfully compiles & runs: # ---------------------------------------------------------------------- ISOcxx_MSG(Insure our tests compile and run:) AC_MSG_CHECKING(correct compilation via ok.cc) ISOcxx_TRY_COMPILE( ["${testdir}ok.cc"], status=ok, status=PROBLEM!) AC_MSG_RESULT(${status}) if test "${status}" != "ok" ; then : exit 1; fi AC_MSG_CHECKING(correct linking via ok.cc) ISOcxx_TRY_LINK( ["${testdir}ok.cc"], status=ok, status=PROBLEM!) AC_MSG_RESULT(${status}) if test "${status}" != "ok" ; then : exit 2; fi AC_MSG_CHECKING(correct execution via ok.cc) ISOcxx_TRY_RUN( ["${testdir}ok.cc"], status=ok, status=PROBLEM!) AC_MSG_RESULT(${status}) if test "${status}" != "ok" ; then : exit 3; fi # ---------------------------------------------------------------------- # Begin seeking compiler extensions: # ---------------------------------------------------------------------- ISOcxx_MSG(Probe for compiler extensions:) # ---------------------------------------------------------------------- # Do we support the (nonstandard) #include_next directive? # ---------------------------------------------------------------------- pound="#" ISOcxx_TEST_EXTENSION([(nonstandard) ${pound}include_next directive], EXTENSION_INCLUDE_NEXT, incnext.cc) lquote='"' rquote='"' # ---------------------------------------------------------------------- # Do we support the (nonstandard) include_alias pragma? # ---------------------------------------------------------------------- pound="#" ISOcxx_TEST_EXTENSION([${pound}pragma include_alias], EXTENSION_INCLUDE_ALIAS, incalias.cc) lquote='"' rquote='"' # ---------------------------------------------------------------------- # Do we support the (nonstandard) long long int type? # ---------------------------------------------------------------------- ISOcxx_TEST_EXTENSION([(nonstandard) long long int], EXTENSION_LONG_LONG, ll.cc) # ---------------------------------------------------------------------- # Begin seeking compiler defects: # ---------------------------------------------------------------------- ISOcxx_MSG(Probe for compiler defects:) # ---------------------------------------------------------------------- # Test 'bool' and related keywords: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT(['bool' and related keywords], DEFECT_NO_BOOL, ISOcxx_HAS_BOOL, bool.cc) ISOcxx_TEST_DEFECT([whether 'bool' is a distinct type], DEFECT_BOOL_NOT_DISTINCT_TYPE, ISOcxx_BOOL_IS_DISTINCT_TYPE, booluniq.cc) # ---------------------------------------------------------------------- # Test operands 2/3 in a conditional expression: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([operands 2 & 3 in a conditional expression], DEFECT_CONDITIONAL, ISOcxx_CONDITIONAL, conditnl.cc) # ---------------------------------------------------------------------- # Test 'wchar_t' keyword: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT(['wchar_t' keyword], DEFECT_NO_WCHAR_T, ISOcxx_HAS_WCHAR_T, wchart.cc) ISOcxx_TEST_DEFECT([whether 'wchar_t' is a distinct type], DEFECT_WCHAR_T_NOT_DISTINCT_TYPE, ISOcxx_WCHAR_T_IS_DISTINCT_TYPE, wchruniq.cc) # ---------------------------------------------------------------------- # Test const_cast<> and static_cast<>: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([new-style casts], DEFECT_OLD_STYLE_CASTS, ISOcxx_NEW_STYLE_CASTS, casts.cc) # ---------------------------------------------------------------------- # Test for-scoping: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT(['for' scoping], DEFECT_OLD_FOR_SCOPING, ISOcxx_NEW_FOR_SCOPING, forok.cc, forbad.cc) # ---------------------------------------------------------------------- # Test keyword 'mutable': # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT(['mutable' keyword], DEFECT_NO_MUTABLE, ISOcxx_HAS_MUTABLE, mutable.cc) # ---------------------------------------------------------------------- # Test keyword 'explicit': # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT(['explicit' keyword], DEFECT_NO_EXPLICIT, ISOcxx_HAS_EXPLICIT, explicit.cc) # ---------------------------------------------------------------------- # Test 'namespace' and related keywords, etc.: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT(['namespace' support], DEFECT_NO_NAMESPACES, ISOcxx_HAS_NAMESPACES, nmspace.cc) # ---------------------------------------------------------------------- # Test 'using namespace' behavior: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT(['using namespace' behavior], DEFECT_USING_NAMESPACE_OVERLOAD, ISOcxx_USING_NAMESPACE_OVERLOAD, using_ns.cc) # ---------------------------------------------------------------------- # Test member using behavior: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([member using behavior], DEFECT_NO_MEMBER_USING, ISOcxx_OK_MEMBER_USING, usingmbr.cc) # ---------------------------------------------------------------------- # Test virtual covariance: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([virtual covariance], DEFECT_NO_VIRTUAL_COVARIANCE, ISOcxx_HAS_VIRTUAL_COVARIANCE, covary.cc) # ---------------------------------------------------------------------- # Do we correctly support nested class names? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([nested class names], DEFECT_NESTED_CLASS_ID, ISOcxx_NESTED_CLASS_ID, nestcls.cc) # ---------------------------------------------------------------------- # Test 'template' keyword: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([basic template support], DEFECT_NO_TEMPLATES, ISOcxx_HAS_TEMPLATES, template.cc) # ---------------------------------------------------------------------- # Do we support default template parameters? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([default template parameters], DEFECT_NO_DEFAULT_TEMPLATE_PARAMETERS, ISOcxx_HAS_DEFAULT_TEMPLATE_PARAMETERS, default.cc) # ---------------------------------------------------------------------- # Do we support templates as template parameters? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([template template parameters], DEFECT_NO_TEMPLATES_AS_TEMPLATE_PARAMETERS, ISOcxx_HAS_TEMPLATES_AS_TEMPLATE_PARAMETERS, tmpltmpl.cc) # ---------------------------------------------------------------------- # Do we support template partial specialization? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([partial specialization], DEFECT_NO_PARTIAL_SPECIALIZATION, ISOcxx_HAS_PARTIAL_SPECIALIZATION, partspec.cc) # ---------------------------------------------------------------------- # Do we support template methods' specialization? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([method specialization], DEFECT_NO_METHOD_SPECIALIZATION, ISOcxx_HAS_METHOD_SPECIALIZATION, methspec.cc) # ---------------------------------------------------------------------- # Do we support template functions partial ordering? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([partial ordering], DEFECT_NO_FUNCTMPL_PARTIAL_ORDERING, ISOcxx_HAS_FUNCTMPL_PARTIAL_ORDERING, porder.cc) # ---------------------------------------------------------------------- # Do we support complete (full) template specialization? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([full specialization], DEFECT_NO_FULL_SPECIALIZATION_SYNTAX, ISOcxx_HAS_FULL_SPECIALIZATION_SYNTAX, fullspec.cc) # ---------------------------------------------------------------------- # Do we support forward declaration of template member functions? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([template member forward declarations], DEFECT_NO_TEMPLATE_MEMBER_FWDDECL, ISOcxx_HAS_TEMPLATE_MEMBER_FWDDECL, membrfwd.cc) # ---------------------------------------------------------------------- # Do we support forward declaration of member functions of a # class nested within a templated class? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([template member nested forward declarations], DEFECT_NO_TEMPLATE_NESTEDCLASS_FWDDECL, ISOcxx_HAS_TEMPLATE_NESTEDCLASS_FWDDECL, nestfwd.cc) # ---------------------------------------------------------------------- # Do we support members that are templates? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([member templates], DEFECT_NO_MEMBER_TEMPLATES, ISOcxx_HAS_MEMBER_TEMPLATES, tmplmbr.cc) # ---------------------------------------------------------------------- # Do we support friends that are templates? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([friend templates], DEFECT_NO_FRIEND_TEMPLATES, ISOcxx_HAS_FRIEND_TEMPLATES, tmplfrnd.cc) # ---------------------------------------------------------------------- # Do we support static template members? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([static template members], DEFECT_NO_STATIC_TEMPLATE_DATA, ISOcxx_HAS_STATIC_TEMPLATE_DATA, tmplstat.cc) # ---------------------------------------------------------------------- # Do we support const static inline initialization? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([const static inline init], DEFECT_NO_STATIC_CONST_INIT, ISOcxx_HAS_STATIC_CONST_INIT, tmplinit.cc) # ---------------------------------------------------------------------- # Do we support overloading a virtual function in a derived class? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([overloading a virtual function in a derived class], DEFECT_NO_VIRTUAL_OVERRIDE, ISOcxx_HAS_VIRTUAL_OVERRIDE, virtovrd.cc) # ---------------------------------------------------------------------- # Test 'typename' keyword: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT(['typename' keyword], DEFECT_NO_TYPENAME, ISOcxx_HAS_TYPENAME, typename.cc) # ---------------------------------------------------------------------- # Test behavior of large enum values: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([large enum values], DEFECT_NO_UNSIGNED_ENUM, ISOcxx_HAS_UNSIGNED_ENUM, bigenum.cc) # ---------------------------------------------------------------------- # Do we permit dynamic allocation of const objects? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([allocation of const objects], DEFECT_NO_NEW_CONST, ISOcxx_HAS_NEW_CONST, newconst.cc) # ---------------------------------------------------------------------- # Do we permit deletion via pointer-to-const? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([deletion via pointer-to-const], DEFECT_NO_DELETE_CONST, ISOcxx_HAS_DELETE_CONST, delconst.cc) # ---------------------------------------------------------------------- # Do we support exceptions? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([exception-handling], DEFECT_NO_EXCEPTIONS, ISOcxx_HAS_EXCEPTIONS, except.cc) # ---------------------------------------------------------------------- # Do we support function try blocks? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([function try blocks], DEFECT_NO_FUNCTION_TRY_BLOCKS, ISOcxx_OK_FUNCTION_TRY_BLOCKS, fctntry.cc) # ---------------------------------------------------------------------- # Do we support virtual inheritance from an abstract base? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([virtual inheritance from abstract base], DEFECT_ABSTRACT_VIRTUAL_BASE, ISOcxx_ABSTRACT_VIRTUAL_BASE, absvbase.cc) # ---------------------------------------------------------------------- # Is "pascal" a keyword? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([erroneous pascal keyword], DEFECT_PASCAL_IS_KEYWORD, ISOcxx_PASCAL_NOT_KEYWORD, pascal.cc) # ---------------------------------------------------------------------- # Do we permit member constant definitions? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([member constant definitions], DEFECT_NO_MEMBER_CONSTANTS, ISOcxx_HAS_MEMBER_CONSTANTS, mbrconst.cc) # ---------------------------------------------------------------------- # Begin locating the required headers: # ---------------------------------------------------------------------- ISOcxx_MSG(Locate required header files:) # ---------------------------------------------------------------------- # Where are the native C++ library headers located? # ---------------------------------------------------------------------- ISOcxx_LOCATE_HDR(algorithm, ISOcxx_ALGORITHM_HEADER, DEFECT_NO_ALGORITHM_HEADER, DEFECT_ALGORITHM_H) ISOcxx_LOCATE_HDR(bitset, ISOcxx_BITSET_HEADER, DEFECT_NO_BITSET_HEADER, DEFECT_BITSET_H) ISOcxx_LOCATE_HDR(complex, ISOcxx_COMPLEX_HEADER, DEFECT_NO_COMPLEX_HEADER, DEFECT_COMPLEX_H) ISOcxx_LOCATE_HDR(deque, ISOcxx_DEQUE_HEADER, DEFECT_NO_DEQUE_HEADER, DEFECT_DEQUE_H) ISOcxx_LOCATE_HDR(exception, ISOcxx_EXCEPTION_HEADER, DEFECT_NO_EXCEPTION_HEADER, DEFECT_EXCEPTION_H) ISOcxx_LOCATE_HDR(fstream, ISOcxx_FSTREAM_HEADER, DEFECT_NO_FSTREAM_HEADER, DEFECT_FSTREAM_H) ISOcxx_LOCATE_HDR(functional, ISOcxx_FUNCTIONAL_HEADER, DEFECT_NO_FUNCTIONAL_HEADER, DEFECT_FUNCTIONAL_H) ISOcxx_LOCATE_HDR(iomanip, ISOcxx_IOMANIP_HEADER, DEFECT_NO_IOMANIP_HEADER, DEFECT_IOMANIP_H) ISOcxx_LOCATE_HDR(ios, ISOcxx_IOS_HEADER, DEFECT_NO_IOS_HEADER, DEFECT_IOS_H) ISOcxx_LOCATE_HDR(iosfwd, ISOcxx_IOSFWD_HEADER, DEFECT_NO_IOSFWD_HEADER, DEFECT_IOSFWD_H) ISOcxx_LOCATE_HDR(iostream, ISOcxx_IOSTREAM_HEADER, DEFECT_NO_IOSTREAM_HEADER, DEFECT_IOSTREAM_H) ISOcxx_LOCATE_HDR(istream, ISOcxx_ISTREAM_HEADER, DEFECT_NO_ISTREAM_HEADER, DEFECT_ISTREAM_H) ISOcxx_LOCATE_HDR(iterator, ISOcxx_ITERATOR_HEADER, DEFECT_NO_ITERATOR_HEADER, DEFECT_ITERATOR_H) ISOcxx_LOCATE_HDR(limits, ISOcxx_LIMITS_HEADER, DEFECT_NO_LIMITS_HEADER) ISOcxx_LOCATE_HDR(list, ISOcxx_LIST_HEADER, DEFECT_NO_LIST_HEADER, DEFECT_LIST_H) ISOcxx_LOCATE_HDR(locale, ISOcxx_LOCALE_HEADER, DEFECT_NO_LOCALE_HEADER) ISOcxx_LOCATE_HDR(map, ISOcxx_MAP_HEADER, DEFECT_NO_MAP_HEADER, DEFECT_MAP_H) ISOcxx_LOCATE_HDR(memory, ISOcxx_MEMORY_HEADER, DEFECT_NO_MEMORY_HEADER, DEFECT_MEMORY_H) ISOcxx_LOCATE_HDR(new, ISOcxx_NEW_HEADER, DEFECT_NO_NEW_HEADER, DEFECT_NEW_H) ISOcxx_LOCATE_HDR(numeric, ISOcxx_NUMERIC_HEADER, DEFECT_NO_NUMERIC_HEADER, DEFECT_NUMERIC_H) ISOcxx_LOCATE_HDR(ostream, ISOcxx_OSTREAM_HEADER, DEFECT_NO_OSTREAM_HEADER, DEFECT_OSTREAM_H) ISOcxx_LOCATE_HDR(queue, ISOcxx_QUEUE_HEADER, DEFECT_NO_QUEUE_HEADER, DEFECT_QUEUE_H) ISOcxx_LOCATE_HDR(set, ISOcxx_SET_HEADER, DEFECT_NO_SET_HEADER, DEFECT_SET_H) ISOcxx_LOCATE_HDR(sstream, ISOcxx_SSTREAM_HEADER, DEFECT_NO_SSTREAM_HEADER, DEFECT_SSTREAM_H) ISOcxx_LOCATE_HDR(stack, ISOcxx_STACK_HEADER, DEFECT_NO_STACK_HEADER, DEFECT_STACK_H) ISOcxx_LOCATE_HDR(stdexcept, ISOcxx_STDEXCEPT_HEADER, DEFECT_NO_STDEXCEPT_HEADER, DEFECT_STDEXCEPT_H) ISOcxx_LOCATE_HDR(streambuf, ISOcxx_STREAMBUF_HEADER, DEFECT_NO_STREAMBUF_HEADER, DEFECT_STREAMBUF_H) ISOcxx_LOCATE_HDR(string, ISOcxx_STRING_HEADER, DEFECT_NO_STRING_HEADER) ISOcxx_LOCATE_HDR(strstream, ISOcxx_STRSTREAM_HEADER, DEFECT_NO_STRSTREAM_HEADER, DEFECT_STRSTREAM_H) ISOcxx_LOCATE_HDR(typeinfo, ISOcxx_TYPEINFO_HEADER, DEFECT_NO_TYPEINFO_HEADER, DEFECT_TYPEINFO_H) ISOcxx_LOCATE_HDR(utility, ISOcxx_UTILITY_HEADER, DEFECT_NO_UTILITY_HEADER, DEFECT_UTILITY_H) ISOcxx_LOCATE_HDR(valarray, ISOcxx_VALARRAY_HEADER, DEFECT_NO_VALARRAY_HEADER, DEFECT_VALARRAY_H) ISOcxx_LOCATE_HDR(vector, ISOcxx_VECTOR_HEADER, DEFECT_NO_VECTOR_HEADER, DEFECT_VECTOR_H) # ---------------------------------------------------------------------- # Where are the native C++-style C library headers located? # ---------------------------------------------------------------------- ISOcxx_LOCATE_HDR(cassert,ISOcxx_CASSERT_HEADER,DEFECT_NO_CASSERT_HEADER) ISOcxx_LOCATE_HDR(cctype, ISOcxx_CCTYPE_HEADER, DEFECT_NO_CCTYPE_HEADER) ISOcxx_LOCATE_HDR(cerrno, ISOcxx_CERRNO_HEADER, DEFECT_NO_CERRNO_HEADER) ISOcxx_LOCATE_HDR(cfloat, ISOcxx_CFLOAT_HEADER, DEFECT_NO_CFLOAT_HEADER) ISOcxx_LOCATE_HDR(ciso646,ISOcxx_CISO646_HEADER,DEFECT_NO_CISO646_HEADER) ISOcxx_LOCATE_HDR(climits,ISOcxx_CLIMITS_HEADER,DEFECT_NO_CLIMITS_HEADER) ISOcxx_LOCATE_HDR(clocale,ISOcxx_CLOCALE_HEADER,DEFECT_NO_CLOCALE_HEADER) ISOcxx_LOCATE_HDR(cmath, ISOcxx_CMATH_HEADER, DEFECT_NO_CMATH_HEADER) ISOcxx_LOCATE_HDR(csetjmp,ISOcxx_CSETJMP_HEADER,DEFECT_NO_CSETJMP_HEADER) ISOcxx_LOCATE_HDR(csignal,ISOcxx_CSIGNAL_HEADER,DEFECT_NO_CSIGNAL_HEADER) ISOcxx_LOCATE_HDR(cstdarg,ISOcxx_CSTDARG_HEADER,DEFECT_NO_CSTDARG_HEADER) ISOcxx_LOCATE_HDR(cstddef,ISOcxx_CSTDDEF_HEADER,DEFECT_NO_CSTDDEF_HEADER) ISOcxx_LOCATE_HDR(cstdio, ISOcxx_CSTDIO_HEADER, DEFECT_NO_CSTDIO_HEADER) ISOcxx_LOCATE_HDR(cstdlib,ISOcxx_CSTDLIB_HEADER,DEFECT_NO_CSTDLIB_HEADER) ISOcxx_LOCATE_HDR(cstring,ISOcxx_CSTRING_HEADER,DEFECT_NO_CSTRING_HEADER) ISOcxx_LOCATE_HDR(ctime, ISOcxx_CTIME_HEADER, DEFECT_NO_CTIME_HEADER) ISOcxx_LOCATE_HDR(cwchar, ISOcxx_CWCHAR_HEADER, DEFECT_NO_CWCHAR_HEADER) ISOcxx_LOCATE_HDR(cwctype,ISOcxx_CWCTYPE_HEADER,DEFECT_NO_CWCTYPE_HEADER) # ---------------------------------------------------------------------- # Where are the native C library headers located? # ---------------------------------------------------------------------- ISOcxx_LOCATE_HDR(assert.h,ISOcxx_ASSERT_H_HEADER,DEFECT_NO_ASSERT_H_HEADER) ISOcxx_LOCATE_HDR(ctype.h, ISOcxx_CTYPE_H_HEADER, DEFECT_NO_CTYPE_H_HEADER) ISOcxx_LOCATE_HDR(errno.h, ISOcxx_ERRNO_H_HEADER, DEFECT_NO_ERRNO_H_HEADER) ISOcxx_LOCATE_HDR(float.h, ISOcxx_FLOAT_H_HEADER, DEFECT_NO_FLOAT_H_HEADER) ISOcxx_LOCATE_HDR(iso646.h,ISOcxx_ISO646_H_HEADER,DEFECT_NO_ISO646_H_HEADER) ISOcxx_LOCATE_HDR(limits.h,ISOcxx_LIMITS_H_HEADER,DEFECT_NO_LIMITS_H_HEADER) ISOcxx_LOCATE_HDR(locale.h,ISOcxx_LOCALE_H_HEADER,DEFECT_NO_LOCALE_H_HEADER) ISOcxx_LOCATE_HDR(math.h, ISOcxx_MATH_H_HEADER, DEFECT_NO_MATH_H_HEADER) ISOcxx_LOCATE_HDR(setjmp.h,ISOcxx_SETJMP_H_HEADER,DEFECT_NO_SETJMP_H_HEADER) ISOcxx_LOCATE_HDR(signal.h,ISOcxx_SIGNAL_H_HEADER,DEFECT_NO_SIGNAL_H_HEADER) ISOcxx_LOCATE_HDR(stdarg.h,ISOcxx_STDARG_H_HEADER,DEFECT_NO_STDARG_H_HEADER) ISOcxx_LOCATE_HDR(stddef.h,ISOcxx_STDDEF_H_HEADER,DEFECT_NO_STDDEF_H_HEADER) ISOcxx_LOCATE_HDR(stdio.h, ISOcxx_STDIO_H_HEADER, DEFECT_NO_STDIO_H_HEADER) ISOcxx_LOCATE_HDR(stdlib.h,ISOcxx_STDLIB_H_HEADER,DEFECT_NO_STDLIB_H_HEADER) ISOcxx_LOCATE_HDR(string.h,ISOcxx_STRING_H_HEADER,DEFECT_NO_STRING_H_HEADER) ISOcxx_LOCATE_HDR(time.h, ISOcxx_TIME_H_HEADER, DEFECT_NO_TIME_H_HEADER) ISOcxx_LOCATE_HDR(wchar.h, ISOcxx_WCHAR_H_HEADER, DEFECT_NO_WCHAR_H_HEADER) ISOcxx_LOCATE_HDR(wctype.h,ISOcxx_WCTYPE_H_HEADER,DEFECT_NO_WCTYPE_H_HEADER) # ---------------------------------------------------------------------- # 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 : AC_DEFINE_UNQUOTED(DEFECT_OLD_IOSTREAM_HEADERS) else AC_DEFINE_UNQUOTED(ISOcxx_NEW_IOSTREAM_HEADERS) 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 : AC_DEFINE_UNQUOTED(DEFECT_OLD_STDC_HEADERS) else AC_DEFINE_UNQUOTED(ISOcxx_NEW_STDC_HEADERS) 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 : AC_DEFINE_UNQUOTED(DEFECT_OLD_STL_HEADERS) else AC_DEFINE_UNQUOTED(ISOcxx_NEW_STL_HEADERS) fi # ---------------------------------------------------------------------- # Seek substitute headers in alternate locations: # ---------------------------------------------------------------------- if test -n "${DEFECT_NO_ALGORITHM_HEADER}" \ -a -z "${ISOcxx_ALGORITHM_HEADER}" \ ; then : ISOcxx_LOCATE_HDR(algo.h, ISOcxx_ALGORITHM_HEADER) ISOcxx_LOCATE_HDR(algobase.h, ISOcxx_ALGORITHM_HEADER2) fi if test -n "${DEFECT_NO_IOS_HEADER}" \ -a -z "${DEFECT_NO_IOSTREAM_HEADER}" \ ; then : ISOcxx_LOCATE_HDR(iostream, ISOcxx_IOS_HEADER) fi if test -n "${DEFECT_NO_NUMERIC_HEADER}"\ -a -z "${ISOcxx_NUMERIC_HEADER}" \ ; then : ISOcxx_LOCATE_HDR(algo.h, ISOcxx_NUMERIC_HEADER) ISOcxx_LOCATE_HDR(algobase.h, ISOcxx_NUMERIC_HEADER2) fi if test -n "${DEFECT_NO_STRING_HEADER}" \ -a -z "${ISOcxx_STRING_HEADER}" \ ; then : AC_DEFINE_UNQUOTED(DEFECT_SGICC_STRING_HEADER) ISOcxx_LOCATE_HDR(mstring.h, ISOcxx_STRING_HEADER) else AC_DEFINE_UNQUOTED(ISOcxx_OK_STRING_HEADER) fi if test -n "${DEFECT_NO_UTILITY_HEADER}"\ -a -z "${ISOcxx_UTILITY_HEADER}" \ ; then : ISOcxx_LOCATE_HDR(function.h, ISOcxx_UTILITY_HEADER) ISOcxx_LOCATE_HDR(pair.h, ISOcxx_UTILITY_HEADER2) fi # ---------------------------------------------------------------------- # Assure we know about , if available: # ---------------------------------------------------------------------- if test -n "${DEFECT_NO_SSTREAM_HEADER}"\ -a -z "${ISOcxx_SSTREAM_HEADER}" \ ; then : AC_DEFINE_UNQUOTED(DEFECT_NO_SSTREAM) AC_DEFINE_UNQUOTED(DEFECT_OLD_STRINGSTREAM) else AC_DEFINE_UNQUOTED(ISOcxx_HAS_SSTREAM) AC_DEFINE_UNQUOTED(ISOcxx_NEW_STRINGSTREAM) fi # ---------------------------------------------------------------------- # Begin seeking library defects: # ---------------------------------------------------------------------- ISOcxx_MSG(Probe for general library defects:) # ---------------------------------------------------------------------- # 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 have all the std::abs()'s? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([abs(double)], DEFECT_NO_ABS_DOUBLE, ISOcxx_HAS_ABS_DOUBLE, abs_dbl.cc) ISOcxx_TEST_DEFECT([abs(float)], DEFECT_NO_ABS_FLOAT, ISOcxx_HAS_ABS_FLOAT, abs_flt.cc) ISOcxx_TEST_DEFECT([abs(long double)], DEFECT_NO_ABS_LONG_DOUBLE, ISOcxx_HAS_ABS_LONG_DOUBLE, abs_ldbl.cc) # ---------------------------------------------------------------------- # Test for std::: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT(['s namespace], DEFECT_CMATH_NOT_STD, ISOcxx_CMATH_IN_STD, cmathstd.cc) # ---------------------------------------------------------------------- # Test for all required versions of 's functions: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([full functionality], DEFECT_CMATH_DOUBLE_VERSIONS, ISOcxx_CMATH_ALL_VERSIONS, cmathver.cc) # ---------------------------------------------------------------------- # Test for std::: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT(['s namespace], DEFECT_CSTDDEF_NOT_STD, ISOcxx_CSTDDEF_IN_STD, cstdfstd.cc) # ---------------------------------------------------------------------- # Does have ::abs(int)? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([abs(int)], DEFECT_NO_ABS, ISOcxx_HAS_ABS, abs_int.cc) # ---------------------------------------------------------------------- # Does have std::abs(long)? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([abs(long)], DEFECT_NO_ABS_LONG, ISOcxx_HAS_ABS_LONG, abs_long.cc) # ---------------------------------------------------------------------- # Does have the div(long,long) function? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([div(long,long)], DEFECT_NO_DIV_LONG_LONG, ISOcxx_HAS_DIV_LONG_LONG, div_l_l.cc) # ---------------------------------------------------------------------- # Does have the wchar functions? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([wchar functions], DEFECT_NO_WCHAR_FUNCTIONS, ISOcxx_HAS_WCHAR_FUNCTIONS, multibyt.cc) # ---------------------------------------------------------------------- # Test for std::: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT(['s namespace], DEFECT_CSTDLIB_NOT_STD, ISOcxx_CSTDLIB_IN_STD, cstlbstd.cc) # ---------------------------------------------------------------------- # Test for std::: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT(['s namespace], DEFECT_CSTRING_NOT_STD, ISOcxx_CSTRING_IN_STD, cstrgstd.cc) # ---------------------------------------------------------------------- # Does have std::min() and std::max()? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([min() and max()], DEFECT_NO_MIN_MAX, ISOcxx_HAS_MIN_MAX, min_max.cc) # ---------------------------------------------------------------------- # Test for old count() signature in : # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([count()'s signature], DEFECT_OLD_STL_COUNT, ISOcxx_NEW_STL_COUNT, countok.cc)#, countbad.cc) # ---------------------------------------------------------------------- # Does have const_mem_fun1_t<>? # MUST PRECEDE DEFECT_MEM_FUN1 # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([ for const_mem_fun1_t], DEFECT_NO_CONST_MEM_FUN1_T, ISOcxx_HAS_CONST_MEM_FUN1_T, cmf1t.cc) # ---------------------------------------------------------------------- # Do we support the 3-arg forms of mem_fun & mem_fun_ref? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([3-arg forms of mem_fun & mem_fun_ref], DEFECT_MEM_FUN1, ISOcxx_MEM_FUN1, mem_fun1.cc) # ---------------------------------------------------------------------- # Do we support auto_ptr<>? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([ for auto_ptr<>], DEFECT_NO_AUTO_PTR, ISOcxx_HAS_AUTO_PTR, autoptr.cc) # ---------------------------------------------------------------------- # Does the long double infinity() work properly? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([numeric_limitsinfinity()], DEFECT_INF_LONG_DOUBLE, ISOcxx_INF_LONG_DOUBLE, inf_ldbl.cc) # ---------------------------------------------------------------------- # Do we support user placement delete parameters? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([user placement delete parameters], DEFECT_NO_USER_PLACEMENT_DELETE, ISOcxx_HAS_USER_PLACEMENT_DELETE, placedel.cc) # ---------------------------------------------------------------------- # Is allocator a template? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([ allocator's templatization], DEFECT_ALLOCATOR_NOT_TEMPLATE, ISOcxx_ALLOCATOR_IS_TEMPLATE, alloc.cc) # ---------------------------------------------------------------------- # Test vulnerability to DEFECT_NO_UNSIGNED_ENUM: # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([ vulnerability], DEFECT_WCTYPE_H_NEEDS_UNSIGNED_ENUM, ISOcxx_WCTYPE_H_OK, wctype.cc) # ---------------------------------------------------------------------- # Begin seeking library i/o-related defects: # ---------------------------------------------------------------------- ISOcxx_MSG(Probe for library i/o-related defects:) # ---------------------------------------------------------------------- # : # ---------------------------------------------------------------------- # Do we have class std::ios_base? ISOcxx_TEST_DEFECT([class std::ios_base], DEFECT_NO_IOS_BASE, ISOcxx_HAS_IOS_BASE, iosbase.cc) # Do we have manipulators? ISOcxx_TEST_DEFECT([ manipulators], DEFECT_NO_IOS_MANIPULATORS, ISOcxx_HAS_IOS_MANIPULATORS, iosmanip.cc) # ---------------------------------------------------------------------- # Does an istream's eof() behave properly? # ---------------------------------------------------------------------- ISOcxx_TEST_DEFECT([eof()], DEFECT_EOF, ISOcxx_OK_EOF, eof.cc) # ---------------------------------------------------------------------- # Begin seeking library container-related defects: # ---------------------------------------------------------------------- ISOcxx_MSG(Probe for library container-related defects:) # ---------------------------------------------------------------------- # iterator<>s: # ---------------------------------------------------------------------- # Do iterator<>s have all template arguments? ISOcxx_TEST_DEFECT([iterator<> template arguments], DEFECT_BAD_ITERATOR_ARGS, ISOcxx_OK_ITERATOR_ARGS, iter8or.cc) # Do reverse_iterator<>s have the right number of template arguments? ISOcxx_TEST_DEFECT([reverse_iterator<> template arguments], DEFECT_OLD_REVERSE_ITERATOR, ISOcxx_OK_REVERSE_ITERATOR, reviter.cc) # ---------------------------------------------------------------------- # string<>s: # ---------------------------------------------------------------------- # Do string<>s have clear()? ISOcxx_TEST_DEFECT([ clear()], DEFECT_NO_STRING_CLEAR, ISOcxx_HAS_STRING_CLEAR, clearstr.cc) # ---------------------------------------------------------------------- # deque<>s: # ---------------------------------------------------------------------- # Do deque<>s support custom allocators? ISOcxx_TEST_DEFECT([ allocator option], DEFECT_NO_DEQUE_ALLOCATOR, ISOcxx_OK_DEQUE_ALLOCATOR, allocdeq.cc) # Do deque<>s support at()? ISOcxx_TEST_DEFECT([ at()], DEFECT_NO_DEQUE_AT, ISOcxx_HAS_DEQUE_AT, atdeq.cc) # ---------------------------------------------------------------------- # list<>s: # ---------------------------------------------------------------------- # Do list<>s support custom allocators? ISOcxx_TEST_DEFECT([ allocator option], DEFECT_NO_LIST_ALLOCATOR, ISOcxx_OK_LIST_ALLOCATOR, alloclst.cc) # Does list<>'s splice() work correctly? ISOcxx_TEST_DEFECT(['s splice()], DEFECT_BAD_LIST_SPLICE, ISOcxx_OK_LIST_SPLICE, splice.cc) # ---------------------------------------------------------------------- # vector<>s: # ---------------------------------------------------------------------- # Do vector<>s support custom allocators? ISOcxx_TEST_DEFECT([ allocator option], DEFECT_NO_VECTOR_ALLOCATOR, ISOcxx_OK_VECTOR_ALLOCATOR, allocvec.cc) # Do vector<>s support at()? ISOcxx_TEST_DEFECT([ at()], DEFECT_NO_VECTOR_AT, ISOcxx_HAS_VECTOR_AT, atvec.cc) # ---------------------------------------------------------------------- # queue<>s: # ---------------------------------------------------------------------- # Do s have the container_type typedef? # MUST PRECEDE OTHER queue<> tests ISOcxx_TEST_DEFECT([queue<> container_type], DEFECT_NO_QUEUE_CONTAINER_TYPE, ISOcxx_HAS_QUEUE_CONTAINER_TYPE, conttque.cc) # Do queue<>s have the correct Container default? ISOcxx_TEST_DEFECT([queue<>'s Container default], DEFECT_BAD_QUEUE_DEFAULT_CONTAINER, ISOcxx_OK_QUEUE_DEFAULT_CONTAINER, defque.cc) # Do queue<>s support custom underlying containers? ISOcxx_TEST_DEFECT([queue<> custom container], DEFECT_NO_QUEUE_CONTAINER, ISOcxx_OK_QUEUE_CONTAINER, contque.cc) # ---------------------------------------------------------------------- # priority_queue<>s: # ---------------------------------------------------------------------- # Do priority_queue<>s have the correct Container default? ISOcxx_TEST_DEFECT([priority_queue<>'s Container default], DEFECT_BAD_PRIQ_DEFAULT_CONTAINER, ISOcxx_OK_PRIQ_DEFAULT_CONTAINER, defpriq.cc) # Do priority_queue<>s support custom underlying containers? ISOcxx_TEST_DEFECT([priority_queue<> custom container], DEFECT_NO_PRIQ_CONTAINER, ISOcxx_OK_PRIQ_CONTAINER, contpriq.cc) # Do priority_queue<>s support custom comparators? ISOcxx_TEST_DEFECT([priority_queue<> custom comparator], DEFECT_NO_PRIQ_COMPARATOR, ISOcxx_OK_PRIQ_COMPARATOR, comppriq.cc) # ---------------------------------------------------------------------- # stack<>s: # ---------------------------------------------------------------------- # Do s have the container_type typedef? # MUST PRECEDE OTHER stack<> tests ISOcxx_TEST_DEFECT([stack<> container_type], DEFECT_NO_STACK_CONTAINER_TYPE, ISOcxx_HAS_STACK_CONTAINER_TYPE, conttstk.cc) # Do stack<>s have the correct Container default? ISOcxx_TEST_DEFECT([stack<>'s Container default], DEFECT_BAD_STACK_DEFAULT_CONTAINER, ISOcxx_OK_STACK_DEFAULT_CONTAINER, defstk.cc) # Do stack<>s support custom underlying containers? ISOcxx_TEST_DEFECT([stack<> custom container], DEFECT_NO_STACK_CONTAINER, ISOcxx_OK_STACK_CONTAINER, contstk.cc) # ---------------------------------------------------------------------- # map<>s: # ---------------------------------------------------------------------- # Do map<>s support custom comparators? ISOcxx_TEST_DEFECT([map<> custom comparator], DEFECT_NO_MAP_COMPARATOR, ISOcxx_OK_MAP_COMPARATOR, compmap.cc) # Do map<>s have the correct default allocators? ISOcxx_TEST_DEFECT([map<> default allocator], DEFECT_BAD_MAP_DEFAULT_ALLOCATOR, ISOcxx_OK_MAP_DEFAULT_ALLOCATOR, defmapal.cc) # Do map<>s support custom allocators? ISOcxx_TEST_DEFECT([map<> custom allocator], DEFECT_NO_MAP_ALLOCATOR, ISOcxx_OK_MAP_ALLOCATOR, allocmap.cc) # ---------------------------------------------------------------------- # set<>s: # ---------------------------------------------------------------------- # Do set<>s support custom comparators? ISOcxx_TEST_DEFECT([set<> custom comparator], DEFECT_NO_SET_COMPARATOR, ISOcxx_OK_SET_COMPARATOR, compset.cc) # Do set<>s support custom allocators? ISOcxx_TEST_DEFECT([set<> custom allocator], DEFECT_NO_SET_ALLOCATOR, ISOcxx_OK_SET_ALLOCATOR, allocset.cc) # ---------------------------------------------------------------------- # multimap<>s: # ---------------------------------------------------------------------- # Do multimap<>s support custom comparators? ISOcxx_TEST_DEFECT([multimap<> custom comparator], DEFECT_NO_MULTIMAP_COMPARATOR, ISOcxx_OK_MULTIMAP_COMPARATOR, compmmap.cc) # Do multimap<>s support custom allocators? ISOcxx_TEST_DEFECT([multimap<> custom allocator], DEFECT_NO_MULTIMAP_ALLOCATOR, ISOcxx_OK_MULTIMAP_ALLOCATOR, allocmmp.cc) # ---------------------------------------------------------------------- # multiset<>s: # ---------------------------------------------------------------------- # Do multiset<>s support custom comparators? ISOcxx_TEST_DEFECT([multiset<> custom comparator], DEFECT_NO_MULTISET_COMPARATOR, ISOcxx_OK_MULTISET_COMPARATOR, compmset.cc) # Do multiset<>s support custom allocators? ISOcxx_TEST_DEFECT([multiset<> custom allocator], DEFECT_NO_MULTISET_ALLOCATOR, ISOcxx_OK_MULTISET_ALLOCATOR, allocmst.cc) # ---------------------------------------------------------------------- # bitset<>s: # ---------------------------------------------------------------------- # Do we have basic bitset<> support? ISOcxx_TEST_DEFECT([basic bitset<> support], DEFECT_BAD_BITSET_SUPPORT, ISOcxx_OK_BITSET_SUPPORT, bitset.cc) # ---------------------------------------------------------------------- # Begin seeking library extensions: # ---------------------------------------------------------------------- ISOcxx_MSG(Probe for library extensions:) # ---------------------------------------------------------------------- # Do we support (nonstandard) long long streaming? # ---------------------------------------------------------------------- ISOcxx_TEST_EXTENSION([(nonstandard) long long streaming], EXTENSION_LONG_LONG_STREAM_OPERATOR, llio.cc) # ---------------------------------------------------------------------- # Final check: # ---------------------------------------------------------------------- ISOcxx_MSG(Epilog:) # ---------------------------------------------------------------------- # Test all library headers' accessibility: # ---------------------------------------------------------------------- AC_MSG_CHECKING([library accessibility via library.cc]) ISOcxx_TRY_RUN( ["${testdir}library.cc"], status=ok, status=PROBLEM!) AC_MSG_RESULT(${status}) # ---------------------------------------------------------------------- # Final test for ISOcxx internal consistency: # ---------------------------------------------------------------------- AC_MSG_CHECKING(ISOcxx internal consistency via final.cc) ISOcxx_TRY_RUN( ["${testdir}final.cc"], status=ok, status=PROBLEM!) AC_MSG_RESULT(${status}) # ---------------------------------------------------------------------- # Done; produce output file, summary information, and validate success: # ---------------------------------------------------------------------- AC_OUTPUT() if test "$defect_list" = "" ; then ISOcxx_MSG(No defects detected!) else ISOcxx_MSG(Summary of defects detected: ${defect_list}\\n) fi if test "$problem_list" != "" ; then ISOcxx_MSG(Summary of PROBLEMs needing attention: ${problem_list}\\n) fi test "${ISOcxx_success}" = yes || exit 9