bgirgis/cpp-thirdparty
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update boost on linux

Browse Source
This commit is contained in:
Bassem Girgis
2019-08-10 16:06:25 -05:00
parent 76ad52be58
commit 861b918727
5363 changed files with 483306 additions and 116507 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
linx64/include/boost/spirit/home/classic/core/composite/actions.hpp
View File

@@ -11,6 +11,7 @@
#include <boost/spirit/home/classic/namespace.hpp>
#include <boost/spirit/home/classic/core/parser.hpp>
#include <boost/spirit/home/classic/core/composite/composite.hpp>
#include <boost/core/ignore_unused.hpp>
namespace boost { namespace spirit {
@@ -107,7 +108,7 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
typedef typename ScannerT::iterator_t iterator_t;
typedef typename parser_result<self_t, ScannerT>::type result_t;
scan.at_end(); // allow skipper to take effect
ignore_unused(scan.at_end()); // allow skipper to take effect
iterator_t save = scan.first;
result_t hit = this->subject().parse(scan);
if (hit)

9
linx64/include/boost/spirit/home/classic/core/composite/epsilon.hpp
View File

@@ -16,6 +16,11 @@
#include <boost/spirit/home/classic/core/composite/composite.hpp>
#include <boost/spirit/home/classic/core/composite/no_actions.hpp>
#if defined(BOOST_MSVC)
# pragma warning(push)
# pragma warning(disable: 4800) // forcing value to bool 'true' or 'false'
#endif
////////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
@@ -273,4 +278,8 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_END
}} // namespace BOOST_SPIRIT_CLASSIC_NS
#ifdef BOOST_MSVC
# pragma warning (pop)
#endif
#endif

8
linx64/include/boost/spirit/home/classic/core/composite/no_actions.hpp
View File

@@ -38,10 +38,10 @@ struct no_actions_action_policy:
template<typename ActorT, typename AttrT, typename IteratorT>
void
do_action(
ActorT const& actor,
AttrT& val,
IteratorT const& first,
IteratorT const& last) const
ActorT const& /*actor*/,
AttrT& /*val*/,
IteratorT const& /*first*/,
IteratorT const& /*last*/) const
{}
};

14
linx64/include/boost/spirit/home/classic/core/match.hpp
View File

