configure.in

vc2005 wince 的 stlport 的工程源代码

    [ac_cv_td_bug="no"],
    [AC_DEFINE(_STLP_TRIVIAL_DESTRUCTOR_BUG) ac_cv_td_bug="yes"])
AC_MSG_RESULT($ac_cv_td_bug)

AC_MSG_CHECKING(for explicit function template arguments)
AC_TRY_LINK(
    [  template <class T> class foo;
       template<class T> bool operator==(const foo<T>& lhs,const foo<T>& rhs);
      template <class T> class foo {
	private:
	  T bar;
	friend bool operator== <> (const foo<T>&,const foo<T>&);
     };
     template<class T> bool operator==(const foo<T>& lhs,const foo<T>& rhs) {
	return  lhs.bar==rhs.bar;
     }],
    [ foo<int> f1, f2;
      int ret= (f1==f2) ],
    [ _NULLARGS="<>" ac_cv_expl_fun_args="yes"],
    [ AC_DEFINE(_STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS) ac_cv_expl_fun_args="no" _NULLARGS=""])
AC_MSG_RESULT($ac_cv_expl_fun_args)

AC_MSG_CHECKING(for template parameter baseclass matching)
AC_TRY_LINK(
    [struct output_iterator_tag {};
     struct derived1_tag : public output_iterator_tag {};
     struct derived2_tag : public derived1_tag {};
     template<class T> struct output_iterator { 
	public:
	output_iterator() {} 
	~output_iterator() {} 
	friend inline int operator== $_NULLARGS (const output_iterator<T>&, 
                                      const output_iterator<T>&);
	};
     template<class T> inline int operator==(const output_iterator<T>&, 
                              	        const output_iterator<T>&) {
       return 0;
     }
     template<class T> inline output_iterator_tag
     iterator_category(const output_iterator<T>&) {return output_iterator_tag();}
     template <class T>
     struct derived_iterator : public output_iterator<T> {
	public:
	derived_iterator() {} 
	~derived_iterator() {}
	};
     template<class T> inline T select_foo(T t, output_iterator_tag) { return t;}     
     template<class T> inline int select_foo_2(T, T,
                                             output_iterator_tag) { return 0;}     
     template<class T> inline T tbase_foo(T pm )  { 
	derived_iterator<T> di1, di2; int i( di1==di2 && pm);
	return select_foo((int)1,iterator_category(derived_iterator<T>())); 
    }
    ],
    [ (void)tbase_foo((int)1); ],
    [ac_cv_base_match="yes"],
    [AC_DEFINE(_STLP_BASE_MATCH_BUG) ac_cv_base_match="no"])
AC_MSG_RESULT($ac_cv_base_match)

AC_MSG_CHECKING(for non-template parameter baseclass matching )
AC_TRY_LINK(
    [struct output_iterator_tag {};
     struct derived1_tag : public output_iterator_tag {};
     struct derived2_tag : public derived1_tag {};
     struct derived3_tag : public derived2_tag {};
     template<class T> struct output_iterator { 
	public:
	output_iterator() {} 
	~output_iterator() {} 
	};
     template<class T> inline output_iterator_tag
     iterator_category(const output_iterator<T>&) {return output_iterator_tag();}
     template <class T>
     struct derived_iterator : public output_iterator<T> {
	public:
	derived_iterator() {} 
	~derived_iterator() {}
	};
     template<class T> inline int select_foo_2(T, T,
                                             output_iterator_tag) { return 0;}     
     template<class T> inline int select_foo_2(T, T,
                                             derived1_tag) { return 0;}     
     template<class T> inline void nont_base_foo(T pm )  { 
	derived_iterator<T> di1, di2; 
	(void)select_foo_2(di1, (const derived_iterator<T>&)di2, derived3_tag());
    }
    ],
    [ nont_base_foo((int)1); ],
    [ac_cv_nont_base_match="yes"],
    [AC_DEFINE(_STLP_NONTEMPL_BASE_MATCH_BUG) ac_cv_nont_base_match="no"])
AC_MSG_RESULT($ac_cv_nont_base_match)

AC_MSG_CHECKING(for nested type parameters bug)
AC_TRY_LINK(
    [template<class T> struct nt_o { typedef int ii; inline ii foo(ii);};
     template <class T> inline nt_o<T>::ii nt_o<T>::foo(ii) { return 0; }],
    [],
    [ac_cv_nested_type_param_bug="no"],
    [AC_DEFINE(_STLP_NESTED_TYPE_PARAM_BUG) ac_cv_nested_type_param_bug="yes"])
AC_MSG_RESULT($ac_cv_nested_type_param_bug)


