[pkg-boost-commits] r14175 - in boost/trunk: boost/date_time boost/function boost/graph boost/numeric/ublas boost/python/detail boost/regex/v4 boost/test debian debian/patches libs/regex/test/regress tools/jam/src
smr at alioth.debian.org
smr at alioth.debian.org
Sun Mar 23 05:25:25 UTC 2008
Author: smr
Date: 2008-03-23 05:25:24 +0000 (Sun, 23 Mar 2008)
New Revision: 14175
Added:
boost/trunk/debian/patches/bjam-no-strict-aliasing.patch
boost/trunk/debian/patches/function-template-thread-safety.patch
boost/trunk/debian/patches/gcc-4.3.patch
boost/trunk/debian/patches/regex-vulnerability.patch
boost/trunk/debian/patches/series
boost/trunk/debian/patches/suppress-compiler-warnings.patch
Modified:
boost/trunk/boost/date_time/time.hpp
boost/trunk/boost/date_time/time_facet.hpp
boost/trunk/boost/function/function_base.hpp
boost/trunk/boost/function/function_template.hpp
boost/trunk/boost/graph/topological_sort.hpp
boost/trunk/boost/numeric/ublas/matrix.hpp
boost/trunk/boost/numeric/ublas/matrix_sparse.hpp
boost/trunk/boost/python/detail/def_helper.hpp
boost/trunk/boost/regex/v4/basic_regex_parser.hpp
boost/trunk/boost/regex/v4/cpp_regex_traits.hpp
boost/trunk/boost/test/test_tools.hpp
boost/trunk/debian/changelog
boost/trunk/debian/control
boost/trunk/debian/rules
boost/trunk/libs/regex/test/regress/test_perl_ex.cpp
boost/trunk/tools/jam/src/build.jam
Log:
Move all source patches into quilt patch series.
Modified: boost/trunk/boost/date_time/time.hpp
===================================================================
--- boost/trunk/boost/date_time/time.hpp 2008-03-23 03:41:10 UTC (rev 14174)
+++ boost/trunk/boost/date_time/time.hpp 2008-03-23 05:25:24 UTC (rev 14175)
@@ -77,14 +77,14 @@
/*! Optional bool parameter will return time zone as an offset
* (ie "+07:00"). Empty string is returned for classes that do
* not use a time_zone */
- std::string zone_name(bool = false) const
+ std::string zone_name(bool as_offset=false) const
{
return time_system::zone_name(time_);
}
/*! Optional bool parameter will return time zone as an offset
* (ie "+07:00"). Empty string is returned for classes that do
* not use a time_zone */
- std::string zone_abbrev(bool = false) const
+ std::string zone_abbrev(bool as_offset=false) const
{
return time_system::zone_name(time_);
}
Modified: boost/trunk/boost/date_time/time_facet.hpp
===================================================================
--- boost/trunk/boost/date_time/time_facet.hpp 2008-03-23 03:41:10 UTC (rev 14174)
+++ boost/trunk/boost/date_time/time_facet.hpp 2008-03-23 05:25:24 UTC (rev 14175)
@@ -197,7 +197,7 @@
#endif
//! sets default formats for ptime, local_date_time, and time_duration
- explicit time_facet(::size_t = 0)
+ explicit time_facet(::size_t a_ref = 0)
//: base_type(standard_format),
: base_type(default_time_format),
m_time_duration_format(string_type(duration_sign_negative_only) + default_time_duration_format)
Modified: boost/trunk/boost/function/function_base.hpp
===================================================================
--- boost/trunk/boost/function/function_base.hpp 2008-03-23 03:41:10 UTC (rev 14174)
+++ boost/trunk/boost/function/function_base.hpp 2008-03-23 05:25:24 UTC (rev 14175)
@@ -30,20 +30,6 @@
#endif
#include <boost/function_equal.hpp>
-#if defined(BOOST_MSVC)
-# pragma warning( push )
-# pragma warning( disable : 4793 ) // complaint about native code generation
-# pragma warning( disable : 4127 ) // "conditional expression is constant"
-#endif
-
-// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
-#ifdef BOOST_NO_EXCEPTION_STD_NAMESPACE
-// Embedded VC++ does not have type_info in namespace std
-# define BOOST_FUNCTION_STD_NS
-#else
-# define BOOST_FUNCTION_STD_NS std
-#endif
-
// Borrowed from Boost.Python library: determines the cases where we
// need to use std::type_info::name to compare instead of operator==.
# if (defined(__GNUC__) && __GNUC__ >= 3) \
@@ -73,7 +59,7 @@
#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
|| defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) \
- || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
+ || !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
# define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
#endif
@@ -212,8 +198,8 @@
struct reference_manager
{
static inline void
- manage(const function_buffer& in_buffer, function_buffer& out_buffer,
- functor_manager_operation_type op)
+ get(const function_buffer& in_buffer, function_buffer& out_buffer,
+ functor_manager_operation_type op)
{
switch (op) {
case clone_functor_tag:
@@ -229,8 +215,8 @@
// DPG TBD: Since we're only storing a pointer, it's
// possible that the user could ask for a base class or
// derived class. Is that okay?
- const BOOST_FUNCTION_STD_NS::type_info& check_type =
- *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
+ const std::type_info& check_type =
+ *static_cast<const std::type_info*>(out_buffer.const_obj_ptr);
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F)))
out_buffer.obj_ptr = in_buffer.obj_ptr;
else
@@ -279,8 +265,8 @@
else if (op == destroy_functor_tag)
out_buffer.func_ptr = 0;
else /* op == check_functor_type_tag */ {
- const BOOST_FUNCTION_STD_NS::type_info& check_type =
- *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
+ const std::type_info& check_type =
+ *static_cast<const std::type_info*>(out_buffer.const_obj_ptr);
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
out_buffer.obj_ptr = &in_buffer.func_ptr;
else
@@ -301,8 +287,8 @@
// Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
} else /* op == check_functor_type_tag */ {
- const BOOST_FUNCTION_STD_NS::type_info& check_type =
- *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
+ const std::type_info& check_type =
+ *static_cast<const std::type_info*>(out_buffer.const_obj_ptr);
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
out_buffer.obj_ptr = &in_buffer.data;
else
@@ -362,8 +348,8 @@
# endif // BOOST_NO_STD_ALLOCATOR
out_buffer.obj_ptr = 0;
} else /* op == check_functor_type_tag */ {
- const BOOST_FUNCTION_STD_NS::type_info& check_type =
- *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
+ const std::type_info& check_type =
+ *static_cast<const std::type_info*>(out_buffer.const_obj_ptr);
if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
out_buffer.obj_ptr = in_buffer.obj_ptr;
else
@@ -382,15 +368,6 @@
mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
}
- // For member pointers, we treat them as function objects with
- // the small-object optimization always enabled.
- static inline void
- manager(const function_buffer& in_buffer, function_buffer& out_buffer,
- functor_manager_operation_type op, member_ptr_tag)
- {
- manager(in_buffer, out_buffer, op, mpl::true_());
- }
-
public:
/* Dispatch to an appropriate manager based on whether we have a
function pointer or a function object pointer. */
@@ -479,6 +456,7 @@
*/
struct vtable_base
{
+ vtable_base() : manager(0) { }
void (*manager)(const function_buffer& in_buffer,
function_buffer& out_buffer,
functor_manager_operation_type op);
@@ -502,13 +480,13 @@
/** Retrieve the type of the stored function object, or typeid(void)
if this is empty. */
- const BOOST_FUNCTION_STD_NS::type_info& target_type() const
+ const std::type_info& target_type() const
{
if (!vtable) return typeid(void);
detail::function::function_buffer type;
vtable->manager(functor, type, detail::function::get_functor_type_tag);
- return *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(type.const_obj_ptr);
+ return *static_cast<const std::type_info*>(type.const_obj_ptr);
}
template<typename Functor>
@@ -580,7 +558,7 @@
#endif
public: // should be protected, but GCC 2.95.3 will fail to allow access
- const detail::function::vtable_base* vtable;
+ detail::function::vtable_base* vtable;
mutable detail::function::function_buffer functor;
};
@@ -755,8 +733,4 @@
#undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
#undef BOOST_FUNCTION_COMPARE_TYPE_ID
-#if defined(BOOST_MSVC)
-# pragma warning( pop )
-#endif
-
#endif // BOOST_FUNCTION_BASE_HEADER
Modified: boost/trunk/boost/function/function_template.hpp
===================================================================
--- boost/trunk/boost/function/function_template.hpp 2008-03-23 03:41:10 UTC (rev 14174)
+++ boost/trunk/boost/function/function_template.hpp 2008-03-23 05:25:24 UTC (rev 14175)
@@ -11,11 +11,6 @@
// protection.
#include <boost/function/detail/prologue.hpp>
-#if defined(BOOST_MSVC)
-# pragma warning( push )
-# pragma warning( disable : 4127 ) // "conditional expression is constant"
-#endif
-
#define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
#define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
@@ -59,20 +54,12 @@
BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \
BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_MEMBER_INVOKER \
- BOOST_JOIN(member_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_VOID_MEMBER_INVOKER \
- BOOST_JOIN(void_member_invoker,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_GET_FUNCTION_INVOKER \
BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \
BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_GET_MEMBER_INVOKER \
- BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
-#define BOOST_FUNCTION_GET_INVOKER \
- BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
#define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
#ifndef BOOST_NO_VOID_RETURNS
@@ -83,6 +70,16 @@
# define BOOST_FUNCTION_RETURN(X) X; return BOOST_FUNCTION_VOID_RETURN_TYPE ()
#endif
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable: 4127) // conditional expression is constant.
+#endif
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable: 4127) // conditional expression is constant.
+#endif
+
namespace boost {
namespace detail {
namespace function {
@@ -194,45 +191,7 @@
}
};
-#if BOOST_FUNCTION_NUM_ARGS > 0
- /* Handle invocation of member pointers. */
template<
- typename MemberPtr,
- typename R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_PARMS
- >
- struct BOOST_FUNCTION_MEMBER_INVOKER
- {
- static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_PARMS)
-
- {
- MemberPtr* f =
- reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
- return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
- }
- };
-
- template<
- typename MemberPtr,
- typename R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_PARMS
- >
- struct BOOST_FUNCTION_VOID_MEMBER_INVOKER
- {
- static BOOST_FUNCTION_VOID_RETURN_TYPE
- invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_PARMS)
-
- {
- MemberPtr* f =
- reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
- BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS));
- }
- };
-#endif
-
- template<
typename FunctionPtr,
typename R BOOST_FUNCTION_COMMA
BOOST_FUNCTION_TEMPLATE_PARMS
@@ -295,130 +254,12 @@
>::type type;
};
-#if BOOST_FUNCTION_NUM_ARGS > 0
- /* Retrieve the appropriate invoker for a member pointer. */
- template<
- typename MemberPtr,
- typename R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_PARMS
- >
- struct BOOST_FUNCTION_GET_MEMBER_INVOKER
- {
- typedef typename mpl::if_c<(is_void<R>::value),
- BOOST_FUNCTION_VOID_MEMBER_INVOKER<
- MemberPtr,
- R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_ARGS
- >,
- BOOST_FUNCTION_MEMBER_INVOKER<
- MemberPtr,
- R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_ARGS
- >
- >::type type;
- };
-#endif
-
- /* Given the tag returned by get_function_tag, retrieve the
- actual invoker that will be used for the given function
- object.
-
- Each specialization contains an "apply" nested class template
- that accepts the function object, return type, function
- argument types, and allocator. The resulting "apply" class
- contains two typedefs, "invoker_type" and "manager_type",
- which correspond to the invoker and manager types. */
- template<typename Tag>
- struct BOOST_FUNCTION_GET_INVOKER { };
-
- /* Retrieve the invoker for a function pointer. */
- template<>
- struct BOOST_FUNCTION_GET_INVOKER<function_ptr_tag>
- {
- template<typename FunctionPtr,
- typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
- typename Allocator>
- struct apply
- {
- typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
- FunctionPtr,
- R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_ARGS
- >::type
- invoker_type;
-
- typedef functor_manager<FunctionPtr, Allocator> manager_type;
- };
- };
-
-#if BOOST_FUNCTION_NUM_ARGS > 0
- /* Retrieve the invoker for a member pointer. */
- template<>
- struct BOOST_FUNCTION_GET_INVOKER<member_ptr_tag>
- {
- template<typename MemberPtr,
- typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
- typename Allocator>
- struct apply
- {
- typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
- MemberPtr,
- R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_ARGS
- >::type
- invoker_type;
-
- typedef functor_manager<MemberPtr, Allocator> manager_type;
- };
- };
-#endif
-
- /* Retrieve the invoker for a function object. */
- template<>
- struct BOOST_FUNCTION_GET_INVOKER<function_obj_tag>
- {
- template<typename FunctionObj,
- typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
- typename Allocator>
- struct apply
- {
- typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
- FunctionObj,
- R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_ARGS
- >::type
- invoker_type;
-
- typedef functor_manager<FunctionObj, Allocator> manager_type;
- };
- };
-
- /* Retrieve the invoker for a reference to a function object. */
- template<>
- struct BOOST_FUNCTION_GET_INVOKER<function_obj_ref_tag>
- {
- template<typename RefWrapper,
- typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
- typename Allocator>
- struct apply
- {
- typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
- typename RefWrapper::type,
- R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_ARGS
- >::type
- invoker_type;
-
- typedef reference_manager<typename RefWrapper::type> manager_type;
- };
- };
-
/**
* vtable for a specific boost::function instance.
*/
template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
typename Allocator>
- struct BOOST_FUNCTION_VTABLE
+ struct BOOST_FUNCTION_VTABLE : vtable_base
{
#ifndef BOOST_NO_VOID_RETURNS
typedef R result_type;
@@ -431,25 +272,50 @@
BOOST_FUNCTION_TEMPLATE_ARGS);
template<typename F>
- bool assign_to(const F& f, function_buffer& functor) const
+ BOOST_FUNCTION_VTABLE(F f) : vtable_base(), invoker(0)
{
+ init(f);
+ }
+
+ template<typename F>
+ bool assign_to(F f, function_buffer& functor)
+ {
typedef typename get_function_tag<F>::type tag;
return assign_to(f, functor, tag());
}
- void clear(function_buffer& functor) const
+ void clear(function_buffer& functor)
{
- if (base.manager)
- base.manager(functor, functor, destroy_functor_tag);
+ if (manager)
+ manager(functor, functor, destroy_functor_tag);
}
-#ifndef BOOST_NO_PRIVATE_IN_AGGREGATE
+
private:
-#endif
+ template<typename F>
+ void init(F f)
+ {
+ typedef typename get_function_tag<F>::type tag;
+ init(f, tag());
+ }
+
// Function pointers
template<typename FunctionPtr>
+ void init(FunctionPtr /*f*/, function_ptr_tag)
+ {
+ typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
+ FunctionPtr,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >::type
+ actual_invoker_type;
+
+ invoker = &actual_invoker_type::invoke;
+ manager = &functor_manager<FunctionPtr, Allocator>::manage;
+ }
+
+ template<typename FunctionPtr>
bool
- assign_to(FunctionPtr f, function_buffer& functor,
- function_ptr_tag) const
+ assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
{
this->clear(functor);
if (f) {
@@ -465,13 +331,22 @@
// Member pointers
#if BOOST_FUNCTION_NUM_ARGS > 0
template<typename MemberPtr>
- bool
- assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+ void init(MemberPtr f, member_ptr_tag)
{
+ // DPG TBD: Add explicit support for member function
+ // objects, so we invoke through mem_fn() but we retain the
+ // right target_type() values.
+ this->init(mem_fn(f));
+ }
+
+ template<typename MemberPtr>
+ bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
+ {
+ // DPG TBD: Add explicit support for member function
+ // objects, so we invoke through mem_fn() but we retain the
+ // right target_type() values.
if (f) {
- // Always use the small-object optimization for member
- // pointers.
- assign_functor(f, functor, mpl::true_());
+ this->assign_to(mem_fn(f), functor);
return true;
} else {
return false;
@@ -480,11 +355,24 @@
#endif // BOOST_FUNCTION_NUM_ARGS > 0
// Function objects
+ template<typename FunctionObj>
+ void init(FunctionObj /*f*/, function_obj_tag)
+ {
+ typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
+ FunctionObj,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >::type
+ actual_invoker_type;
+
+ invoker = &actual_invoker_type::invoke;
+ manager = &functor_manager<FunctionObj, Allocator>::manage;
+ }
+
// Assign to a function object using the small object optimization
template<typename FunctionObj>
void
- assign_functor(const FunctionObj& f, function_buffer& functor,
- mpl::true_) const
+ assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
{
new ((void*)&functor.data) FunctionObj(f);
}
@@ -492,8 +380,7 @@
// Assign to a function object allocated on the heap.
template<typename FunctionObj>
void
- assign_functor(const FunctionObj& f, function_buffer& functor,
- mpl::false_) const
+ assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
{
#ifndef BOOST_NO_STD_ALLOCATOR
typedef typename Allocator::template rebind<FunctionObj>::other
@@ -513,8 +400,7 @@
template<typename FunctionObj>
bool
- assign_to(const FunctionObj& f, function_buffer& functor,
- function_obj_tag) const
+ assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
{
if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
assign_functor(f, functor,
@@ -527,9 +413,24 @@
// Reference to a function object
template<typename FunctionObj>
+ void
+ init(const reference_wrapper<FunctionObj>& /*f*/, function_obj_ref_tag)
+ {
+ typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
+ FunctionObj,
+ R BOOST_FUNCTION_COMMA
+ BOOST_FUNCTION_TEMPLATE_ARGS
+ >::type
+ actual_invoker_type;
+
+ invoker = &actual_invoker_type::invoke;
+ manager = &reference_manager<FunctionObj>::get;
+ }
+
+ template<typename FunctionObj>
bool
assign_to(const reference_wrapper<FunctionObj>& f,
- function_buffer& functor, function_obj_ref_tag) const
+ function_buffer& functor, function_obj_ref_tag)
{
if (!boost::detail::function::has_empty_target(f.get_pointer())) {
// DPG TBD: We might need to detect constness of
@@ -544,7 +445,6 @@
}
public:
- vtable_base base;
invoker_type invoker;
};
} // end namespace function
@@ -556,17 +456,6 @@
typename Allocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR
>
class BOOST_FUNCTION_FUNCTION : public function_base
-
-#if BOOST_FUNCTION_NUM_ARGS == 1
-
- , public std::unary_function<T0,R>
-
-#elif BOOST_FUNCTION_NUM_ARGS == 2
-
- , public std::binary_function<T0,T1,R>
-
-#endif
-
{
public:
#ifndef BOOST_NO_VOID_RETURNS
@@ -648,7 +537,7 @@
if (this->empty())
boost::throw_exception(bad_function_call());
- return reinterpret_cast<const vtable_type*>(vtable)->invoker
+ return static_cast<vtable_type*>(vtable)->invoker
(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
}
#else
@@ -672,16 +561,12 @@
operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
{
this->clear();
-#ifndef BOOST_NO_EXCEPTIONS
try {
this->assign_to(f);
} catch (...) {
vtable = 0;
throw;
}
-#else
- this->assign_to(f);
-#endif
return *this;
}
@@ -707,16 +592,12 @@
return *this;
this->clear();
-#ifndef BOOST_NO_EXCEPTIONS
try {
this->assign_to_own(f);
} catch (...) {
vtable = 0;
throw;
}
-#else
- this->assign_to_own(f);
-#endif
return *this;
}
@@ -734,7 +615,7 @@
void clear()
{
if (vtable) {
- reinterpret_cast<const vtable_type*>(vtable)->clear(this->functor);
+ static_cast<vtable_type*>(vtable)->clear(this->functor);
vtable = 0;
}
}
@@ -769,24 +650,10 @@
}
template<typename Functor>
- void assign_to(const Functor& f)
+ void assign_to(Functor f)
{
- using detail::function::vtable_base;
-
- typedef typename detail::function::get_function_tag<Functor>::type tag;
- typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
- typedef typename get_invoker::
- template apply<Functor, R BOOST_FUNCTION_COMMA
- BOOST_FUNCTION_TEMPLATE_ARGS, Allocator>
- handler_type;
-
- typedef typename handler_type::invoker_type invoker_type;
- typedef typename handler_type::manager_type manager_type;
-
- static const vtable_type stored_vtable =
- { { &manager_type::manage }, &invoker_type::invoke };
-
- if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable.base;
+ static vtable_type stored_vtable(f);
+ if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable;
else vtable = 0;
}
};
@@ -821,7 +688,7 @@
if (this->empty())
boost::throw_exception(bad_function_call());
- return reinterpret_cast<const vtable_type*>(vtable)->invoker
+ return static_cast<vtable_type*>(vtable)->invoker
(this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
}
#endif
@@ -931,14 +798,21 @@
}
};
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
#undef BOOST_FUNCTION_PARTIAL_SPEC
#endif // have partial specialization
} // end namespace boost
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
// Cleanup after ourselves...
#undef BOOST_FUNCTION_VTABLE
-#undef BOOST_FUNCTION_GET_INVOKER
#undef BOOST_FUNCTION_DEFAULT_ALLOCATOR
#undef BOOST_FUNCTION_COMMA
#undef BOOST_FUNCTION_FUNCTION
@@ -948,12 +822,10 @@
#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
#undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
-#undef BOOST_FUNCTION_MEMBER_INVOKER
-#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
#undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
-#undef BOOST_FUNCTION_GET_MEMBER_INVOKER
+#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
#undef BOOST_FUNCTION_TEMPLATE_PARMS
#undef BOOST_FUNCTION_TEMPLATE_ARGS
#undef BOOST_FUNCTION_PARMS
@@ -963,7 +835,3 @@
#undef BOOST_FUNCTION_ARG_TYPES
#undef BOOST_FUNCTION_VOID_RETURN_TYPE
#undef BOOST_FUNCTION_RETURN
-
-#if defined(BOOST_MSVC)
-# pragma warning( pop )
-#endif
Modified: boost/trunk/boost/graph/topological_sort.hpp
===================================================================
--- boost/trunk/boost/graph/topological_sort.hpp 2008-03-23 03:41:10 UTC (rev 14174)
+++ boost/trunk/boost/graph/topological_sort.hpp 2008-03-23 05:25:24 UTC (rev 14175)
@@ -37,7 +37,7 @@
: m_iter(_iter) { }
template <typename Edge, typename Graph>
- void back_edge(const Edge&, Graph&) { throw not_a_dag(); }
+ void back_edge(const Edge& u, Graph&) { throw not_a_dag(); }
template <typename Vertex, typename Graph>
void finish_vertex(const Vertex& u, Graph&) { *m_iter++ = u; }
Modified: boost/trunk/boost/numeric/ublas/matrix.hpp
===================================================================
--- boost/trunk/boost/numeric/ublas/matrix.hpp 2008-03-23 03:41:10 UTC (rev 14174)
+++ boost/trunk/boost/numeric/ublas/matrix.hpp 2008-03-23 05:25:24 UTC (rev 14175)
@@ -2271,7 +2271,6 @@
BOOST_UBLAS_INLINE
const_iterator2 &operator = (const const_iterator2 &it) {
container_const_reference<self_type>::assign (&it ());
- detail::ignore_unused_variable_warning(it);
return *this;
}
Modified: boost/trunk/boost/numeric/ublas/matrix_sparse.hpp
===================================================================
--- boost/trunk/boost/numeric/ublas/matrix_sparse.hpp 2008-03-23 03:41:10 UTC (rev 14174)
+++ boost/trunk/boost/numeric/ublas/matrix_sparse.hpp 2008-03-23 05:25:24 UTC (rev 14175)
@@ -2681,7 +2681,6 @@
void resize (size_type size1, size_type size2, bool preserve = true) {
// FIXME preserve unimplemented
BOOST_UBLAS_CHECK (!preserve, internal_logic ());
- detail::ignore_unused_variable_warning(preserve);
size1_ = size1;
size2_ = size2;
capacity_ = restrict_capacity (capacity_);
Modified: boost/trunk/boost/python/detail/def_helper.hpp
===================================================================
--- boost/trunk/boost/python/detail/def_helper.hpp 2008-03-23 03:41:10 UTC (rev 14174)
+++ boost/trunk/boost/python/detail/def_helper.hpp 2008-03-23 05:25:24 UTC (rev 14175)
@@ -155,7 +155,7 @@
, T3 const&
, T4 const&
, default_call_policies
- , detail::keywords<0>
+ , keywords<0>
, char const*
, void(not_specified::*)() // A function pointer type which is never an
// appropriate default implementation
Modified: boost/trunk/boost/regex/v4/basic_regex_parser.hpp
===================================================================
--- boost/trunk/boost/regex/v4/basic_regex_parser.hpp 2008-03-23 03:41:10 UTC (rev 14174)
+++ boost/trunk/boost/regex/v4/basic_regex_parser.hpp 2008-03-23 05:25:24 UTC (rev 14175)
@@ -777,7 +777,6 @@
case syntax_element_restart_continue:
case syntax_element_jump:
case syntax_element_startmark:
- case syntax_element_backstep:
// can't legally repeat any of the above:
fail(regex_constants::error_badrepeat, m_position - m_base);
return false;
@@ -1863,7 +1862,6 @@
if(markid == -4)
{
re_syntax_base* b = this->getaddress(expected_alt_point);
- // Make sure we have exactly one alternative following this state:
if(b->type != syntax_element_alt)
{
re_alt* alt = static_cast<re_alt*>(this->insert_state(expected_alt_point, syntax_element_alt, sizeof(re_alt)));
@@ -1874,15 +1872,6 @@
fail(regex_constants::error_bad_pattern, m_position - m_base);
return false;
}
- // check for invalid repetition of next state:
- b = this->getaddress(expected_alt_point);
- b = this->getaddress(static_cast<re_alt*>(b)->next.i, b);
- if((b->type != syntax_element_assert_backref)
- && (b->type != syntax_element_startmark))
- {
- fail(regex_constants::error_badrepeat, m_position - m_base);
- return false;
- }
}
//
// append closing parenthesis state:
Modified: boost/trunk/boost/regex/v4/cpp_regex_traits.hpp
===================================================================
--- boost/trunk/boost/regex/v4/cpp_regex_traits.hpp 2008-03-23 03:41:10 UTC (rev 14174)
+++ boost/trunk/boost/regex/v4/cpp_regex_traits.hpp 2008-03-23 05:25:24 UTC (rev 14175)
@@ -41,7 +41,6 @@
#include <istream>
#include <ios>
-#include <climits>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
Modified: boost/trunk/boost/test/test_tools.hpp
===================================================================
--- boost/trunk/boost/test/test_tools.hpp 2008-03-23 03:41:10 UTC (rev 14174)
+++ boost/trunk/boost/test/test_tools.hpp 2008-03-23 05:25:24 UTC (rev 14175)
@@ -44,7 +44,6 @@
// STL
#include <cstddef> // for std::size_t
#include <iosfwd>
-#include <climits> // for CHAR_BIT
#include <boost/test/detail/suppress_warnings.hpp>
Modified: boost/trunk/debian/changelog
===================================================================
--- boost/trunk/debian/changelog 2008-03-23 03:41:10 UTC (rev 14174)
+++ boost/trunk/debian/changelog 2008-03-23 05:25:24 UTC (rev 14175)
@@ -1,3 +1,22 @@
+boost (1.34.1-9) UNRELEASED; urgency=low
+
+ * debian/control:
+ * debian/rules: Set up to use Quilt for maintaining patches.
+
+ * boost/numeric/ublas/matrix.hpp:
+ * boost/numeric/ublas/matrix_sparse.hpp: Revert. These originated in
+ the merge of 1.33.1 (change 13900) and appear to be erroneous.
+
+ * Reverted all other diffs outside of debian/ and created the following
+ set of quilt patches:
+ - debian/patches/regex-vulnerability.patch
+ - debian/patches/suppress-compiler-warnings.patch
+ - debian/patches/function-template-thread-safety.patch
+ - debian/patches/bjam-no-strict-aliasing.patch
+ - debian/patches/gcc-4.3.patch
+
+ -- Steve M. Robbins <steve at sumost.ca> Sat, 22 Mar 2008 22:41:18 -0500
+
boost (1.34.1-8) unstable; urgency=low
* debian/rules: Replace all use of $(PWD) and `pwd` by $(CURDIR); clears
Modified: boost/trunk/debian/control
===================================================================
--- boost/trunk/debian/control 2008-03-23 03:41:10 UTC (rev 14174)
+++ boost/trunk/debian/control 2008-03-23 05:25:24 UTC (rev 14175)
@@ -4,7 +4,7 @@
Priority: optional
Maintainer: Debian Boost Team <pkg-boost-devel at lists.alioth.debian.org>
Uploaders: Steve M. Robbins <smr at debian.org>, Domenico Andreoli <cavok at debian.org>, Christophe Prud'homme <prudhomm at debian.org>
-Build-Depends: debhelper (>= 4), bison, flex, docbook-to-man, xsltproc, doxygen, zlib1g-dev, libbz2-dev, libicu-dev, python-all-dev, python-support (>= 0.6), g++-4.2
+Build-Depends: debhelper (>= 4), quilt, bison, flex, docbook-to-man, xsltproc, doxygen, zlib1g-dev, libbz2-dev, libicu-dev, python-all-dev, python-support (>= 0.6), g++-4.2
XS-Python-Version: 2.4, 2.5
Standards-Version: 3.7.2
Added: boost/trunk/debian/patches/bjam-no-strict-aliasing.patch
===================================================================
--- boost/trunk/debian/patches/bjam-no-strict-aliasing.patch (rev 0)
+++ boost/trunk/debian/patches/bjam-no-strict-aliasing.patch 2008-03-23 05:25:24 UTC (rev 14175)
@@ -0,0 +1,11 @@
+--- trunk.orig/tools/jam/src/build.jam
++++ trunk/tools/jam/src/build.jam
+@@ -152,7 +152,7 @@
+ : -L$(--python-lib[1]) -l$(--python-lib[2]) ;
+ ## GCC 2.x, 3.x, 4.x
+ toolset gcc gcc : "-o " : -D
+- : -pedantic
++ : -pedantic -fno-strict-aliasing
+ [ opt --release : [ opt --symbols : -g : -s ] -O3 ]
+ [ opt --debug : -g -O0 -fno-inline ]
+ -I$(--python-include) -Wno-long-long
Added: boost/trunk/debian/patches/function-template-thread-safety.patch
===================================================================
--- boost/trunk/debian/patches/function-template-thread-safety.patch (rev 0)
+++ boost/trunk/debian/patches/function-template-thread-safety.patch 2008-03-23 05:25:24 UTC (rev 14175)
@@ -0,0 +1,694 @@
+--- trunk.orig/boost/function/function_base.hpp
++++ trunk/boost/function/function_base.hpp
+@@ -30,6 +30,20 @@
+ #endif
+ #include <boost/function_equal.hpp>
+
++#if defined(BOOST_MSVC)
++# pragma warning( push )
++# pragma warning( disable : 4793 ) // complaint about native code generation
++# pragma warning( disable : 4127 ) // "conditional expression is constant"
++#endif
++
++// Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
++#ifdef BOOST_NO_EXCEPTION_STD_NAMESPACE
++// Embedded VC++ does not have type_info in namespace std
++# define BOOST_FUNCTION_STD_NS
++#else
++# define BOOST_FUNCTION_STD_NS std
++#endif
++
+ // Borrowed from Boost.Python library: determines the cases where we
+ // need to use std::type_info::name to compare instead of operator==.
+ # if (defined(__GNUC__) && __GNUC__ >= 3) \
+@@ -59,7 +73,7 @@
+
+ #if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+ || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) \
+- || !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
++ || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
+ # define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
+ #endif
+
+@@ -198,8 +212,8 @@
+ struct reference_manager
+ {
+ static inline void
+- get(const function_buffer& in_buffer, function_buffer& out_buffer,
+- functor_manager_operation_type op)
++ manage(const function_buffer& in_buffer, function_buffer& out_buffer,
++ functor_manager_operation_type op)
+ {
+ switch (op) {
+ case clone_functor_tag:
+@@ -215,8 +229,8 @@
+ // DPG TBD: Since we're only storing a pointer, it's
+ // possible that the user could ask for a base class or
+ // derived class. Is that okay?
+- const std::type_info& check_type =
+- *static_cast<const std::type_info*>(out_buffer.const_obj_ptr);
++ const BOOST_FUNCTION_STD_NS::type_info& check_type =
++ *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
+ if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F)))
+ out_buffer.obj_ptr = in_buffer.obj_ptr;
+ else
+@@ -265,8 +279,8 @@
+ else if (op == destroy_functor_tag)
+ out_buffer.func_ptr = 0;
+ else /* op == check_functor_type_tag */ {
+- const std::type_info& check_type =
+- *static_cast<const std::type_info*>(out_buffer.const_obj_ptr);
++ const BOOST_FUNCTION_STD_NS::type_info& check_type =
++ *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
+ if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+ out_buffer.obj_ptr = &in_buffer.func_ptr;
+ else
+@@ -287,8 +301,8 @@
+ // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
+ reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
+ } else /* op == check_functor_type_tag */ {
+- const std::type_info& check_type =
+- *static_cast<const std::type_info*>(out_buffer.const_obj_ptr);
++ const BOOST_FUNCTION_STD_NS::type_info& check_type =
++ *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
+ if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+ out_buffer.obj_ptr = &in_buffer.data;
+ else
+@@ -348,8 +362,8 @@
+ # endif // BOOST_NO_STD_ALLOCATOR
+ out_buffer.obj_ptr = 0;
+ } else /* op == check_functor_type_tag */ {
+- const std::type_info& check_type =
+- *static_cast<const std::type_info*>(out_buffer.const_obj_ptr);
++ const BOOST_FUNCTION_STD_NS::type_info& check_type =
++ *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
+ if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+ out_buffer.obj_ptr = in_buffer.obj_ptr;
+ else
+@@ -368,6 +382,15 @@
+ mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
+ }
+
++ // For member pointers, we treat them as function objects with
++ // the small-object optimization always enabled.
++ static inline void
++ manager(const function_buffer& in_buffer, function_buffer& out_buffer,
++ functor_manager_operation_type op, member_ptr_tag)
++ {
++ manager(in_buffer, out_buffer, op, mpl::true_());
++ }
++
+ public:
+ /* Dispatch to an appropriate manager based on whether we have a
+ function pointer or a function object pointer. */
+@@ -456,7 +479,6 @@
+ */
+ struct vtable_base
+ {
+- vtable_base() : manager(0) { }
+ void (*manager)(const function_buffer& in_buffer,
+ function_buffer& out_buffer,
+ functor_manager_operation_type op);
+@@ -480,13 +502,13 @@
+
+ /** Retrieve the type of the stored function object, or typeid(void)
+ if this is empty. */
+- const std::type_info& target_type() const
++ const BOOST_FUNCTION_STD_NS::type_info& target_type() const
+ {
+ if (!vtable) return typeid(void);
+
+ detail::function::function_buffer type;
+ vtable->manager(functor, type, detail::function::get_functor_type_tag);
+- return *static_cast<const std::type_info*>(type.const_obj_ptr);
++ return *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(type.const_obj_ptr);
+ }
+
+ template<typename Functor>
+@@ -558,7 +580,7 @@
+ #endif
+
+ public: // should be protected, but GCC 2.95.3 will fail to allow access
+- detail::function::vtable_base* vtable;
++ const detail::function::vtable_base* vtable;
+ mutable detail::function::function_buffer functor;
+ };
+
+@@ -733,4 +755,8 @@
+ #undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
+ #undef BOOST_FUNCTION_COMPARE_TYPE_ID
+
++#if defined(BOOST_MSVC)
++# pragma warning( pop )
++#endif
++
+ #endif // BOOST_FUNCTION_BASE_HEADER
+--- trunk.orig/boost/function/function_template.hpp
++++ trunk/boost/function/function_template.hpp
+@@ -11,6 +11,11 @@
+ // protection.
+ #include <boost/function/detail/prologue.hpp>
+
++#if defined(BOOST_MSVC)
++# pragma warning( push )
++# pragma warning( disable : 4127 ) // "conditional expression is constant"
++#endif
++
+ #define BOOST_FUNCTION_TEMPLATE_PARMS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, typename T)
+
+ #define BOOST_FUNCTION_TEMPLATE_ARGS BOOST_PP_ENUM_PARAMS(BOOST_FUNCTION_NUM_ARGS, T)
+@@ -54,12 +59,20 @@
+ BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+ #define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \
+ BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
++#define BOOST_FUNCTION_MEMBER_INVOKER \
++ BOOST_JOIN(member_invoker,BOOST_FUNCTION_NUM_ARGS)
++#define BOOST_FUNCTION_VOID_MEMBER_INVOKER \
++ BOOST_JOIN(void_member_invoker,BOOST_FUNCTION_NUM_ARGS)
+ #define BOOST_FUNCTION_GET_FUNCTION_INVOKER \
+ BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+ #define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
+ BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+ #define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \
+ BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
++#define BOOST_FUNCTION_GET_MEMBER_INVOKER \
++ BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
++#define BOOST_FUNCTION_GET_INVOKER \
++ BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
+ #define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)
+
+ #ifndef BOOST_NO_VOID_RETURNS
+@@ -70,16 +83,6 @@
+ # define BOOST_FUNCTION_RETURN(X) X; return BOOST_FUNCTION_VOID_RETURN_TYPE ()
+ #endif
+
+-#ifdef BOOST_MSVC
+-# pragma warning(push)
+-# pragma warning(disable: 4127) // conditional expression is constant.
+-#endif
+-
+-#ifdef BOOST_MSVC
+-# pragma warning(push)
+-# pragma warning(disable: 4127) // conditional expression is constant.
+-#endif
+-
+ namespace boost {
+ namespace detail {
+ namespace function {
+@@ -191,6 +194,44 @@
+ }
+ };
+
++#if BOOST_FUNCTION_NUM_ARGS > 0
++ /* Handle invocation of member pointers. */
++ template<
++ typename MemberPtr,
++ typename R BOOST_FUNCTION_COMMA
++ BOOST_FUNCTION_TEMPLATE_PARMS
++ >
++ struct BOOST_FUNCTION_MEMBER_INVOKER
++ {
++ static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
++ BOOST_FUNCTION_PARMS)
++
++ {
++ MemberPtr* f =
++ reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
++ return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
++ }
++ };
++
++ template<
++ typename MemberPtr,
++ typename R BOOST_FUNCTION_COMMA
++ BOOST_FUNCTION_TEMPLATE_PARMS
++ >
++ struct BOOST_FUNCTION_VOID_MEMBER_INVOKER
++ {
++ static BOOST_FUNCTION_VOID_RETURN_TYPE
++ invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
++ BOOST_FUNCTION_PARMS)
++
++ {
++ MemberPtr* f =
++ reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
++ BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS));
++ }
++ };
++#endif
++
+ template<
+ typename FunctionPtr,
+ typename R BOOST_FUNCTION_COMMA
+@@ -254,12 +295,130 @@
+ >::type type;
+ };
+
++#if BOOST_FUNCTION_NUM_ARGS > 0
++ /* Retrieve the appropriate invoker for a member pointer. */
++ template<
++ typename MemberPtr,
++ typename R BOOST_FUNCTION_COMMA
++ BOOST_FUNCTION_TEMPLATE_PARMS
++ >
++ struct BOOST_FUNCTION_GET_MEMBER_INVOKER
++ {
++ typedef typename mpl::if_c<(is_void<R>::value),
++ BOOST_FUNCTION_VOID_MEMBER_INVOKER<
++ MemberPtr,
++ R BOOST_FUNCTION_COMMA
++ BOOST_FUNCTION_TEMPLATE_ARGS
++ >,
++ BOOST_FUNCTION_MEMBER_INVOKER<
++ MemberPtr,
++ R BOOST_FUNCTION_COMMA
++ BOOST_FUNCTION_TEMPLATE_ARGS
++ >
++ >::type type;
++ };
++#endif
++
++ /* Given the tag returned by get_function_tag, retrieve the
++ actual invoker that will be used for the given function
++ object.
++
++ Each specialization contains an "apply" nested class template
++ that accepts the function object, return type, function
++ argument types, and allocator. The resulting "apply" class
++ contains two typedefs, "invoker_type" and "manager_type",
++ which correspond to the invoker and manager types. */
++ template<typename Tag>
++ struct BOOST_FUNCTION_GET_INVOKER { };
++
++ /* Retrieve the invoker for a function pointer. */
++ template<>
++ struct BOOST_FUNCTION_GET_INVOKER<function_ptr_tag>
++ {
++ template<typename FunctionPtr,
++ typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
++ typename Allocator>
++ struct apply
++ {
++ typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
++ FunctionPtr,
++ R BOOST_FUNCTION_COMMA
++ BOOST_FUNCTION_TEMPLATE_ARGS
++ >::type
++ invoker_type;
++
++ typedef functor_manager<FunctionPtr, Allocator> manager_type;
++ };
++ };
++
++#if BOOST_FUNCTION_NUM_ARGS > 0
++ /* Retrieve the invoker for a member pointer. */
++ template<>
++ struct BOOST_FUNCTION_GET_INVOKER<member_ptr_tag>
++ {
++ template<typename MemberPtr,
++ typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
++ typename Allocator>
++ struct apply
++ {
++ typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
++ MemberPtr,
++ R BOOST_FUNCTION_COMMA
++ BOOST_FUNCTION_TEMPLATE_ARGS
++ >::type
++ invoker_type;
++
++ typedef functor_manager<MemberPtr, Allocator> manager_type;
++ };
++ };
++#endif
++
++ /* Retrieve the invoker for a function object. */
++ template<>
++ struct BOOST_FUNCTION_GET_INVOKER<function_obj_tag>
++ {
++ template<typename FunctionObj,
++ typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
++ typename Allocator>
++ struct apply
++ {
++ typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
++ FunctionObj,
++ R BOOST_FUNCTION_COMMA
++ BOOST_FUNCTION_TEMPLATE_ARGS
++ >::type
++ invoker_type;
++
++ typedef functor_manager<FunctionObj, Allocator> manager_type;
++ };
++ };
++
++ /* Retrieve the invoker for a reference to a function object. */
++ template<>
++ struct BOOST_FUNCTION_GET_INVOKER<function_obj_ref_tag>
++ {
++ template<typename RefWrapper,
++ typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
++ typename Allocator>
++ struct apply
++ {
++ typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
++ typename RefWrapper::type,
++ R BOOST_FUNCTION_COMMA
++ BOOST_FUNCTION_TEMPLATE_ARGS
++ >::type
++ invoker_type;
++
++ typedef reference_manager<typename RefWrapper::type> manager_type;
++ };
++ };
++
+ /**
+ * vtable for a specific boost::function instance.
+ */
+ template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+ typename Allocator>
+- struct BOOST_FUNCTION_VTABLE : vtable_base
++ struct BOOST_FUNCTION_VTABLE
+ {
+ #ifndef BOOST_NO_VOID_RETURNS
+ typedef R result_type;
+@@ -272,50 +431,25 @@
+ BOOST_FUNCTION_TEMPLATE_ARGS);
+
+ template<typename F>
+- BOOST_FUNCTION_VTABLE(F f) : vtable_base(), invoker(0)
+- {
+- init(f);
+- }
+-
+- template<typename F>
+- bool assign_to(F f, function_buffer& functor)
++ bool assign_to(const F& f, function_buffer& functor) const
+ {
+ typedef typename get_function_tag<F>::type tag;
+ return assign_to(f, functor, tag());
+ }
+
+- void clear(function_buffer& functor)
++ void clear(function_buffer& functor) const
+ {
+- if (manager)
+- manager(functor, functor, destroy_functor_tag);
++ if (base.manager)
++ base.manager(functor, functor, destroy_functor_tag);
+ }
+-
++#ifndef BOOST_NO_PRIVATE_IN_AGGREGATE
+ private:
+- template<typename F>
+- void init(F f)
+- {
+- typedef typename get_function_tag<F>::type tag;
+- init(f, tag());
+- }
+-
++#endif
+ // Function pointers
+ template<typename FunctionPtr>
+- void init(FunctionPtr /*f*/, function_ptr_tag)
+- {
+- typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
+- FunctionPtr,
+- R BOOST_FUNCTION_COMMA
+- BOOST_FUNCTION_TEMPLATE_ARGS
+- >::type
+- actual_invoker_type;
+-
+- invoker = &actual_invoker_type::invoke;
+- manager = &functor_manager<FunctionPtr, Allocator>::manage;
+- }
+-
+- template<typename FunctionPtr>
+ bool
+- assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
++ assign_to(FunctionPtr f, function_buffer& functor,
++ function_ptr_tag) const
+ {
+ this->clear(functor);
+ if (f) {
+@@ -331,22 +465,13 @@
+ // Member pointers
+ #if BOOST_FUNCTION_NUM_ARGS > 0
+ template<typename MemberPtr>
+- void init(MemberPtr f, member_ptr_tag)
+- {
+- // DPG TBD: Add explicit support for member function
+- // objects, so we invoke through mem_fn() but we retain the
+- // right target_type() values.
+- this->init(mem_fn(f));
+- }
+-
+- template<typename MemberPtr>
+- bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
++ bool
++ assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+ {
+- // DPG TBD: Add explicit support for member function
+- // objects, so we invoke through mem_fn() but we retain the
+- // right target_type() values.
+ if (f) {
+- this->assign_to(mem_fn(f), functor);
++ // Always use the small-object optimization for member
++ // pointers.
++ assign_functor(f, functor, mpl::true_());
+ return true;
+ } else {
+ return false;
+@@ -355,24 +480,11 @@
+ #endif // BOOST_FUNCTION_NUM_ARGS > 0
+
+ // Function objects
+- template<typename FunctionObj>
+- void init(FunctionObj /*f*/, function_obj_tag)
+- {
+- typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
+- FunctionObj,
+- R BOOST_FUNCTION_COMMA
+- BOOST_FUNCTION_TEMPLATE_ARGS
+- >::type
+- actual_invoker_type;
+-
+- invoker = &actual_invoker_type::invoke;
+- manager = &functor_manager<FunctionObj, Allocator>::manage;
+- }
+-
+ // Assign to a function object using the small object optimization
+ template<typename FunctionObj>
+ void
+- assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
++ assign_functor(const FunctionObj& f, function_buffer& functor,
++ mpl::true_) const
+ {
+ new ((void*)&functor.data) FunctionObj(f);
+ }
+@@ -380,7 +492,8 @@
+ // Assign to a function object allocated on the heap.
+ template<typename FunctionObj>
+ void
+- assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
++ assign_functor(const FunctionObj& f, function_buffer& functor,
++ mpl::false_) const
+ {
+ #ifndef BOOST_NO_STD_ALLOCATOR
+ typedef typename Allocator::template rebind<FunctionObj>::other
+@@ -400,7 +513,8 @@
+
+ template<typename FunctionObj>
+ bool
+- assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
++ assign_to(const FunctionObj& f, function_buffer& functor,
++ function_obj_tag) const
+ {
+ if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+ assign_functor(f, functor,
+@@ -413,24 +527,9 @@
+
+ // Reference to a function object
+ template<typename FunctionObj>
+- void
+- init(const reference_wrapper<FunctionObj>& /*f*/, function_obj_ref_tag)
+- {
+- typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
+- FunctionObj,
+- R BOOST_FUNCTION_COMMA
+- BOOST_FUNCTION_TEMPLATE_ARGS
+- >::type
+- actual_invoker_type;
+-
+- invoker = &actual_invoker_type::invoke;
+- manager = &reference_manager<FunctionObj>::get;
+- }
+-
+- template<typename FunctionObj>
+ bool
+ assign_to(const reference_wrapper<FunctionObj>& f,
+- function_buffer& functor, function_obj_ref_tag)
++ function_buffer& functor, function_obj_ref_tag) const
+ {
+ if (!boost::detail::function::has_empty_target(f.get_pointer())) {
+ // DPG TBD: We might need to detect constness of
+@@ -445,6 +544,7 @@
+ }
+
+ public:
++ vtable_base base;
+ invoker_type invoker;
+ };
+ } // end namespace function
+@@ -456,6 +556,17 @@
+ typename Allocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR
+ >
+ class BOOST_FUNCTION_FUNCTION : public function_base
++
++#if BOOST_FUNCTION_NUM_ARGS == 1
++
++ , public std::unary_function<T0,R>
++
++#elif BOOST_FUNCTION_NUM_ARGS == 2
++
++ , public std::binary_function<T0,T1,R>
++
++#endif
++
+ {
+ public:
+ #ifndef BOOST_NO_VOID_RETURNS
+@@ -537,7 +648,7 @@
+ if (this->empty())
+ boost::throw_exception(bad_function_call());
+
+- return static_cast<vtable_type*>(vtable)->invoker
++ return reinterpret_cast<const vtable_type*>(vtable)->invoker
+ (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
+ }
+ #else
+@@ -561,12 +672,16 @@
+ operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
+ {
+ this->clear();
++#ifndef BOOST_NO_EXCEPTIONS
+ try {
+ this->assign_to(f);
+ } catch (...) {
+ vtable = 0;
+ throw;
+ }
++#else
++ this->assign_to(f);
++#endif
+ return *this;
+ }
+
+@@ -592,12 +707,16 @@
+ return *this;
+
+ this->clear();
++#ifndef BOOST_NO_EXCEPTIONS
+ try {
+ this->assign_to_own(f);
+ } catch (...) {
+ vtable = 0;
+ throw;
+ }
++#else
++ this->assign_to_own(f);
++#endif
+ return *this;
+ }
+
+@@ -615,7 +734,7 @@
+ void clear()
+ {
+ if (vtable) {
+- static_cast<vtable_type*>(vtable)->clear(this->functor);
++ reinterpret_cast<const vtable_type*>(vtable)->clear(this->functor);
+ vtable = 0;
+ }
+ }
+@@ -650,10 +769,24 @@
+ }
+
+ template<typename Functor>
+- void assign_to(Functor f)
++ void assign_to(const Functor& f)
+ {
+- static vtable_type stored_vtable(f);
+- if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable;
++ using detail::function::vtable_base;
++
++ typedef typename detail::function::get_function_tag<Functor>::type tag;
++ typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
++ typedef typename get_invoker::
++ template apply<Functor, R BOOST_FUNCTION_COMMA
++ BOOST_FUNCTION_TEMPLATE_ARGS, Allocator>
++ handler_type;
++
++ typedef typename handler_type::invoker_type invoker_type;
++ typedef typename handler_type::manager_type manager_type;
++
++ static const vtable_type stored_vtable =
++ { { &manager_type::manage }, &invoker_type::invoke };
++
++ if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable.base;
+ else vtable = 0;
+ }
+ };
+@@ -688,7 +821,7 @@
+ if (this->empty())
+ boost::throw_exception(bad_function_call());
+
+- return static_cast<vtable_type*>(vtable)->invoker
++ return reinterpret_cast<const vtable_type*>(vtable)->invoker
+ (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
+ }
+ #endif
+@@ -798,21 +931,14 @@
+ }
+ };
+
+-#ifdef BOOST_MSVC
+-# pragma warning(pop)
+-#endif
+-
+ #undef BOOST_FUNCTION_PARTIAL_SPEC
+ #endif // have partial specialization
+
+ } // end namespace boost
+
+-#ifdef BOOST_MSVC
+-# pragma warning(pop)
+-#endif
+-
+ // Cleanup after ourselves...
+ #undef BOOST_FUNCTION_VTABLE
++#undef BOOST_FUNCTION_GET_INVOKER
+ #undef BOOST_FUNCTION_DEFAULT_ALLOCATOR
+ #undef BOOST_FUNCTION_COMMA
+ #undef BOOST_FUNCTION_FUNCTION
+@@ -822,10 +948,12 @@
+ #undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
+ #undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
+ #undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
++#undef BOOST_FUNCTION_MEMBER_INVOKER
++#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
+ #undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
+ #undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+ #undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
+-#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
++#undef BOOST_FUNCTION_GET_MEMBER_INVOKER
+ #undef BOOST_FUNCTION_TEMPLATE_PARMS
+ #undef BOOST_FUNCTION_TEMPLATE_ARGS
+ #undef BOOST_FUNCTION_PARMS
+@@ -835,3 +963,7 @@
+ #undef BOOST_FUNCTION_ARG_TYPES
+ #undef BOOST_FUNCTION_VOID_RETURN_TYPE
+ #undef BOOST_FUNCTION_RETURN
++
++#if defined(BOOST_MSVC)
++# pragma warning( pop )
++#endif
Added: boost/trunk/debian/patches/gcc-4.3.patch
===================================================================
--- boost/trunk/debian/patches/gcc-4.3.patch (rev 0)
+++ boost/trunk/debian/patches/gcc-4.3.patch 2008-03-23 05:25:24 UTC (rev 14175)
@@ -0,0 +1,31 @@
+--- trunk.orig/boost/regex/v4/cpp_regex_traits.hpp
++++ trunk/boost/regex/v4/cpp_regex_traits.hpp
+@@ -41,6 +41,7 @@
+
+ #include <istream>
+ #include <ios>
++#include <climits>
+
+ #ifdef BOOST_HAS_ABI_HEADERS
+ # include BOOST_ABI_PREFIX
+--- trunk.orig/boost/test/test_tools.hpp
++++ trunk/boost/test/test_tools.hpp
+@@ -44,6 +44,7 @@
+ // STL
+ #include <cstddef> // for std::size_t
+ #include <iosfwd>
++#include <climits> // for CHAR_BIT
+
+ #include <boost/test/detail/suppress_warnings.hpp>
+
+--- trunk.orig/boost/python/detail/def_helper.hpp
++++ trunk/boost/python/detail/def_helper.hpp
+@@ -155,7 +155,7 @@
+ , T3 const&
+ , T4 const&
+ , default_call_policies
+- , keywords<0>
++ , detail::keywords<0>
+ , char const*
+ , void(not_specified::*)() // A function pointer type which is never an
+ // appropriate default implementation
Added: boost/trunk/debian/patches/regex-vulnerability.patch
===================================================================
--- boost/trunk/debian/patches/regex-vulnerability.patch (rev 0)
+++ boost/trunk/debian/patches/regex-vulnerability.patch 2008-03-23 05:25:24 UTC (rev 14175)
@@ -0,0 +1,54 @@
+--- trunk.orig/boost/regex/v4/basic_regex_parser.hpp
++++ trunk/boost/regex/v4/basic_regex_parser.hpp
+@@ -777,6 +777,7 @@
+ case syntax_element_restart_continue:
+ case syntax_element_jump:
+ case syntax_element_startmark:
++ case syntax_element_backstep:
+ // can't legally repeat any of the above:
+ fail(regex_constants::error_badrepeat, m_position - m_base);
+ return false;
+@@ -1862,6 +1863,7 @@
+ if(markid == -4)
+ {
+ re_syntax_base* b = this->getaddress(expected_alt_point);
++ // Make sure we have exactly one alternative following this state:
+ if(b->type != syntax_element_alt)
+ {
+ re_alt* alt = static_cast<re_alt*>(this->insert_state(expected_alt_point, syntax_element_alt, sizeof(re_alt)));
+@@ -1872,6 +1874,15 @@
+ fail(regex_constants::error_bad_pattern, m_position - m_base);
+ return false;
+ }
++ // check for invalid repetition of next state:
++ b = this->getaddress(expected_alt_point);
++ b = this->getaddress(static_cast<re_alt*>(b)->next.i, b);
++ if((b->type != syntax_element_assert_backref)
++ && (b->type != syntax_element_startmark))
++ {
++ fail(regex_constants::error_badrepeat, m_position - m_base);
++ return false;
++ }
+ }
+ //
+ // append closing parenthesis state:
+--- trunk.orig/libs/regex/test/regress/test_perl_ex.cpp
++++ trunk/libs/regex/test/regress/test_perl_ex.cpp
+@@ -121,6 +121,17 @@
+ TEST_INVALID_REGEX("(?:(a)|b)(?(?:", perl);
+ TEST_INVALID_REGEX("(?:(a)|b)(?(?<", perl);
+ TEST_INVALID_REGEX("(?:(a)|b)(?(?<a", perl);
++
++ TEST_INVALID_REGEX("(?(?!#?)+)", perl);
++ TEST_INVALID_REGEX("(?(?=:-){0})", perl);
++ TEST_INVALID_REGEX("(?(123){1})", perl);
++ TEST_INVALID_REGEX("(?(?<=A)*)", perl);
++ TEST_INVALID_REGEX("(?(?<=A)+)", perl);
++
++ TEST_INVALID_REGEX("(?<!*|^)", perl);
++ TEST_INVALID_REGEX("(?<!*|A)", perl);
++ TEST_INVALID_REGEX("(?<=?|A)", perl);
++ TEST_INVALID_REGEX("(?<=*|\\B)", perl);
+ }
+
+ void test_options()
Added: boost/trunk/debian/patches/series
===================================================================
--- boost/trunk/debian/patches/series (rev 0)
+++ boost/trunk/debian/patches/series 2008-03-23 05:25:24 UTC (rev 14175)
@@ -0,0 +1,5 @@
+suppress-compiler-warnings.patch
+gcc-4.3.patch
+function-template-thread-safety.patch
+regex-vulnerability.patch
+bjam-no-strict-aliasing.patch
Added: boost/trunk/debian/patches/suppress-compiler-warnings.patch
===================================================================
--- boost/trunk/debian/patches/suppress-compiler-warnings.patch (rev 0)
+++ boost/trunk/debian/patches/suppress-compiler-warnings.patch 2008-03-23 05:25:24 UTC (rev 14175)
@@ -0,0 +1,41 @@
+--- trunk.orig/boost/date_time/time.hpp
++++ trunk/boost/date_time/time.hpp
+@@ -77,14 +77,14 @@
+ /*! Optional bool parameter will return time zone as an offset
+ * (ie "+07:00"). Empty string is returned for classes that do
+ * not use a time_zone */
+- std::string zone_name(bool as_offset=false) const
++ std::string zone_name(bool = false) const
+ {
+ return time_system::zone_name(time_);
+ }
+ /*! Optional bool parameter will return time zone as an offset
+ * (ie "+07:00"). Empty string is returned for classes that do
+ * not use a time_zone */
+- std::string zone_abbrev(bool as_offset=false) const
++ std::string zone_abbrev(bool = false) const
+ {
+ return time_system::zone_name(time_);
+ }
+--- trunk.orig/boost/date_time/time_facet.hpp
++++ trunk/boost/date_time/time_facet.hpp
+@@ -197,7 +197,7 @@
+ #endif
+
+ //! sets default formats for ptime, local_date_time, and time_duration
+- explicit time_facet(::size_t a_ref = 0)
++ explicit time_facet(::size_t = 0)
+ //: base_type(standard_format),
+ : base_type(default_time_format),
+ m_time_duration_format(string_type(duration_sign_negative_only) + default_time_duration_format)
+--- trunk.orig/boost/graph/topological_sort.hpp
++++ trunk/boost/graph/topological_sort.hpp
+@@ -37,7 +37,7 @@
+ : m_iter(_iter) { }
+
+ template <typename Edge, typename Graph>
+- void back_edge(const Edge& u, Graph&) { throw not_a_dag(); }
++ void back_edge(const Edge&, Graph&) { throw not_a_dag(); }
+
+ template <typename Vertex, typename Graph>
+ void finish_vertex(const Vertex& u, Graph&) { *m_iter++ = u; }
Modified: boost/trunk/debian/rules
===================================================================
--- boost/trunk/debian/rules 2008-03-23 03:41:10 UTC (rev 14174)
+++ boost/trunk/debian/rules 2008-03-23 05:25:24 UTC (rev 14175)
@@ -5,6 +5,8 @@
export DH_OPTIONS
+include /usr/share/quilt/quilt.make
+
# set the number of build jobs
#JOBS = -j2
@@ -133,7 +135,7 @@
cd tools/jam/src && sh build.sh cc && mv bin.*/bjam .
build: build-stamp
-build-stamp: $(bjam)
+build-stamp: $(QUILT_STAMPFN) $(bjam)
dh_testdir
echo $(TOOLSET_CONFIG) > user-config.jam
@@ -161,7 +163,7 @@
rm -rf debian/libboost-dbg.install
rm -rf debian/libboost-dbg.links
-clean: clean-debhelper
+clean: unpatch clean-debhelper
dh_testdir
dh_testroot
rm -f build-stamp
@@ -177,7 +179,7 @@
rm -rf bin.v2 dist
rm -rf user-config.jam
- dh_clean
+ dh_clean build-stamp
install: DH_OPTIONS=-X.svn
install: build clean-debhelper
Modified: boost/trunk/libs/regex/test/regress/test_perl_ex.cpp
===================================================================
--- boost/trunk/libs/regex/test/regress/test_perl_ex.cpp 2008-03-23 03:41:10 UTC (rev 14174)
+++ boost/trunk/libs/regex/test/regress/test_perl_ex.cpp 2008-03-23 05:25:24 UTC (rev 14175)
@@ -121,17 +121,6 @@
TEST_INVALID_REGEX("(?:(a)|b)(?(?:", perl);
TEST_INVALID_REGEX("(?:(a)|b)(?(?<", perl);
TEST_INVALID_REGEX("(?:(a)|b)(?(?<a", perl);
-
- TEST_INVALID_REGEX("(?(?!#?)+)", perl);
- TEST_INVALID_REGEX("(?(?=:-){0})", perl);
- TEST_INVALID_REGEX("(?(123){1})", perl);
- TEST_INVALID_REGEX("(?(?<=A)*)", perl);
- TEST_INVALID_REGEX("(?(?<=A)+)", perl);
-
- TEST_INVALID_REGEX("(?<!*|^)", perl);
- TEST_INVALID_REGEX("(?<!*|A)", perl);
- TEST_INVALID_REGEX("(?<=?|A)", perl);
- TEST_INVALID_REGEX("(?<=*|\\B)", perl);
}
void test_options()
Modified: boost/trunk/tools/jam/src/build.jam
===================================================================
--- boost/trunk/tools/jam/src/build.jam 2008-03-23 03:41:10 UTC (rev 14174)
+++ boost/trunk/tools/jam/src/build.jam 2008-03-23 05:25:24 UTC (rev 14175)
@@ -152,7 +152,7 @@
: -L$(--python-lib[1]) -l$(--python-lib[2]) ;
## GCC 2.x, 3.x, 4.x
toolset gcc gcc : "-o " : -D
- : -pedantic -fno-strict-aliasing
+ : -pedantic
[ opt --release : [ opt --symbols : -g : -s ] -O3 ]
[ opt --debug : -g -O0 -fno-inline ]
-I$(--python-include) -Wno-long-long
More information about the pkg-boost-commits
mailing list