stabilize build system: depends, installer, boost/bdb fixes, cross targets groundwork
This commit is contained in:
+118
@@ -0,0 +1,118 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2003 Joel de Guzman
|
||||
http://spirit.sourceforge.net/
|
||||
|
||||
Use, modification and distribution is subject to 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)
|
||||
=============================================================================*/
|
||||
#ifndef BOOST_SPIRIT_SYMBOLS_IPP
|
||||
#define BOOST_SPIRIT_SYMBOLS_IPP
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
#include <boost/spirit/home/classic/symbols/impl/tst.ipp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
// MSVC: void warning about the use of 'this' pointer in constructors
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable : 4355)
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
namespace boost { namespace spirit {
|
||||
|
||||
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// symbols class implementation
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
template <typename T, typename CharT, typename SetT>
|
||||
inline symbols<T, CharT, SetT>::symbols()
|
||||
: SetT()
|
||||
, add(*this)
|
||||
{
|
||||
}
|
||||
|
||||
//////////////////////////////////
|
||||
template <typename T, typename CharT, typename SetT>
|
||||
symbols<T, CharT, SetT>::symbols(symbols const& other)
|
||||
: SetT(other)
|
||||
// Tru64 CXX seems to be confused by the explicit call of the default
|
||||
// constructor and generates wrong code which invalidates the just contructed
|
||||
// first base class in the line above.
|
||||
#if !BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590041))
|
||||
, parser<symbols<T, CharT, SetT> >()
|
||||
#endif
|
||||
, add(*this)
|
||||
{
|
||||
}
|
||||
|
||||
//////////////////////////////////
|
||||
template <typename T, typename CharT, typename SetT>
|
||||
inline symbols<T, CharT, SetT>::~symbols()
|
||||
{}
|
||||
|
||||
//////////////////////////////////
|
||||
template <typename T, typename CharT, typename SetT>
|
||||
inline symbols<T, CharT, SetT>&
|
||||
symbols<T, CharT, SetT>::operator=(symbols const& other)
|
||||
{
|
||||
SetT::operator=(other);
|
||||
return *this;
|
||||
}
|
||||
|
||||
//////////////////////////////////
|
||||
template <typename T, typename CharT, typename SetT>
|
||||
inline symbol_inserter<T, SetT> const&
|
||||
symbols<T, CharT, SetT>::operator=(CharT const* str)
|
||||
{
|
||||
return add, str;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Symbol table utilities
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
template <typename T, typename CharT, typename SetT>
|
||||
inline T*
|
||||
find(symbols<T, CharT, SetT> const& table, CharT const* sym)
|
||||
{
|
||||
CharT const* last = sym;
|
||||
while (*last)
|
||||
last++;
|
||||
scanner<CharT const *> scan(sym, last);
|
||||
T* result = table.find(scan);
|
||||
return scan.at_end()? result: 0;
|
||||
}
|
||||
|
||||
//////////////////////////////////
|
||||
template <typename T, typename CharT, typename SetT>
|
||||
inline T*
|
||||
add(symbols<T, CharT, SetT>& table, CharT const* sym, T const& data)
|
||||
{
|
||||
CharT const* first = sym;
|
||||
CharT const* last = sym;
|
||||
while (*last)
|
||||
last++;
|
||||
scanner<CharT const *> scan(first, last);
|
||||
if (table.find(scan) && scan.at_end())
|
||||
return 0; // symbol already contained in symbol table
|
||||
table.add(sym, last, data);
|
||||
first = sym;
|
||||
return table.find(scan); // refind the inserted symbol
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
BOOST_SPIRIT_CLASSIC_NAMESPACE_END
|
||||
|
||||
}} // namespace boost::spirit
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,281 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2003 Joel de Guzman
|
||||
http://spirit.sourceforge.net/
|
||||
|
||||
Use, modification and distribution is subject to 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)
|
||||
=============================================================================*/
|
||||
#ifndef BOOST_SPIRIT_TST_IPP
|
||||
#define BOOST_SPIRIT_TST_IPP
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
#include <memory> // for std::auto_ptr
|
||||
#include <boost/spirit/home/classic/core/assert.hpp>
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
namespace boost { namespace spirit {
|
||||
|
||||
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
|
||||
|
||||
namespace impl
|
||||
{
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// tst class
|
||||
//
|
||||
// Ternary Search Tree implementation. The data structure is faster than
|
||||
// hashing for many typical search problems especially when the search
|
||||
// interface is iterator based. Searching for a string of length k in a
|
||||
// ternary search tree with n strings will require at most O(log n+k)
|
||||
// character comparisons. TSTs are many times faster than hash tables
|
||||
// for unsuccessful searches since mismatches are discovered earlier
|
||||
// after examining only a few characters. Hash tables always examine an
|
||||
// entire key when searching.
|
||||
//
|
||||
// For details see http://www.cs.princeton.edu/~rs/strings/.
|
||||
//
|
||||
// *** This is a low level class and is
|
||||
// not meant for public consumption ***
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
template <typename T, typename CharT>
|
||||
struct tst_node
|
||||
{
|
||||
tst_node(CharT value_)
|
||||
: value(value_)
|
||||
, left(0)
|
||||
, right(0)
|
||||
{ middle.link = 0; }
|
||||
|
||||
~tst_node()
|
||||
{
|
||||
delete left;
|
||||
delete right;
|
||||
if (value)
|
||||
delete middle.link;
|
||||
else
|
||||
delete middle.data;
|
||||
}
|
||||
|
||||
tst_node*
|
||||
clone() const
|
||||
{
|
||||
std::auto_ptr<tst_node> copy(new tst_node(value));
|
||||
|
||||
if (left)
|
||||
copy->left = left->clone();
|
||||
if (right)
|
||||
copy->right = right->clone();
|
||||
|
||||
if (value && middle.link)
|
||||
{
|
||||
copy->middle.link = middle.link->clone();
|
||||
}
|
||||
else
|
||||
{
|
||||
std::auto_ptr<T> mid_data(new T(*middle.data));
|
||||
copy->middle.data = mid_data.release();
|
||||
}
|
||||
|
||||
return copy.release();
|
||||
}
|
||||
|
||||
union center {
|
||||
|
||||
tst_node* link;
|
||||
T* data;
|
||||
};
|
||||
|
||||
CharT value;
|
||||
tst_node* left;
|
||||
center middle;
|
||||
tst_node* right;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
template <typename T, typename CharT>
|
||||
class tst
|
||||
{
|
||||
public:
|
||||
|
||||
struct search_info
|
||||
{
|
||||
T* data;
|
||||
std::size_t length;
|
||||
};
|
||||
|
||||
tst()
|
||||
: root(0) {}
|
||||
|
||||
tst(tst const& other)
|
||||
: root(other.root ? other.root->clone() : 0) {}
|
||||
|
||||
~tst()
|
||||
{ delete root; }
|
||||
|
||||
tst&
|
||||
operator=(tst const& other)
|
||||
{
|
||||
if (this != &other)
|
||||
{
|
||||
node_t* new_root = other.root ? other.root->clone() : 0;
|
||||
delete root;
|
||||
root = new_root;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename IteratorT>
|
||||
T* add(IteratorT first, IteratorT const& last, T const& data)
|
||||
{
|
||||
if (first == last)
|
||||
return 0;
|
||||
|
||||
node_t** np = &root;
|
||||
CharT ch = *first;
|
||||
|
||||
BOOST_SPIRIT_ASSERT((first == last || ch != 0)
|
||||
&& "Won't add string containing null character");
|
||||
|
||||
for (;;)
|
||||
{
|
||||
if (*np == 0 || ch == 0)
|
||||
{
|
||||
node_t* right = 0;
|
||||
if (np != 0)
|
||||
right = *np;
|
||||
*np = new node_t(ch);
|
||||
if (right)
|
||||
(**np).right = right;
|
||||
}
|
||||
|
||||
if (ch < (**np).value)
|
||||
{
|
||||
np = &(**np).left;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (ch == (**np).value)
|
||||
{
|
||||
if (ch == 0)
|
||||
{
|
||||
if ((**np).middle.data == 0)
|
||||
{
|
||||
(**np).middle.data = new T(data);
|
||||
return (**np).middle.data;
|
||||
}
|
||||
else
|
||||
{
|
||||
// re-addition is disallowed
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
++first;
|
||||
ch = (first == last) ? CharT(0) : *first;
|
||||
BOOST_SPIRIT_ASSERT((first == last || ch != 0)
|
||||
&& "Won't add string containing null character");
|
||||
np = &(**np).middle.link;
|
||||
}
|
||||
else
|
||||
{
|
||||
np = &(**np).right;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template <typename ScannerT>
|
||||
search_info find(ScannerT const& scan) const
|
||||
{
|
||||
search_info result = { 0, 0 };
|
||||
if (scan.at_end()) {
|
||||
return result;
|
||||
}
|
||||
|
||||
typedef typename ScannerT::iterator_t iterator_t;
|
||||
node_t* np = root;
|
||||
CharT ch = *scan;
|
||||
iterator_t save = scan.first;
|
||||
iterator_t latest = scan.first;
|
||||
std::size_t latest_len = 0;
|
||||
|
||||
while (np)
|
||||
{
|
||||
|
||||
if (ch < np->value) // => go left!
|
||||
{
|
||||
if (np->value == 0)
|
||||
{
|
||||
result.data = np->middle.data;
|
||||
if (result.data)
|
||||
{
|
||||
latest = scan.first;
|
||||
latest_len = result.length;
|
||||
}
|
||||
}
|
||||
|
||||
np = np->left;
|
||||
}
|
||||
else if (ch == np->value) // => go middle!
|
||||
{
|
||||
// Matching the null character is not allowed.
|
||||
if (np->value == 0)
|
||||
{
|
||||
result.data = np->middle.data;
|
||||
if (result.data)
|
||||
{
|
||||
latest = scan.first;
|
||||
latest_len = result.length;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
++scan;
|
||||
ch = scan.at_end() ? CharT(0) : *scan;
|
||||
np = np->middle.link;
|
||||
++result.length;
|
||||
}
|
||||
else // (ch > np->value) => go right!
|
||||
{
|
||||
if (np->value == 0)
|
||||
{
|
||||
result.data = np->middle.data;
|
||||
if (result.data)
|
||||
{
|
||||
latest = scan.first;
|
||||
latest_len = result.length;
|
||||
}
|
||||
}
|
||||
|
||||
np = np->right;
|
||||
}
|
||||
}
|
||||
|
||||
if (result.data == 0)
|
||||
{
|
||||
scan.first = save;
|
||||
}
|
||||
else
|
||||
{
|
||||
scan.first = latest;
|
||||
result.length = latest_len;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
typedef tst_node<T, CharT> node_t;
|
||||
node_t* root;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
} // namespace impl
|
||||
|
||||
BOOST_SPIRIT_CLASSIC_NAMESPACE_END
|
||||
|
||||
}} // namespace boost::spirit
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,229 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2003 Joel de Guzman
|
||||
http://spirit.sourceforge.net/
|
||||
|
||||
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)
|
||||
=============================================================================*/
|
||||
#ifndef BOOST_SPIRIT_SYMBOLS_HPP
|
||||
#define BOOST_SPIRIT_SYMBOLS_HPP
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
#include <string>
|
||||
|
||||
#include <boost/ref.hpp>
|
||||
|
||||
#include <boost/spirit/home/classic/namespace.hpp>
|
||||
#include <boost/spirit/home/classic/core/parser.hpp>
|
||||
#include <boost/spirit/home/classic/core/composite/directives.hpp>
|
||||
|
||||
#include <boost/spirit/home/classic/symbols/symbols_fwd.hpp>
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
namespace boost { namespace spirit {
|
||||
|
||||
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// symbols class
|
||||
//
|
||||
// This class implements a symbol table. The symbol table holds a
|
||||
// dictionary of symbols where each symbol is a sequence of CharTs.
|
||||
// The template class can work efficiently with 8, 16 and 32 bit
|
||||
// characters. Mutable data of type T is associated with each
|
||||
// symbol.
|
||||
//
|
||||
// The class is a parser. The parse member function returns
|
||||
// additional information in the symbol_match class (see below).
|
||||
// The additional data is a pointer to some data associated with
|
||||
// the matching symbol.
|
||||
//
|
||||
// The actual set implementation is supplied by the SetT template
|
||||
// parameter. By default, this uses the tst class (see tst.ipp).
|
||||
//
|
||||
// Symbols are added into the symbol table statically using the
|
||||
// construct:
|
||||
//
|
||||
// sym = a, b, c, d ...;
|
||||
//
|
||||
// where sym is a symbol table and a..d are strings. Example:
|
||||
//
|
||||
// sym = "pineapple", "orange", "banana", "apple";
|
||||
//
|
||||
// Alternatively, symbols may be added dynamically through the
|
||||
// member functor 'add' (see symbol_inserter below). The member
|
||||
// functor 'add' may be attached to a parser as a semantic action
|
||||
// taking in a begin/end pair:
|
||||
//
|
||||
// p[sym.add]
|
||||
//
|
||||
// where p is a parser (and sym is a symbol table). On success,
|
||||
// the matching portion of the input is added to the symbol table.
|
||||
//
|
||||
// 'add' may also be used to directly initialize data. Examples:
|
||||
//
|
||||
// sym.add("hello", 1)("crazy", 2)("world", 3);
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
template <typename T, typename CharT, typename SetT>
|
||||
class symbols
|
||||
: private SetT
|
||||
, public parser<symbols<T, CharT, SetT> >
|
||||
{
|
||||
public:
|
||||
|
||||
typedef parser<symbols<T, CharT, SetT> > parser_base_t;
|
||||
typedef symbols<T, CharT, SetT> self_t;
|
||||
typedef self_t const& embed_t;
|
||||
typedef T symbol_data_t;
|
||||
typedef boost::reference_wrapper<T> symbol_ref_t;
|
||||
|
||||
symbols();
|
||||
symbols(symbols const& other);
|
||||
~symbols();
|
||||
|
||||
symbols&
|
||||
operator=(symbols const& other);
|
||||
|
||||
symbol_inserter<T, SetT> const&
|
||||
operator=(CharT const* str);
|
||||
|
||||
template <typename ScannerT>
|
||||
struct result
|
||||
{
|
||||
typedef typename match_result<ScannerT, symbol_ref_t>::type type;
|
||||
};
|
||||
|
||||
template <typename ScannerT>
|
||||
typename parser_result<self_t, ScannerT>::type
|
||||
parse_main(ScannerT const& scan) const
|
||||
{
|
||||
typedef typename ScannerT::iterator_t iterator_t;
|
||||
iterator_t first = scan.first;
|
||||
typename SetT::search_info result = SetT::find(scan);
|
||||
|
||||
if (result.data)
|
||||
return scan.
|
||||
create_match(
|
||||
result.length,
|
||||
symbol_ref_t(*result.data),
|
||||
first,
|
||||
scan.first);
|
||||
else
|
||||
return scan.no_match();
|
||||
}
|
||||
|
||||
template <typename ScannerT>
|
||||
typename parser_result<self_t, ScannerT>::type
|
||||
parse(ScannerT const& scan) const
|
||||
{
|
||||
typedef typename parser_result<self_t, ScannerT>::type result_t;
|
||||
return impl::implicit_lexeme_parse<result_t>
|
||||
(*this, scan, scan);
|
||||
}
|
||||
|
||||
template < typename ScannerT >
|
||||
T* find(ScannerT const& scan) const
|
||||
{ return SetT::find(scan).data; }
|
||||
|
||||
symbol_inserter<T, SetT> const add;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Symbol table utilities
|
||||
//
|
||||
// add
|
||||
//
|
||||
// adds a symbol 'sym' (string) to a symbol table 'table' plus an
|
||||
// optional data 'data' associated with the symbol. Returns a pointer to
|
||||
// the data associated with the symbol or NULL if add failed (e.g. when
|
||||
// the symbol is already added before).
|
||||
//
|
||||
// find
|
||||
//
|
||||
// finds a symbol 'sym' (string) from a symbol table 'table'. Returns a
|
||||
// pointer to the data associated with the symbol or NULL if not found
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
template <typename T, typename CharT, typename SetT>
|
||||
T* add(symbols<T, CharT, SetT>& table, CharT const* sym, T const& data = T());
|
||||
|
||||
template <typename T, typename CharT, typename SetT>
|
||||
T* find(symbols<T, CharT, SetT> const& table, CharT const* sym);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// symbol_inserter class
|
||||
//
|
||||
// The symbols class holds an instance of this class named 'add'.
|
||||
// This can be called directly just like a member function,
|
||||
// passing in a first/last iterator and optional data:
|
||||
//
|
||||
// sym.add(first, last, data);
|
||||
//
|
||||
// Or, passing in a C string and optional data:
|
||||
//
|
||||
// sym.add(c_string, data);
|
||||
//
|
||||
// where sym is a symbol table. The 'data' argument is optional.
|
||||
// This may also be used as a semantic action since it conforms
|
||||
// to the action interface (see action.hpp):
|
||||
//
|
||||
// p[sym.add]
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
template <typename T, typename SetT>
|
||||
class symbol_inserter
|
||||
{
|
||||
public:
|
||||
|
||||
symbol_inserter(SetT& set_)
|
||||
: set(set_) {}
|
||||
|
||||
typedef symbol_inserter const & result_type;
|
||||
|
||||
template <typename IteratorT>
|
||||
symbol_inserter const&
|
||||
operator()(IteratorT first, IteratorT const& last, T const& data = T()) const
|
||||
{
|
||||
set.add(first, last, data);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
symbol_inserter const&
|
||||
operator()(CharT const* str, T const& data = T()) const
|
||||
{
|
||||
CharT const* last = str;
|
||||
while (*last)
|
||||
last++;
|
||||
set.add(str, last, data);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename CharT>
|
||||
symbol_inserter const&
|
||||
operator,(CharT const* str) const
|
||||
{
|
||||
CharT const* last = str;
|
||||
while (*last)
|
||||
last++;
|
||||
set.add(str, last, T());
|
||||
return *this;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
SetT& set;
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
BOOST_SPIRIT_CLASSIC_NAMESPACE_END
|
||||
|
||||
}} // namespace BOOST_SPIRIT_CLASSIC_NS
|
||||
|
||||
#include <boost/spirit/home/classic/symbols/impl/symbols.ipp>
|
||||
#endif
|
||||
@@ -0,0 +1,39 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2006 Tobias Schwinger
|
||||
http://spirit.sourceforge.net/
|
||||
|
||||
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_SYMBOLS_FWD_HPP)
|
||||
#define BOOST_SPIRIT_SYMBOLS_FWD_HPP
|
||||
|
||||
#include <boost/spirit/home/classic/namespace.hpp>
|
||||
|
||||
namespace boost { namespace spirit {
|
||||
|
||||
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
|
||||
|
||||
namespace impl
|
||||
{
|
||||
template <typename CharT, typename T>
|
||||
class tst;
|
||||
}
|
||||
|
||||
template
|
||||
<
|
||||
typename T = int,
|
||||
typename CharT = char,
|
||||
typename SetT = impl::tst<T, CharT>
|
||||
>
|
||||
class symbols;
|
||||
|
||||
template <typename T, typename SetT>
|
||||
class symbol_inserter;
|
||||
|
||||
BOOST_SPIRIT_CLASSIC_NAMESPACE_END
|
||||
|
||||
}} // namespace BOOST_SPIRIT_CLASSIC_NS
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,25 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2006 Tobias Schwinger
|
||||
http://spirit.sourceforge.net/
|
||||
|
||||
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_SYMBOLS_TYPEOF_HPP)
|
||||
#define BOOST_SPIRIT_SYMBOLS_TYPEOF_HPP
|
||||
|
||||
#include <boost/typeof/typeof.hpp>
|
||||
|
||||
#include <boost/spirit/home/classic/symbols/symbols_fwd.hpp>
|
||||
|
||||
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
|
||||
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(BOOST_SPIRIT_CLASSIC_NS::symbols,3)
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(BOOST_SPIRIT_CLASSIC_NS::symbol_inserter,2)
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(BOOST_SPIRIT_CLASSIC_NS::impl::tst,2)
|
||||
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(BOOST_SPIRIT_CLASSIC_NS::symbols,2)
|
||||
BOOST_TYPEOF_REGISTER_TEMPLATE(BOOST_SPIRIT_CLASSIC_NS::symbols,1)
|
||||
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user