AC_MSG_CHECKING(if inherited template typedefs broken completely)
AC_TRY_LINK(
    [
template <class Arg1, class Arg2, class Result>
struct binary_function {
    typedef Arg1 first_argument_type;
    typedef Arg2 second_argument_type;
    typedef Result result_type;
};     

template <class T>
struct equal_to : public binary_function<T, T, int> {
    int operator()(const T& x, const T& y) const { return x == y; }
};

template <class Predicate> 
class binary_negate 
    : public binary_function<$__TYPENAME Predicate::first_argument_type,
			     $__TYPENAME Predicate::second_argument_type, 
                             int> {
protected:
    Predicate pred;
public:
    binary_negate(const Predicate& x = Predicate()) : pred(x) {}
    int operator() (const $__TYPENAME Predicate::first_argument_type& x, 
		    const $__TYPENAME Predicate::second_argument_type& y) const {
	return !pred(x, y); 
    }
};
      typedef equal_to<int> eq_int;
      typedef binary_negate<equal_to<int> > int_negate;
      int_negate n;
 ],
    [
      (void)n(1,2);
    ],
    [ac_cv_typebug="no"],
    [AC_DEFINE(_STLP_BASE_TYPEDEF_BUG) 
     AC_DEFINE(_STLP_BASE_TYPEDEF_OUTSIDE_BUG) ac_cv_typebug="yes"])
AC_MSG_RESULT($ac_cv_typebug)

AC_MSG_CHECKING(if inherited typedefs visible from outside)
AC_TRY_COMPILE(
    [
template <class Arg1, class Arg2, class Result>
struct binary_function {
    typedef Arg1 first_argument_type;
    typedef Arg1 second_argument_type;
    typedef Result result_type;
};     


template <class T>
class plus : public binary_function<T, T, T> {
public:
    plus() {}
    plus(const T&) {}
    T operator()(const T& x, const T& y) const { return x + y; };
};

plus<int> p;
plus<int>::first_argument_type a;
],
    [],
    [ac_cv_outside_typedef="yes"],
    [AC_DEFINE(_STLP_BASE_TYPEDEF_OUTSIDE_BUG) ac_cv_outside_typedef="no"])
AC_MSG_RESULT($ac_cv_outside_typedef)

# fi

AC_MSG_CHECKING(if private type static members initializable)
AC_TRY_COMPILE(
    [struct p_Class { private: struct str_ { 
	int a; str_(int i) : a(i) {}}; static str_ my_int; 
     };
     p_Class::str_ p_Class::my_int(0); 
     ],
    [],
    [ac_cv_private="yes"],
    [AC_DEFINE(_STLP_UNINITIALIZABLE_PRIVATE) ac_cv_private="no"])
AC_MSG_RESULT($ac_cv_private)


AC_MSG_CHECKING(for const member constructor bug)
AC_TRY_LINK([
template <class T1, class T2>
struct pair {
    T1 first;
    T2 second;
    pair(): first(T1()), second(T2()) {}
    pair(const pair<T1,T2>& o) : first(o.first), second(o.second) {}
};
pair< const int, const int > p;  
     ],
    [],
    [ac_cv_const_constructor_bug="no"],
    [AC_DEFINE(_STLP_CONST_CONSTRUCTOR_BUG) ac_cv_const_constructor_bug="yes"])
AC_MSG_RESULT($ac_cv_const_constructor_bug)

AC_MSG_CHECKING(for loop inline problems)
AC_TRY_COMPILE(
    [inline int il_foo (int a) { 
      int i; for (i=0; i<a; i++) a+=a;  while (i>0) a-=3; return a; }],
    [(void)il_foo(2);],
    [ac_cv_inline_problems="no"],
    [AC_DEFINE(_STLP_LOOP_INLINE_PROBLEMS) ac_cv_inline_problems="yes"])
if test "$ac_cv_inline_problems" = no; then
# check if no warnings have been issued
  if `check_warning` ; then
     ac_cv_inline_problems="no"
  else
   AC_DEFINE(_STLP_LOOP_INLINE_PROBLEMS)
   ac_cv_inline_problems="yes"
  fi
fi
AC_MSG_RESULT($ac_cv_inline_problems)


AC_MSG_CHECKING(if arrow operator always get instantiated)
AC_TRY_LINK(
    [
     template <class T> struct um_foo { T* ptr; 
	T* operator ->() { return &(operator*());}
	T  operator *()  { return *ptr; }
     };
     template <class T>
	int operator == ( const um_foo<T>& x, const um_foo<T>& y)
	{
    		return *x == *y;
	}
     struct um_tag { int a ; };
     um_foo<um_tag> f;
     um_foo<int> a;
     ],
    [ 
     int b(5); a.ptr=&b;],
    [ac_cv_unused_required="no"],
    [AC_DEFINE(_STPL_NO_ARROW_OPERATOR) ac_cv_unused_required="yes"]
    )
