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

6
linx64/include/boost/spirit/home/x3/operator/detail/alternative.hpp
View File

@@ -4,8 +4,8 @@
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#if !defined(SPIRIT_ALTERNATIVE_DETAIL_JAN_07_2013_1245PM)
#define SPIRIT_ALTERNATIVE_DETAIL_JAN_07_2013_1245PM
#if !defined(BOOST_SPIRIT_X3_ALTERNATIVE_DETAIL_JAN_07_2013_1245PM)
#define BOOST_SPIRIT_X3_ALTERNATIVE_DETAIL_JAN_07_2013_1245PM
#include <boost/spirit/home/x3/support/traits/attribute_of.hpp>
#include <boost/spirit/home/x3/support/traits/is_variant.hpp>
@@ -226,7 +226,7 @@ namespace boost { namespace spirit { namespace x3 { namespace detail
struct move_if_not_alternative
{
template<typename T1, typename T2>
static void call(T1& attr_, T2& attr) {}
static void call(T1& /* attr_ */, T2& /* attr */) {}
};
template <>

135
linx64/include/boost/spirit/home/x3/operator/detail/sequence.hpp
View File

@@ -4,20 +4,21 @@
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#if !defined(SPIRIT_SEQUENCE_DETAIL_JAN_06_2013_1015AM)
#define SPIRIT_SEQUENCE_DETAIL_JAN_06_2013_1015AM
#if !defined(BOOST_SPIRIT_X3_SEQUENCE_DETAIL_JAN_06_2013_1015AM)
#define BOOST_SPIRIT_X3_SEQUENCE_DETAIL_JAN_06_2013_1015AM
#include <boost/spirit/home/x3/support/traits/attribute_of.hpp>
#include <boost/spirit/home/x3/support/traits/attribute_category.hpp>
#include <boost/spirit/home/x3/support/traits/make_attribute.hpp>
#include <boost/spirit/home/x3/support/traits/has_attribute.hpp>
#include <boost/spirit/home/x3/support/traits/is_substitute.hpp>
#include <boost/spirit/home/x3/support/traits/container_traits.hpp>
#include <boost/spirit/home/x3/support/traits/tuple_traits.hpp>
#include <boost/spirit/home/x3/core/detail/parse_into_container.hpp>
#include <boost/fusion/include/begin.hpp>
#include <boost/fusion/include/end.hpp>
#include <boost/fusion/include/advance.hpp>
#include <boost/fusion/include/deref.hpp>
#include <boost/fusion/include/empty.hpp>
#include <boost/fusion/include/front.hpp>
#include <boost/fusion/include/iterator_range.hpp>
@@ -35,6 +36,8 @@
#include <boost/type_traits/add_reference.hpp>
#include <boost/type_traits/is_same.hpp>
#include <iterator> // for std::make_move_iterator
namespace boost { namespace spirit { namespace x3
{
template <typename Left, typename Right>
@@ -79,14 +82,15 @@ namespace boost { namespace spirit { namespace x3 { namespace detail
};
template <typename Attribute>
struct pass_sequence_attribute_front
struct pass_sequence_attribute_size_one_view
{
typedef typename fusion::result_of::front<Attribute>::type type;
typedef typename fusion::result_of::deref<
typename fusion::result_of::begin<Attribute>::type
>::type type;
static typename add_reference<type>::type
call(Attribute& attr)
static type call(Attribute& attr)
{
return fusion::front(attr);
return fusion::deref(fusion::begin(attr));
}
};
@@ -103,30 +107,23 @@ namespace boost { namespace spirit { namespace x3 { namespace detail
}
};
template <typename Parser, typename Attribute, bool pass_through>
struct pass_sequence_attribute_used :
mpl::if_c<
(!pass_through && traits::is_size_one_sequence<Attribute>::value)
, pass_sequence_attribute_front<Attribute>
, pass_through_sequence_attribute<Attribute>>::type {};
template <typename Parser, typename Attribute, bool pass_through = false, typename Enable = void>
template <typename Parser, typename Attribute, typename Enable = void>
struct pass_sequence_attribute :
mpl::if_<
fusion::result_of::empty<Attribute>
, pass_sequence_attribute_unused
, pass_sequence_attribute_used<Parser, Attribute, pass_through>>::type {};
traits::is_size_one_view<Attribute>
, pass_sequence_attribute_size_one_view<Attribute>
, pass_through_sequence_attribute<Attribute>>::type {};
template <typename L, typename R, typename Attribute, bool pass_through>
struct pass_sequence_attribute<sequence<L, R>, Attribute, pass_through>
template <typename L, typename R, typename Attribute>
struct pass_sequence_attribute<sequence<L, R>, Attribute>
: pass_through_sequence_attribute<Attribute> {};
template <typename Parser, typename Attribute>
struct pass_sequence_attribute_subject :
pass_sequence_attribute<typename Parser::subject_type, Attribute> {};
template <typename Parser, typename Attribute, bool pass_through>
struct pass_sequence_attribute<Parser, Attribute, pass_through
template <typename Parser, typename Attribute>
struct pass_sequence_attribute<Parser, Attribute
, typename enable_if_c<(Parser::is_pass_through_unary)>::type>
: pass_sequence_attribute_subject<Parser, Attribute> {};
@@ -134,15 +131,26 @@ namespace boost { namespace spirit { namespace x3 { namespace detail
, typename Enable = void>
struct partition_attribute
{
using attr_category = typename traits::attribute_category<Attribute>::type;
static_assert(is_same<traits::tuple_attribute, attr_category>::value,
"The parser expects tuple-like attribute type");
static int const l_size = sequence_size<L, Context>::value;
static int const r_size = sequence_size<R, Context>::value;
static int constexpr actual_size = fusion::result_of::size<Attribute>::value;
static int constexpr expected_size = l_size + r_size;
// If you got an error here, then you are trying to pass
// a fusion sequence with the wrong number of elements
// as that expected by the (sequence) parser.
static_assert(
fusion::result_of::size<Attribute>::value == (l_size + r_size)
, "Attribute does not have the expected size."
actual_size >= expected_size
, "Size of the passed attribute is less than expected."
);
static_assert(
actual_size <= expected_size
, "Size of the passed attribute is bigger than expected."
);
typedef typename fusion::result_of::begin<Attribute>::type l_begin;
@@ -150,8 +158,8 @@ namespace boost { namespace spirit { namespace x3 { namespace detail
typedef typename fusion::result_of::end<Attribute>::type r_end;
typedef fusion::iterator_range<l_begin, l_end> l_part;
typedef fusion::iterator_range<l_end, r_end> r_part;
typedef pass_sequence_attribute<L, l_part, false> l_pass;
typedef pass_sequence_attribute<R, r_part, false> r_pass;
typedef pass_sequence_attribute<L, l_part> l_pass;
typedef pass_sequence_attribute<R, r_part> r_pass;
static l_part left(Attribute& s)
{
@@ -175,7 +183,7 @@ namespace boost { namespace spirit { namespace x3 { namespace detail
typedef unused_type l_part;
typedef Attribute& r_part;
typedef pass_sequence_attribute_unused l_pass;
typedef pass_sequence_attribute<R, Attribute, true> r_pass;
typedef pass_sequence_attribute<R, Attribute> r_pass;
static unused_type left(Attribute&)
{
@@ -195,7 +203,7 @@ namespace boost { namespace spirit { namespace x3 { namespace detail
{
typedef Attribute& l_part;
typedef unused_type r_part;
typedef pass_sequence_attribute<L, Attribute, true> l_pass;
typedef pass_sequence_attribute<L, Attribute> l_pass;
typedef pass_sequence_attribute_unused r_pass;
static Attribute& left(Attribute& s)
@@ -290,11 +298,11 @@ namespace boost { namespace spirit { namespace x3 { namespace detail
};
template <typename Parser, typename Iterator, typename Context
, typename RContext, typename Attribute>
, typename RContext, typename Attribute, typename AttributeCategory>
bool parse_sequence(
Parser const& parser, Iterator& first, Iterator const& last
, Context const& context, RContext& rcontext, Attribute& attr
, traits::tuple_attribute)
, AttributeCategory)
{
typedef typename Parser::left_type Left;
typedef typename Parser::right_type Right;
@@ -315,58 +323,32 @@ namespace boost { namespace spirit { namespace x3 { namespace detail
return false;
}
template <typename Parser, typename Context>
constexpr bool pass_sequence_container_attribute
= sequence_size<Parser, Context>::value > 1;
template <typename Parser, typename Iterator, typename Context
, typename RContext, typename Attribute>
bool parse_sequence_plain(
Parser const& parser, Iterator& first, Iterator const& last
, Context const& context, RContext& rcontext, Attribute& attr)
typename enable_if_c<pass_sequence_container_attribute<Parser, Context>, bool>::type
parse_sequence_container(
Parser const& parser
, Iterator& first, Iterator const& last, Context const& context
, RContext& rcontext, Attribute& attr)
{
typedef typename Parser::left_type Left;
typedef typename Parser::right_type Right;
typedef typename traits::attribute_of<Left, Context>::type l_attr_type;
typedef typename traits::attribute_of<Right, Context>::type r_attr_type;
typedef traits::make_attribute<l_attr_type, Attribute> l_make_attribute;
typedef traits::make_attribute<r_attr_type, Attribute> r_make_attribute;
typename l_make_attribute::type l_attr = l_make_attribute::call(attr);
typename r_make_attribute::type r_attr = r_make_attribute::call(attr);
Iterator save = first;
if (parser.left.parse(first, last, context, rcontext, l_attr)
&& parser.right.parse(first, last, context, rcontext, r_attr))
return true;
first = save;
return false;
return parser.parse(first, last, context, rcontext, attr);
}
template <typename Parser, typename Iterator, typename Context
, typename RContext, typename Attribute>
bool parse_sequence(
Parser const& parser, Iterator& first, Iterator const& last
, Context const& context, RContext& rcontext, Attribute& attr
, traits::plain_attribute)
typename disable_if_c<pass_sequence_container_attribute<Parser, Context>, bool>::type
parse_sequence_container(
Parser const& parser
, Iterator& first, Iterator const& last, Context const& context
, RContext& rcontext, Attribute& attr)
{
return parse_sequence_plain(parser, first, last, context, rcontext, attr);
return parse_into_container(parser, first, last, context, rcontext, attr);
}
template <typename Parser, typename Iterator, typename Context
, typename RContext, typename Attribute>
bool parse_sequence(
Parser const& parser, Iterator& first, Iterator const& last
, Context const& context, RContext& rcontext, Attribute& attr
, traits::variant_attribute)
{
return parse_sequence_plain(parser, first, last, context, rcontext, attr);
}
template <typename Left, typename Right, typename Iterator
, typename Context, typename RContext, typename Attribute>
bool parse_sequence(
Left const& left, Right const& right
, Iterator& first, Iterator const& last
, Context const& context, RContext& rcontext, Attribute& attr
, traits::container_attribute);
template <typename Parser, typename Iterator, typename Context
, typename RContext, typename Attribute>
bool parse_sequence(
@@ -375,8 +357,8 @@ namespace boost { namespace spirit { namespace x3 { namespace detail
, traits::container_attribute)
{
Iterator save = first;
if (parse_into_container(parser.left, first, last, context, rcontext, attr)
&& parse_into_container(parser.right, first, last, context, rcontext, attr))
if (parse_sequence_container(parser.left, first, last, context, rcontext, attr)
&& parse_sequence_container(parser.right, first, last, context, rcontext, attr))
return true;
first = save;
return false;
@@ -465,7 +447,8 @@ namespace boost { namespace spirit { namespace x3 { namespace detail
{
return false;
}
traits::append(attr, traits::begin(attr_), traits::end(attr_));
traits::append(attr, std::make_move_iterator(traits::begin(attr_)),
std::make_move_iterator(traits::end(attr_)));
return true;
}