stabilize build system: depends, installer, boost/bdb fixes, cross targets groundwork
This commit is contained in:
+60
@@ -0,0 +1,60 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2014 Joel de Guzman
|
||||
|
||||
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(BOOST_SPIRIT_X3_NO_CASE_STRING_PARSE_APR_18_2014_1125PM)
|
||||
#define BOOST_SPIRIT_X3_NO_CASE_STRING_PARSE_APR_18_2014_1125PM
|
||||
|
||||
#include <boost/spirit/home/x3/char/char.hpp>
|
||||
#include <boost/spirit/home/x3/support/traits/move_to.hpp>
|
||||
|
||||
namespace boost { namespace spirit { namespace x3 { namespace detail
|
||||
{
|
||||
template <typename Char, typename Encoding>
|
||||
struct no_case_string
|
||||
{
|
||||
typedef std::basic_string< Char > string_type;
|
||||
typedef typename string_type::const_iterator const_iterator;
|
||||
|
||||
no_case_string(char_type const* str)
|
||||
: lower(str)
|
||||
, upper(str)
|
||||
{
|
||||
typename string_type::iterator loi = lower.begin();
|
||||
typename string_type::iterator upi = upper.begin();
|
||||
|
||||
typedef typename Encoding::char_type encoded_char_type;
|
||||
Encoding encoding;
|
||||
for (; loi != lower.end(); ++loi, ++upi)
|
||||
{
|
||||
*loi = static_cast<char_type>(encoding.tolower(encoded_char_type(*loi)));
|
||||
*upi = static_cast<char_type>(encoding.toupper(encoded_char_type(*upi)));
|
||||
}
|
||||
}
|
||||
string_type lower;
|
||||
string_type upper;
|
||||
|
||||
};
|
||||
|
||||
template <typename String, typename Iterator, typename Attribute>
|
||||
inline bool no_case_string_parse(
|
||||
String const& str
|
||||
, Iterator& first, Iterator const& last, Attribute& attr)
|
||||
{
|
||||
typename String::const_iterator uc_i = str.upper.begin();
|
||||
typename String::const_iterator uc_last = str.upper.end();
|
||||
typename String::const_iterator lc_i = str.lower.begin();
|
||||
Iterator i = first;
|
||||
|
||||
for (; uc_i != uc_last; ++uc_i, ++lc_i, ++i)
|
||||
if (i == last || ((*uc_i != *i) && (*lc_i != *i)))
|
||||
return false;
|
||||
x3::traits::move_to(first, i, attr);
|
||||
first = i;
|
||||
return true;
|
||||
}
|
||||
}}}}
|
||||
|
||||
#endif
|
||||
+85
@@ -0,0 +1,85 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2014 Joel de Guzman
|
||||
|
||||
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(BOOST_SPIRIT_X3_STRING_PARSE_APR_18_2006_1125PM)
|
||||
#define BOOST_SPIRIT_X3_STRING_PARSE_APR_18_2006_1125PM
|
||||
|
||||
#include <boost/spirit/home/x3/support/traits/move_to.hpp>
|
||||
|
||||
namespace boost { namespace spirit { namespace x3 { namespace detail
|
||||
{
|
||||
template <typename Char, typename Iterator, typename Attribute, typename CaseCompareFunc>
|
||||
inline bool string_parse(
|
||||
Char const* str
|
||||
, Iterator& first, Iterator const& last, Attribute& attr, CaseCompareFunc const& compare)
|
||||
{
|
||||
Iterator i = first;
|
||||
Char ch = *str;
|
||||
|
||||
for (; !!ch; ++i)
|
||||
{
|
||||
if (i == last || (compare(ch, *i) != 0))
|
||||
return false;
|
||||
ch = *++str;
|
||||
}
|
||||
|
||||
x3::traits::move_to(first, i, attr);
|
||||
first = i;
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename String, typename Iterator, typename Attribute, typename CaseCompareFunc>
|
||||
inline bool string_parse(
|
||||
String const& str
|
||||
, Iterator& first, Iterator const& last, Attribute& attr, CaseCompareFunc const& compare)
|
||||
{
|
||||
Iterator i = first;
|
||||
typename String::const_iterator stri = str.begin();
|
||||
typename String::const_iterator str_last = str.end();
|
||||
|
||||
for (; stri != str_last; ++stri, ++i)
|
||||
if (i == last || (compare(*stri, *i) != 0))
|
||||
return false;
|
||||
x3::traits::move_to(first, i, attr);
|
||||
first = i;
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename Char, typename Iterator, typename Attribute>
|
||||
inline bool string_parse(
|
||||
Char const* uc_i, Char const* lc_i
|
||||
, Iterator& first, Iterator const& last, Attribute& attr)
|
||||
{
|
||||
Iterator i = first;
|
||||
|
||||
for (; *uc_i && *lc_i; ++uc_i, ++lc_i, ++i)
|
||||
if (i == last || ((*uc_i != *i) && (*lc_i != *i)))
|
||||
return false;
|
||||
x3::traits::move_to(first, i, attr);
|
||||
first = i;
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename String, typename Iterator, typename Attribute>
|
||||
inline bool string_parse(
|
||||
String const& ucstr, String const& lcstr
|
||||
, Iterator& first, Iterator const& last, Attribute& attr)
|
||||
{
|
||||
typename String::const_iterator uc_i = ucstr.begin();
|
||||
typename String::const_iterator uc_last = ucstr.end();
|
||||
typename String::const_iterator lc_i = lcstr.begin();
|
||||
Iterator i = first;
|
||||
|
||||
for (; uc_i != uc_last; ++uc_i, ++lc_i, ++i)
|
||||
if (i == last || ((*uc_i != *i) && (*lc_i != *i)))
|
||||
return false;
|
||||
x3::traits::move_to(first, i, attr);
|
||||
first = i;
|
||||
return true;
|
||||
}
|
||||
}}}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,205 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2014 Joel de Guzman
|
||||
|
||||
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(BOOST_SPIRIT_X3_TST_MARCH_09_2007_0905AM)
|
||||
#define BOOST_SPIRIT_X3_TST_MARCH_09_2007_0905AM
|
||||
|
||||
#include <boost/call_traits.hpp>
|
||||
#include <boost/detail/iterator.hpp>
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
namespace boost { namespace spirit { namespace x3 { namespace detail
|
||||
{
|
||||
// This file contains low level TST routines, not for
|
||||
// public consumption.
|
||||
|
||||
template <typename Char, typename T>
|
||||
struct tst_node
|
||||
{
|
||||
tst_node(Char id)
|
||||
: id(id), data(0), lt(0), eq(0), gt(0)
|
||||
{
|
||||
}
|
||||
|
||||
template <typename Alloc>
|
||||
static void
|
||||
destruct_node(tst_node* p, Alloc* alloc)
|
||||
{
|
||||
if (p)
|
||||
{
|
||||
if (p->data)
|
||||
alloc->delete_data(p->data);
|
||||
destruct_node(p->lt, alloc);
|
||||
destruct_node(p->eq, alloc);
|
||||
destruct_node(p->gt, alloc);
|
||||
alloc->delete_node(p);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Alloc>
|
||||
static tst_node*
|
||||
clone_node(tst_node* p, Alloc* alloc)
|
||||
{
|
||||
if (p)
|
||||
{
|
||||
tst_node* clone = alloc->new_node(p->id);
|
||||
if (p->data)
|
||||
clone->data = alloc->new_data(*p->data);
|
||||
clone->lt = clone_node(p->lt, alloc);
|
||||
clone->eq = clone_node(p->eq, alloc);
|
||||
clone->gt = clone_node(p->gt, alloc);
|
||||
return clone;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
template <typename Iterator, typename CaseCompare>
|
||||
static T*
|
||||
find(tst_node* start, Iterator& first, Iterator last, CaseCompare comp)
|
||||
{
|
||||
if (first == last)
|
||||
return 0;
|
||||
|
||||
Iterator i = first;
|
||||
Iterator latest = first;
|
||||
tst_node* p = start;
|
||||
T* found = 0;
|
||||
|
||||
while (p && i != last)
|
||||
{
|
||||
int32_t c = comp(*i,p->id);
|
||||
if (c == 0)
|
||||
{
|
||||
if (p->data)
|
||||
{
|
||||
found = p->data;
|
||||
latest = i;
|
||||
}
|
||||
p = p->eq;
|
||||
i++;
|
||||
}
|
||||
else if (c < 0)
|
||||
{
|
||||
p = p->lt;
|
||||
}
|
||||
else
|
||||
{
|
||||
p = p->gt;
|
||||
}
|
||||
}
|
||||
|
||||
if (found)
|
||||
first = ++latest; // one past the last matching char
|
||||
return found;
|
||||
}
|
||||
|
||||
template <typename Iterator, typename Alloc>
|
||||
static T*
|
||||
add(
|
||||
tst_node*& start
|
||||
, Iterator first
|
||||
, Iterator last
|
||||
, typename boost::call_traits<T>::param_type val
|
||||
, Alloc* alloc)
|
||||
{
|
||||
if (first == last)
|
||||
return 0;
|
||||
|
||||
tst_node** pp = &start;
|
||||
for (;;)
|
||||
{
|
||||
typename
|
||||
boost::detail::iterator_traits<Iterator>::value_type
|
||||
c = *first;
|
||||
|
||||
if (*pp == 0)
|
||||
*pp = alloc->new_node(c);
|
||||
tst_node* p = *pp;
|
||||
|
||||
if (c == p->id)
|
||||
{
|
||||
if (++first == last)
|
||||
{
|
||||
if (p->data == 0)
|
||||
p->data = alloc->new_data(val);
|
||||
return p->data;
|
||||
}
|
||||
pp = &p->eq;
|
||||
}
|
||||
else if (c < p->id)
|
||||
{
|
||||
pp = &p->lt;
|
||||
}
|
||||
else
|
||||
{
|
||||
pp = &p->gt;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Iterator, typename Alloc>
|
||||
static void
|
||||
remove(tst_node*& p, Iterator first, Iterator last, Alloc* alloc)
|
||||
{
|
||||
if (p == 0 || first == last)
|
||||
return;
|
||||
|
||||
typename
|
||||
boost::detail::iterator_traits<Iterator>::value_type
|
||||
c = *first;
|
||||
|
||||
if (c == p->id)
|
||||
{
|
||||
if (++first == last)
|
||||
{
|
||||
if (p->data)
|
||||
{
|
||||
alloc->delete_data(p->data);
|
||||
p->data = 0;
|
||||
}
|
||||
}
|
||||
remove(p->eq, first, last, alloc);
|
||||
}
|
||||
else if (c < p->id)
|
||||
{
|
||||
remove(p->lt, first, last, alloc);
|
||||
}
|
||||
else
|
||||
{
|
||||
remove(p->gt, first, last, alloc);
|
||||
}
|
||||
|
||||
if (p->data == 0 && p->lt == 0 && p->eq == 0 && p->gt == 0)
|
||||
{
|
||||
alloc->delete_node(p);
|
||||
p = 0;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename F>
|
||||
static void
|
||||
for_each(tst_node* p, std::basic_string<Char> prefix, F f)
|
||||
{
|
||||
if (p)
|
||||
{
|
||||
for_each(p->lt, prefix, f);
|
||||
std::basic_string<Char> s = prefix + p->id;
|
||||
for_each(p->eq, s, f);
|
||||
if (p->data)
|
||||
f(s, *p->data);
|
||||
for_each(p->gt, prefix, f);
|
||||
}
|
||||
}
|
||||
|
||||
Char id; // the node's identity character
|
||||
T* data; // optional data
|
||||
tst_node* lt; // left pointer
|
||||
tst_node* eq; // middle pointer
|
||||
tst_node* gt; // right pointer
|
||||
};
|
||||
}}}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,248 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2014 Joel de Guzman
|
||||
|
||||
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(BOOST_SPIRIT_X3_LITERAL_STRING_APR_18_2006_1125PM)
|
||||
#define BOOST_SPIRIT_X3_LITERAL_STRING_APR_18_2006_1125PM
|
||||
|
||||
#include <boost/spirit/home/x3/core/parser.hpp>
|
||||
#include <boost/spirit/home/x3/core/skip_over.hpp>
|
||||
#include <boost/spirit/home/x3/string/detail/string_parse.hpp>
|
||||
#include <boost/spirit/home/x3/support/no_case.hpp>
|
||||
#include <boost/spirit/home/x3/string/detail/no_case_string_parse.hpp>
|
||||
#include <boost/spirit/home/x3/support/utility/utf8.hpp>
|
||||
#include <boost/spirit/home/support/char_encoding/ascii.hpp>
|
||||
#include <boost/spirit/home/support/char_encoding/standard.hpp>
|
||||
#include <boost/spirit/home/support/char_encoding/standard_wide.hpp>
|
||||
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/type_traits/add_reference.hpp>
|
||||
#include <string>
|
||||
|
||||
namespace boost { namespace spirit { namespace x3
|
||||
{
|
||||
template <typename String, typename Encoding,
|
||||
typename Attribute = std::basic_string<typename Encoding::char_type>>
|
||||
struct literal_string : parser<literal_string<String, Encoding, Attribute>>
|
||||
{
|
||||
typedef typename Encoding::char_type char_type;
|
||||
typedef Encoding encoding;
|
||||
typedef Attribute attribute_type;
|
||||
static bool const has_attribute =
|
||||
!is_same<unused_type, attribute_type>::value;
|
||||
static bool const handles_container = has_attribute;
|
||||
|
||||
literal_string(typename add_reference< typename add_const<String>::type >::type str)
|
||||
: str(str)
|
||||
{}
|
||||
|
||||
template <typename Iterator, typename Context, typename Attribute_>
|
||||
bool parse(Iterator& first, Iterator const& last
|
||||
, Context const& context, unused_type, Attribute_& attr) const
|
||||
{
|
||||
x3::skip_over(first, last, context);
|
||||
return detail::string_parse(str, first, last, attr, get_case_compare<encoding>(context));
|
||||
}
|
||||
|
||||
String str;
|
||||
};
|
||||
|
||||
namespace standard
|
||||
{
|
||||
inline literal_string<char const*, char_encoding::standard>
|
||||
string(char const* s)
|
||||
{
|
||||
return { s };
|
||||
}
|
||||
|
||||
inline literal_string<std::basic_string<char>, char_encoding::standard>
|
||||
string(std::basic_string<char> const& s)
|
||||
{
|
||||
return { s };
|
||||
}
|
||||
|
||||
inline literal_string<char const*, char_encoding::standard, unused_type>
|
||||
lit(char const* s)
|
||||
{
|
||||
return { s };
|
||||
}
|
||||
|
||||
template <typename Char>
|
||||
literal_string<std::basic_string<Char>, char_encoding::standard, unused_type>
|
||||
lit(std::basic_string<Char> const& s)
|
||||
{
|
||||
return { s };
|
||||
}
|
||||
}
|
||||
|
||||
namespace standard_wide
|
||||
{
|
||||
inline literal_string<wchar_t const*, char_encoding::standard_wide>
|
||||
string(wchar_t const* s)
|
||||
{
|
||||
return { s };
|
||||
}
|
||||
|
||||
inline literal_string<std::basic_string<wchar_t>, char_encoding::standard_wide>
|
||||
string(std::basic_string<wchar_t> const& s)
|
||||
{
|
||||
return { s };
|
||||
}
|
||||
|
||||
inline literal_string<wchar_t const*, char_encoding::standard_wide, unused_type>
|
||||
lit(wchar_t const* s)
|
||||
{
|
||||
return { s };
|
||||
}
|
||||
|
||||
inline literal_string<std::basic_string<wchar_t>, char_encoding::standard_wide, unused_type>
|
||||
lit(std::basic_string<wchar_t> const& s)
|
||||
{
|
||||
return { s };
|
||||
}
|
||||
}
|
||||
|
||||
namespace ascii
|
||||
{
|
||||
inline literal_string<wchar_t const*, char_encoding::ascii>
|
||||
string(wchar_t const* s)
|
||||
{
|
||||
return { s };
|
||||
}
|
||||
|
||||
inline literal_string<std::basic_string<wchar_t>, char_encoding::ascii>
|
||||
string(std::basic_string<wchar_t> const& s)
|
||||
{
|
||||
return { s };
|
||||
}
|
||||
|
||||
inline literal_string<char const*, char_encoding::ascii, unused_type>
|
||||
lit(char const* s)
|
||||
{
|
||||
return { s };
|
||||
}
|
||||
|
||||
template <typename Char>
|
||||
literal_string<std::basic_string<Char>, char_encoding::ascii, unused_type>
|
||||
lit(std::basic_string<Char> const& s)
|
||||
{
|
||||
return { s };
|
||||
}
|
||||
}
|
||||
|
||||
namespace iso8859_1
|
||||
{
|
||||
inline literal_string<wchar_t const*, char_encoding::iso8859_1>
|
||||
string(wchar_t const* s)
|
||||
{
|
||||
return { s };
|
||||
}
|
||||
|
||||
inline literal_string<std::basic_string<wchar_t>, char_encoding::iso8859_1>
|
||||
string(std::basic_string<wchar_t> const& s)
|
||||
{
|
||||
return { s };
|
||||
}
|
||||
|
||||
inline literal_string<char const*, char_encoding::iso8859_1, unused_type>
|
||||
lit(char const* s)
|
||||
{
|
||||
return { s };
|
||||
}
|
||||
|
||||
template <typename Char>
|
||||
literal_string<std::basic_string<Char>, char_encoding::iso8859_1, unused_type>
|
||||
lit(std::basic_string<Char> const& s)
|
||||
{
|
||||
return { s };
|
||||
}
|
||||
}
|
||||
|
||||
using standard::string;
|
||||
using standard::lit;
|
||||
using standard_wide::string;
|
||||
using standard_wide::lit;
|
||||
|
||||
namespace extension
|
||||
{
|
||||
template <int N>
|
||||
struct as_parser<char[N]>
|
||||
{
|
||||
typedef literal_string<
|
||||
char const*, char_encoding::standard, unused_type>
|
||||
type;
|
||||
|
||||
typedef type value_type;
|
||||
|
||||
static type call(char const* s)
|
||||
{
|
||||
return type(s);
|
||||
}
|
||||
};
|
||||
|
||||
template <int N>
|
||||
struct as_parser<char const[N]> : as_parser<char[N]> {};
|
||||
|
||||
template <int N>
|
||||
struct as_parser<wchar_t[N]>
|
||||
{
|
||||
typedef literal_string<
|
||||
wchar_t const*, char_encoding::standard_wide, unused_type>
|
||||
type;
|
||||
|
||||
typedef type value_type;
|
||||
|
||||
static type call(wchar_t const* s)
|
||||
{
|
||||
return type(s);
|
||||
}
|
||||
};
|
||||
|
||||
template <int N>
|
||||
struct as_parser<wchar_t const[N]> : as_parser<wchar_t[N]> {};
|
||||
|
||||
template <>
|
||||
struct as_parser<char const*>
|
||||
{
|
||||
typedef literal_string<
|
||||
char const*, char_encoding::standard, unused_type>
|
||||
type;
|
||||
|
||||
typedef type value_type;
|
||||
|
||||
static type call(char const* s)
|
||||
{
|
||||
return type(s);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Char>
|
||||
struct as_parser< std::basic_string<Char> >
|
||||
{
|
||||
typedef literal_string<
|
||||
Char const*, char_encoding::standard, unused_type>
|
||||
type;
|
||||
|
||||
typedef type value_type;
|
||||
|
||||
static type call(std::basic_string<Char> const& s)
|
||||
{
|
||||
return type(s.c_str());
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
template <typename String, typename Encoding, typename Attribute>
|
||||
struct get_info<literal_string<String, Encoding, Attribute>>
|
||||
{
|
||||
typedef std::string result_type;
|
||||
std::string operator()(literal_string<String, Encoding, Attribute> const& p) const
|
||||
{
|
||||
return '"' + to_utf8(p.str) + '"';
|
||||
}
|
||||
};
|
||||
}}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,370 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2014 Joel de Guzman
|
||||
Copyright (c) 2013 Carl Barron
|
||||
|
||||
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(BOOST_SPIRIT_X3_SYMBOLS_MARCH_11_2007_1055AM)
|
||||
#define BOOST_SPIRIT_X3_SYMBOLS_MARCH_11_2007_1055AM
|
||||
|
||||
#include <boost/spirit/home/x3/core/skip_over.hpp>
|
||||
#include <boost/spirit/home/x3/core/parser.hpp>
|
||||
#include <boost/spirit/home/x3/string/tst.hpp>
|
||||
#include <boost/spirit/home/x3/support/unused.hpp>
|
||||
#include <boost/spirit/home/x3/support/traits/string_traits.hpp>
|
||||
#include <boost/spirit/home/x3/support/traits/move_to.hpp>
|
||||
#include <boost/spirit/home/x3/support/no_case.hpp>
|
||||
|
||||
#include <boost/spirit/home/support/char_encoding/ascii.hpp>
|
||||
#include <boost/spirit/home/support/char_encoding/iso8859_1.hpp>
|
||||
#include <boost/spirit/home/support/char_encoding/standard.hpp>
|
||||
#include <boost/spirit/home/support/char_encoding/standard_wide.hpp>
|
||||
|
||||
#include <boost/fusion/include/at.hpp>
|
||||
#include <boost/range.hpp>
|
||||
#include <boost/type_traits/add_reference.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
|
||||
#include <initializer_list>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning(push)
|
||||
# pragma warning(disable: 4355) // 'this' : used in base member initializer list warning
|
||||
#endif
|
||||
|
||||
namespace boost { namespace spirit { namespace x3
|
||||
{
|
||||
template <
|
||||
typename Encoding
|
||||
, typename T = unused_type
|
||||
, typename Lookup = tst<typename Encoding::char_type, T> >
|
||||
struct symbols_parser : parser<symbols_parser<Encoding, T, Lookup>>
|
||||
{
|
||||
typedef typename Encoding::char_type char_type; // the character type
|
||||
typedef Encoding encoding;
|
||||
typedef T value_type; // the value associated with each entry
|
||||
typedef value_type attribute_type;
|
||||
|
||||
static bool const has_attribute =
|
||||
!is_same<unused_type, attribute_type>::value;
|
||||
static bool const handles_container =
|
||||
traits::is_container<attribute_type>::value;
|
||||
|
||||
symbols_parser(std::string const& name = "symbols")
|
||||
: add(*this)
|
||||
, remove(*this)
|
||||
, lookup(new Lookup())
|
||||
, name_(name)
|
||||
{
|
||||
}
|
||||
|
||||
symbols_parser(symbols_parser const& syms)
|
||||
: add(*this)
|
||||
, remove(*this)
|
||||
, lookup(syms.lookup)
|
||||
, name_(syms.name_)
|
||||
{
|
||||
}
|
||||
|
||||
template <typename Symbols>
|
||||
symbols_parser(Symbols const& syms, std::string const& name = "symbols")
|
||||
: add(*this)
|
||||
, remove(*this)
|
||||
, lookup(new Lookup())
|
||||
, name_(name)
|
||||
{
|
||||
typename range_const_iterator<Symbols>::type si = boost::begin(syms);
|
||||
while (si != boost::end(syms))
|
||||
add(*si++);
|
||||
}
|
||||
|
||||
template <typename Symbols, typename Data>
|
||||
symbols_parser(Symbols const& syms, Data const& data
|
||||
, std::string const& name = "symbols")
|
||||
: add(*this)
|
||||
, remove(*this)
|
||||
, lookup(new Lookup())
|
||||
, name_(name)
|
||||
{
|
||||
typename range_const_iterator<Symbols>::type si = boost::begin(syms);
|
||||
typename range_const_iterator<Data>::type di = boost::begin(data);
|
||||
while (si != boost::end(syms))
|
||||
add(*si++, *di++);
|
||||
}
|
||||
|
||||
symbols_parser(std::initializer_list<std::pair<char_type const*, T>> syms
|
||||
, std::string const & name="symbols")
|
||||
: add(*this)
|
||||
, remove(*this)
|
||||
, lookup(new Lookup())
|
||||
, name_(name)
|
||||
{
|
||||
typedef std::initializer_list<std::pair<char_type const*, T>> symbols_t;
|
||||
typename range_const_iterator<symbols_t>::type si = boost::begin(syms);
|
||||
for (;si != boost::end(syms); ++si)
|
||||
add(si->first, si->second);
|
||||
}
|
||||
|
||||
symbols_parser(std::initializer_list<char_type const*> syms
|
||||
, std::string const &name="symbols")
|
||||
: add(*this)
|
||||
, remove(*this)
|
||||
, lookup(new Lookup())
|
||||
, name_(name)
|
||||
{
|
||||
typedef std::initializer_list<char_type const*> symbols_t;
|
||||
typename range_const_iterator<symbols_t>::type si = boost::begin(syms);
|
||||
while (si != boost::end(syms))
|
||||
add(*si++);
|
||||
}
|
||||
|
||||
symbols_parser&
|
||||
operator=(symbols_parser const& rhs)
|
||||
{
|
||||
name_ = rhs.name_;
|
||||
lookup = rhs.lookup;
|
||||
return *this;
|
||||
}
|
||||
|
||||
void clear()
|
||||
{
|
||||
lookup->clear();
|
||||
}
|
||||
|
||||
struct adder;
|
||||
struct remover;
|
||||
|
||||
template <typename Str>
|
||||
adder const&
|
||||
operator=(Str const& str)
|
||||
{
|
||||
lookup->clear();
|
||||
return add(str);
|
||||
}
|
||||
|
||||
template <typename Str>
|
||||
friend adder const&
|
||||
operator+=(symbols_parser& sym, Str const& str)
|
||||
{
|
||||
return sym.add(str);
|
||||
}
|
||||
|
||||
template <typename Str>
|
||||
friend remover const&
|
||||
operator-=(symbols_parser& sym, Str const& str)
|
||||
{
|
||||
return sym.remove(str);
|
||||
}
|
||||
|
||||
template <typename F>
|
||||
void for_each(F f) const
|
||||
{
|
||||
lookup->for_each(f);
|
||||
}
|
||||
|
||||
template <typename Str>
|
||||
value_type& at(Str const& str)
|
||||
{
|
||||
return *lookup->add(traits::get_string_begin<char_type>(str)
|
||||
, traits::get_string_end<char_type>(str), T());
|
||||
}
|
||||
|
||||
template <typename Iterator>
|
||||
value_type* prefix_find(Iterator& first, Iterator const& last)
|
||||
{
|
||||
return lookup->find(first, last, case_compare<Encoding>());
|
||||
}
|
||||
|
||||
template <typename Iterator>
|
||||
value_type const* prefix_find(Iterator& first, Iterator const& last) const
|
||||
{
|
||||
return lookup->find(first, last, case_compare<Encoding>());
|
||||
}
|
||||
|
||||
template <typename Str>
|
||||
value_type* find(Str const& str)
|
||||
{
|
||||
return find_impl(traits::get_string_begin<char_type>(str)
|
||||
, traits::get_string_end<char_type>(str));
|
||||
}
|
||||
|
||||
template <typename Str>
|
||||
value_type const* find(Str const& str) const
|
||||
{
|
||||
return find_impl(traits::get_string_begin<char_type>(str)
|
||||
, traits::get_string_end<char_type>(str));
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
template <typename Iterator>
|
||||
value_type* find_impl(Iterator begin, Iterator end)
|
||||
{
|
||||
value_type* r = lookup->find(begin, end, case_compare<Encoding>());
|
||||
return begin == end ? r : 0;
|
||||
}
|
||||
|
||||
template <typename Iterator>
|
||||
value_type const* find_impl(Iterator begin, Iterator end) const
|
||||
{
|
||||
value_type const* r = lookup->find(begin, end, case_compare<Encoding>());
|
||||
return begin == end ? r : 0;
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
template <typename Iterator, typename Context, typename Attribute>
|
||||
bool parse(Iterator& first, Iterator const& last
|
||||
, Context const& context, unused_type, Attribute& attr) const
|
||||
{
|
||||
x3::skip_over(first, last, context);
|
||||
|
||||
if (value_type const* val_ptr
|
||||
= lookup->find(first, last, get_case_compare<Encoding>(context)))
|
||||
{
|
||||
x3::traits::move_to(*val_ptr, attr);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void name(std::string const &str)
|
||||
{
|
||||
name_ = str;
|
||||
}
|
||||
std::string const &name() const
|
||||
{
|
||||
return name_;
|
||||
}
|
||||
|
||||
struct adder
|
||||
{
|
||||
template <typename, typename = unused_type, typename = unused_type>
|
||||
struct result { typedef adder const& type; };
|
||||
|
||||
adder(symbols_parser& sym)
|
||||
: sym(sym)
|
||||
{
|
||||
}
|
||||
|
||||
template <typename Iterator>
|
||||
adder const&
|
||||
operator()(Iterator first, Iterator last, T const& val) const
|
||||
{
|
||||
sym.lookup->add(first, last, val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename Str>
|
||||
adder const&
|
||||
operator()(Str const& s, T const& val = T()) const
|
||||
{
|
||||
sym.lookup->add(traits::get_string_begin<char_type>(s)
|
||||
, traits::get_string_end<char_type>(s), val);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename Str>
|
||||
adder const&
|
||||
operator,(Str const& s) const
|
||||
{
|
||||
sym.lookup->add(traits::get_string_begin<char_type>(s)
|
||||
, traits::get_string_end<char_type>(s), T());
|
||||
return *this;
|
||||
}
|
||||
|
||||
symbols_parser& sym;
|
||||
};
|
||||
|
||||
struct remover
|
||||
{
|
||||
template <typename, typename = unused_type, typename = unused_type>
|
||||
struct result { typedef remover const& type; };
|
||||
|
||||
remover(symbols_parser& sym)
|
||||
: sym(sym)
|
||||
{
|
||||
}
|
||||
|
||||
template <typename Iterator>
|
||||
remover const&
|
||||
operator()(Iterator const& first, Iterator const& last) const
|
||||
{
|
||||
sym.lookup->remove(first, last);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename Str>
|
||||
remover const&
|
||||
operator()(Str const& s) const
|
||||
{
|
||||
sym.lookup->remove(traits::get_string_begin<char_type>(s)
|
||||
, traits::get_string_end<char_type>(s));
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename Str>
|
||||
remover const&
|
||||
operator,(Str const& s) const
|
||||
{
|
||||
sym.lookup->remove(traits::get_string_begin<char_type>(s)
|
||||
, traits::get_string_end<char_type>(s));
|
||||
return *this;
|
||||
}
|
||||
|
||||
symbols_parser& sym;
|
||||
};
|
||||
|
||||
adder add;
|
||||
remover remove;
|
||||
shared_ptr<Lookup> lookup;
|
||||
std::string name_;
|
||||
};
|
||||
|
||||
template <typename Encoding, typename T, typename Lookup>
|
||||
struct get_info<symbols_parser<Encoding, T, Lookup>>
|
||||
{
|
||||
typedef std::string result_type;
|
||||
result_type operator()(symbols_parser< Encoding, T
|
||||
, Lookup
|
||||
> const& symbols) const
|
||||
{
|
||||
return symbols.name();
|
||||
}
|
||||
};
|
||||
|
||||
namespace standard
|
||||
{
|
||||
template <typename T = unused_type>
|
||||
using symbols = symbols_parser<char_encoding::standard, T>;
|
||||
}
|
||||
|
||||
using standard::symbols;
|
||||
|
||||
namespace standard_wide
|
||||
{
|
||||
template <typename T = unused_type>
|
||||
using symbols = symbols_parser<char_encoding::standard_wide, T>;
|
||||
}
|
||||
|
||||
namespace ascii
|
||||
{
|
||||
template <typename T = unused_type>
|
||||
using symbols = symbols_parser<char_encoding::ascii, T>;
|
||||
}
|
||||
|
||||
namespace iso8859_1
|
||||
{
|
||||
template <typename T = unused_type>
|
||||
using symbols = symbols_parser<char_encoding::iso8859_1, T>;
|
||||
}
|
||||
|
||||
}}}
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,133 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2014 Joel de Guzman
|
||||
|
||||
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(BOOST_SPIRIT_X3_TST_JUNE_03_2007_1031AM)
|
||||
#define BOOST_SPIRIT_X3_TST_JUNE_03_2007_1031AM
|
||||
|
||||
#include <boost/spirit/home/x3/string/detail/tst.hpp>
|
||||
|
||||
namespace boost { namespace spirit { namespace x3
|
||||
{
|
||||
struct tst_pass_through
|
||||
{
|
||||
template <typename Char>
|
||||
Char operator()(Char ch) const
|
||||
{
|
||||
return ch;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Char, typename T>
|
||||
struct tst
|
||||
{
|
||||
typedef Char char_type; // the character type
|
||||
typedef T value_type; // the value associated with each entry
|
||||
typedef detail::tst_node<Char, T> node;
|
||||
|
||||
tst()
|
||||
: root(0)
|
||||
{
|
||||
}
|
||||
|
||||
~tst()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
|
||||
tst(tst const& rhs)
|
||||
: root(0)
|
||||
{
|
||||
copy(rhs);
|
||||
}
|
||||
|
||||
tst& operator=(tst const& rhs)
|
||||
{
|
||||
return assign(rhs);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename CaseCompare>
|
||||
T* find(Iterator& first, Iterator last, CaseCompare caseCompare) const
|
||||
{
|
||||
return node::find(root, first, last, caseCompare);
|
||||
}
|
||||
|
||||
/*template <typename Iterator>
|
||||
T* find(Iterator& first, Iterator last) const
|
||||
{
|
||||
return find(first, last, case_compare<tst_pass_through());
|
||||
}*/
|
||||
|
||||
template <typename Iterator>
|
||||
T* add(
|
||||
Iterator first
|
||||
, Iterator last
|
||||
, typename boost::call_traits<T>::param_type val)
|
||||
{
|
||||
return node::add(root, first, last, val, this);
|
||||
}
|
||||
|
||||
template <typename Iterator>
|
||||
void remove(Iterator first, Iterator last)
|
||||
{
|
||||
node::remove(root, first, last, this);
|
||||
}
|
||||
|
||||
void clear()
|
||||
{
|
||||
node::destruct_node(root, this);
|
||||
root = 0;
|
||||
}
|
||||
|
||||
template <typename F>
|
||||
void for_each(F f) const
|
||||
{
|
||||
node::for_each(root, std::basic_string<Char>(), f);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
friend struct detail::tst_node<Char, T>;
|
||||
|
||||
void copy(tst const& rhs)
|
||||
{
|
||||
root = node::clone_node(rhs.root, this);
|
||||
}
|
||||
|
||||
tst& assign(tst const& rhs)
|
||||
{
|
||||
if (this != &rhs)
|
||||
{
|
||||
clear();
|
||||
copy(rhs);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
node* root;
|
||||
|
||||
node* new_node(Char id)
|
||||
{
|
||||
return new node(id);
|
||||
}
|
||||
|
||||
T* new_data(typename boost::call_traits<T>::param_type val)
|
||||
{
|
||||
return new T(val);
|
||||
}
|
||||
|
||||
void delete_node(node* p)
|
||||
{
|
||||
delete p;
|
||||
}
|
||||
|
||||
void delete_data(T* p)
|
||||
{
|
||||
delete p;
|
||||
}
|
||||
};
|
||||
}}}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,212 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2014 Joel de Guzman
|
||||
|
||||
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(BOOST_SPIRIT_X3_TST_MAP_JUNE_03_2007_1143AM)
|
||||
#define BOOST_SPIRIT_X3_TST_MAP_JUNE_03_2007_1143AM
|
||||
|
||||
#include <boost/spirit/home/x3/string/detail/tst.hpp>
|
||||
#include <unordered_map>
|
||||
#include <boost/pool/object_pool.hpp>
|
||||
|
||||
namespace boost { namespace spirit { namespace x3
|
||||
{
|
||||
struct tst_pass_through; // declared in tst.hpp
|
||||
|
||||
template <typename Char, typename T>
|
||||
struct tst_map
|
||||
{
|
||||
typedef Char char_type; // the character type
|
||||
typedef T value_type; // the value associated with each entry
|
||||
typedef detail::tst_node<Char, T> node;
|
||||
|
||||
tst_map()
|
||||
{
|
||||
}
|
||||
|
||||
~tst_map()
|
||||
{
|
||||
// Nothing to do here.
|
||||
// The pools do the right thing for us
|
||||
}
|
||||
|
||||
tst_map(tst_map const& rhs)
|
||||
{
|
||||
copy(rhs);
|
||||
}
|
||||
|
||||
tst_map& operator=(tst_map const& rhs)
|
||||
{
|
||||
return assign(rhs);
|
||||
}
|
||||
|
||||
template <typename Iterator, typename Filter>
|
||||
T* find(Iterator& first, Iterator last, Filter filter) const
|
||||
{
|
||||
if (first != last)
|
||||
{
|
||||
Iterator save = first;
|
||||
typename map_type::const_iterator
|
||||
i = map.find(filter(*first++));
|
||||
if (i == map.end())
|
||||
{
|
||||
first = save;
|
||||
return 0;
|
||||
}
|
||||
if (T* p = node::find(i->second.root, first, last, filter))
|
||||
{
|
||||
return p;
|
||||
}
|
||||
return i->second.data;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
template <typename Iterator>
|
||||
T* find(Iterator& first, Iterator last) const
|
||||
{
|
||||
return find(first, last, tst_pass_through());
|
||||
}
|
||||
|
||||
template <typename Iterator>
|
||||
bool add(
|
||||
Iterator first
|
||||
, Iterator last
|
||||
, typename boost::call_traits<T>::param_type val)
|
||||
{
|
||||
if (first != last)
|
||||
{
|
||||
map_data x = {0, 0};
|
||||
std::pair<typename map_type::iterator, bool>
|
||||
r = map.insert(std::pair<Char, map_data>(*first++, x));
|
||||
|
||||
if (first != last)
|
||||
{
|
||||
return node::add(r.first->second.root
|
||||
, first, last, val, this) ? true : false;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (r.first->second.data)
|
||||
return false;
|
||||
r.first->second.data = this->new_data(val);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
template <typename Iterator>
|
||||
void remove(Iterator first, Iterator last)
|
||||
{
|
||||
if (first != last)
|
||||
{
|
||||
typename map_type::iterator i = map.find(*first++);
|
||||
if (i != map.end())
|
||||
{
|
||||
if (first != last)
|
||||
{
|
||||
node::remove(i->second.root, first, last, this);
|
||||
}
|
||||
else if (i->second.data)
|
||||
{
|
||||
this->delete_data(i->second.data);
|
||||
i->second.data = 0;
|
||||
}
|
||||
if (i->second.data == 0 && i->second.root == 0)
|
||||
{
|
||||
map.erase(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void clear()
|
||||
{
|
||||
for (typename map_type::value_type& x : map)
|
||||
{
|
||||
node::destruct_node(x.second.root, this);
|
||||
if (x.second.data)
|
||||
this->delete_data(x.second.data);
|
||||
}
|
||||
map.clear();
|
||||
}
|
||||
|
||||
template <typename F>
|
||||
void for_each(F f) const
|
||||
{
|
||||
for (typename map_type::value_type const& x : map)
|
||||
{
|
||||
std::basic_string<Char> s(1, x.first);
|
||||
node::for_each(x.second.root, s, f);
|
||||
if (x.second.data)
|
||||
f(s, *x.second.data);
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
friend struct detail::tst_node<Char, T>;
|
||||
|
||||
struct map_data
|
||||
{
|
||||
node* root;
|
||||
T* data;
|
||||
};
|
||||
|
||||
typedef std::unordered_map<Char, map_data> map_type;
|
||||
|
||||
void copy(tst_map const& rhs)
|
||||
{
|
||||
for (typename map_type::value_type const& x : rhs.map)
|
||||
{
|
||||
map_data xx = {node::clone_node(x.second.root, this), 0};
|
||||
if (x.second.data)
|
||||
xx.data = data_pool.construct(*x.second.data);
|
||||
map[x.first] = xx;
|
||||
}
|
||||
}
|
||||
|
||||
tst_map& assign(tst_map const& rhs)
|
||||
{
|
||||
if (this != &rhs)
|
||||
{
|
||||
for (typename map_type::value_type& x : map)
|
||||
{
|
||||
node::destruct_node(x.second.root, this);
|
||||
}
|
||||
map.clear();
|
||||
copy(rhs);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
node* new_node(Char id)
|
||||
{
|
||||
return node_pool.construct(id);
|
||||
}
|
||||
|
||||
T* new_data(typename boost::call_traits<T>::param_type val)
|
||||
{
|
||||
return data_pool.construct(val);
|
||||
}
|
||||
|
||||
void delete_node(node* p)
|
||||
{
|
||||
node_pool.destroy(p);
|
||||
}
|
||||
|
||||
void delete_data(T* p)
|
||||
{
|
||||
data_pool.destroy(p);
|
||||
}
|
||||
|
||||
map_type map;
|
||||
object_pool<node> node_pool;
|
||||
object_pool<T> data_pool;
|
||||
};
|
||||
}}}
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user