AC_MSG_RESULT($ac_cv_unused_required)

AC_MSG_CHECKING(for pointer-to-member parameter bug)
AC_TRY_COMPILE(
    [
struct pmf_foo {
	int bar() { return 0; };
};

template <class Class, class Result> 
class mem_fun_t {
protected:
    typedef Result (Class::*fun_type)(void);
    fun_type ptr;
public:
    mem_fun_t() {}
    mem_fun_t(fun_type p) : ptr(p) {}
    Result operator()(Class* x) const { return (x->*ptr)();}
};

template <class Class, class Result>
inline mem_fun_t <Class, Result> 
mem_fun(Result (Class::*ptr)(void)) {
    return mem_fun_t<Class, Result>(ptr);
}
],
    [pmf_foo pmf; (void)mem_fun(&pmf_foo::bar)(&pmf)],
    [ac_cv_pmf_bug="no"],
    [AC_DEFINE( _STLP_MEMBER_POINTER_PARAM_BUG) ac_cv_pmf_bug="yes"])
AC_MSG_RESULT($ac_cv_pmf_bug)

AC_MSG_CHECKING(if bad_alloc defined in <new>)
AC_TRY_COMPILE(
    [
     #if !defined (_STLP_NO_NEW_STYLE_HEADERS)
     #include <new>
     #else
     #include <new.h>
     #endif

     # if !defined (_STLP_HAS_NO_NAMESPACES)
       using namespace $_TEST_STD;
     # endif

     bad_alloc badalloc_foo() { bad_alloc err; return err;}],
    [(void)badalloc_foo()],
    [ac_cv_bad_alloc="yes"],
    [AC_DEFINE(_STLP_NO_BAD_ALLOC) ac_cv_bad_alloc="no"])
AC_MSG_RESULT($ac_cv_bad_alloc)

AC_MSG_CHECKING(for __type_traits automatic specialization)
AC_TRY_LINK(
    [template <class T> int tt_foo(const T&) {
	typedef __type_traits<T> traits;
	return 0;
     }],
    [(void)tt_foo(5)],
    [AC_DEFINE(_STLP_AUTOMATIC_TYPE_TRAITS) ac_cv_type_traits="yes"],
    [ac_cv_type_traits="no"])
AC_MSG_RESULT($ac_cv_type_traits)


# package options - exceptions
AC_MSG_RESULT(***)
AC_MSG_RESULT($0: Setting implementation options...)
AC_MSG_RESULT(***)

if test "$ac_cv_exceptions" = yes; then
AC_ARG_ENABLE(exceptions,[--enable-exceptions Use exceptions support (default if posssible)
 --disable-exceptions Don't use exceptions support],
[
case "$enableval" in
           no) AC_DEFINE(_STLP_NO_EXCEPTIONS)
               AC_MSG_RESULT(Config arg --disable-exceptions : disabling exceptions by user request);;
           *)  AC_MSG_RESULT(Config default: exceptions enabled)
esac
],
[AC_MSG_RESULT(Config default: exceptions enabled) ]
)
else
 AC_MSG_RESULT(Compiler restriction : no exceptions support used)
fi

if test "$ac_cv_namespaces" = yes; then
AC_ARG_ENABLE(relops,[--enable-relops Separate rel_ops namespace for relational operators (default if posssible)
--disable-relops No separate rel_ops namespace for relational operators],
[
case "$enableval" in
	no) AC_DEFINE(_STLP_NO_RELOPS_NAMESPACE) 
            AC_MSG_RESULT(Config arg --disable-relops : no std::rel_ops namespace by user request);;
	 *) AC_MSG_RESULT(Config default: Separate std::rel_ops namespace for relational operators)
esac
],
[AC_MSG_RESULT(Config default: Separate std::rel_ops namespace for relational operators)]
)
else
 AC_DEFINE(_STLP_NO_RELOPS_NAMESPACE) 
fi

if test "$ac_cv_newheaders" = yes; then
AC_ARG_ENABLE(new-style-headers,[--enable-new-style-headers Use new-style headers (default)
--disable-new-style-headers Don't use new-style headers],
[
case "$enableval" in
	no) AC_DEFINE(_STLP_NO_NEW_STYLE_HEADERS) 
            AC_MSG_RESULT(Config arg --disable-new-style-headers : not using new-style headers);;
	 *) AC_MSG_RESULT(Config default: using new-style headers)
esac
],
[AC_MSG_RESULT(Config default: using new-style headers)]
)
else
 AC_DEFINE(_STLP_NO_NEW_STYLE_HEADERS)
fi

