mirror of
https://git.lyx.org/repos/lyx.git
synced 2024-09-21 15:18:45 +00:00
1763 lines
31 KiB
Plaintext
1763 lines
31 KiB
Plaintext
|
dnl Process with autoconf to generate configure script -*- sh -*-
|
||
|
|
|
||
|
|
AC_INIT(boost/config.hpp)
|
||
|
|
AC_PREREQ(2.13) dnl We want to use autoconf 2.13
|
||
|
|
AM_CONFIG_HEADER(boost/config.h)
|
||
|
|
|
||
|
|
dnl This is a trick to make autoheader do the right thing
|
||
|
|
dnl AM_CONFIG_HEADER(boost/config.h)
|
||
|
|
|
||
|
|
AC_CANONICAL_SYSTEM
|
||
|
|
AC_VALIDATE_CACHE_SYSTEM_TYPE
|
||
|
|
|
||
|
|
AM_INIT_AUTOMAKE(boost, 0.1lyx)
|
||
|
|
|
||
|
|
### Check for programs
|
||
|
|
AC_PROG_MAKE_SET
|
||
|
|
AC_PROG_INSTALL
|
||
|
|
|
||
|
|
# Work around a problem in automake 1.4: when invoking install-strip,
|
||
|
|
# INSTALL_PROGRAM is changed to 'install -s', and since
|
||
|
|
# INSTALL_SCRIPT==INSTALL_PROGRAM, we get errors with fileutils-4.0
|
||
|
|
# which returns an error condition when stripping fails.
|
||
|
|
INSTALL_SCRIPT='${INSTALL}'
|
||
|
|
|
||
|
|
### we will also need a C compiler to compile GNU gettext
|
||
|
|
AC_PROG_CC
|
||
|
|
|
||
|
|
### check for special systems
|
||
|
|
AC_ISC_POSIX
|
||
|
|
AC_AIX
|
||
|
|
|
||
|
|
### Check for program extensions (.exe or nothing)
|
||
|
|
AC_EXEEXT
|
||
|
|
|
||
|
|
### Check for a C++ compiler
|
||
|
|
AC_LANG_CPLUSPLUS
|
||
|
|
AC_PROG_CXX
|
||
|
|
AC_PROG_CXXCPP
|
||
|
|
AC_DISABLE_SHARED
|
||
|
|
AC_LIBTOOL_WIN32_DLL
|
||
|
|
AM_PROG_LIBTOOL
|
||
|
|
|
||
|
|
####################################################
|
||
|
|
####################################################
|
||
|
|
####################################################
|
||
|
|
|
||
|
|
AC_DEFINE(BOOST_RE_AUTO_CONFIGURE, [])
|
||
|
|
dnl Disable any caching here
|
||
|
|
define([AC_CACHE_LOAD], )dnl
|
||
|
|
define([AC_CACHE_SAVE], )dnl
|
||
|
|
|
||
|
|
AC_MSG_RESULT(*** $0: regex++ configuration utility ***)
|
||
|
|
if test "${CXXFLAGS}" = ""; then
|
||
|
|
AC_MSG_RESULT(* Note: for best reliability - try \"CXXFLAGS=-treat_warnings_as_errors\" $0 )
|
||
|
|
AC_MSG_RESULT(* Please don't forget specifying typical CXXFLAGS you'll be using - )
|
||
|
|
AC_MSG_RESULT(* such as that enabling exceptions handling, etc. )
|
||
|
|
AC_MSG_RESULT(* Add option forcing instantiation of all templates to CXXFLAGS if possible. )
|
||
|
|
AC_MSG_RESULT(* Add option enabling merging of template instances between translation units)
|
||
|
|
AC_MSG_RESULT(* to CXXFLAGS if possible. )
|
||
|
|
fi
|
||
|
|
AC_MSG_RESULT(Please stand by while exploring compiler capabilities...)
|
||
|
|
AC_MSG_RESULT(Be patient - this could take some time...)
|
||
|
|
AC_MSG_RESULT(***)
|
||
|
|
|
||
|
|
AC_ARG_ENABLE(extension,[--enable-extension=<ext>],
|
||
|
|
[
|
||
|
|
case "$enableval" in
|
||
|
|
no) AC_MSG_RESULT(Info :.cpp used as extension for tests)
|
||
|
|
ac_ext=cpp
|
||
|
|
;;
|
||
|
|
*) AC_MSG_RESULT(Argument : .$enableval used as extension)
|
||
|
|
ac_ext=$enableval
|
||
|
|
esac
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(Info : .cpp used as extension for tests)
|
||
|
|
ac_ext=cpp
|
||
|
|
]
|
||
|
|
)
|
||
|
|
|
||
|
|
AC_ARG_ENABLE(sizeof-short, [--enable-sizeof-short=<short size>], [], [enable_sizeof_short=2])
|
||
|
|
AC_ARG_ENABLE(sizeof-int, [--enable-sizeof-int=<int size>], [], [enable_sizeof_int=4])
|
||
|
|
AC_ARG_ENABLE(sizeof-long, [--enable-sizeof-long=<long size>], [], [enable_sizeof_long=4])
|
||
|
|
AC_ARG_ENABLE(force-cross, [--enable-force-cross forces cross compile mode])
|
||
|
|
|
||
|
|
|
||
|
|
# Save that, as it is being redefined several times
|
||
|
|
use_ac_ext=$ac_ext
|
||
|
|
|
||
|
|
AC_LANG_CPLUSPLUS
|
||
|
|
ac_ext=$use_ac_ext
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for object file extention)
|
||
|
|
cat > "xyqtcz.$ac_ext" << EOF
|
||
|
|
|
||
|
|
int main()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
EOF
|
||
|
|
|
||
|
|
if eval "$CXX $CXXFLAGS -c xyqtcz.$ac_ext"; then
|
||
|
|
rm -f "xyqtcz.$ac_ext"
|
||
|
|
ac_obj_ext=`find xyqtcz.* | sed 's/xyqtcz\(.*\)/\1/g'`
|
||
|
|
AC_MSG_RESULT(yes - $ac_obj_ext)
|
||
|
|
rm -f "xyqtcz$ac_obj_ext"
|
||
|
|
|
||
|
|
else
|
||
|
|
|
||
|
|
AC_MSG_RESULT(no - could not create or find object file, defaulting to .o)
|
||
|
|
rm -f "xyqtcz.$ac_ext"
|
||
|
|
ac_obj_ext='.o'
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for executable file extention)
|
||
|
|
ac_exe_ext=""
|
||
|
|
for file in /bin/sh.*
|
||
|
|
do
|
||
|
|
|
||
|
|
if test -x "$file"; then
|
||
|
|
ac_exe_ext=`echo "$file" | sed 's/\/bin\/sh\(.*\)/\1/g'`
|
||
|
|
fi
|
||
|
|
|
||
|
|
done
|
||
|
|
|
||
|
|
AC_MSG_RESULT(yes - $ac_exe_ext)
|
||
|
|
AC_SUBST(ac_exe_ext)
|
||
|
|
AC_SUBST(ac_obj_ext)
|
||
|
|
|
||
|
|
|
||
|
|
#
|
||
|
|
# determine machine word sizes
|
||
|
|
# and set BOOST_RE_INT32 to be the
|
||
|
|
# equivalent of intfast32_t in <inttypes.h>
|
||
|
|
#
|
||
|
|
if test "$enable_force_cross" = "yes"; then
|
||
|
|
cross_compiling="yes"
|
||
|
|
echo forced cross compilation mode turned on
|
||
|
|
fi
|
||
|
|
|
||
|
|
AC_CHECK_SIZEOF(short,"$enable_sizeof_short")
|
||
|
|
ac_ext=$use_ac_ext
|
||
|
|
AC_CHECK_SIZEOF(int,"$enable_sizeof_int")
|
||
|
|
ac_ext=$use_ac_ext
|
||
|
|
AC_CHECK_SIZEOF(long,"$enable_sizeof_long")
|
||
|
|
ac_ext=$use_ac_ext
|
||
|
|
|
||
|
|
AC_DEFINE_UNQUOTED(BOOST_RE_SIZEOF_SHORT, [$ac_cv_sizeof_short])
|
||
|
|
AC_DEFINE_UNQUOTED(BOOST_RE_SIZEOF_INT, [$ac_cv_sizeof_int])
|
||
|
|
AC_DEFINE_UNQUOTED(BOOST_RE_SIZEOF_LONG, [$ac_cv_sizeof_long])
|
||
|
|
|
||
|
|
|
||
|
|
if test "$ac_cv_sizeof_int" -lt 4; then
|
||
|
|
if test "$ac_cv_sizeof_long" -ge 4; then
|
||
|
|
AC_DEFINE(BOOST_RE_INT32_LONG)
|
||
|
|
else
|
||
|
|
AC_MSG_ERROR(Cannot find any 32-bit integer type for your compiler)
|
||
|
|
fi
|
||
|
|
ac_ext=$use_ac_ext
|
||
|
|
fi
|
||
|
|
ac_ext=$use_ac_ext
|
||
|
|
|
||
|
|
|
||
|
|
ac_ext=$use_ac_ext
|
||
|
|
|
||
|
|
dnl checking for compiler capabilities
|
||
|
|
AC_MSG_CHECKING(for basic template compatibility)
|
||
|
|
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 plus : public binary_function<T, T, T> {
|
||
|
|
T operator()(const T& x, const T& y) const;
|
||
|
|
};
|
||
|
|
|
||
|
|
//
|
||
|
|
// non-inline
|
||
|
|
// link will fail if template is not instantiated
|
||
|
|
//
|
||
|
|
template <class T>
|
||
|
|
T plus<T>::operator()(const T& x, const T& y) const
|
||
|
|
{ return x + y; }
|
||
|
|
|
||
|
|
plus<int> p;
|
||
|
|
],
|
||
|
|
[
|
||
|
|
// check member function is actually instantiated
|
||
|
|
int i, j, k;
|
||
|
|
i = p(k, j);
|
||
|
|
],
|
||
|
|
[ac_cv_compat="yes"],
|
||
|
|
[AC_MSG_ERROR(Your compiler won't be able to compile this implementation. Sorry.)
|
||
|
|
ac_cv_compat="no"]
|
||
|
|
)
|
||
|
|
AC_MSG_RESULT($ac_cv_compat)
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for exception support)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <stdlib.h>
|
||
|
|
|
||
|
|
int f1()throw()
|
||
|
|
{
|
||
|
|
return 23;
|
||
|
|
}
|
||
|
|
|
||
|
|
void do_throw()
|
||
|
|
{
|
||
|
|
throw (int)25;
|
||
|
|
}
|
||
|
|
],
|
||
|
|
[
|
||
|
|
try
|
||
|
|
{
|
||
|
|
f1();
|
||
|
|
do_throw();
|
||
|
|
}
|
||
|
|
catch(int i)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
catch(...)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
AC_MSG_ERROR(Sorry, without exception handling you can't compile this library)])
|
||
|
|
|
||
|
|
|
||
|
|
AC_ARG_ENABLE(mutable, [--disable-mutable turns off mutable support])
|
||
|
|
if test "$enable_mutable" = "no"; then
|
||
|
|
AC_DEFINE(BOOST_RE_NO_MUTABLE, [])
|
||
|
|
else
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for mutable keyword)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <stdlib.h>
|
||
|
|
|
||
|
|
class foo
|
||
|
|
{
|
||
|
|
mutable int val;
|
||
|
|
public:
|
||
|
|
foo(int i) : val(i) {}
|
||
|
|
void set(int i)const;
|
||
|
|
};
|
||
|
|
|
||
|
|
void foo::set(int i)const
|
||
|
|
{
|
||
|
|
val = i;
|
||
|
|
}
|
||
|
|
],
|
||
|
|
[
|
||
|
|
const foo f(4);
|
||
|
|
f.set(3);
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_DEFINE(BOOST_RE_NO_MUTABLE, []) AC_MSG_RESULT(no)])
|
||
|
|
fi
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for default template parameter support)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <stdlib.h>
|
||
|
|
|
||
|
|
template <class T, class U = int>
|
||
|
|
struct foo
|
||
|
|
{
|
||
|
|
T val;
|
||
|
|
U alt;
|
||
|
|
};
|
||
|
|
],
|
||
|
|
[
|
||
|
|
foo<int, double> f1;
|
||
|
|
foo<int, int> f2;
|
||
|
|
foo<double> f3;
|
||
|
|
foo<int> f4;
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_MSG_ERROR(Sorry: you can't compile this library)])
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for derived default template parameter support)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <stdlib.h>
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
class inner
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
typedef T inner_type;
|
||
|
|
};
|
||
|
|
|
||
|
|
template <class T, class U = inner<T> >
|
||
|
|
struct foo
|
||
|
|
{
|
||
|
|
T val;
|
||
|
|
U alt;
|
||
|
|
};
|
||
|
|
],
|
||
|
|
[
|
||
|
|
foo<int, inner<double> > f1;
|
||
|
|
foo<int, inner<int> > f2;
|
||
|
|
foo<double> f3;
|
||
|
|
foo<int> f4;
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_MSG_ERROR(Sorry, you can't compile this library)])
|
||
|
|
|
||
|
|
|
||
|
|
AC_MSG_CHECKING([for function template partial ordering])
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <stdlib.h>
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
struct dummy{};
|
||
|
|
|
||
|
|
struct dummy2
|
||
|
|
{
|
||
|
|
int result()const { return 1; }
|
||
|
|
};
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
int foo(const T& t)
|
||
|
|
{ return t.result(); }
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
int foo(const dummy<T>& )
|
||
|
|
{ return 0; }
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
dummy<double> d;
|
||
|
|
dummy2 d2;
|
||
|
|
int i = foo(d);
|
||
|
|
i = foo(d2);
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_DEFINE(BOOST_RE_NO_PARTIAL_FUNC_SPEC, []) AC_MSG_RESULT(no)])
|
||
|
|
|
||
|
|
AC_MSG_CHECKING([for template friend functions])
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <stdlib.h>
|
||
|
|
|
||
|
|
template <class T2>
|
||
|
|
void foo(T2 t);
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
struct dummy
|
||
|
|
{
|
||
|
|
template <class T2> friend void foo(T2);
|
||
|
|
private:
|
||
|
|
void foo2();
|
||
|
|
void foo3()const;
|
||
|
|
};
|
||
|
|
|
||
|
|
template <class T2>
|
||
|
|
void foo(T2 t)
|
||
|
|
{
|
||
|
|
dummy<T2> d1;
|
||
|
|
d1.foo2();
|
||
|
|
d1.foo3();
|
||
|
|
dummy<int> d2;
|
||
|
|
d2.foo2();
|
||
|
|
d2.foo3();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
foo(3);
|
||
|
|
foo(2.345);
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_DEFINE(BOOST_RE_NO_TEMPLATE_FRIEND, []) AC_MSG_RESULT(no)])
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
AC_ARG_ENABLE(ms-windows, [--disable-ms-windows turns off native MS Windows support (when available)])
|
||
|
|
AC_ARG_ENABLE(threads, [--disable-threads turns off multi-threading support (when available)])
|
||
|
|
if test "$enable_ms_windows" != "no"; then
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for MS Windows)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <windows.h>
|
||
|
|
|
||
|
|
#if defined(__GNUC__) && (__GNUC_MINOR__ == 95) && (__GNUC__ == 2)
|
||
|
|
#error can't mix STL code with <windows.h> due to bug in gcc2.95.x
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
int i = GetVersion();
|
||
|
|
],
|
||
|
|
[iswin="true"
|
||
|
|
AC_DEFINE(BOOST_RE_PLATFORM_WINDOWS, [])
|
||
|
|
AC_MSG_RESULT(yes)],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
enable_ms_windows="no"]
|
||
|
|
)
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$enable_ms_windows" != "no"; then
|
||
|
|
dnl Ok check for Win32, then linkage:
|
||
|
|
AC_MSG_CHECKING(for MS Win32)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <windows.h>
|
||
|
|
|
||
|
|
CRITICAL_SECTION cs;
|
||
|
|
],
|
||
|
|
[
|
||
|
|
InitializeCriticalSection(&cs);
|
||
|
|
EnterCriticalSection(&cs);
|
||
|
|
LeaveCriticalSection(&cs);
|
||
|
|
DeleteCriticalSection(&cs);
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
enable_ms_windows="no"]
|
||
|
|
)
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$enable_ms_windows" != "no"; then
|
||
|
|
|
||
|
|
if test "$CXX" != "cl"; then
|
||
|
|
AC_CHECK_LIB(user32, main, [LIBS="$LIBS -luser32"], [])
|
||
|
|
AC_CHECK_LIB(kernel32, main, [LIBS="$LIBS -lkernel32"], [])
|
||
|
|
fi
|
||
|
|
|
||
|
|
AC_TRY_LINK(
|
||
|
|
[
|
||
|
|
#include <windows.h>
|
||
|
|
|
||
|
|
CRITICAL_SECTION cs;
|
||
|
|
],
|
||
|
|
[
|
||
|
|
InitializeCriticalSection(&cs);
|
||
|
|
EnterCriticalSection(&cs);
|
||
|
|
LeaveCriticalSection(&cs);
|
||
|
|
DeleteCriticalSection(&cs);
|
||
|
|
HeapAlloc(0, 0, 20);
|
||
|
|
CharLower((LPTSTR)0);
|
||
|
|
LoadString(0, 0, 0, 0);
|
||
|
|
],
|
||
|
|
[
|
||
|
|
if test "enable_threads" != "no"; then
|
||
|
|
# turn on threading support:
|
||
|
|
AC_MSG_CHECKING(for mult-thread support)
|
||
|
|
AC_MSG_RESULT("yes")
|
||
|
|
AC_DEFINE(BOOST_RE_THREADS, [])
|
||
|
|
AC_DEFINE(BOOST_RE_PLATFORM_W32, [])
|
||
|
|
fi
|
||
|
|
],
|
||
|
|
[
|
||
|
|
# bu**er, windows is present but we can't link
|
||
|
|
AC_MSG_WARN([
|
||
|
|
MS Win32 seems to be present, but we can't link,
|
||
|
|
or find the default library names for kernal32.dll
|
||
|
|
and user32.dll.
|
||
|
|
$0 is disabling MS Windows support, re-run $0 with
|
||
|
|
the environment variable "LIBS" set to the library
|
||
|
|
files required to re-enable Win32 support.])
|
||
|
|
enable_ms_windows="no"
|
||
|
|
]
|
||
|
|
)
|
||
|
|
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
|
||
|
|
if test "$iswin" != "true"; then
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for MS DOS)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <dos.h>
|
||
|
|
],
|
||
|
|
[
|
||
|
|
int i = _doserrno;
|
||
|
|
],
|
||
|
|
[AC_DEFINE(BOOST_RE_PLATFORM_DOS, []) AC_MSG_RESULT(yes)],
|
||
|
|
[AC_MSG_RESULT(no)])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for bool support)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
],
|
||
|
|
[
|
||
|
|
bool i = true;
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_DEFINE(BOOST_RE_NO_BOOL,[])
|
||
|
|
AC_MSG_RESULT(no)])
|
||
|
|
|
||
|
|
|
||
|
|
AC_ARG_ENABLE(wstring, [--disable-wstring turns off wide character string support])
|
||
|
|
|
||
|
|
if test "$enable_wstring" = "no"; then
|
||
|
|
AC_DEFINE(BOOST_RE_NO_WCHAR_H, [])
|
||
|
|
else
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for <cwchar>)
|
||
|
|
AC_TRY_LINK(
|
||
|
|
[
|
||
|
|
#include <cwchar>
|
||
|
|
],
|
||
|
|
[
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_DEFINE(BOOST_RE_NO_WCHAR_H,[])
|
||
|
|
AC_MSG_RESULT(no)]
|
||
|
|
)
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$enable_wstring" = "no"; then
|
||
|
|
AC_DEFINE(BOOST_RE_NO_WCTYPE_H, [])
|
||
|
|
else
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for <cwctype>)
|
||
|
|
AC_TRY_LINK(
|
||
|
|
[
|
||
|
|
#include <cwctype>
|
||
|
|
],
|
||
|
|
[
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_DEFINE(BOOST_RE_NO_WCTYPE_H,[])
|
||
|
|
AC_MSG_RESULT(no)]
|
||
|
|
)
|
||
|
|
fi
|
||
|
|
|
||
|
|
|
||
|
|
if test "$enable_wstring" = "no"; then
|
||
|
|
AC_DEFINE(BOOST_RE_NO_WCSTRING, [])
|
||
|
|
else
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for wide string functions)
|
||
|
|
AC_TRY_LINK(
|
||
|
|
[
|
||
|
|
#include "confdefs.h"
|
||
|
|
#ifndef BOOST_RE_NO_WCHAR_H
|
||
|
|
#include <cwchar>
|
||
|
|
#endif
|
||
|
|
#ifndef BOOST_RE_NO_WCTYPE_H
|
||
|
|
#include <cwctype>
|
||
|
|
#endif
|
||
|
|
#include <cstdlib>
|
||
|
|
#include <cstdio>
|
||
|
|
#include <cstring>
|
||
|
|
#include <cctype>
|
||
|
|
#include <string>
|
||
|
|
template class std::basic_string<wchar_t>;
|
||
|
|
],
|
||
|
|
[
|
||
|
|
using namespace std;
|
||
|
|
wchar_t c[50];
|
||
|
|
char d[50];
|
||
|
|
wcscpy(c, L"abcd");
|
||
|
|
wcscmp(L"", L"");
|
||
|
|
wcslen(L"");
|
||
|
|
wcsxfrm(0, L"", 0);
|
||
|
|
wcstombs(d, L"", 0);
|
||
|
|
mbstowcs(c, "", 0);
|
||
|
|
iswlower(L'c');
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)]
|
||
|
|
enable_wstring="yes",
|
||
|
|
[AC_DEFINE(BOOST_RE_NO_WCSTRING,[])
|
||
|
|
AC_MSG_RESULT(no)]
|
||
|
|
enable_wstring="no")
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$enable_wstring" != "no"; then
|
||
|
|
AC_MSG_CHECKING(for swprintf support)
|
||
|
|
AC_TRY_LINK(
|
||
|
|
[
|
||
|
|
#include "confdefs.h"
|
||
|
|
#ifndef BOOST_RE_NO_WCHAR_H
|
||
|
|
#include <wchar.h>
|
||
|
|
#endif
|
||
|
|
#ifndef BOOST_RE_NO_WCTYPE_H
|
||
|
|
#include <wctype.h>
|
||
|
|
#endif
|
||
|
|
#include <string.h>
|
||
|
|
#include <stdio.h>
|
||
|
|
],
|
||
|
|
[
|
||
|
|
wchar_t c[50];
|
||
|
|
swprintf(c, 50, L"abcd");
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_DEFINE(BOOST_RE_NO_SWPRINTF,[])
|
||
|
|
AC_MSG_RESULT(no)]
|
||
|
|
enable_swprintf="no")
|
||
|
|
fi
|
||
|
|
|
||
|
|
|
||
|
|
AC_ARG_ENABLE(member-templates, [--disable-member-templates turns off member template class and function support])
|
||
|
|
if test "$enable_member_templates" = "no"; then
|
||
|
|
AC_DEFINE(BOOST_RE_NO_MEMBER_TEMPLATES, [])
|
||
|
|
else
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for member template classes and functions)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
class alloc
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
void* allocate(int);
|
||
|
|
void deallocate(void*);
|
||
|
|
alloc();
|
||
|
|
alloc(const alloc&);
|
||
|
|
template <class U>
|
||
|
|
alloc(const alloc<U>&) {}
|
||
|
|
alloc& operator=(const alloc&);
|
||
|
|
template <class U>
|
||
|
|
alloc& operator=(const alloc<U>&)
|
||
|
|
{ return *this; }
|
||
|
|
|
||
|
|
template <class U>
|
||
|
|
struct rebind
|
||
|
|
{
|
||
|
|
typedef alloc<U> other;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
alloc<int> ia;
|
||
|
|
alloc<double> da(ia);
|
||
|
|
alloc<float> fa;
|
||
|
|
fa.allocate(5);
|
||
|
|
fa = ia;
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_DEFINE(BOOST_RE_NO_MEMBER_TEMPLATES,[])
|
||
|
|
AC_MSG_RESULT(no)])
|
||
|
|
fi
|
||
|
|
|
||
|
|
|
||
|
|
AC_ARG_ENABLE(template-returns, [--disable-template-returns turns off support for templates specialised by return type])
|
||
|
|
if test "$enable_template_returns" = "no"; then
|
||
|
|
AC_DEFINE(BOOST_RE_NO_TEMPLATE_RETURNS, [])
|
||
|
|
else
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for parameterised function returns)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
template <class T>
|
||
|
|
T coerse(int i)
|
||
|
|
{ return T(i); }
|
||
|
|
],
|
||
|
|
[
|
||
|
|
double d = coerse<double>(5);
|
||
|
|
int i = coerse<int>(3);
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_DEFINE(BOOST_RE_NO_TEMPLATE_RETURNS,[])
|
||
|
|
AC_MSG_RESULT(no)])
|
||
|
|
fi
|
||
|
|
|
||
|
|
|
||
|
|
AC_ARG_ENABLE(int64, [--disable-int64 turns off support for 64-bit integer types])
|
||
|
|
if test "$enable_int64" = "no"; then
|
||
|
|
AC_DEFINE(BOOST_RE_INT64_T_0)
|
||
|
|
else
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for 64-bit integral type)
|
||
|
|
|
||
|
|
if test "$ac_cv_sizeof_short" -eq 8; then
|
||
|
|
AC_DEFINE(BOOST_RE_INT64_T_1)
|
||
|
|
AC_MSG_RESULT(yes - short)
|
||
|
|
have_int64="true"
|
||
|
|
fi
|
||
|
|
if test "$ac_cv_sizeof_int" -eq 8 && test "$have_int64" != "true"; then
|
||
|
|
AC_DEFINE(BOOST_RE_INT64_T_2)
|
||
|
|
AC_MSG_RESULT(yes - int)
|
||
|
|
have_int64="true"
|
||
|
|
fi
|
||
|
|
if test "$ac_cv_sizeof_long" -eq 8 && test "$have_int64" != "true"; then
|
||
|
|
AC_DEFINE(BOOST_RE_INT64_T_3)
|
||
|
|
AC_MSG_RESULT(yes - long)
|
||
|
|
have_int64="true"
|
||
|
|
fi
|
||
|
|
if test "$have_int64" != "true"; then
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <inttypes.h>
|
||
|
|
|
||
|
|
int64_t i = INT64_C(0x100000000);
|
||
|
|
],
|
||
|
|
[
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes - int64_t)
|
||
|
|
have_int64="true"
|
||
|
|
AC_DEFINE(BOOST_RE_INT64_T_4)
|
||
|
|
],
|
||
|
|
[])
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$have_int64" != "true"; then
|
||
|
|
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <stdlib.h>
|
||
|
|
|
||
|
|
long long i = 0x100000000LL;
|
||
|
|
],
|
||
|
|
[
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes - long long)
|
||
|
|
have_int64="true"
|
||
|
|
AC_DEFINE(BOOST_RE_INT64_T_5)
|
||
|
|
],
|
||
|
|
[])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$have_int64" != "true"; then
|
||
|
|
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <stdlib.h>
|
||
|
|
|
||
|
|
__int64 i = 0x100000000i64;
|
||
|
|
],
|
||
|
|
[
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes - __int64)
|
||
|
|
have_int64="true"
|
||
|
|
AC_DEFINE(BOOST_RE_INT64_T_6)
|
||
|
|
],
|
||
|
|
[])
|
||
|
|
fi
|
||
|
|
if test "$have_int64" != "true"; then
|
||
|
|
AC_DEFINE(BOOST_RE_INT64_T,0)
|
||
|
|
AC_MSG_RESULT(no)
|
||
|
|
fi
|
||
|
|
fi
|
||
|
|
|
||
|
|
|
||
|
|
AC_ARG_ENABLE(messages, [--disable-messages turns off support for POSIX message categories, when available.])
|
||
|
|
if test "$enable_messages" = "no" || test "$enable_ms_windows" != "no"; then
|
||
|
|
AC_DEFINE(BOOST_RE_NO_CAT, [])
|
||
|
|
else
|
||
|
|
|
||
|
|
AC_CHECK_LIB(nl_types, catopen)
|
||
|
|
AC_CHECK_LIB(posix, catopen)
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for POSIX message categories)
|
||
|
|
AC_TRY_LINK(
|
||
|
|
[
|
||
|
|
#include <nl_types.h>
|
||
|
|
|
||
|
|
nl_catd message_cat = (nl_catd)-1;
|
||
|
|
],
|
||
|
|
[
|
||
|
|
message_cat = catopen("some_name", 0);
|
||
|
|
catclose(message_cat);
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_DEFINE(BOOST_RE_NO_CAT,[])
|
||
|
|
AC_MSG_RESULT(no)])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$enable_threads" != "no" && test "$enable_ms_windows" = "no"; then
|
||
|
|
|
||
|
|
AC_CHECK_LIB(pthread, pthread_mutex_init)
|
||
|
|
AC_CHECK_LIB(posix, pthread_mutex_init)
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for POSIX threads)
|
||
|
|
AC_TRY_LINK(
|
||
|
|
[
|
||
|
|
#include <pthread.h>
|
||
|
|
|
||
|
|
pthread_mutex_t m;
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
pthread_mutex_init(&m, NULL);
|
||
|
|
pthread_mutex_lock(&m);
|
||
|
|
pthread_mutex_unlock(&m);
|
||
|
|
pthread_mutex_destroy(&m);
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
AC_DEFINE(BOOST_RE_THREADS, [])],
|
||
|
|
[AC_MSG_RESULT(no)])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
|
||
|
|
AC_ARG_ENABLE(nested-template-prefix, [--disable-nested-template-prefix turns off use of \"template\" as the nested template class access specifier.])
|
||
|
|
if test "$enable_nested_template_prefix" = "no" || test "$enable_member_templates" = "no"; then
|
||
|
|
AC_DEFINE(BOOST_RE_NESTED_TEMPLATE_DECL, [])
|
||
|
|
else
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for template nested class access)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
template <class T>
|
||
|
|
class alloc
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
void* allocate(int);
|
||
|
|
void deallocate(void*);
|
||
|
|
alloc();
|
||
|
|
alloc(const alloc&);
|
||
|
|
template <class U>
|
||
|
|
alloc(const alloc<U>&) {}
|
||
|
|
alloc& operator=(const alloc&);
|
||
|
|
template <class U>
|
||
|
|
alloc& operator=(const alloc<U>&)
|
||
|
|
{ return *this; }
|
||
|
|
|
||
|
|
template <class U>
|
||
|
|
struct rebind
|
||
|
|
{
|
||
|
|
typedef alloc<U> other;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
alloc<int> ia;
|
||
|
|
alloc<double> da(ia);
|
||
|
|
alloc<float> fa;
|
||
|
|
fa.allocate(5);
|
||
|
|
fa = ia;
|
||
|
|
alloc<int>::template rebind<double>::other da2(ia);
|
||
|
|
],
|
||
|
|
[
|
||
|
|
AC_MSG_RESULT(yes)
|
||
|
|
AC_DEFINE(BOOST_RE_NESTED_TEMPLATE_DECL,template)
|
||
|
|
],
|
||
|
|
[
|
||
|
|
AC_DEFINE(BOOST_RE_NESTED_TEMPLATE_DECL,[])
|
||
|
|
AC_MSG_RESULT(no)
|
||
|
|
])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for explicit template instantiation)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include "confdefs.h"
|
||
|
|
#include <stdlib.h>
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
class factorial
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
factorial();
|
||
|
|
T operator()(T);
|
||
|
|
};
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
factorial<T>::factorial()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
T factorial<T>::operator()(T t)
|
||
|
|
{
|
||
|
|
T result = 1;
|
||
|
|
for(T i = 1; i <= t; ++i)
|
||
|
|
{
|
||
|
|
result *= i;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
template class factorial<int>;
|
||
|
|
template class factorial<short>;
|
||
|
|
],
|
||
|
|
[
|
||
|
|
],
|
||
|
|
[
|
||
|
|
AC_MSG_RESULT(yes)
|
||
|
|
],
|
||
|
|
[
|
||
|
|
AC_DEFINE(BOOST_RE_NO_TEMPLATE_INST,[])
|
||
|
|
AC_MSG_RESULT(no)
|
||
|
|
])
|
||
|
|
|
||
|
|
|
||
|
|
AC_ARG_ENABLE(fastcall, [--disable-fastcall turns off use __fastcall and __stdcall.])
|
||
|
|
if test "$enable_fastcall" = "no" || test "$enable_ms_windows" != "no"; then
|
||
|
|
AC_DEFINE(BOOST_RE_CALL, [])
|
||
|
|
AC_DEFINE(BOOST_RE_CCALL, [])
|
||
|
|
else
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for __fastcall and __stdcall)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
void __fastcall f1(int)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
void __stdcall f2(int)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
f1(2);
|
||
|
|
f2(3);
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
AC_DEFINE(BOOST_RE_CALL, [__fastcall])
|
||
|
|
AC_DEFINE(BOOST_RE_CCALL, [__stdcall])
|
||
|
|
],
|
||
|
|
[AC_DEFINE(BOOST_RE_CALL, [])
|
||
|
|
AC_DEFINE(BOOST_RE_CCALL, [])
|
||
|
|
AC_MSG_RESULT(no)])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
# move on to STL options:
|
||
|
|
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for standard library namespace)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <stddef.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <list>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
namespace jm{
|
||
|
|
|
||
|
|
struct dummy{};
|
||
|
|
|
||
|
|
}; // namespace
|
||
|
|
|
||
|
|
jm::dummy d;
|
||
|
|
|
||
|
|
std::list<int> v;
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes - std)
|
||
|
|
have_std_namespace="yes"
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no - either STL is not present or in a non-standard namespace.)
|
||
|
|
AC_MSG_ERROR([Sorry, you can't compile this library unless the standard library is in namespace std.])])
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for <exception>)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <exception>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
class bad_expression : public std::exception
|
||
|
|
{
|
||
|
|
unsigned int code;
|
||
|
|
public:
|
||
|
|
bad_expression(unsigned int err) : code(err) {}
|
||
|
|
bad_expression(const bad_expression& e) : std::exception(e), code(e.code) {}
|
||
|
|
bad_expression& operator=(const bad_expression& e)
|
||
|
|
{
|
||
|
|
std::exception::operator=(e);
|
||
|
|
code = e.code;
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
virtual const char* what()const throw();
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
std::exception e;
|
||
|
|
std::bad_exception e3;
|
||
|
|
],
|
||
|
|
[
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
AC_DEFINE(BOOST_RE_NO_EXCEPTION_H, [])
|
||
|
|
])
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for <iterator>)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <iterator>
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
AC_DEFINE(BOOST_RE_NO_ITERATOR_H, [])
|
||
|
|
])
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for <algorithm>)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <algorithm>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
need_algo="yes"
|
||
|
|
])
|
||
|
|
|
||
|
|
if test "$enable_stl" != "no" && test "$need_algo" = "yes"; then
|
||
|
|
AC_MSG_CHECKING(for <algo>)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <algo>
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
AC_DEFINE(BOOST_RE_USE_ALGO, [])
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no - disabling STL support)
|
||
|
|
AC_DEFINE(BOOST_RE_NO_STL, [])
|
||
|
|
AC_DEFINE(BOOST_RE_NO_EXCEPTION_H, [])
|
||
|
|
AC_DEFINE(BOOST_RE_NO_ITERATOR_H, [])
|
||
|
|
AC_DEFINE(BOOST_RE_NO_MEMORY_H, [])
|
||
|
|
AC_DEFINE(BOOST_RE_NO_LOCALE_H, [])
|
||
|
|
AC_DEFINE(BOOST_RE_NO_STRING_H, [])
|
||
|
|
enable_stl="no"
|
||
|
|
])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for <memory>)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <memory>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
std::allocator<char> a;
|
||
|
|
std::allocator<double> d(a);
|
||
|
|
|
||
|
|
typedef std::allocator<char> alloc_type;
|
||
|
|
|
||
|
|
alloc_type::BOOST_RE_NESTED_TEMPLATE_DECL rebind<int>::other o(a);
|
||
|
|
],
|
||
|
|
[
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
AC_DEFINE(BOOST_RE_NO_MEMORY_H, [])
|
||
|
|
])
|
||
|
|
|
||
|
|
|
||
|
|
if test "$enable_stl" != "no"; then
|
||
|
|
AC_MSG_CHECKING(for <string>)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <string>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
std::string a;
|
||
|
|
//std::wstring ws;
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
AC_MSG_ERROR(Sorry: you can't compile this library without <string>)
|
||
|
|
])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$enable_stl" != "no"; then
|
||
|
|
AC_MSG_CHECKING(for std::basic_string default arguments)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <string>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
std::basic_string<char> s1;
|
||
|
|
std::basic_string<wchar_t> s2;
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
AC_DEFINE(BOOST_RE_NO_STRING_DEF_ARGS, [])
|
||
|
|
])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
ac_have_locale='no'
|
||
|
|
if test "$enable_stl" != "no"; then
|
||
|
|
AC_MSG_CHECKING(for <locale>)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <locale>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
std::locale l;
|
||
|
|
],
|
||
|
|
[
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
ac_have_locale='yes'
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
AC_DEFINE(BOOST_RE_NO_LOCALE_H, [])
|
||
|
|
])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$enable_stl" != "no"; then
|
||
|
|
AC_MSG_CHECKING(for <iostream>)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <iostream>
|
||
|
|
#include <locale>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
std::locale l;
|
||
|
|
std::cout.imbue(l);
|
||
|
|
std::cout << "some text" << std::endl;
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
AC_DEFINE(BOOST_RE_OLD_IOSTREAM, [])
|
||
|
|
])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for std::distance)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <iterator>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
int i, *j, *k;
|
||
|
|
i = std::distance(j, k);
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
AC_DEFINE(BOOST_RE_DISTANCE_T_1)
|
||
|
|
have_dist="yes"
|
||
|
|
],
|
||
|
|
[])
|
||
|
|
|
||
|
|
if test "$enable_stl" != "no" && test "$have_dist" != "yes"; then
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <iterator>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
int i, *j, *k;
|
||
|
|
std::distance(j, k, i);
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
AC_DEFINE(BOOST_RE_DISTANCE_T_2)
|
||
|
|
have_dist="yes"
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
AC_DEFINE(BOOST_RE_DISTANCE_T_0)
|
||
|
|
have_dist="yes"])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$enable_stl" != "no" && test "$have_si" != "yes"; then
|
||
|
|
AC_MSG_CHECKING(for standard iterator syntax)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <iterator>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
std::iterator<std::output_iterator_tag, char, std::ptrdiff_t, char*, char&> oi;
|
||
|
|
std::iterator<std::input_iterator_tag, char, std::ptrdiff_t, char*, char&> ii;
|
||
|
|
std::iterator<std::forward_iterator_tag, char, std::ptrdiff_t, char*, char&> fi;
|
||
|
|
std::iterator<std::bidirectional_iterator_tag, char, std::ptrdiff_t, char*, char&> bi;
|
||
|
|
std::iterator<std::random_access_iterator_tag, char, std::ptrdiff_t, char*, char&> ri;
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
AC_DEFINE(BOOST_RE_ITERATOR_T_1)
|
||
|
|
have_si="yes"
|
||
|
|
have_oi="yes"
|
||
|
|
have_ii="yes"
|
||
|
|
have_fi="yes"
|
||
|
|
have_bi="yes"
|
||
|
|
have_ri="yes"
|
||
|
|
],
|
||
|
|
[])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$enable_stl" != "no" && test "$have_si" != "yes"; then
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <iterator>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
std::iterator<std::output_iterator_tag, char, std::ptrdiff_t> oi;
|
||
|
|
std::iterator<std::input_iterator_tag, char, std::ptrdiff_t> ii;
|
||
|
|
std::iterator<std::forward_iterator_tag, char, std::ptrdiff_t> fi;
|
||
|
|
std::iterator<std::bidirectional_iterator_tag, char, std::ptrdiff_t> bi;
|
||
|
|
std::iterator<std::random_access_iterator_tag, char, std::ptrdiff_t> ri;
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
AC_DEFINE(BOOST_RE_ITERATOR_T_2)
|
||
|
|
have_si="yes"
|
||
|
|
have_oi="yes"
|
||
|
|
have_ii="yes"
|
||
|
|
have_fi="yes"
|
||
|
|
have_bi="yes"
|
||
|
|
have_ri="yes"
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no)])
|
||
|
|
AC_DEFINE(BOOST_RE_ITERATOR_T_0)
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
|
||
|
|
if test "$have_oi" != "yes"; then
|
||
|
|
AC_MSG_CHECKING(for output iterator syntax)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <iterator>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
std::output_iterator oi;
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
AC_DEFINE(BOOST_RE_OI_T_3)
|
||
|
|
have_oi="yes"
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
AC_DEFINE(BOOST_RE_OI_T_0)
|
||
|
|
have_oi="yes"])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$enable_stl" != "no" && test "$have_ii" != "yes"; then
|
||
|
|
AC_MSG_CHECKING(for input iterator syntax)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <iterator>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
std::input_iterator<char, std::ptrdiff_t> oi;
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
AC_DEFINE(BOOST_RE_II_T_3)
|
||
|
|
have_ii="yes"
|
||
|
|
],
|
||
|
|
[])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$enable_stl" != "no" && test "$have_ii" != "yes"; then
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <iterator>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
std::input_iterator<char> oi;
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
AC_DEFINE(BOOST_RE_II_T_4)
|
||
|
|
have_ii="yes"
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
AC_DEFINE(BOOST_RE_II_T_0)
|
||
|
|
have_ii="yes"])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$enable_stl" != "no" && test "$have_fi" != "yes"; then
|
||
|
|
AC_MSG_CHECKING(for forward iterator syntax)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <iterator>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
std::forward_iterator<int, std::ptrdiff_t> oi;
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
AC_DEFINE(BOOST_RE_FI_T_3)
|
||
|
|
have_fi="yes"
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
AC_DEFINE(BOOST_RE_FI_T_0)
|
||
|
|
have_fi="yes"])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$enable_stl" != "no" && test "$have_bi" != "yes"; then
|
||
|
|
AC_MSG_CHECKING(for bidirectional iterator syntax)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <iterator>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
std::bidirectional_iterator<int, std::ptrdiff_t> oi;
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
AC_DEFINE(BOOST_RE_BI_T_)
|
||
|
|
have_bi="yes"
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
AC_DEFINE(BOOST_RE_BI_T_0)
|
||
|
|
have_bi="yes"])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$enable_stl" != "no" && test "$have_ri" != "yes"; then
|
||
|
|
AC_MSG_CHECKING(for random access iterator syntax)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include <iterator>
|
||
|
|
#include "confdefs.h"
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
std::random_access_iterator<int, std::ptrdiff_t> oi;
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
AC_DEFINE(BOOST_RE_RI_T_3)
|
||
|
|
have_ri="yes"
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
AC_DEFINE(BOOST_RE_RI_T_0)
|
||
|
|
have_ri="yes"])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
if test "$enable_stl" != "no"; then
|
||
|
|
AC_MSG_CHECKING(for output iterator assignment)
|
||
|
|
AC_TRY_COMPILE(
|
||
|
|
[
|
||
|
|
#include "confdefs.h"
|
||
|
|
#include <iterator>
|
||
|
|
#ifdef BOOST_RE_OLD_IOSTREAM
|
||
|
|
#include <iostream.h>
|
||
|
|
std::ostream_iterator<char> a(cout);
|
||
|
|
std::ostream_iterator<char> b(cout);
|
||
|
|
#else
|
||
|
|
#include <iostream>
|
||
|
|
std::ostream_iterator<char> a(std::cout);
|
||
|
|
std::ostream_iterator<char> b(std::cout);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#include <list>
|
||
|
|
#if !defined(BOOST_RE_NO_TRICKY_DEFAULT_PARAM) && !defined(BOOST_RE_NO_DEFAULT_PARAM)
|
||
|
|
typedef std::list<int> list_type;
|
||
|
|
#else
|
||
|
|
typedef std::list<int, jm_def_alloc> list_type;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
list_type v;
|
||
|
|
|
||
|
|
std:: back_insert_iterator<list_type> c(v);
|
||
|
|
std:: back_insert_iterator<list_type> d(v);
|
||
|
|
|
||
|
|
],
|
||
|
|
[
|
||
|
|
a = b;
|
||
|
|
c = d;
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(no)
|
||
|
|
AC_DEFINE(BOOST_RE_NO_OI_ASSIGN, [])
|
||
|
|
])
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
#
|
||
|
|
# generate include dependencies
|
||
|
|
#
|
||
|
|
#ac_all_h=""
|
||
|
|
#ac_all_dep=""
|
||
|
|
#for file in ../../boost/re_detail/*.hpp
|
||
|
|
#do
|
||
|
|
# if test "$file" != '../../boost/re_detail/*.hpp'; then
|
||
|
|
# ac_all_h="$ac_all_h ../$file"
|
||
|
|
# ac_all_dep="$ac_all_dep $file"
|
||
|
|
# fi
|
||
|
|
#done
|
||
|
|
#echo "$ac_all_h"
|
||
|
|
|
||
|
|
#
|
||
|
|
# generate source dependencies
|
||
|
|
#
|
||
|
|
#ac_all_o=""
|
||
|
|
#ac_rules=""
|
||
|
|
#ac_all_cpp=""
|
||
|
|
#cat ./lib/makefile.org > ./lib/makefile.in
|
||
|
|
#for file in src/*.cpp src/*.c
|
||
|
|
#do
|
||
|
|
# if test "$file" != 'src/*.cpp' && test "$file" != 'src/*.c'; then
|
||
|
|
# dnl echo source dependency found "$file"
|
||
|
|
# ac_all_dep="$ac_all_dep $file"
|
||
|
|
# ac_all_cpp="$ac_all_cpp $file"
|
||
|
|
# root=`echo "$file" | sed 's/src\/\(.*\)\..*/\1/g'`
|
||
|
|
# dnl echo root file name is "$root"
|
||
|
|
# ac_all_o="$ac_all_o $root$ac_obj_ext"
|
||
|
|
# echo >> ./lib/makefile.in
|
||
|
|
# echo >> ./lib/makefile.in
|
||
|
|
# echo "$root$ac_obj_ext"': $(ALL_H) '"../$file" >> ./lib/makefile.in
|
||
|
|
# echo ' $(CPP) $(CPP_PROJ)'" ../$file" >> ./lib/makefile.in
|
||
|
|
# echo ' $(AR) -rc lib$(LIBNAME).a'" $root$ac_obj_ext" >> ./lib/makefile.in
|
||
|
|
# fi
|
||
|
|
#done
|
||
|
|
|
||
|
|
#echo "$ac_rules" >> ./lib/makefile.in
|
||
|
|
|
||
|
|
#AC_SUBST(ac_all_o)
|
||
|
|
#AC_SUBST(ac_all_h)
|
||
|
|
#AC_SUBST(ac_all_cpp)
|
||
|
|
#AC_SUBST(ac_all_dep)
|
||
|
|
|
||
|
|
#ac_regress="$ac_regress r1$ac_exe_ext"
|
||
|
|
|
||
|
|
#if test "$enable_wstring" != "no"; then
|
||
|
|
#ac_regress="$ac_regress r2$ac_exe_ext"
|
||
|
|
#fi
|
||
|
|
|
||
|
|
#AC_SUBST(ac_regress)
|
||
|
|
|
||
|
|
if test "$enable_ms_windows" = "no"; then
|
||
|
|
AC_DEFINE(BOOST_RE_NO_W32, [])
|
||
|
|
fi
|
||
|
|
|
||
|
|
|
||
|
|
#
|
||
|
|
# OK final test for possible link time problems:
|
||
|
|
#
|
||
|
|
cat > conf2.h << EOF
|
||
|
|
|
||
|
|
#include "confdefs.h"
|
||
|
|
#include <stdlib.h>
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
class factorial
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
factorial();
|
||
|
|
T operator()(T);
|
||
|
|
};
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
factorial<T>::factorial()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
T factorial<T>::operator()(T t)
|
||
|
|
{
|
||
|
|
T result = 1;
|
||
|
|
for(T i = 1; i <= t; ++i)
|
||
|
|
{
|
||
|
|
result *= i;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
int conf2_test();
|
||
|
|
|
||
|
|
|
||
|
|
EOF
|
||
|
|
|
||
|
|
cat > conf2.cpp << EOF
|
||
|
|
|
||
|
|
#include "conf2.h"
|
||
|
|
|
||
|
|
int conf2_test()
|
||
|
|
{
|
||
|
|
factorial<int> f;
|
||
|
|
return f(8);
|
||
|
|
}
|
||
|
|
|
||
|
|
EOF
|
||
|
|
|
||
|
|
old_libs="$LIBS"
|
||
|
|
|
||
|
|
LIBS="conf2.cpp $old_libs"
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for link time template merging)
|
||
|
|
AC_TRY_LINK(
|
||
|
|
[
|
||
|
|
#include "conf2.h"
|
||
|
|
],
|
||
|
|
[
|
||
|
|
factorial<int> g;
|
||
|
|
g(5);
|
||
|
|
conf2_test();
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_DEFINE(BOOST_RE_NO_TEMPLATE_MERGE, [])
|
||
|
|
AC_MSG_RESULT(no)
|
||
|
|
AC_MSG_RESULT([ Warning - $0 has determined that your compiler can not merge])
|
||
|
|
AC_MSG_RESULT([ template instances, you may have problems linking to libregex++.a - ])
|
||
|
|
AC_MSG_RESULT([ see the FAQ for further details.])
|
||
|
|
]
|
||
|
|
)
|
||
|
|
|
||
|
|
if eval "$CXX $CXXFLAGS -c conf2.cpp" && eval "ar -rc libconf2.a conf2$ac_obj_ext"; then
|
||
|
|
LIBS="-L./ -lconf2 $old_libs"
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for link time template merging from archive files)
|
||
|
|
AC_TRY_LINK(
|
||
|
|
[
|
||
|
|
#include "conf2.h"
|
||
|
|
],
|
||
|
|
[
|
||
|
|
factorial<int> g;
|
||
|
|
g(5);
|
||
|
|
conf2_test();
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_DEFINE(BOOST_RE_NO_TEMPLATE_MERGE_A, [])
|
||
|
|
AC_MSG_RESULT(no)
|
||
|
|
AC_MSG_RESULT([ Warning - $0 has determined that your compiler can not merge ])
|
||
|
|
AC_MSG_RESULT([ template instances, if these are located inside an archive file,])
|
||
|
|
AC_MSG_RESULT([ you may have problems linking to libregex++.a - see the FAQ for])
|
||
|
|
AC_MSG_RESULT([ further details.])
|
||
|
|
]
|
||
|
|
)
|
||
|
|
|
||
|
|
else
|
||
|
|
|
||
|
|
AC_MSG_RESULT(Unable to create library archive, library may not be fully configured.)
|
||
|
|
|
||
|
|
fi
|
||
|
|
|
||
|
|
|
||
|
|
#
|
||
|
|
# cleanup
|
||
|
|
#
|
||
|
|
rm -f conf2.h
|
||
|
|
rm -f conf2.cpp
|
||
|
|
rm -f "conf2$ac_obj_ext"
|
||
|
|
rm -f libconf2.a
|
||
|
|
LIBS="$old_libs"
|
||
|
|
|
||
|
|
cat > conf2.h << EOF
|
||
|
|
|
||
|
|
#include "confdefs.h"
|
||
|
|
#include <stdlib.h>
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
class factorial
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
factorial();
|
||
|
|
T operator()(T);
|
||
|
|
};
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
factorial<T>::factorial()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
template <class T>
|
||
|
|
T factorial<T>::operator()(T t)
|
||
|
|
{
|
||
|
|
T result = 1;
|
||
|
|
switch(t)
|
||
|
|
{
|
||
|
|
case 2:
|
||
|
|
for(T i = 1; i <= 2; ++i)
|
||
|
|
{
|
||
|
|
result *= i;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
case 3:
|
||
|
|
for(T i = 1; i <= 3; ++i)
|
||
|
|
{
|
||
|
|
result *= i;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
case 4:
|
||
|
|
for(T i = 1; i <= 4; ++i)
|
||
|
|
{
|
||
|
|
result *= i;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
case 5:
|
||
|
|
for(T i = 1; i <= 5; ++i)
|
||
|
|
{
|
||
|
|
result *= i;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
case 6:
|
||
|
|
for(T i = 1; i <= 6; ++i)
|
||
|
|
{
|
||
|
|
result *= i;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
case 7:
|
||
|
|
for(T i = 1; i <= 7; ++i)
|
||
|
|
{
|
||
|
|
result *= i;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
default:
|
||
|
|
for(T i = 1; i <= t; ++i)
|
||
|
|
{
|
||
|
|
result *= i;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int conf2_test();
|
||
|
|
|
||
|
|
|
||
|
|
EOF
|
||
|
|
|
||
|
|
cat > conf2.cpp << EOF
|
||
|
|
|
||
|
|
#include "conf2.h"
|
||
|
|
|
||
|
|
int conf2_test()
|
||
|
|
{
|
||
|
|
factorial<int> f;
|
||
|
|
return f(8);
|
||
|
|
}
|
||
|
|
|
||
|
|
EOF
|
||
|
|
|
||
|
|
old_libs="$LIBS"
|
||
|
|
|
||
|
|
LIBS="conf2.cpp $old_libs"
|
||
|
|
|
||
|
|
AC_MSG_CHECKING(for link time template merging of switch statements)
|
||
|
|
AC_TRY_LINK(
|
||
|
|
[
|
||
|
|
#include "conf2.h"
|
||
|
|
],
|
||
|
|
[
|
||
|
|
factorial<int> g;
|
||
|
|
g(5);
|
||
|
|
conf2_test();
|
||
|
|
],
|
||
|
|
[AC_MSG_RESULT(yes)],
|
||
|
|
[AC_DEFINE(BOOST_RE_NO_TEMPLATE_SWITCH_MERGE, [])
|
||
|
|
AC_MSG_RESULT(no)
|
||
|
|
AC_MSG_RESULT([ Warning - $0 has determined that your compiler can not merge])
|
||
|
|
AC_MSG_RESULT([ template instances, if those instances contain switch statements, ])
|
||
|
|
AC_MSG_RESULT([ you may have problems linking to libregex++.a - ])
|
||
|
|
AC_MSG_RESULT([ see the FAQ for further details.])
|
||
|
|
]
|
||
|
|
)
|
||
|
|
|
||
|
|
#
|
||
|
|
# cleanup
|
||
|
|
#
|
||
|
|
rm -f conf2.h
|
||
|
|
rm -f conf2.cpp
|
||
|
|
LIBS="$old_libs"
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
AC_DEFINE(BOOST_RE_AUTO_CONF)
|
||
|
|
|
||
|
|
#AC_MSG_RESULT(***)
|
||
|
|
#AC_MSG_RESULT($0: setting up headers...)
|
||
|
|
#AC_MSG_RESULT(***)
|
||
|
|
#AC_OUTPUT(lib/makefile demo/jgrep/makefile demo/timer/makefile demo/regress/makefile makefile)
|
||
|
|
#AC_MSG_RESULT(***)
|
||
|
|
#AC_MSG_RESULT($0: regex++ package tuned for use with \"${CXX}\" compiler.)
|
||
|
|
#AC_MSG_RESULT($0: To restore original settings - copy jm_opt.in to ../../boost/re_detail/regex_options.hpp)
|
||
|
|
#AC_MSG_RESULT(***)
|
||
|
|
|
||
|
|
#post processing cleanup:
|
||
|
|
#sed 's%^[ ]*#[ ]*undef[ ][ ]*\(.*\)[ ]*$%/* #define \1 */%' ../../boost/re_detail/regex_options.hpp > jm_opt.out
|
||
|
|
#cat jm_opt.out > ../../boost/re_detail/regex_options.hpp
|
||
|
|
#sed 's%\(#[ ]*\)undef[ ]%\1define %' ../../boost/re_detail/regex_options.hpp > jm_opt.out
|
||
|
|
#cat jm_opt.out > ../../boost/re_detail/regex_options.hpp
|
||
|
|
#rm -f jm_opt.out
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
####################################################
|
||
|
|
####################################################
|
||
|
|
####################################################
|
||
|
|
|
||
|
|
### Finish the work.
|
||
|
|
AC_OUTPUT([Makefile \
|
||
|
|
], [])
|
||
|
|
|
||
|
|
|