@@ -17,6 +17,8 @@
#include <boost/spirit/home/classic/core/safe_bool.hpp>
#include <boost/spirit/home/classic/core/impl/match_attr_traits.ipp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/type_traits/conditional.hpp>
#include <boost/type_traits/is_reference.hpp>
namespace boost { namespace spirit {
@@ -62,12 +64,20 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
template <typename T = nil_t>
class match : public safe_bool<match<T> >
{
typedef typename
conditional<
is_reference<T>::value
, T
, typename add_reference<
typename add_const<T>::type
>::type
>::type attr_ref_t;
public:
typedef typename boost::optional<T> optional_type;
typedef typename optional_type::argument_type ctor_param_t;
typedef typename optional_type::reference_const_type return_t;
typedef attr_ref_t ctor_param_t;
typedef attr_ref_t return_t;
typedef T attr_t;
match();

14
linx64/include/boost/spirit/home/classic/core/non_terminal/impl/grammar.ipp
View File

@@ -15,7 +15,7 @@
#include <boost/spirit/home/classic/core/non_terminal/impl/object_with_id.ipp>
#include <algorithm>
#include <functional>
#include <memory> // for std::auto_ptr
#include <boost/move/unique_ptr.hpp>
#include <boost/weak_ptr.hpp>
#endif
@@ -70,7 +70,7 @@ struct grammar_definition
{ // Does _not_ copy the helpers member !
}
grammar_helper_list& operator=(grammar_helper_list const& x)
grammar_helper_list& operator=(grammar_helper_list const& /*x*/)
{ // Does _not_ copy the helpers member !
return *this;
}
@@ -156,7 +156,7 @@ struct grammar_definition
if (definitions[id]!=0)
return *definitions[id];
std::auto_ptr<definition_t>
boost::movelib::unique_ptr<definition_t>
result(new definition_t(target_grammar->derived()));
#ifdef BOOST_SPIRIT_THREADSAFE
@@ -286,18 +286,10 @@ struct grammar_definition
helper_list_t& helpers =
grammartract_helper_list::do_(self);
# if defined(BOOST_INTEL_CXX_VERSION)
typedef typename helper_list_t::vector_t::reverse_iterator iterator_t;
for (iterator_t i = helpers.rbegin(); i != helpers.rend(); ++i)
(*i)->undefine(self);
# else
typedef impl::grammar_helper_base<GrammarT> helper_base_t;
std::for_each(helpers.rbegin(), helpers.rend(),
std::bind2nd(std::mem_fun(&helper_base_t::undefine), self));
# endif
#else
(void)self;
#endif

6
linx64/include/boost/spirit/home/classic/core/primitives/impl/primitives.ipp
View File

@@ -375,6 +375,12 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
return to_char_type<wchar_t>(towupper(to_int_type(c)));
}
inline bool
isblank_(bool)
{
return false;
}
#endif // !defined(BOOST_NO_CWCTYPE)
}

19
linx64/include/boost/spirit/home/classic/core/primitives/primitives.hpp
View File

@@ -49,6 +49,12 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
{
typedef typename ScannerT::value_t value_t;
typedef typename ScannerT::iterator_t iterator_t;
typedef scanner_policies<
no_skipper_iteration_policy<
BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>,
BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t,
BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t
> policies_t;
if (!scan.at_end())
{
@@ -56,7 +62,7 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
if (this->derived().test(ch))
{
iterator_t save(scan.first);
++scan.first;
++scan.change_policies(policies_t(scan));
return scan.create_match(1, ch, save, scan.first);
}
}
@@ -584,19 +590,26 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
typedef scanner_policies<
no_skipper_iteration_policy<
BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>,
BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t,
BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t
> policies_t;
typename ScannerT::iterator_t save = scan.first;
std::size_t len = 0;
if (!scan.at_end() && *scan == '\r') // CR
{
++scan.first;
++scan.change_policies(policies_t(scan));
++len;
}
// Don't call skipper here
if (scan.first != scan.last && *scan == '\n') // LF
{
++scan.first;
++scan.change_policies(policies_t(scan));
++len;
}

16
linx64/include/boost/spirit/home/classic/core/scanner/impl/skipper.ipp
View File

@@ -98,12 +98,12 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
ParserT const& p,
SkipT const& skip)
{
typedef skip_parser_iteration_policy<SkipT> iter_policy_t;
typedef scanner_policies<iter_policy_t> scanner_policies_t;
typedef scanner<IteratorT, scanner_policies_t> scanner_t;
typedef skip_parser_iteration_policy<SkipT> it_policy_t;
typedef scanner_policies<it_policy_t> scan_policies_t;
typedef scanner<IteratorT, scan_policies_t> scanner_t;
iter_policy_t iter_policy(skip);
scanner_policies_t policies(iter_policy);
it_policy_t iter_policy(skip);
scan_policies_t policies(iter_policy);
IteratorT first = first_;
scanner_t scan(first, last, policies);
match<nil_t> hit = p.parse(scan);
@@ -124,9 +124,9 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
ParserT const& p,
space_parser const&)
{
typedef skipper_iteration_policy<> iter_policy_t;
typedef scanner_policies<iter_policy_t> scanner_policies_t;
typedef scanner<IteratorT, scanner_policies_t> scanner_t;
typedef skipper_iteration_policy<> it_policy_t;
typedef scanner_policies<it_policy_t> scan_policies_t;
typedef scanner<IteratorT, scan_policies_t> scanner_t;
IteratorT first = first_;
scanner_t scan(first, last);

5
linx64/include/boost/spirit/home/classic/core/scanner/scanner.hpp
View File

@@ -13,7 +13,6 @@
#include <boost/spirit/home/classic/namespace.hpp>
#include <boost/spirit/home/classic/core/match.hpp>
#include <boost/spirit/home/classic/core/non_terminal/parser_id.hpp>
#include <boost/detail/iterator.hpp> // for boost::detail::iterator_traits
#include <boost/spirit/home/classic/core/scanner/scanner_fwd.hpp>
@@ -219,9 +218,9 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
typedef IteratorT iterator_t;
typedef PoliciesT policies_t;
typedef typename boost::detail::
typedef typename std::
iterator_traits<IteratorT>::value_type value_t;
typedef typename boost::detail::
typedef typename std::
iterator_traits<IteratorT>::reference ref_t;
typedef typename boost::
call_traits<IteratorT>::param_type iter_param_t;

10
linx64/include/boost/spirit/home/classic/debug/impl/parser_names.ipp
View File

@@ -95,7 +95,7 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
// from numerics.hpp
template <typename T, int Radix, unsigned MinDigits, int MaxDigits>
inline std::string
parser_name(uint_parser<T, Radix, MinDigits, MaxDigits> const& p)
parser_name(uint_parser<T, Radix, MinDigits, MaxDigits> const& /*p*/)
{
BOOST_SPIRIT_SSTREAM stream;
stream << Radix << ", " << MinDigits << ", " << MaxDigits;
@@ -106,7 +106,7 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
template <typename T, int Radix, unsigned MinDigits, int MaxDigits>
inline std::string
parser_name(int_parser<T, Radix, MinDigits, MaxDigits> const& p)
parser_name(int_parser<T, Radix, MinDigits, MaxDigits> const& /*p*/)
{
BOOST_SPIRIT_SSTREAM stream;
stream << Radix << ", " << MinDigits << ", " << MaxDigits;
@@ -117,7 +117,7 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
template <typename T, typename RealPoliciesT>
inline std::string
parser_name(real_parser<T, RealPoliciesT> const& p)
parser_name(real_parser<T, RealPoliciesT> const& /*p*/)
{
return std::string("real_parser");
}
@@ -218,7 +218,7 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
// from parser.hpp
template <typename DerivedT>
inline std::string
parser_name(parser<DerivedT> const& p)
parser_name(parser<DerivedT> const& /*p*/)
{
return std::string("parser");
}
@@ -227,7 +227,7 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
// from primitives.hpp
template <typename DerivedT>
inline std::string
parser_name(char_parser<DerivedT> const &p)
parser_name(char_parser<DerivedT> const &/*p*/)
{
return std::string("char_parser");
}

4
linx64/include/boost/spirit/home/classic/dynamic/for.hpp
View File

@@ -108,15 +108,13 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const &scan) const
{
typedef typename parser_result<self_t, ScannerT>::type
result_t;
typedef typename parser_result<parser_t, ScannerT>::type
body_result_t;
typename ScannerT::iterator_t save(scan.first);
std::size_t length = 0;
int eval_length = 0;
std::ptrdiff_t eval_length = 0;
this->init();
while ((eval_length = this->evaluate(scan))>=0)

7
linx64/include/boost/spirit/home/classic/dynamic/impl/switch.ipp
View File

@@ -12,6 +12,7 @@
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/static_assert.hpp>
#include <boost/core/ignore_unused.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/inc.hpp>
@@ -328,8 +329,8 @@ struct compound_case_parser
case_chain<self_t>::depth < BOOST_SPIRIT_SWITCH_CASE_LIMIT
);
typedef case_parser<N1, ParserT1, IsDefault1> right_t;
return compound_case_parser<self_t, right_t, IsDefault1>(*this, p);
typedef case_parser<N1, ParserT1, IsDefault1> rhs_t;
return compound_case_parser<self_t, rhs_t, IsDefault1>(*this, p);
}
};
@@ -445,7 +446,7 @@ inline typename parser_result<
compound_case_parser<LeftT, RightT, IsDefault>::
parse(ScannerT const& scan, CondT const &cond) const
{
scan.at_end(); // allow skipper to take effect
ignore_unused(scan.at_end()); // allow skipper to take effect
return parse_switch<value, case_chain<self_t>::depth, is_default>::
do_(*this, scan, cond(scan), scan.first);
}

2
linx64/include/boost/spirit/home/classic/dynamic/while.hpp
View File

@@ -71,7 +71,7 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
iterator_t save(scan.first);
std::size_t length = 0;
int eval_length = 0;
std::ptrdiff_t eval_length = 0;
bool dont_check_condition = is_do_parser;

9
linx64/include/boost/spirit/home/classic/error_handling/exceptions.hpp
View File

@@ -34,12 +34,12 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
// to allow a single catch handler to catch all exceptions.
//
///////////////////////////////////////////////////////////////////////////
class parser_error_base : public std::exception
class BOOST_SYMBOL_VISIBLE parser_error_base : public std::exception
{
protected:
parser_error_base() {}
virtual ~parser_error_base() throw() {}
virtual ~parser_error_base() BOOST_NOEXCEPT_OR_NOTHROW {}
public:
@@ -87,10 +87,10 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
}
virtual
~parser_error() throw() {}
~parser_error() BOOST_NOEXCEPT_OR_NOTHROW {}
virtual const char*
what() const throw()
what() const BOOST_NOEXCEPT_OR_NOTHROW
{
return "BOOST_SPIRIT_CLASSIC_NS::parser_error";
}
@@ -140,7 +140,6 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
parse(ScannerT const& scan) const
{
typedef typename parser_result<ParserT, ScannerT>::type result_t;
typedef typename ScannerT::iterator_t iterator_t;
result_t hit = this->subject().parse(scan);
if (!hit)

6
linx64/include/boost/spirit/home/classic/iterator/impl/file_iterator.ipp
View File

@@ -130,7 +130,7 @@ public:
void advance(std::ptrdiff_t n)
{
m_pos += n * sizeof(CharT);
m_pos += static_cast<long>(n) * sizeof(CharT);
update_char();
}
@@ -141,14 +141,14 @@ public:
private:
boost::shared_ptr<std::FILE> m_file;
std::size_t m_pos;
long m_pos;
CharT m_curChar;
bool m_eof;
void update_char(void)
{
using namespace std;
if ((std::size_t)ftell(m_file.get()) != m_pos)
if (ftell(m_file.get()) != m_pos)
fseek(m_file.get(), m_pos, SEEK_SET);
m_eof = (fread(&m_curChar, sizeof(CharT), 1, m_file.get()) < 1);

18
linx64/include/boost/spirit/home/classic/iterator/impl/position_iterator.ipp
View File

@@ -17,7 +17,7 @@
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/spirit/home/classic/core/nil.hpp> // for nil_t
#include <boost/detail/iterator.hpp> // for boost::detail::iterator_traits
#include <iterator> // for std::iterator_traits
namespace boost { namespace spirit {
@@ -91,6 +91,16 @@ private:
/* namespace boost::spirit { */ namespace iterator_ { namespace impl {
template <typename T>
struct make_const : boost::add_const<T>
{};
template <typename T>
struct make_const<T&>
{
typedef typename boost::add_const<T>::type& type;
};
///////////////////////////////////////////////////////////////////////////////
//
// position_iterator_base_generator
@@ -104,9 +114,10 @@ template <typename MainIterT, typename ForwardIterT, typename PositionT>
struct position_iterator_base_generator
{
private:
typedef boost::detail::iterator_traits<ForwardIterT> traits;
typedef std::iterator_traits<ForwardIterT> traits;
typedef typename traits::value_type value_type;
typedef typename traits::iterator_category iter_category_t;
typedef typename traits::reference reference;
// Position iterator is always a non-mutable iterator
typedef typename boost::add_const<value_type>::type const_value_type;
@@ -125,7 +136,8 @@ public:
main_iter_t,
ForwardIterT,
const_value_type,
boost::forward_traversal_tag
boost::forward_traversal_tag,
typename make_const<reference>::type
> type;
};

41
linx64/include/boost/spirit/home/classic/iterator/multi_pass.hpp
View File

@@ -16,12 +16,10 @@
#include <algorithm> // for std::swap
#include <exception> // for std::exception
#include <boost/limits.hpp>
#include <boost/iterator.hpp>
#include <boost/spirit/home/classic/namespace.hpp>
#include <boost/spirit/home/classic/core/assert.hpp> // for BOOST_SPIRIT_ASSERT
#include <boost/spirit/home/classic/iterator/fixed_size_queue.hpp>
#include <boost/detail/iterator.hpp> // for boost::detail::iterator_traits
#include <boost/spirit/home/classic/iterator/multi_pass_fwd.hpp>
@@ -147,15 +145,15 @@ class first_owner
// thrown by buf_id_check CheckingPolicy if an instance of an iterator is
// used after another one has invalidated the queue
///////////////////////////////////////////////////////////////////////////////
class illegal_backtracking : public std::exception
class BOOST_SYMBOL_VISIBLE illegal_backtracking : public std::exception
{
public:
illegal_backtracking() throw() {}
~illegal_backtracking() throw() {}
illegal_backtracking() BOOST_NOEXCEPT_OR_NOTHROW {}
~illegal_backtracking() BOOST_NOEXCEPT_OR_NOTHROW {}
virtual const char*
what() const throw()
what() const BOOST_NOEXCEPT_OR_NOTHROW
{ return "BOOST_SPIRIT_CLASSIC_NS::illegal_backtracking"; }
};
@@ -492,7 +490,7 @@ class inner
{
private:
typedef
typename boost::detail::iterator_traits<InputT>::value_type
typename std::iterator_traits<InputT>::value_type
result_type;
public:
@@ -517,13 +515,13 @@ class inner
public:
typedef
typename boost::detail::iterator_traits<InputT>::difference_type
typename std::iterator_traits<InputT>::difference_type
difference_type;
typedef
typename boost::detail::iterator_traits<InputT>::pointer
typename std::iterator_traits<InputT>::pointer
pointer;
typedef
typename boost::detail::iterator_traits<InputT>::reference
typename std::iterator_traits<InputT>::reference
reference;
protected:
@@ -551,7 +549,7 @@ class inner
}
typedef
typename boost::detail::iterator_traits<InputT>::value_type
typename std::iterator_traits<InputT>::value_type
value_t;
void swap(inner& x)
{
@@ -760,24 +758,19 @@ class inner
namespace iterator_ { namespace impl {
// Meta-function to generate a std::iterator<> base class for multi_pass. This
// is used mainly to improve conformance of compilers not supporting PTS
// and thus relying on inheritance to recognize an iterator.
// We are using boost::iterator<> because it offers an automatic workaround
// for broken std::iterator<> implementations.
// Meta-function to generate a std::iterator<>-like base class for multi_pass.
template <typename InputPolicyT, typename InputT>
struct iterator_base_creator
{
typedef typename InputPolicyT::BOOST_NESTED_TEMPLATE inner<InputT> input_t;
typedef boost::iterator
<
std::forward_iterator_tag,
typename input_t::value_type,
typename input_t::difference_type,
typename input_t::pointer,
typename input_t::reference
> type;
struct type {
typedef std::forward_iterator_tag iterator_category;
typedef typename input_t::value_type value_type;
typedef typename input_t::difference_type difference_type;
typedef typename input_t::pointer pointer;
typedef typename input_t::reference reference;
};
};
}}

6
linx64/include/boost/spirit/home/classic/iterator/position_iterator_fwd.hpp
View File

@@ -10,7 +10,7 @@
#define BOOST_SPIRIT_POSITION_ITERATOR_FWD_HPP
#include <string>
#include <boost/detail/iterator.hpp> // for boost::detail::iterator_traits
#include <iterator> // for std::iterator_traits
#include <boost/spirit/home/classic/namespace.hpp>
#include <boost/spirit/home/classic/core/nil.hpp>
@@ -32,7 +32,7 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
typename ForwardIteratorT,
typename PositionT = file_position_base<
std::basic_string<
typename boost::detail::iterator_traits<ForwardIteratorT>::value_type
typename std::iterator_traits<ForwardIteratorT>::value_type
>
>,
typename SelfT = nil_t
@@ -44,7 +44,7 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
typename ForwardIteratorT,
typename PositionT = file_position_base<
std::basic_string<
typename boost::detail::iterator_traits<ForwardIteratorT>::value_type
typename std::iterator_traits<ForwardIteratorT>::value_type
>
>
>

2
linx64/include/boost/spirit/home/classic/meta/impl/refactoring.ipp
View File

@@ -324,7 +324,7 @@ namespace impl {
>
static typename parser_result<ParserT, ScannerT>::type
parse(ParserT const &, ScannerT const& scan, ActionT const &action,
NestedT const& nested_d)
NestedT const& /*nested_d*/)
{
return action.parse(scan);
}

3
linx64/include/boost/spirit/home/classic/phoenix/actor.hpp
View File

@@ -10,6 +10,7 @@
///////////////////////////////////////////////////////////////////////////////
#include <boost/spirit/home/classic/phoenix/tuples.hpp>
#include <boost/type_traits/remove_reference.hpp>
///////////////////////////////////////////////////////////////////////////////
namespace phoenix {
@@ -120,7 +121,7 @@ template <typename ActorT, typename TupleT>
struct actor_result {
typedef typename ActorT::template result<TupleT>::type type;
typedef typename remove_reference<type>::type plain_type;
typedef typename boost::remove_reference<type>::type plain_type;
};
//////////////////////////////////

12
linx64/include/boost/spirit/home/classic/phoenix/composite.hpp
View File

@@ -1374,13 +1374,13 @@ namespace impl {
<OperationT, actor<BaseT>, B>::type type;
static type
construct(actor<BaseT> const& _0, B const& _1)
construct(actor<BaseT> const& _0_, B const& _1_)
{
typedef typename make_composite
<OperationT, actor<BaseT>, B>::composite_type
ret_t;
return ret_t(OperationT(), _0, as_actor<B>::convert(_1));
return ret_t(OperationT(), _0_, as_actor<B>::convert(_1_));
}
};
@@ -1392,13 +1392,13 @@ namespace impl {
<OperationT, A, actor<BaseT> >::type type;
static type
construct(A const& _0, actor<BaseT> const& _1)
construct(A const& _0_, actor<BaseT> const& _1_)
{
typedef typename make_composite
<OperationT, A, actor<BaseT> >::composite_type
ret_t;
return ret_t(OperationT(), as_actor<A>::convert(_0), _1);
return ret_t(OperationT(), as_actor<A>::convert(_0_), _1_);
}
};
@@ -1410,13 +1410,13 @@ namespace impl {
<OperationT, actor<BaseA>, actor<BaseB> >::type type;
static type
construct(actor<BaseA> const& _0, actor<BaseB> const& _1)
construct(actor<BaseA> const& _0_, actor<BaseB> const& _1_)
{
typedef typename make_composite
<OperationT, actor<BaseA>, actor<BaseB> >::composite_type
ret_t;
return ret_t(OperationT(), _0, _1);
return ret_t(OperationT(), _0_, _1_);
}
};

13
linx64/include/boost/spirit/home/classic/phoenix/special_ops.hpp
View File

@@ -20,6 +20,7 @@
///////////////////////////////////////////////////////////////////////////////
#include <boost/spirit/home/classic/phoenix/operators.hpp>
#include <iosfwd>
#include <complex>
///////////////////////////////////////////////////////////////////////////////
#if defined(_STLPORT_VERSION) && defined(__STL_USE_OWN_NAMESPACE)
@@ -29,18 +30,6 @@
#define PHOENIX_STD std
#endif
///////////////////////////////////////////////////////////////////////////////
//#if !defined(PHOENIX_NO_STD_NAMESPACE)
namespace PHOENIX_STD
{
//#endif
template<typename T> class complex;
//#if !defined(PHOENIX_NO_STD_NAMESPACE)
}
//#endif
///////////////////////////////////////////////////////////////////////////////
namespace phoenix
{

2
linx64/include/boost/spirit/home/classic/phoenix/tuples.hpp
View File

@@ -207,7 +207,7 @@ struct tuple_element
typedef nil_t& rtype;
typedef nil_t const& crtype;
static nil_t get(TupleT const& t) { return nil_t(); }
static nil_t get(TupleT const&) { return nil_t(); }
};
//////////////////////////////////

6
linx64/include/boost/spirit/home/classic/symbols/impl/tst.ipp
View File

@@ -10,7 +10,7 @@
#define BOOST_SPIRIT_TST_IPP
///////////////////////////////////////////////////////////////////////////////
#include <memory> // for std::auto_ptr
#include <boost/move/unique_ptr.hpp>
#include <boost/spirit/home/classic/core/assert.hpp>
///////////////////////////////////////////////////////////////////////////////
@@ -62,7 +62,7 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
tst_node*
clone() const
{
std::auto_ptr<tst_node> copy(new tst_node(value));
boost::movelib::unique_ptr<tst_node> copy(new tst_node(value));
if (left)
copy->left = left->clone();
@@ -75,7 +75,7 @@ BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
}
else
{
std::auto_ptr<T> mid_data(new T(*middle.data));
boost::movelib::unique_ptr<T> mid_data(new T(*middle.data));
copy->middle.data = mid_data.release();
}

12
linx64/include/boost/spirit/home/classic/tree/ast.hpp
View File

@@ -301,15 +301,15 @@ ast_parse(
SkipT const& skip_,
AstFactoryT const & /*dummy_*/ = AstFactoryT())
{
typedef skip_parser_iteration_policy<SkipT> iter_policy_t;
typedef skip_parser_iteration_policy<SkipT> it_policy_t;
typedef ast_match_policy<IteratorT, AstFactoryT> ast_match_policy_t;
typedef
scanner_policies<iter_policy_t, ast_match_policy_t>
scanner_policies_t;
typedef scanner<IteratorT, scanner_policies_t> scanner_t;
scanner_policies<it_policy_t, ast_match_policy_t>
scan_policies_t;
typedef scanner<IteratorT, scan_policies_t> scanner_t;
iter_policy_t iter_policy(skip_);
scanner_policies_t policies(iter_policy);
it_policy_t iter_policy(skip_);
scan_policies_t policies(iter_policy);
IteratorT first = first_;
scanner_t scan(first, last_, policies);
tree_match<IteratorT, AstFactoryT> hit = parser.derived().parse(scan);

5
linx64/include/boost/spirit/home/classic/tree/common.hpp
View File

@@ -26,7 +26,6 @@
#include <boost/call_traits.hpp>
#include <boost/spirit/home/classic/namespace.hpp>
#include <boost/spirit/home/classic/core.hpp>
#include <boost/detail/iterator.hpp> // for boost::detail::iterator_traits
#include <boost/assert.hpp>
#if defined(BOOST_SPIRIT_DEBUG) && \
@@ -37,6 +36,8 @@
#include <boost/spirit/home/classic/tree/common_fwd.hpp>
#include <iterator> // for std::iterator_traits, std::distance
namespace boost { namespace spirit {
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
@@ -242,7 +243,7 @@ template <typename IteratorT = char const*, typename ValueT = nil_t>
struct node_val_data
{
typedef
typename boost::detail::iterator_traits<IteratorT>::value_type
typename std::iterator_traits<IteratorT>::value_type
value_type;
#if !defined(BOOST_SPIRIT_USE_BOOST_ALLOCATOR_FOR_TREES)

12
linx64/include/boost/spirit/home/classic/tree/parse_tree.hpp
View File

@@ -210,15 +210,15 @@ pt_parse(
SkipT const& skip,
NodeFactoryT const& /*dummy_*/ = NodeFactoryT())
{
typedef skip_parser_iteration_policy<SkipT> iter_policy_t;
typedef skip_parser_iteration_policy<SkipT> it_policy_t;
typedef pt_match_policy<IteratorT, NodeFactoryT> pt_match_policy_t;
typedef
scanner_policies<iter_policy_t, pt_match_policy_t>
scanner_policies_t;
typedef scanner<IteratorT, scanner_policies_t> scanner_t;
scanner_policies<it_policy_t, pt_match_policy_t>
scan_policies_t;
typedef scanner<IteratorT, scan_policies_t> scanner_t;
iter_policy_t iter_policy(skip);
scanner_policies_t policies(iter_policy);
it_policy_t iter_policy(skip);
scan_policies_t policies(iter_policy);
IteratorT first = first_;
scanner_t scan(first, last, policies);
tree_match<IteratorT, NodeFactoryT> hit = p.derived().parse(scan);

2
linx64/include/boost/spirit/home/classic/utility.hpp
View File

@@ -34,7 +34,9 @@
// Utility.Support
#include <boost/spirit/home/classic/utility/flush_multi_pass.hpp>
#ifdef BOOST_SPIRIT_THREADSAFE
#include <boost/spirit/home/classic/utility/scoped_lock.hpp>
#endif
#endif // !defined(BOOST_SPIRIT_UTILITY_MAIN_HPP)

2
linx64/include/boost/spirit/home/classic/utility/impl/escape_char.ipp
View File

@@ -33,7 +33,7 @@ const unsigned long lex_escapes = c_escapes << 1;
namespace impl {
//////////////////////////////////
#if (defined(BOOST_MSVC) && (BOOST_MSVC <= 1310))
#if defined(BOOST_MSVC)
#pragma warning(push)
#pragma warning(disable:4127)
#endif

2
linx64/include/boost/spirit/home/classic/utility/loops.hpp
View File

@@ -14,6 +14,8 @@
#include <boost/spirit/home/classic/namespace.hpp>
#include <boost/spirit/home/classic/core/parser.hpp>
#include <boost/spirit/home/classic/core/composite/composite.hpp>
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_same.hpp>
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {

4
linx64/include/boost/spirit/home/classic/utility/regex.hpp
View File

@@ -47,7 +47,7 @@
#include <boost/spirit/home/classic/meta/as_parser.hpp>
#include <boost/spirit/home/classic/core/parser.hpp>
#include <boost/spirit/home/classic/utility/impl/regex.ipp>
#include <boost/detail/iterator.hpp> // for boost::detail::iterator_traits
#include <iterator> // for std::iterator_traits
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
@@ -75,7 +75,7 @@ struct rxstrlit : public parser<rxstrlit<CharT> > {
// forward iterators do not work here.
typedef typename ScannerT::iterator_t iterator_t;
typedef
typename boost::detail::iterator_traits<iterator_t>::iterator_category
typename std::iterator_traits<iterator_t>::iterator_category
iterator_category;
BOOST_STATIC_ASSERT((

13
linx64/include/boost/spirit/home/classic/version.hpp
View File

@@ -8,23 +8,12 @@
#if !defined(SPIRIT_CLASSIC_VERSION_HPP)
#define SPIRIT_CLASSIC_VERSION_HPP
///////////////////////////////////////////////////////////////////////////////
//
// This checks, whether the used Boost library is at least V1.32.0
//
///////////////////////////////////////////////////////////////////////////////
#include <boost/version.hpp>
#if BOOST_VERSION < 103200
#error "Spirit v1.8.x needs at least Boost V1.32.0 to compile successfully."
#endif
///////////////////////////////////////////////////////////////////////////////
//
// This is the version of the current Spirit distribution
//
///////////////////////////////////////////////////////////////////////////////
#define SPIRIT_VERSION 0x1806
#define SPIRIT_VERSION 0x1811
#define SPIRIT_PIZZA_VERSION SPIRIT_MEGA_VEGGI // :-)
#endif // defined(SPIRIT_VERSION_HPP)