if test "$ac_cv_newstreams" = yes; then
AC_ARG_ENABLE(new-iostreams,[--enable-new-iostreams Use new iostreams (default)
--disable-new-iostreams Don't use new iostreams],
[
case "$enableval" in
	no) AC_DEFINE(_STLP_NO_NEW_IOSTREAMS) 
            AC_MSG_RESULT(Config arg --disable-new-iostreams : not using new iostreams);;
	 *) AC_MSG_RESULT(Config default: using new iostreams)
esac
],
[AC_MSG_RESULT(Config default: using new iostreams)]
)
else
  AC_DEFINE(_STLP_NO_NEW_IOSTREAMS)
fi

AC_ARG_ENABLE(sgi-allocators,[--enable-sgi-allocators : set default parameter to SGI-style default alloc, not allocator<T>
 --disable-sgi-allocators : use allocator<T> if possible],
[
case "$enableval" in
	  yes ) AC_MSG_RESULT(Config arg  --enable-sgi-allocators : SGI-style alloc as default allocator) 
                AC_DEFINE(_STLP_USE_RAW_SGI_ALLOCATORS);;
	    * ) AC_MSG_RESULT(Config default: using allocator<T> as default allocator if possible )
esac
],
[
 AC_MSG_RESULT(Config default: using allocator<T> as default allocator if possible)
]
)

AC_ARG_ENABLE(malloc,[--enable-malloc : set default alloc to malloc-based allocator ( malloc_alloc_template<instance_no>, alloc.h )
--disable-malloc : choose (default) sgi node allocator (__alloc<threads,no>  alloc.h )],
[
case "$enableval" in
	  yes ) AC_MSG_RESULT(Config arg  --enable-malloc : setting malloc_alloc as default alloc) 
                AC_DEFINE(_STLP_USE_MALLOC);;
	    * ) AC_MSG_RESULT(Config default: not using malloc_alloc as default alloc)
esac
],
[
 AC_MSG_RESULT(Config default: not using malloc_alloc as default alloc)
]
)

AC_ARG_ENABLE(newalloc,[--enable-newalloc : set default alloc to new-based allocator ( new_alloc, alloc.h )
--disable-newalloc : choose (default) sgi allocator (__alloc<threads,no>  alloc.h )],
[
case "$enableval" in
	  yes ) AC_MSG_RESULT(Config arg  --enable-newalloc : setting new_alloc as default alloc) 
                AC_DEFINE(_STLP_USE_NEWALLOC);;
	    * )
                AC_MSG_RESULT(Config default: not using new_alloc as default alloc)
esac
],
[
 AC_MSG_RESULT(Config default: not using new_alloc as default alloc)
]
)

AC_ARG_ENABLE(defalloc,[--enable-defalloc : make HP-style defalloc.h included in alloc.h )
--disable-defalloc : leave defalloc.h alone],
[
case "$enableval" in
	  no ) AC_MSG_RESULT(Config arg --disable-defalloc : not including HP-style defalloc.h into alloc.h);;

	  * ) AC_MSG_RESULT(Config default : including HP-style defalloc.h into alloc.h) 
                AC_DEFINE(_STLP_USE_DEFALLOC)
esac
],
[
          AC_MSG_RESULT(Config default : not including HP-style defalloc.h into alloc.h)
]
)


AC_ARG_ENABLE(debugalloc,[--enable-debugalloc : use debug versions of allocators
--disable-debugalloc : not using debug allocators],
[
case "$enableval" in
	  yes ) AC_MSG_RESULT(Config arg --enable-debugalloc : use debug versions of allocators ) 
                AC_DEFINE(_STLP_DEBUG_ALLOC);;
	  * )
          AC_MSG_RESULT(Config default : not using debug allocators)
esac
],
[
          AC_MSG_RESULT(Config default : not using debug allocators)
]
)


AC_ARG_ENABLE(abbrevs,[--enable-abbrevs : use abbreviated class names internally for linker benefit (don't affect interface)
--disable-abbrevs : don't use abbreviated names],
[
case "$enableval" in
	  yes ) AC_MSG_RESULT(Config arg --enable-abbrevs : using abbreviated class names internally) 
                AC_DEFINE(_STLP_USE_ABBREVS);;
	  * )
          AC_MSG_RESULT(Config default : not using abbreviated class names internally)
esac
],
[
          AC_MSG_RESULT(Config default : not using abbreviated class names internally)
]
)


AC_DEFINE(__AUTO_CONFIGURED)

AC_MSG_RESULT(***)
AC_MSG_RESULT($0: setting up headers...)
AC_MSG_RESULT(***)
AC_OUTPUT(stlconf.h)
AC_MSG_RESULT(***)
AC_MSG_RESULT($0: STLport configured for use with \"${CXX}\" compiler, CXXFLAGS used: \"${CXXFLAGS}\".)
AC_MSG_RESULT($0: To restore original settings - run \"./unconfigure\" or copy stlconf.h.in to stlconf.h.)
AC_MSG_RESULT(***)