boost/spirit
2
0
Fork 0
mirror of https://github.com/boostorg/spirit.git synced 2026-01-19 04:42:11 +00:00
Code Issues Projects Releases Wiki Activity

First commit from BOOST_REVIEW branch spirit.sf.net

Browse Source 
[SVN r17107]
This commit is contained in:
Joel de Guzman
2003-01-31 10:44:50 +00:00
commit 8190791653
109 changed files with 33148 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
.gitattributes vendored Normal file
View File

@@ -0,0 +1,96 @@
* text=auto !eol svneol=native#text/plain
*.gitattributes text svneol=native#text/plain
# Scriptish formats
*.bat text svneol=native#text/plain
*.bsh text svneol=native#text/x-beanshell
*.cgi text svneol=native#text/plain
*.cmd text svneol=native#text/plain
*.js text svneol=native#text/javascript
*.php text svneol=native#text/x-php
*.pl text svneol=native#text/x-perl
*.pm text svneol=native#text/x-perl
*.py text svneol=native#text/x-python
*.sh eol=lf svneol=LF#text/x-sh
configure eol=lf svneol=LF#text/x-sh
# Image formats
*.bmp binary svneol=unset#image/bmp
*.gif binary svneol=unset#image/gif
*.ico binary svneol=unset#image/ico
*.jpeg binary svneol=unset#image/jpeg
*.jpg binary svneol=unset#image/jpeg
*.png binary svneol=unset#image/png
*.tif binary svneol=unset#image/tiff
*.tiff binary svneol=unset#image/tiff
*.svg text svneol=native#image/svg%2Bxml
# Data formats
*.pdf binary svneol=unset#application/pdf
*.avi binary svneol=unset#video/avi
*.doc binary svneol=unset#application/msword
*.dsp text svneol=crlf#text/plain
*.dsw text svneol=crlf#text/plain
*.eps binary svneol=unset#application/postscript
*.gz binary svneol=unset#application/gzip
*.mov binary svneol=unset#video/quicktime
*.mp3 binary svneol=unset#audio/mpeg
*.ppt binary svneol=unset#application/vnd.ms-powerpoint
*.ps binary svneol=unset#application/postscript
*.psd binary svneol=unset#application/photoshop
*.rdf binary svneol=unset#text/rdf
*.rss text svneol=unset#text/xml
*.rtf binary svneol=unset#text/rtf
*.sln text svneol=native#text/plain
*.swf binary svneol=unset#application/x-shockwave-flash
*.tgz binary svneol=unset#application/gzip
*.vcproj text svneol=native#text/xml
*.vcxproj text svneol=native#text/xml
*.vsprops text svneol=native#text/xml
*.wav binary svneol=unset#audio/wav
*.xls binary svneol=unset#application/vnd.ms-excel
*.zip binary svneol=unset#application/zip
# Text formats
.htaccess text svneol=native#text/plain
*.bbk text svneol=native#text/xml
*.cmake text svneol=native#text/plain
*.css text svneol=native#text/css
*.dtd text svneol=native#text/xml
*.htm text svneol=native#text/html
*.html text svneol=native#text/html
*.ini text svneol=native#text/plain
*.log text svneol=native#text/plain
*.mak text svneol=native#text/plain
*.qbk text svneol=native#text/plain
*.rst text svneol=native#text/plain
*.sql text svneol=native#text/x-sql
*.txt text svneol=native#text/plain
*.xhtml text svneol=native#text/xhtml%2Bxml
*.xml text svneol=native#text/xml
*.xsd text svneol=native#text/xml
*.xsl text svneol=native#text/xml
*.xslt text svneol=native#text/xml
*.xul text svneol=native#text/xul
*.yml text svneol=native#text/plain
boost-no-inspect text svneol=native#text/plain
CHANGES text svneol=native#text/plain
COPYING text svneol=native#text/plain
INSTALL text svneol=native#text/plain
Jamfile text svneol=native#text/plain
Jamroot text svneol=native#text/plain
Jamfile.v2 text svneol=native#text/plain
Jamrules text svneol=native#text/plain
Makefile* text svneol=native#text/plain
README text svneol=native#text/plain
TODO text svneol=native#text/plain
# Code formats
*.c text svneol=native#text/plain
*.cpp text svneol=native#text/plain
*.h text svneol=native#text/plain
*.hpp text svneol=native#text/plain
*.ipp text svneol=native#text/plain
*.tpp text svneol=native#text/plain
*.jam text svneol=native#text/plain
*.java text svneol=native#text/plain

67
include/boost/spirit.hpp Normal file
View File

@@ -0,0 +1,67 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
Copyright (c) 2001-2003 Daniel Nuffer
Copyright (c) 2001-2003 Hartmut Kaiser
Copyright (c) 2002-2003 Martin Wille
Copyright (c) 2002 Juan Carlos Arevalo-Baeza
Copyright (c) 2002 Raghavendra Satish
Copyright (c) 2002 Jeff Westfahl
Copyright (c) 2001 Bruce Florman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(SPIRIT_HPP)
#define SPIRIT_HPP
#define SPIRIT_VERSION 0x1501
#define SPIRIT_PIZZA_VERSION PEPPERONI_PLUS // :-)
///////////////////////////////////////////////////////////////////////////////
//
// If SPIRIT_DEBUG is defined, the following header includes the
// Spirit.Debug layer, otherwise the non-debug Spirit.Core is included.
//
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/core.hpp"
///////////////////////////////////////////////////////////////////////////////
//
// Spirit.ErrorHandling
//
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/error_handling.hpp"
///////////////////////////////////////////////////////////////////////////////
//
// Spirit.Iterators
//
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/iterator.hpp"
///////////////////////////////////////////////////////////////////////////////
//
// Spirit.Symbols
//
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/symbols.hpp"
///////////////////////////////////////////////////////////////////////////////
//
// Spirit.Utilities
//
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/utility.hpp"
///////////////////////////////////////////////////////////////////////////////
//
// Spirit.Attributes
//
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/attribute.hpp"
#endif // !defined(SPIRIT_HPP)

4
include/boost/spirit/Makefile.am Normal file
View File

@@ -0,0 +1,4 @@
#This file generated by Makefileamgen.sh
SUBDIRS = tree core debug error_handling symbols utility attribute iterator
spiritinclude_HEADERS = attribute.hpp core.hpp debug.hpp error_handling.hpp iterator.hpp symbols.hpp utility.hpp
spiritincludedir = $(includedir)/spirit/boost/spirit

39
include/boost/spirit/attribute.hpp Normal file
View File

@@ -0,0 +1,39 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001-2003 Joel de Guzman
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_ATTRIBUTE_MAIN_HPP)
#define BOOST_SPIRIT_ATTRIBUTE_MAIN_HPP
///////////////////////////////////////////////////////////////////////////////
//
// Master header for Spirit.Attributes
//
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//
// Phoenix predefined maximum limit. This limit defines the maximum
// number of elements a tuple can hold. This number defaults to 3. The
// actual maximum is rounded up in multiples of 3. Thus, if this value
// is 4, the actual limit is 6. The ultimate maximum limit in this
// implementation is 15.
//
///////////////////////////////////////////////////////////////////////////////
#if !defined(PHOENIX_LIMIT)
#define PHOENIX_LIMIT 3
#endif // !defined(PHOENIX_LIMIT)
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/attribute/parametric.hpp"
#include "boost/spirit/attribute/closure.hpp"
#include "boost/spirit/attribute/grouping.hpp"
#endif // !defined(BOOST_SPIRIT_ATTRIBUTE_MAIN_HPP)

4
include/boost/spirit/attribute/Makefile.am Normal file
View File

@@ -0,0 +1,4 @@
#This file generated by Makefileamgen.sh
SUBDIRS = impl
spiritinclude_HEADERS = closure.hpp grouping.hpp parametric.hpp
spiritincludedir = $(includedir)/spirit/boost/spirit/attribute

1077
include/boost/spirit/attribute/closure.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

177
include/boost/spirit/attribute/grouping.hpp Normal file
View File

@@ -0,0 +1,177 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#ifndef BOOST_SPIRIT_GROUPING_HPP
#define BOOST_SPIRIT_GROUPING_HPP
#include <utility>
#include "boost/phoenix/tuples.hpp"
#include "boost/phoenix/tuple_helpers.hpp"
#include "boost/phoenix/functions.hpp"
#include "boost/spirit/core/parser.hpp"
#include "boost/spirit/attribute/impl/grouping.ipp"
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
//
// grouping_result class
//
// This type computer returnes the tuple type of a grouping parser.
//
///////////////////////////////////////////////////////////////////////////////
template <typename ParserT, typename ScannerT, typename CategoryT>
struct grouping_result {
typedef typename impl::tuple_result<CategoryT>
::template result<ParserT, ScannerT>::type type;
};
///////////////////////////////////////////////////////////////////////////////
//
// grouping_parser class
//
// The grouping parser template handles the composition of single parser
// results of a composite parser into one overall parser result, which
// can be used for accessing all the parser results from inside a single
// semantic action code attached to the grouping parser. For instance
//
// std::pair<double, double> c;
// group_d[real_p >> ',' >> real_p]
// [
// c = construct<std::pair<double, double> >(arg1, arg3)
// ]
//
// will parse two comma separated real numbers and assigns them after
// a successful match to the pair variable 'c'. As you can see, the
// result of the first real_p parser is accessible through the 'arg1'
// placeholder variable and the third parser result (the second real_p)
// is accessible through the 'arg3' placeholder variable.
//
// If a single parser does not return a result value (the corresponding
// match<> result contains nil_t as its value), a std::pair of iterators
// pointing to the begin and the end of the corresponding matched input
// sequence will be stored as the parser result. For instance
//
// std::string result_string;
// rule<> esc_string = *(c_escape_ch_p - '"');
// group_d[ch_p('"') >> esc_string >> '"']
// [
// result_string =
// construct<std::string>(first(arg2), second(arg2));
// ]
//
// will fill the return_string variable with the C style escaped character
// string, which was embedded into the '"'.
//
///////////////////////////////////////////////////////////////////////////////
struct grouping_parser_gen;
template <typename ParserT>
struct grouping_parser
: public unary<ParserT, parser<grouping_parser<ParserT> > >
{
typedef grouping_parser<ParserT> self_t;
typedef grouping_parser_gen parser_generator_t;
typedef unary_parser_category parser_category_t;
typedef unary<ParserT, parser<self_t> > base_t;
typedef typename ParserT::parser_category_t base_category_t;
template <typename ScannerT>
struct result
{
typedef
typename grouping_result<ParserT, ScannerT, base_category_t>::type
tuple_t;
typedef phoenix::unpack_tuple<tuple_t> attr_t;
typedef typename match_result<ScannerT, attr_t>::type type;
};
grouping_parser()
: base_t(ParserT()) {}
grouping_parser(ParserT const &p)
: base_t(p) {}
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
impl::grouped_parser<ParserT, ScannerT, self_t, base_category_t> p;
return p.parse(this->subject(), scan);
}
};
struct grouping_parser_gen {
template <typename ParserT>
struct result {
typedef grouping_parser<ParserT> type;
};
template <typename ParserT>
static grouping_parser<ParserT>
generate (parser<ParserT> const &p)
{
return grouping_parser<ParserT>(p.derived());
}
template <typename ParserT>
grouping_parser<ParserT>
operator[] (parser<ParserT> const &p) const
{
return grouping_parser<ParserT>(p.derived());
}
};
const grouping_parser_gen group_d = grouping_parser_gen();
///////////////////////////////////////////////////////////////////////////////
//
// first() and second() lazy access functions for accessing the .first and
// .second members of a std::pair as embedded into the grouping result tuple
// for parsers, not returning an explicit result.
//
///////////////////////////////////////////////////////////////////////////////
struct first_impl {
template <typename IteratorT>
struct result { typedef IteratorT type; };
template <typename IteratorT>
IteratorT operator()(std::pair<IteratorT, IteratorT> const &p) const
{ return p.first; }
};
struct second_impl {
template <typename IteratorT>
struct result { typedef IteratorT type; };
template <typename IteratorT>
IteratorT operator()(std::pair<IteratorT, IteratorT> const &p) const
{ return p.second; }
};
phoenix::function<first_impl> const first;
phoenix::function<second_impl> const second;
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif // BOOST_SPIRIT_GROUPING_HPP

3
include/boost/spirit/attribute/impl/Makefile.am Normal file
View File

@@ -0,0 +1,3 @@
#This file generated by Makefileamgen.sh
spiritinclude_HEADERS = grouping.ipp
spiritincludedir = $(includedir)/spirit/boost/spirit/attribute/impl

320
include/boost/spirit/attribute/impl/grouping.ipp Normal file
View File

@@ -0,0 +1,320 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#ifndef BOOST_SPIRIT_GROUPING_IPP
#define BOOST_SPIRIT_GROUPING_IPP
#include <boost/type_traits.hpp>
#include "boost/spirit/core/meta/traverse.hpp"
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
namespace impl
{
///////////////////////////////////////////////////////////////////////////////
//
// tuple_result type computer
//
// This template class returns the type of a tuple containing all the
// return values of all parsers, which compose a given parser.
//
// For all parser types except binary_category_parser type parsers the
// tuple_result template returnes the return type of a given parser
// wrapped into a tuple.
// For binary_parser_category type parsers the tuple_result template
// returnes a tuple, which containes the tuple members of the left
// subparser concatinated with the tuple members of right subparser.
//
///////////////////////////////////////////////////////////////////////////////
template <typename CategoryT>
struct tuple_result;
template <>
struct tuple_result<plain_parser_category> {
template <typename ParserT, typename ScannerT>
struct result {
// The type 'match_t' is the type of the match<> class returned by the
// parser under inspection.
typedef typename parser_result<ParserT, ScannerT>::type match_t;
// The type 'type' is the parser return type of the parser under
// inspection, converted to a corresponding tuple type.
// If the parser under inspection does not return any value, a std::pair
// containing the corresponding 'begin' and 'end' iterators pointing to
// the begin and the end of the matched input sequence is considered to
// be the parser result.
#if defined(__BORLANDC__) && __BORLANDC__ >= 0x561
enum {
value = ::boost::is_same<nil_t, typename match_t::attr_t>::value
};
#else
BOOST_STATIC_CONSTANT(int,
value = (::boost::is_same<nil_t, typename match_t::attr_t>::value));
#endif
typedef result self_t;
typedef typename ScannerT::iterator_t iterator_t;
typedef typename
if_t<bool_t<(self_t::value)>,
std::pair<iterator_t, iterator_t>,
typename match_t::attr_t
>::type
result_t;
typedef typename phoenix::make_tuple<result_t>::type type;
};
};
template <>
struct tuple_result<unary_parser_category> {
template <typename ParserT, typename ScannerT>
struct result {
typedef typename ParserT::subject_t subject_t;
typedef typename subject_t::parser_category_t subject_category_t;
typedef typename tuple_result<subject_category_t>
::template result<subject_t, ScannerT>::type subject_result_t;
// The type 'type' is the parser return type of the subject of the
// parser under inspection
typedef subject_result_t type;
};
};
template <>
struct tuple_result<action_parser_category> {
template <typename ParserT, typename ScannerT>
struct result {
typedef typename ParserT::subject_t subject_t;
typedef typename subject_t::parser_category_t subject_category_t;
typedef typename tuple_result<subject_category_t>
::template result<subject_t, ScannerT>::type subject_result_t;
// The type 'type' is the parser return type of the subject of the
// parser under inspection
typedef subject_result_t type;
};
};
template <>
struct tuple_result<binary_parser_category> {
template <typename ParserT, typename ScannerT>
struct result {
typedef typename ParserT::left_t left_t;
typedef typename ParserT::right_t right_t;
typedef typename left_t::parser_category_t left_category_t;
typedef typename right_t::parser_category_t right_category_t;
typedef typename tuple_result<left_category_t>
::template result<left_t, ScannerT>::type left_result_t;
typedef typename tuple_result<right_category_t>
::template result<right_t, ScannerT>::type right_result_t;
// The type 'type' is the concatenation of the two tuple types, returned
// by the left and right subparsers of the binary parser under inspection.
typedef
typename phoenix::concat_tuples<left_result_t, right_result_t>::type
type;
};
};
///////////////////////////////////////////////////////////////////////////////
//
// grouped_parser parse helper template
//
// The grouping should be done for binary_category type parsers only.
// All other parsers are left without any change.
//
///////////////////////////////////////////////////////////////////////////////
template <
typename ParserT, typename ScannerT, typename GroupingT,
typename CategoryT
>
struct grouped_parser
: public parser<grouped_parser<ParserT, ScannerT, GroupingT, CategoryT> > {
typedef CategoryT parser_category_t;
static typename parser_result<GroupingT, ScannerT>::type
parse (ParserT const &p, ScannerT const &scan)
{
return p.parse(scan);
}
};
///////////////////////////////////////////////////////////////////////////////
template <typename TupleT, int N>
class group_actor {
public:
group_actor (TupleT &tuple_) : t(tuple_) {}
template <typename T>
void operator() (T const &val) const
{
t[phoenix::tuple_index<N>()] = val;
}
template <typename IteratorT>
void operator()(IteratorT const &begin, IteratorT const &end) const
{
t[phoenix::tuple_index<N>()] = std::pair<IteratorT, IteratorT>(begin, end);
}
private:
mutable TupleT &t;
};
///////////////////////////////////////////////////////////////////////////////
//
// group_transform template
//
// The group_transform template is a metafunction, which is used during
// parser traversal of the composite parser to be grouped. It attaches an
// action parser to all leaf parsers (all plain_parser_category parsers),
// which in turn will assign the result of the leaf parser to the
// corresponding tuple member of the grouped parser result tuple.
//
///////////////////////////////////////////////////////////////////////////////
template <typename TransformT, typename TupleT>
class group_transform_plain_policy {
public:
group_transform_plain_policy(TupleT &tuple_) : t(tuple_) {}
template <typename ParserT, typename EnvT>
struct plain_result {
typedef group_actor<TupleT, (EnvT::index)> actor_t;
typedef action<ParserT, actor_t> type;
};
template <typename ParserT, typename EnvT>
typename parser_traversal_plain_result<TransformT, ParserT, EnvT>::type
generate_plain(ParserT const &parser_, EnvT const &env) const
{
typedef group_actor<TupleT, (EnvT::index)> actor_t;
return parser_[actor_t(t)];
}
private:
TupleT &t;
};
//////////////////////////////////
template <typename TransformT, typename TupleT>
struct group_transform_policies
: public group_transform_plain_policy<TransformT, TupleT>,
public unary_identity_policy<TransformT>,
public action_identity_policy<TransformT>,
public binary_identity_policy<TransformT>
{
group_transform_policies(TupleT &tuple_)
: group_transform_plain_policy<TransformT, TupleT>(tuple_) {}
};
//////////////////////////////////
template <typename TupleT>
struct group_transform
: public group_transform_policies<group_transform<TupleT>, TupleT> {
group_transform(TupleT &tuple_)
: group_transform_policies<group_transform<TupleT>, TupleT>(tuple_) {}
};
///////////////////////////////////////////////////////////////////////////////
//
// This template is the real workhorse behind the group_d generated parsers,
// if the parser to group is a binary parser.
//
// The main work this template does, is to attach a special actor as a
// semantic action recursivly to all leaf parsers of the original binary
// parser. This is done by the help of the post_order parser traversal
// algorithm. So during the parsing process every leaf parser calls the
// corresponding operator() functions of its respective actor, providing it
// with its parser result.
//
// The attached actors are constructed such, that they assign the parser
// result values to the corresponding member of the overall result tuple.
//
// The correct tuple member number is computed during the post_order parser
// traversal process such, that the leaf parsers are numbered from left to
// right. Such the most left leaf parser result is accessible as 'arg1' inside
// the sematic action code attached to the grouped parser, the second leaf
// parser result is accessible 'arg2' and so on.
//
// After a successful match this tuple value is feeded into the usual
// Spirit semantic action mechanics and the tuple members are available from
// inside the semantic action code attached to the grouped parser.
//
///////////////////////////////////////////////////////////////////////////////
template <typename ParserT, typename ScannerT, typename GroupingT>
struct grouped_parser<ParserT, ScannerT, GroupingT, binary_parser_category>
: public parser<
grouped_parser<ParserT, ScannerT, GroupingT, binary_parser_category> >
{
typedef typename parser_result<GroupingT, ScannerT>::type result_t;
typedef typename result_t::attr_t::tuple_t tuple_t;
typedef binary_parser_category parser_category_t;
typedef
grouped_parser<ParserT, ScannerT, GroupingT, binary_parser_category>
self_t;
typedef typename parser_result<ParserT, ScannerT>::type embedded_result_t;
// the resulting tuple should contain at least 2 elements
BOOST_STATIC_ASSERT(tuple_t::length >= 2);
result_t
parse (ParserT const &p, ScannerT const &scan) const
{
typename ScannerT::iterator_t save = scan.first;
embedded_result_t hit =
post_order::traverse(group_transform<tuple_t>(t), p).parse(scan);
if (hit) {
return scan.create_match(hit.length(),
phoenix::unpack_tuple<tuple_t>(t), save, scan.first);
}
return scan.no_match();
}
private:
mutable tuple_t t;
};
///////////////////////////////////////////////////////////////////////////////
} // namespace impl
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif // BOOST_SPIRIT_GROUPING_IPP

142
include/boost/spirit/attribute/parametric.hpp Normal file
View File

@@ -0,0 +1,142 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001-2003 Joel de Guzman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#ifndef BOOST_SPIRIT_PARAMETRIC_HPP
#define BOOST_SPIRIT_PARAMETRIC_HPP
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/core/parser.hpp"
#include "boost/spirit/core/composite/composite.hpp"
#include "boost/spirit/core/primitives/primitives.hpp"
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////
//
// f_chlit class [ functional version of chlit ]
//
///////////////////////////////////////////////////////////////////////////
template <typename ChGenT>
struct f_chlit : public char_parser<f_chlit<ChGenT> >
{
f_chlit(ChGenT chgen_)
: chgen(chgen_) {}
template <typename T>
bool test(T ch) const
{ return ch == chgen(); }
ChGenT chgen;
};
template <typename ChGenT>
inline f_chlit<ChGenT>
f_ch_p(ChGenT chgen)
{ return f_chlit<ChGenT>(chgen); }
///////////////////////////////////////////////////////////////////////////
//
// f_range class [ functional version of range ]
//
///////////////////////////////////////////////////////////////////////////
template <typename ChGenAT, typename ChGenBT>
struct f_range : public char_parser<f_range<ChGenAT, ChGenBT> >
{
f_range(ChGenAT first_, ChGenBT last_)
: first(first_), last(last_)
{}
template <typename T>
bool test(T ch) const
{
BOOST_SPIRIT_ASSERT(first() <= last());
return (ch >= first()) && (ch <= last());
}
ChGenAT first;
ChGenBT last;
};
template <typename ChGenAT, typename ChGenBT>
inline f_range<ChGenAT, ChGenBT>
f_range_p(ChGenAT first, ChGenBT last)
{ return f_range<ChGenAT, ChGenBT>(first, last); }
///////////////////////////////////////////////////////////////////////////
//
// f_chseq class [ functional version of chseq ]
//
///////////////////////////////////////////////////////////////////////////
template <typename IterGenAT, typename IterGenBT>
class f_chseq : public parser<f_chseq<IterGenAT, IterGenBT> >
{
public:
typedef f_chseq<IterGenAT, IterGenBT> self_t;
f_chseq(IterGenAT first_, IterGenBT last_)
: first(first_), last(last_) {}
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::string_parser_parse<result_t>(first(), last(), scan);
}
private:
IterGenAT first;
IterGenBT last;
};
template <typename IterGenAT, typename IterGenBT>
inline f_chseq<IterGenAT, IterGenBT>
f_chseq_p(IterGenAT first, IterGenBT last)
{ return f_chseq<IterGenAT, IterGenBT>(first, last); }
///////////////////////////////////////////////////////////////////////////
//
// f_strlit class [ functional version of strlit ]
//
///////////////////////////////////////////////////////////////////////////
template <typename IterGenAT, typename IterGenBT>
class f_strlit : public parser<f_strlit<IterGenAT, IterGenBT> >
{
public:
typedef f_strlit<IterGenAT, IterGenBT> self_t;
f_strlit(IterGenAT first, IterGenBT last)
: seq(first, last) {}
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::contiguous_parser_parse<result_t>
(seq, scan, scan);
}
private:
f_chseq<IterGenAT, IterGenBT> seq;
};
template <typename IterGenAT, typename IterGenBT>
inline f_strlit<IterGenAT, IterGenBT>
f_str_p(IterGenAT first, IterGenBT last)
{ return f_strlit<IterGenAT, IterGenBT>(first, last); }
}} // namespace boost::spirit
#endif

65
include/boost/spirit/core.hpp Normal file
View File

@@ -0,0 +1,65 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
Copyright (c) 2001-2003 Daniel Nuffer
Copyright (c) 2001-2003 Hartmut Kaiser
Copyright (c) 2002-2003 Martin Wille
Copyright (c) 2002 Raghavendra Satish
Copyright (c) 2001 Bruce Florman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_CORE_MAIN_HPP)
#define BOOST_SPIRIT_CORE_MAIN_HPP
#include "boost/spirit/debug.hpp"
///////////////////////////////////////////////////////////////////////////////
//
// Spirit.Core includes
//
///////////////////////////////////////////////////////////////////////////////
// Spirit.Core.Kernel
#include "boost/spirit/core/basics.hpp"
#include "boost/spirit/core/match.hpp"
#include "boost/spirit/core/parser.hpp"
// Spirit.Core.Primitives
#include "boost/spirit/core/primitives/primitives.hpp"
#include "boost/spirit/core/primitives/numerics.hpp"
// Spirit.Core.Meta
#include "boost/spirit/core/meta/fundamental.hpp"
#include "boost/spirit/core/meta/parser_traits.hpp"
#include "boost/spirit/core/meta/impl/parser_type.hpp"
#include "boost/spirit/core/meta/traverse.hpp"
// Spirit.Core.Scanner
#include "boost/spirit/core/scanner/scanner.hpp"
#include "boost/spirit/core/scanner/skipper.hpp"
// Spirit.Core.NonTerminal
#include "boost/spirit/core/non_terminal/subrule.hpp"
#include "boost/spirit/core/non_terminal/rule.hpp"
#include "boost/spirit/core/non_terminal/grammar.hpp"
// Spirit.Core.Composite
#include "boost/spirit/core/composite/actions.hpp"
#include "boost/spirit/core/composite/composite.hpp"
#include "boost/spirit/core/composite/directives.hpp"
#include "boost/spirit/core/composite/operators.hpp"
#include "boost/spirit/core/composite/epsilon.hpp"
#if defined(BOOST_SPIRIT_DEBUG)
//////////////////////////////////
#include "boost/spirit/debug/parser_names.hpp"
#endif // BOOST_SPIRIT_DEBUG
#endif // BOOST_SPIRIT_CORE_MAIN_HPP

4
include/boost/spirit/core/Makefile.am Normal file
View File

@@ -0,0 +1,4 @@
#This file generated by Makefileamgen.sh
SUBDIRS = impl composite meta non_terminal primitives scanner
spiritinclude_HEADERS = basics.hpp match.hpp parser.hpp
spiritincludedir = $(includedir)/spirit/boost/spirit/core

69
include/boost/spirit/core/basics.hpp Normal file
View File

@@ -0,0 +1,69 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001-2003 Joel de Guzman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_BASICS_HPP)
#define BOOST_SPIRIT_BASICS_HPP
#include <boost/config.hpp>
#include <boost/spirit/core/impl/basics.ipp>
#if defined(BOOST_MSVC) || defined(BOOST_INTEL_CXX_VERSION)
#include "boost/spirit/core/impl/msvc.hpp"
#endif
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
#define BOOST_SPIRIT_TYPENAME
#else
#define BOOST_SPIRIT_TYPENAME typename
#endif
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
struct nil_t {};
struct void_t {};
struct default_t {};
template <int N>
struct int_t { BOOST_STATIC_CONSTANT(int, value = N); };
template <bool C>
struct bool_t { BOOST_STATIC_CONSTANT(bool, value = C); };
typedef bool_t<true> true_t;
typedef bool_t<false> false_t;
///////////////////////////////////////////////////////////////////////////
//
// if_t selects type A or B depending on the condition C.
// If C is of type true_t, A is selected, otherwise B
//
///////////////////////////////////////////////////////////////////////////
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template <typename C, typename A, typename B>
struct if_t
{
typedef typename impl::chooser<C>::type chooser_t;
typedef typename chooser_t::template result<A, B>::type type;
};
#else
template <typename C, typename A, typename B>
struct if_t { typedef A type; };
template <typename A, typename B>
struct if_t<false_t, A, B> { typedef B type; };
#endif
}} // namespace boost::spirit
#endif

4
include/boost/spirit/core/composite/Makefile.am Normal file
View File

@@ -0,0 +1,4 @@
#This file generated by Makefileamgen.sh
SUBDIRS = impl
spiritinclude_HEADERS = actions.hpp composite.hpp directives.hpp operators.hpp
spiritincludedir = $(includedir)/spirit/boost/spirit/core/composite

299
include/boost/spirit/core/composite/actions.hpp Normal file
View File

@@ -0,0 +1,299 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#ifndef BOOST_SPIRIT_ACTIONS_HPP
#define BOOST_SPIRIT_ACTIONS_HPP
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include "boost/spirit/core/parser.hpp"
#include "boost/spirit/core/composite/composite.hpp"
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////
//
// action class
//
// The action class binds a parser with a user defined semantic
// action. Instances of action are never created manually. Instead,
// action objects are typically created indirectly through
// expression templates of the form:
//
// p[f]
//
// where p is a parser and f is a function or functor. The semantic
// action may be a function or a functor. When the parser is
// successful, the actor calls the scanner's action_policy policy
// (see scanner.hpp):
//
// scan.do_action(actor, attribute, first, last);
//
// passing in these information:
//
// actor: The action's function or functor
// attribute: The match (returned by the parser) object's
// attribute (see match.hpp)
// first: Iterator pointing to the start of the matching
// portion of the input
// last: Iterator pointing to one past the end of the
// matching portion of the input
//
// It is the responsibility of the scanner's action_policy policy to
// dispatch the function or functor as it sees fit. The expected
// function or functor signature depends on the parser being
// wrapped. In general, if the attribute type of the parser being
// wrapped is a nil_t, the function or functor expect the signature:
//
// void func(Iterator first, Iterator last); // functions
//
// struct ftor // functors
// {
// void func(Iterator first, Iterator last) const;
// };
//
// where Iterator is the type of the iterator that is being used and
// first and last are the iterators pointing to the matching portion
// of the input.
//
// If the attribute type of the parser being wrapped is not a nil_t,
// the function or functor usually expect the signature:
//
// void func(T val); // functions
//
// struct ftor // functors
// {
// void func(T val) const;
// };
//
// where T is the attribute type and val is the attribute value
// returned by the parser being wrapped.
//
///////////////////////////////////////////////////////////////////////////
template <typename ParserT, typename ActionT>
class action : public unary<ParserT, parser<action<ParserT, ActionT> > >
{
public:
typedef action<ParserT, ActionT> self_t;
typedef action_parser_category parser_category_t;
typedef unary<ParserT, parser<self_t> > base_t;
typedef ActionT predicate_t;
template <typename ScannerT>
struct result
{
typedef typename parser_result<ParserT, ScannerT>::type type;
};
action()
: base_t(ParserT())
, actor(ActionT()) {}
action(ParserT const& p, ActionT const& a)
: base_t(p)
, actor(a) {}
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
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
iterator_t save = scan.first;
result_t hit = this->subject().parse(scan);
if (hit)
scan.do_action(actor, hit.value(), save, scan.first);
return hit;
}
ActionT const& predicate() const { return actor; }
private:
ActionT actor;
};
///////////////////////////////////////////////////////////////////////////
//
// assign_actor class
//
// assign_actor is a predefined semantic action functor. It can be
// used to extract the result of a successful parse and assign it to
// a variable. The functor overloads two function call operators:
// operator(), one that takes in a single value argument and another
// that accepts two iterators (first and last).
//
// The constructor expects a reference to a variable. The functor is
// polymorphic and should work with any variable type as long as it
// is compatible with the requirements outlined below.
//
// 1 The single argument function call operator assigns the
// argument received to the variable. The variable is required
// to accept the statement:
//
// v = value;
//
// where v is the variable and value is the extracted result
// of the parser.
//
// 2 The other function call operator that takes in the
// first/last iterator expects the variable to accept the
// statement:
//
// v.assign(first, last);
//
// 2.a The variable has a member function assign, taking in
// the iterator pair. Any STL container that has an
// assign(first, last) member function may be used.
//
// Requirements 1 and 2 are exclusive and applies only if the
// corresponding single or double argument operator is actually
// called.
//
// Instances of assign_actor are not created directly. Instead a
// generator function:
//
// assign(T& ref)
//
// taking in a reference to a variable of arbitrary type is used to
// instantiate an assign_actor object of the proper type.
//
///////////////////////////////////////////////////////////////////////////
template <typename T>
class assign_actor
{
public:
explicit
assign_actor(T& ref_)
: ref(ref_) {}
template <typename T2>
void operator()(T2 const& val) const
{ ref = val; }
template <typename IteratorT>
void operator()(IteratorT const& first, IteratorT const& last) const
{ ref.assign(first, last); }
private:
T& ref;
};
//////////////////////////////////
template <typename T>
inline assign_actor<T> const
assign(T& ref)
{
return assign_actor<T>(ref);
}
///////////////////////////////////////////////////////////////////////////
//
// append_actor class
//
// append_actor is a predefined semantic action functor. It can be
// used to extract the result of a successful parse and append it to
// a variable. The functor overloads two function call operators:
// operator(), one that takes in a single value argument and another
// that accepts two iterators (first and last).
//
// The constructor expects a reference to a variable. The functor is
// polymorphic and should work with any variable type as long as it
// is compatible with the requirements outlined below.
//
// 1 The variable is assumed to be a container of some sort. An
// STL container is a perfectly valid candidate.
//
// 2 The single argument function call operator appends the
// extracted parser result and appends it to the container.
// The container is required to accept the statement:
//
// c.insert(c.end(), value)
//
// where c is the container and value is the extracted result
// of the parser.
//
// 2.a The container is required to have a member function
// end() that returns an iterator to its 'end' element.
//
// 2.b The container is required to have a member function
// insert that takes in the 'end' iterator and a value
// compatible with the container's element type.
//
// 3 The function call operator that takes in the first/last
// iterator first constructs a value from the iterator pair
// before appending the value to the container. The container
// is required to accept the statement:
//
// c.insert(c.end(), T::value_type(first, last));
//
// where c is the container and T is the container type. In
// addition to the requirements 1 and 2 above,
//
// 3.a The container is also required to have a typedef
// value_type (the container's value type) that can be
// constructed given a first/last iterator pair.
//
// Requirement 2 is exclusive of requirement 3. Requirement 3
// only applies if the corresponding double argument operator
// is actually called.
//
// Instances of append_actor are not created directly. Instead a
// generator function:
//
// append(T& ref)
//
// taking in a reference to a variable of arbitrary type is used to
// instantiate an append_actor object of the proper type.
//
///////////////////////////////////////////////////////////////////////////
template <typename T>
class append_actor
{
public:
explicit
append_actor(T& ref_)
: ref(ref_) {}
template <typename T2>
void operator()(T2 const& val) const
{ ref.insert(ref.end(), val); }
template <typename IteratorT>
void operator()(IteratorT const& first, IteratorT const& last) const
{
typedef typename T::value_type value_type;
ref.insert(ref.end(), value_type(first, last));
}
private:
T& ref;
};
//////////////////////////////////
template <typename T>
inline append_actor<T> const
append(T& ref)
{
return append_actor<T>(ref);
}
}} // namespace boost::spirit
#endif

151
include/boost/spirit/core/composite/composite.hpp Normal file
View File

@@ -0,0 +1,151 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_COMPOSITE_HPP)
#define BOOST_SPIRIT_COMPOSITE_HPP
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/core/composite/impl/composite.ipp"
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////
//
// unary class.
//
// Composite class composed of a single subject. This template class
// is parameterized by the subject type S and a base class to
// inherit from, BaseT. The unary class is meant to be a base class
// to inherit from. The inheritance structure, given the BaseT
// template parameter places the unary class in the middle of a
// linear, single parent hierarchy. For instance, given a class S
// and a base class B, a class D can derive from unary:
//
// struct D : public unary<S, B> {...};
//
// The inheritance structure is thus:
//
// B
// |
// unary (has S)
// |
// D
//
// The subject can be accessed from the derived class D as:
// this->subject();
//
// Typically, the subject S is specified as typename S::embed_t.
// embed_t specifies how the subject is embedded in the composite
// (See parser.hpp for details).
//
///////////////////////////////////////////////////////////////////////////
template <typename S, typename BaseT>
class unary : public impl::subject<typename S::embed_t, BaseT>
{
typedef impl::subject<typename S::embed_t, BaseT> base_t;
typedef typename base_t::param_t param_t;
typedef typename base_t::return_t return_t;
public:
typedef S subject_t;
typedef typename S::embed_t subject_embed_t;
unary()
: base_t() {}
unary(BaseT const& base)
: base_t(base) {}
unary(param_t s)
: base_t(s) {}
unary(BaseT const& base, param_t s)
: base_t(base, s) {}
return_t
subject() const
{ return base_t::get(); }
};
///////////////////////////////////////////////////////////////////////////
//
// binary class.
//
// Composite class composed of a pair (left and right). This
// template class is parameterized by the left and right subject
// types A and B and a base class to inherit from, BaseT. The binary
// class is meant to be a base class to inherit from. The
// inheritance structure, given the BaseT template parameter places
// the binary class in the middle of a linear, single parent
// hierarchy. For instance, given classes X and Y and a base class
// B, a class D can derive from binary:
//
// struct D : public binary<X, Y, B> {...};
//
// The inheritance structure is thus:
//
// B
// |
// binary (has X and Y)
// |
// D
//
// The left and right subjects can be accessed from the derived
// class D as: this->left(); and this->right();
//
// Typically, the pairs X and Y are specified as typename X::embed_t
// and typename Y::embed_t. embed_t specifies how the subject is
// embedded in the composite (See parser.hpp for details).
//
///////////////////////////////////////////////////////////////////////////////
template <typename A, typename B, typename BaseT>
class binary
: public
impl::left_subject<typename A::embed_t,
impl::right_subject<typename B::embed_t, BaseT> >
{
typedef
impl::left_subject<typename A::embed_t,
impl::right_subject<typename B::embed_t, BaseT> > left_base_t;
typedef typename left_base_t::param_t left_param_t;
typedef typename left_base_t::return_t left_return_t;
typedef impl::right_subject<typename B::embed_t, BaseT> right_base_t;
typedef typename right_base_t::param_t right_param_t;
typedef typename right_base_t::return_t right_return_t;
public:
typedef A left_t;
typedef typename A::embed_t left_embed_t;
typedef B right_t;
typedef typename B::embed_t right_embed_t;
binary()
: left_base_t(right_base_t()) {}
binary(left_param_t a, right_param_t b)
: left_base_t(right_base_t(b), a) {}
left_return_t
left() const
{ return left_base_t::left(); }
right_return_t
right() const
{ return right_base_t::right(); }
};
}} // namespace boost::spirit
#endif

589
include/boost/spirit/core/composite/directives.hpp Normal file
View File

@@ -0,0 +1,589 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
Copyright (c) 2001 Daniel Nuffer
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_DIRECTIVES_HPP)
#define BOOST_SPIRIT_DIRECTIVES_HPP
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#if !defined(BOOST_SPIRIT_PARSER_HPP)
#include "boost/spirit/core/parser.hpp"
#endif
#if !defined(BOOST_SPIRIT_PRIMITIVES_HPP)
#include "boost/spirit/core/primitives/primitives.hpp"
#endif
#if !defined(BOOST_SPIRIT_COMPOSITE_HPP)
#include "boost/spirit/core/composite/composite.hpp"
#endif
#if !defined(BOOST_SPIRIT_DIRECTIVES_IPP)
#include "boost/spirit/core/composite/impl/directives.ipp"
#endif
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////
//
// no_skipper_iteration_policy class
//
///////////////////////////////////////////////////////////////////////////
template <typename BaseT>
struct no_skipper_iteration_policy : public BaseT
{
typedef BaseT base_t;
no_skipper_iteration_policy()
: BaseT() {}
template <typename PolicyT>
no_skipper_iteration_policy(PolicyT const& other)
: BaseT(other) {}
template <typename ScannerT>
void
skip(ScannerT const& /*scan*/) const {}
};
///////////////////////////////////////////////////////////////////////////
//
// contiguous class
//
///////////////////////////////////////////////////////////////////////////
struct lexeme_parser_gen;
template <typename ParserT>
struct contiguous
: public unary<ParserT, parser<contiguous<ParserT> > >
{
typedef contiguous<ParserT> self_t;
typedef unary_parser_category parser_category_t;
typedef lexeme_parser_gen parser_generator_t;
typedef unary<ParserT, parser<self_t> > base_t;
template <typename ScannerT>
struct result
{
typedef typename parser_result<ParserT, ScannerT>::type type;
};
contiguous()
: base_t(ParserT()) {}
contiguous(ParserT const& p)
: base_t(p) {}
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::contiguous_parser_parse<result_t>
(this->subject(), scan, scan);
}
};
struct lexeme_parser_gen
{
template <typename ParserT>
struct result {
typedef contiguous<ParserT> type;
};
template <typename ParserT>
static contiguous<ParserT>
generate(parser<ParserT> const& subject)
{
return contiguous<ParserT>(subject.derived());
}
template <typename ParserT>
contiguous<ParserT>
operator[](parser<ParserT> const& subject) const
{
return contiguous<ParserT>(subject.derived());
}
};
//////////////////////////////////
const lexeme_parser_gen lexeme_d = lexeme_parser_gen();
///////////////////////////////////////////////////////////////////////////
//
// inhibit_case_iteration_policy class
//
///////////////////////////////////////////////////////////////////////////
template <typename BaseT>
struct inhibit_case_iteration_policy : public BaseT
{
typedef BaseT base_t;
inhibit_case_iteration_policy()
: BaseT() {}
template <typename PolicyT>
inhibit_case_iteration_policy(PolicyT const& other)
: BaseT(other) {}
template <typename CharT>
CharT filter(CharT ch) const
{ return impl::tolower_(ch); }
};
///////////////////////////////////////////////////////////////////////////
//
// inhibit_case class
//
///////////////////////////////////////////////////////////////////////////
struct inhibit_case_parser_gen;
template <typename ParserT>
struct inhibit_case
: public unary<ParserT, parser<inhibit_case<ParserT> > >
{
typedef inhibit_case<ParserT> self_t;
typedef unary_parser_category parser_category_t;
typedef inhibit_case_parser_gen parser_generator_t;
typedef unary<ParserT, parser<self_t> > base_t;
template <typename ScannerT>
struct result
{
typedef typename parser_result<ParserT, ScannerT>::type type;
};
inhibit_case()
: base_t(ParserT()) {}
inhibit_case(ParserT const& p)
: base_t(p) {}
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::inhibit_case_parser_parse<result_t>
(this->subject(), scan, scan);
}
};
template <int N>
struct inhibit_case_parser_gen_base
{
// This hack is needed to make borland happy.
// If these member operators were defined in the
// inhibit_case_parser_gen class, or if this class
// is non-templated, borland ICEs.
static inhibit_case<strlit<char const*> >
generate(char const* str)
{ return inhibit_case<strlit<char const*> >(str); }
static inhibit_case<strlit<wchar_t const*> >
generate(wchar_t const* str)
{ return inhibit_case<strlit<wchar_t const*> >(str); }
static inhibit_case<chlit<char> >
generate(char ch)
{ return inhibit_case<chlit<char> >(ch); }
static inhibit_case<chlit<wchar_t> >
generate(wchar_t ch)
{ return inhibit_case<chlit<wchar_t> >(ch); }
template <typename ParserT>
static inhibit_case<ParserT>
generate(parser<ParserT> const& subject)
{ return inhibit_case<ParserT>(subject.derived()); }
inhibit_case<strlit<char const*> >
operator[](char const* str) const
{ return inhibit_case<strlit<char const*> >(str); }
inhibit_case<strlit<wchar_t const*> >
operator[](wchar_t const* str) const
{ return inhibit_case<strlit<wchar_t const*> >(str); }
inhibit_case<chlit<char> >
operator[](char ch) const
{ return inhibit_case<chlit<char> >(ch); }
inhibit_case<chlit<wchar_t> >
operator[](wchar_t ch) const
{ return inhibit_case<chlit<wchar_t> >(ch); }
template <typename ParserT>
inhibit_case<ParserT>
operator[](parser<ParserT> const& subject) const
{ return inhibit_case<ParserT>(subject.derived()); }
};
//////////////////////////////////
struct inhibit_case_parser_gen : public inhibit_case_parser_gen_base<0>
{
inhibit_case_parser_gen() {}
};
//////////////////////////////////
const inhibit_case_parser_gen nocase_d = inhibit_case_parser_gen();
///////////////////////////////////////////////////////////////////////////
//
// longest_alternative class
//
///////////////////////////////////////////////////////////////////////////
struct longest_parser_gen;
template <typename A, typename B>
struct longest_alternative
: public binary<A, B, parser<longest_alternative<A, B> > >
{
typedef longest_alternative<A, B> self_t;
typedef binary_parser_category parser_category_t;
typedef longest_parser_gen parser_generator_t;
typedef binary<A, B, parser<self_t> > base_t;
longest_alternative()
: base_t(A(), B()) {}
longest_alternative(A const& a, B const& b)
: base_t(a, b) {}
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;
typename ScannerT::iterator_t save = scan.first;
result_t l = this->left().parse(scan);
std::swap(scan.first, save);
result_t r = this->right().parse(scan);
if (l || r)
{
if (l.length() > r.length())
{
scan.first = save;
return l;
}
return r;
}
return scan.no_match();
}
};
struct longest_parser_gen
{
template <typename A, typename B>
struct result {
typedef typename
impl::to_longest_alternative<alternative<A, B> >::result_t
type;
};
template <typename A, typename B>
static typename
impl::to_longest_alternative<alternative<A, B> >::result_t
generate(alternative<A, B> const& alt)
{
return impl::to_longest_alternative<alternative<A, B> >::
convert(alt);
}
template <typename A, typename B>
typename impl::to_longest_alternative<alternative<A, B> >::result_t
operator[](alternative<A, B> const& alt) const
{
return impl::to_longest_alternative<alternative<A, B> >::
convert(alt);
}
};
const longest_parser_gen longest_d = longest_parser_gen();
///////////////////////////////////////////////////////////////////////////
//
// shortest_alternative class
//
///////////////////////////////////////////////////////////////////////////
struct shortest_parser_gen;
template <typename A, typename B>
struct shortest_alternative
: public binary<A, B, parser<shortest_alternative<A, B> > >
{
typedef shortest_alternative<A, B> self_t;
typedef binary_parser_category parser_category_t;
typedef shortest_parser_gen parser_generator_t;
typedef binary<A, B, parser<self_t> > base_t;
shortest_alternative()
: base_t(A(), B()) {}
shortest_alternative(A const& a, B const& b)
: base_t(a, b) {}
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;
typename ScannerT::iterator_t save = scan.first;
result_t l = this->left().parse(scan);
std::swap(scan.first, save);
result_t r = this->right().parse(scan);
if (l || r)
{
if (l.length() < r.length())
{
scan.first = save;
return l;
}
return r;
}
return scan.no_match();
}
};
struct shortest_parser_gen
{
template <typename A, typename B>
struct result {
typedef typename
impl::to_shortest_alternative<alternative<A, B> >::result_t
type;
};
template <typename A, typename B>
static typename
impl::to_shortest_alternative<alternative<A, B> >::result_t
generate(alternative<A, B> const& alt)
{
return impl::to_shortest_alternative<alternative<A, B> >::
convert(alt);
}
template <typename A, typename B>
typename impl::to_shortest_alternative<alternative<A, B> >::result_t
operator[](alternative<A, B> const& alt) const
{
return impl::to_shortest_alternative<alternative<A, B> >::
convert(alt);
}
};
const shortest_parser_gen shortest_d = shortest_parser_gen();
///////////////////////////////////////////////////////////////////////////
//
// min_bounded class
//
///////////////////////////////////////////////////////////////////////////
template <typename BoundsT>
struct min_bounded_gen;
template <typename ParserT, typename BoundsT>
struct min_bounded
: public unary<ParserT, parser<min_bounded<ParserT, BoundsT> > >
{
typedef min_bounded<ParserT, BoundsT> self_t;
typedef unary_parser_category parser_category_t;
typedef min_bounded_gen<BoundsT> parser_generator_t;
typedef unary<ParserT, parser<self_t> > base_t;
template <typename ScannerT>
struct result
{
typedef typename parser_result<ParserT, ScannerT>::type type;
};
min_bounded()
: base_t(ParserT()) {}
min_bounded(ParserT const& p, BoundsT const& min__)
: base_t(p)
, min_(min__) {}
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;
result_t hit = this->subject().parse(scan);
if (hit.value() < min_)
return scan.no_match();
return hit;
}
BoundsT min_;
};
template <typename BoundsT>
struct min_bounded_gen
{
min_bounded_gen(BoundsT const& min__)
: min_(min__) {}
template <typename DerivedT>
min_bounded<DerivedT, BoundsT>
operator[](parser<DerivedT> const& p) const
{ return min_bounded<DerivedT, BoundsT>(p.derived(), min_); }
BoundsT min_;
};
template <typename BoundsT>
inline min_bounded_gen<BoundsT>
min_limit_d(BoundsT const& min_)
{ return min_bounded_gen<BoundsT>(min_); }
///////////////////////////////////////////////////////////////////////////
//
// max_bounded class
//
///////////////////////////////////////////////////////////////////////////
template <typename BoundsT>
struct max_bounded_gen;
template <typename ParserT, typename BoundsT>
struct max_bounded
: public unary<ParserT, parser<max_bounded<ParserT, BoundsT> > >
{
typedef max_bounded<ParserT, BoundsT> self_t;
typedef unary_parser_category parser_category_t;
typedef max_bounded_gen<BoundsT> parser_generator_t;
typedef unary<ParserT, parser<self_t> > base_t;
template <typename ScannerT>
struct result
{
typedef typename parser_result<ParserT, ScannerT>::type type;
};
max_bounded()
: base_t(ParserT()) {}
max_bounded(ParserT const& p, BoundsT const& max__)
: base_t(p)
, max_(max__) {}
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;
result_t hit = this->subject().parse(scan);
if (hit.value() > max_)
return scan.no_match();
return hit;
}
BoundsT max_;
};
template <typename BoundsT>
struct max_bounded_gen
{
max_bounded_gen(BoundsT const& max__)
: max_(max__) {}
template <typename DerivedT>
max_bounded<DerivedT, BoundsT>
operator[](parser<DerivedT> const& p) const
{ return max_bounded<DerivedT, BoundsT>(p.derived(), max_); }
BoundsT max_;
};
//////////////////////////////////
template <typename BoundsT>
inline max_bounded_gen<BoundsT>
max_limit_d(BoundsT const& max_)
{ return max_bounded_gen<BoundsT>(max_); }
///////////////////////////////////////////////////////////////////////////
//
// bounded class
//
///////////////////////////////////////////////////////////////////////////
template <typename BoundsT>
struct bounded_gen;
template <typename ParserT, typename BoundsT>
struct bounded
: public unary<ParserT, parser<bounded<ParserT, BoundsT> > >
{
typedef bounded<ParserT, BoundsT> self_t;
typedef unary_parser_category parser_category_t;
typedef bounded_gen<BoundsT> parser_generator_t;
typedef unary<ParserT, parser<self_t> > base_t;
template <typename ScannerT>
struct result
{
typedef typename parser_result<ParserT, ScannerT>::type type;
};
bounded()
: base_t(ParserT()) {}
bounded(ParserT const& p, BoundsT const& min__, BoundsT const& max__)
: base_t(p)
, min_(min__)
, max_(max__) {}
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;
result_t hit = this->subject().parse(scan);
if (hit.value() < min_ || hit.value() > max_)
return scan.no_match();
return hit;
}
BoundsT min_, max_;
};
template <typename BoundsT>
struct bounded_gen
{
bounded_gen(BoundsT const& min__, BoundsT const& max__)
: min_(min__)
, max_(max__) {}
template <typename DerivedT>
bounded<DerivedT, BoundsT>
operator[](parser<DerivedT> const& p) const
{ return bounded<DerivedT, BoundsT>(p.derived(), min_, max_); }
BoundsT min_, max_;
};
template <typename BoundsT>
inline bounded_gen<BoundsT>
limit_d(BoundsT const& min_, BoundsT const& max_)
{ return bounded_gen<BoundsT>(min_, max_); }
}} // namespace boost::spirit
#endif

279
include/boost/spirit/core/composite/epsilon.hpp Normal file
View File

@@ -0,0 +1,279 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
Copyright (c) 2002-2003 Martin Wille
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#ifndef BOOST_SPIRIT_EPSILON_HPP
#define BOOST_SPIRIT_EPSILON_HPP
////////////////////////////////////////////////////////////////////////////////
#if !defined(BOOST_SPIRIT_PARSER_HPP)
#include "boost/spirit/core/parser.hpp"
#endif
#if !defined(BOOST_SPIRIT_PARSER_TRAITS_HPP)
#include "boost/spirit/core/meta/parser_traits.hpp"
#endif
#if !defined(BOOST_SPIRIT_COMPOSITE_HPP)
#include "boost/spirit/core/composite/composite.hpp"
#endif
////////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
//
// condition_parser class
//
// handles expresions of the form
// epsilon_p(cond)
// where cond is a function or a functor that returns a value
// suitable to be used in boolean context. The expression returns
// a parser that returns an empty match when the condition evaluates
// to true.
//
///////////////////////////////////////////////////////////////////////////////
template <typename CondT, bool positive = true>
struct condition_parser
: public impl::subject<CondT, parser<condition_parser<CondT, positive> > >
{
typedef condition_parser<CondT, positive> self_t;
typedef impl::subject<CondT, parser<self_t> > base_t;
// not explicit! (needed for implementation of if_p et al.)
condition_parser(CondT const &cond) : base_t(cond) {}
condition_parser() : base_t() {}
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
if (positive == this->get()())
return scan.empty_match();
else
return scan.no_match();
}
condition_parser<CondT, !positive>
negate() const
{
return condition_parser<CondT, !positive>(this->get());
}
private:
};
template <typename CondT, bool positive>
inline condition_parser<CondT, !positive>
operator~(condition_parser<CondT, positive> const &p)
{
return p.negate();
}
///////////////////////////////////////////////////////////////////////////////
//
// empty_match_parser class
//
// handles expressions of the form
// epsilon_p(subject)
// where subject is a parser. The expresion returns a composite
// parser that returns an empty match if the subject parser matches.
//
///////////////////////////////////////////////////////////////////////////////
struct empty_match_parser_gen;
struct negated_empty_match_parser_gen;
template<typename SubjectT> struct negated_empty_match_parser;
template<typename SubjectT>
struct empty_match_parser
: public unary<SubjectT, parser<empty_match_parser<SubjectT> > >
{
typedef empty_match_parser<SubjectT> self_t;
typedef unary<SubjectT, parser<self_t> > base_t;
typedef unary_parser_category parser_category_t;
typedef empty_match_parser_gen parser_genererator_t;
typedef self_t embed_t;
explicit empty_match_parser(SubjectT const &p) : base_t(p) {}
empty_match_parser() : base_t() {}
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, nil_t>::type type;
};
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
typename ScannerT::iterator_t save(scan.first);
bool matches = this->subject().parse(scan);
if (matches)
{
scan.first = save; // reset the position
return scan.empty_match();
}
else
return scan.no_match();
}
negated_empty_match_parser<SubjectT>
negate() const
{
return negated_empty_match_parser<SubjectT>(this->subject());
}
};
template<typename SubjectT>
struct negated_empty_match_parser
: public unary<SubjectT, parser<negated_empty_match_parser<SubjectT> > >
{
typedef negated_empty_match_parser<SubjectT> self_t;
typedef unary<SubjectT, parser<self_t> > base_t;
typedef unary_parser_category parser_category_t;
typedef negated_empty_match_parser_gen parser_genererator_t;
explicit negated_empty_match_parser(SubjectT const &p) : base_t(p) {}
negated_empty_match_parser() : base_t() {}
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, nil_t>::type type;
};
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
typename ScannerT::iterator_t save(scan.first);
bool matches = this->subject().parse(scan);
if (!matches)
{
scan.first = save; // reset the position
return scan.empty_match();
}
else
return scan.no_match();
}
empty_match_parser<SubjectT>
negate() const
{
return empty_match_parser<SubjectT>(this->subject());
}
};
//////////////////////////////
struct empty_match_parser_gen
{
template <typename SubjectT>
struct result
{
typedef empty_match_parser<SubjectT> type;
};
template <typename SubjectT>
static empty_match_parser<SubjectT>
generate(parser<SubjectT> const &subject)
{
return empty_match_parser<SubjectT>(subject.derived());
}
};
struct negated_empty_match_parser_gen
{
template <typename SubjectT>
struct result
{
typedef negated_empty_match_parser<SubjectT> type;
};
template <typename SubjectT>
static negated_empty_match_parser<SubjectT>
generate(parser<SubjectT> const &subject)
{
return negated_empty_match_parser<SubjectT>(subject.derived());
}
};
//////////////////////////////
template <typename SubjectT>
inline /*struct*/ negated_empty_match_parser<SubjectT>
operator ~(empty_match_parser<SubjectT> const &p)
{
return p.negate();
}
template <typename SubjectT>
inline /*struct*/ empty_match_parser<SubjectT>
operator ~(negated_empty_match_parser<SubjectT> const &p)
{
return p.negate();
}
///////////////////////////////////////////////////////////////////////////////
//
// epsilon_ parser and parser generator class
//
// Operates as primitive parser that always matches an empty sequence.
//
// Also operates as a parser generator. According to the type of the
// argument an instance of empty_match_parser<> (when the argument is
// a parser) or condition_parser<> (when the argument is not a parser)
// is returned by operator().
//
///////////////////////////////////////////////////////////////////////////////
namespace impl
{
template <typename SubjectT>
struct epsilon_selector
{
typedef typename as_parser<SubjectT>::type subject_t;
typedef typename
if_t
<bool_t< ::boost::spirit::is_parser<subject_t>::value>
,empty_match_parser<subject_t>
,condition_parser<subject_t>
>::type type;
};
} // namespace impl
struct epsilon_parser : public parser<epsilon_parser>
{
typedef epsilon_parser self_t;
epsilon_parser() {}
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{ return scan.empty_match(); }
template <typename SubjectT>
typename impl::epsilon_selector<SubjectT>::type
operator()(SubjectT const &subject) const
{
typedef typename impl::epsilon_selector<SubjectT>::type result_t;
return result_t(subject);
}
};
//////////////////////////////////
epsilon_parser const epsilon_p = epsilon_parser();
epsilon_parser const eps_p = epsilon_parser();
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif

3
include/boost/spirit/core/composite/impl/Makefile.am Normal file
View File

@@ -0,0 +1,3 @@
#This file generated by Makefileamgen.sh
spiritinclude_HEADERS = composite.ipp directives.ipp operators.ipp
spiritincludedir = $(includedir)/spirit/boost/spirit/core/composite/impl

158
include/boost/spirit/core/composite/impl/composite.ipp Normal file
View File

@@ -0,0 +1,158 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined BOOST_SPIRIT_COMPOSITE_IPP
#define BOOST_SPIRIT_COMPOSITE_IPP
///////////////////////////////////////////////////////////////////////////////
#include <boost/call_traits.hpp>
#include <boost/type_traits.hpp>
#include <boost/spirit/core/basics.hpp>
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
namespace impl
{
///////////////////////////////////////////////////////////////////////
//
// This class is used when the subject is known to be empty
// (zero size). In such a case, the subject is not stored
// as a member variable to save space.
//
///////////////////////////////////////////////////////////////////////
template <typename T, typename BaseT>
struct empty_subject : public BaseT
{
typedef typename boost::call_traits<T>::param_type param_t;
typedef T return_t;
empty_subject()
: BaseT() {}
empty_subject(BaseT const& base)
: BaseT(base) {}
empty_subject(param_t)
: BaseT() {}
empty_subject(BaseT const& base, param_t)
: BaseT(base) {}
return_t get() const { return return_t(); }
};
///////////////////////////////////////////////////////////////////////
//
// This class is used when the subject is known to be non-empty
// (non-zero size). In a such a case, the subject is stored
// as a member variable.
//
///////////////////////////////////////////////////////////////////////
template <typename T, typename BaseT>
struct non_empty_subject : public BaseT
{
typedef typename boost::call_traits<T>::param_type param_t;
typedef typename boost::call_traits<T>::const_reference return_t;
non_empty_subject()
: BaseT(), s() {}
non_empty_subject(BaseT const& base)
: BaseT(base), s() {}
non_empty_subject(param_t s_)
: BaseT(), s(s_) {}
non_empty_subject(BaseT const& base, param_t s_)
: BaseT(base), s(s_) {}
return_t get() const { return s; }
T s;
};
///////////////////////////////////////////////////////////////////////
//
// Test T if it is empty and switch the proper implementation
// class appropriately (empty_subject or non_empty_subject)
//
///////////////////////////////////////////////////////////////////////
template <typename T, typename BaseT>
struct subject_type
{
enum { is_empty = boost::is_empty<T>::value };
typedef typename if_t
<
bool_t<is_empty>, // IF
empty_subject<T, BaseT>, // THEN
non_empty_subject<T, BaseT> // ELSE
>::type type;
};
///////////////////////////////////////////////////////////////////////
//
// subject, left_subject and right_subject classes.
//
// The three classes below are virtually similar except for the
// names. These classes are used by the public unary and binary
// classes for the unary::subject, binary::left and binary::right
// implementations.
//
///////////////////////////////////////////////////////////////////////
template <typename T, typename BaseT>
struct subject : subject_type<T, BaseT>::type
{
typedef typename subject_type<T, BaseT>::type base_t;
typedef typename boost::call_traits<T>::param_type param_t;
typedef typename base_t::return_t return_t;
subject() : base_t() {}
subject(BaseT const& base) : base_t(base) {}
subject(param_t s) : base_t(s) {}
subject(BaseT const& base, param_t s) : base_t(base, s) {}
};
//////////////////////////////////
template <typename T, typename BaseT>
struct left_subject : subject_type<T, BaseT>::type
{
typedef typename subject_type<T, BaseT>::type base_t;
typedef typename boost::call_traits<T>::param_type param_t;
typedef typename base_t::return_t return_t;
left_subject() : base_t() {}
left_subject(BaseT const& base) : base_t(base) {}
left_subject(param_t s) : base_t(s) {}
left_subject(BaseT const& base, param_t s) : base_t(base, s) {}
return_t
left() const { return base_t::get(); }
};
//////////////////////////////////
template <typename T, typename BaseT>
struct right_subject : subject_type<T, BaseT>::type
{
typedef typename subject_type<T, BaseT>::type base_t;
typedef typename boost::call_traits<T>::param_type param_t;
typedef typename base_t::return_t return_t;
right_subject() : base_t() {}
right_subject(BaseT const& base) : base_t(base) {}
right_subject(param_t s) : base_t(s) {}
right_subject(BaseT const& base, param_t s) : base_t(base, s) {}
return_t
right() const { return base_t::get(); }
};
}
}} // namespace boost::spirit
#endif

374
include/boost/spirit/core/composite/impl/directives.ipp Normal file
View File

@@ -0,0 +1,374 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
Copyright (c) 2001 Daniel Nuffer
Copyright (c) 2001 Bruce Florman
Copyright (c) 2002 Raghavendra Satish
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_DIRECTIVES_IPP)
#define BOOST_SPIRIT_DIRECTIVES_IPP
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/core/scanner/skipper.hpp"
namespace boost { namespace spirit {
template <typename BaseT>
struct no_skipper_iteration_policy;
template <typename BaseT>
struct inhibit_case_iteration_policy;
template <typename A, typename B>
struct alternative;
template <typename A, typename B>
struct longest_alternative;
template <typename A, typename B>
struct shortest_alternative;
namespace impl
{
template <typename RT, typename ST, typename ScannerT, typename BaseT>
inline RT
contiguous_parser_parse(
ST const& s,
ScannerT const& scan,
skipper_iteration_policy<BaseT> const&)
{
typedef scanner_policies<
no_skipper_iteration_policy<
BOOST_SPIRIT_TYPENAME ScannerT::iteration_policy_t>,
BOOST_SPIRIT_TYPENAME ScannerT::match_policy_t,
BOOST_SPIRIT_TYPENAME ScannerT::action_policy_t
> policies_t;
scan.skip(scan);
RT hit = s.parse(scan.change_policies(policies_t(scan)));
// We will not do a post skip!!!
return hit;
}
template <typename RT, typename ST, typename ScannerT, typename BaseT>
inline RT
contiguous_parser_parse(
ST const& s,
ScannerT const& scan,
no_skipper_iteration_policy<BaseT> const&)
{
return s.parse(scan);
}
template <typename RT, typename ST, typename ScannerT>
inline RT
contiguous_parser_parse(
ST const& s,
ScannerT const& scan,
iteration_policy const&)
{
return s.parse(scan);
}
template <
typename RT,
typename ParserT,
typename ScannerT,
typename BaseT>
inline RT
implicit_lexeme_parse(
ParserT const& p,
ScannerT const& scan,
skipper_iteration_policy<BaseT> const&)
{
typedef scanner_policies<
no_skipper_iteration_policy<
BOOST_SPIRIT_TYPENAME ScannerT::iteration_policy_t>,
BOOST_SPIRIT_TYPENAME ScannerT::match_policy_t,
BOOST_SPIRIT_TYPENAME ScannerT::action_policy_t
> policies_t;
scan.skip(scan);
RT hit = p.parse_main(scan.change_policies(policies_t(scan)));
// We will not do a post skip!!!
return hit;
}
template <
typename RT,
typename ParserT,
typename ScannerT,
typename BaseT>
inline RT
implicit_lexeme_parse(
ParserT const& p,
ScannerT const& scan,
no_skipper_iteration_policy<BaseT> const&)
{
return p.parse_main(scan);
}
template <typename RT, typename ParserT, typename ScannerT>
inline RT
implicit_lexeme_parse(
ParserT const& p,
ScannerT const& scan,
iteration_policy const&)
{
return p.parse_main(scan);
}
template <typename RT, typename ST, typename ScannerT>
inline RT
inhibit_case_parser_parse(
ST const& s,
ScannerT const& scan,
iteration_policy const&)
{
typedef scanner_policies<
inhibit_case_iteration_policy<
BOOST_SPIRIT_TYPENAME ScannerT::iteration_policy_t>,
BOOST_SPIRIT_TYPENAME ScannerT::match_policy_t,
BOOST_SPIRIT_TYPENAME ScannerT::action_policy_t
> policies_t;
return s.parse(scan.change_policies(policies_t(scan)));
}
template <typename RT, typename ST, typename ScannerT, typename BaseT>
inline RT
inhibit_case_parser_parse(
ST const& s,
ScannerT const& scan,
inhibit_case_iteration_policy<BaseT> const&)
{
return s.parse(scan);
}
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
///////////////////////////////////////////////////////////////////////
//
// from spirit 1.1 (copyright (c) 2001 Bruce Florman)
// various workarounds to support longest and shortest directives
//
///////////////////////////////////////////////////////////////////////
template <typename T>
struct is_alternative
{
// Determine at compile time (without partial specialization)
// whether a given type is an instance of the alternative<A,B>
static T t();
template <typename A, typename B>
static char test_(alternative<A, B> const&); // no implementation
static int test_(...); // no implementation
enum { r = sizeof(char) == sizeof(test_(t())) };
typedef bool_t<r> value;
};
template <typename T> struct select_to_longest;
template <typename T>
struct to_longest_alternative
{
typedef typename select_to_longest<T>::result_t result_t;
typedef typename select_to_longest<T>::plain_t plain_t;
typedef typename select_to_longest<T>::choose_t choose_t;
static result_t convert(T const& a);
};
template <typename T>
struct to_longest_generic
{
typedef T const& result_t;
typedef T plain_t;
typedef false_t choose_t;
};
template <typename T>
inline T const&
to_longest_convert(T const& a, false_t)
{ return a; }
template <typename T>
struct to_longest_recursive
{
typedef typename to_longest_alternative<
typename T::left_t>::plain_t a_t;
typedef typename to_longest_alternative<
typename T::right_t>::plain_t b_t;
typedef longest_alternative<a_t, b_t> result_t;
typedef result_t plain_t;
typedef true_t choose_t;
};
template <typename A, typename B>
inline typename to_longest_alternative<alternative<A, B> >::result_t
to_longest_convert(alternative<A, B> const& alt, true_t)
{
typedef typename to_longest_alternative<
alternative<A, B> >::result_t result_t;
return result_t(
to_longest_alternative<A>::convert(alt.left()),
to_longest_alternative<B>::convert(alt.right()));
}
template <typename T>
inline typename to_longest_alternative<T>::result_t
to_longest_alternative<T>::convert(T const& a)
{
return to_longest_convert(
a, to_longest_alternative<T>::choose_t());
}
template <typename T>
struct select_to_longest
{
typedef typename if_t
<
is_alternative<T>::value // IF
, to_longest_recursive<T> // THEN
, to_longest_generic<T> // ELSE
>::type type;
typedef typename select_to_longest::type::result_t result_t;
typedef typename select_to_longest::type::plain_t plain_t;
typedef typename select_to_longest::type::choose_t choose_t;
};
template <typename T> struct select_to_shortest;
template <typename T>
struct to_shortest_alternative
{
typedef typename select_to_shortest<T>::result_t result_t;
typedef typename select_to_shortest<T>::plain_t plain_t;
typedef typename select_to_shortest<T>::choose_t choose_t;
static result_t convert(T const& a);
};
template <typename T>
struct to_shortest_generic
{
typedef T const& result_t;
typedef T plain_t;
typedef false_t choose_t;
};
template <typename T>
inline T const&
to_shortest_convert(T const& a, false_t) { return a; }
template <typename T>
struct to_shortest_recursive
{
typedef typename to_shortest_alternative<
typename T::left_t>::plain_t a_t;
typedef typename to_shortest_alternative<
typename T::right_t>::plain_t b_t;
typedef shortest_alternative<a_t, b_t> result_t;
typedef result_t plain_t;
typedef true_t choose_t;
};
template <typename A, typename B>
inline typename to_shortest_alternative<alternative<A, B> >::result_t
to_shortest_convert(alternative<A, B> const& alt, true_t)
{
typedef typename to_shortest_alternative<
alternative<A, B> >::result_t result_t;
return result_t(
to_shortest_alternative<A>::convert(alt.left()),
to_shortest_alternative<B>::convert(alt.right()));
}
template <typename T>
inline typename to_shortest_alternative<T>::result_t
to_shortest_alternative<T>::convert(T const& a)
{
return to_shortest_convert(
a, to_shortest_alternative<T>::choose_t());
}
template <typename T>
struct select_to_shortest
{
typedef typename if_t
<
is_alternative<T>::value // IF
, to_shortest_recursive<T> // THEN
, to_shortest_generic<T> // ELSE
>::type type;
typedef typename select_to_shortest::type::result_t result_t;
typedef typename select_to_shortest::type::plain_t plain_t;
typedef typename select_to_shortest::type::choose_t choose_t;
};
#else
template <typename T>
struct to_longest_alternative
{
typedef T result_t;
static result_t const&
convert(T const& a) // Special (end) case
{ return a; }
};
template <typename A, typename B>
struct to_longest_alternative<alternative<A, B> >
{
typedef typename to_longest_alternative<A>::result_t a_t;
typedef typename to_longest_alternative<B>::result_t b_t;
typedef longest_alternative<a_t, b_t> result_t;
static result_t
convert(alternative<A, B> const& alt) // Recursive case
{
return result_t(
to_longest_alternative<A>::convert(alt.left()),
to_longest_alternative<B>::convert(alt.right()));
}
};
template <typename T>
struct to_shortest_alternative
{
typedef T result_t;
static result_t const&
convert(T const& a) // Special (end) case
{ return a; }
};
template <typename A, typename B>
struct to_shortest_alternative<alternative<A, B> >
{
typedef typename to_shortest_alternative<A>::result_t a_t;
typedef typename to_shortest_alternative<B>::result_t b_t;
typedef shortest_alternative<a_t, b_t> result_t;
static result_t
convert(alternative<A, B> const& alt) // Recursive case
{
return result_t(
to_shortest_alternative<A>::convert(alt.left()),
to_shortest_alternative<B>::convert(alt.right()));
}
};
#endif
}
}} // namespace boost::spirit
#endif

668
include/boost/spirit/core/composite/impl/operators.ipp Normal file
View File

@@ -0,0 +1,668 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
Copyright (c) 2001 Daniel Nuffer
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_OPERATORS_IPP)
#define BOOST_SPIRIT_OPERATORS_IPP
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
//
// sequence class implementation
//
///////////////////////////////////////////////////////////////////////////////
template <typename A, typename B>
inline sequence<A, B>
operator>>(parser<A> const& a, parser<B> const& b)
{
return sequence<A, B>(a.derived(), b.derived());
}
//////////////////////////////////
template <typename A>
inline sequence<A, chlit<char> >
operator>>(parser<A> const& a, char b)
{
return sequence<A, chlit<char> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline sequence<chlit<char>, B>
operator>>(char a, parser<B> const& b)
{
return sequence<chlit<char>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline sequence<A, strlit<char const*> >
operator>>(parser<A> const& a, char const* b)
{
return sequence<A, strlit<char const*> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline sequence<strlit<char const*>, B>
operator>>(char const* a, parser<B> const& b)
{
return sequence<strlit<char const*>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline sequence<A, chlit<wchar_t> >
operator>>(parser<A> const& a, wchar_t b)
{
return sequence<A, chlit<wchar_t> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline sequence<chlit<wchar_t>, B>
operator>>(wchar_t a, parser<B> const& b)
{
return sequence<chlit<wchar_t>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline sequence<A, strlit<wchar_t const*> >
operator>>(parser<A> const& a, wchar_t const* b)
{
return sequence<A, strlit<wchar_t const*> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline sequence<strlit<wchar_t const*>, B>
operator>>(wchar_t const* a, parser<B> const& b)
{
return sequence<strlit<wchar_t const*>, B>(a, b.derived());
}
///////////////////////////////////////////////////////////////////////////////
//
// sequential-and operators implementation
//
///////////////////////////////////////////////////////////////////////////////
template <typename A, typename B>
inline sequence<A, B>
operator&&(parser<A> const& a, parser<B> const& b)
{
return sequence<A, B>(a.derived(), b.derived());
}
//////////////////////////////////
template <typename A>
inline sequence<A, chlit<char> >
operator&&(parser<A> const& a, char b)
{
return sequence<A, chlit<char> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline sequence<chlit<char>, B>
operator&&(char a, parser<B> const& b)
{
return sequence<chlit<char>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline sequence<A, strlit<char const*> >
operator&&(parser<A> const& a, char const* b)
{
return sequence<A, strlit<char const*> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline sequence<strlit<char const*>, B>
operator&&(char const* a, parser<B> const& b)
{
return sequence<strlit<char const*>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline sequence<A, chlit<wchar_t> >
operator&&(parser<A> const& a, wchar_t b)
{
return sequence<A, chlit<wchar_t> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline sequence<chlit<wchar_t>, B>
operator&&(wchar_t a, parser<B> const& b)
{
return sequence<chlit<wchar_t>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline sequence<A, strlit<wchar_t const*> >
operator&&(parser<A> const& a, wchar_t const* b)
{
return sequence<A, strlit<wchar_t const*> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline sequence<strlit<wchar_t const*>, B>
operator&&(wchar_t const* a, parser<B> const& b)
{
return sequence<strlit<wchar_t const*>, B>(a, b.derived());
}
///////////////////////////////////////////////////////////////////////////////
//
// sequential-or class implementation
//
///////////////////////////////////////////////////////////////////////////////
template <typename A, typename B>
inline sequential_or<A, B>
operator||(parser<A> const& a, parser<B> const& b)
{
return sequential_or<A, B>(a.derived(), b.derived());
}
//////////////////////////////////
template <typename A>
inline sequential_or<A, chlit<char> >
operator||(parser<A> const& a, char b)
{
return sequential_or<A, chlit<char> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline sequential_or<chlit<char>, B>
operator||(char a, parser<B> const& b)
{
return sequential_or<chlit<char>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline sequential_or<A, strlit<char const*> >
operator||(parser<A> const& a, char const* b)
{
return sequential_or<A, strlit<char const*> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline sequential_or<strlit<char const*>, B>
operator||(char const* a, parser<B> const& b)
{
return sequential_or<strlit<char const*>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline sequential_or<A, chlit<wchar_t> >
operator||(parser<A> const& a, wchar_t b)
{
return sequential_or<A, chlit<wchar_t> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline sequential_or<chlit<wchar_t>, B>
operator||(wchar_t a, parser<B> const& b)
{
return sequential_or<chlit<wchar_t>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline sequential_or<A, strlit<wchar_t const*> >
operator||(parser<A> const& a, wchar_t const* b)
{
return sequential_or<A, strlit<wchar_t const*> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline sequential_or<strlit<wchar_t const*>, B>
operator||(wchar_t const* a, parser<B> const& b)
{
return sequential_or<strlit<wchar_t const*>, B>(a, b.derived());
}
///////////////////////////////////////////////////////////////////////////////
//
// alternative class implementation
//
///////////////////////////////////////////////////////////////////////////////
template <typename A, typename B>
inline alternative<A, B>
operator|(parser<A> const& a, parser<B> const& b)
{
return alternative<A, B>(a.derived(), b.derived());
}
//////////////////////////////////
template <typename A>
inline alternative<A, chlit<char> >
operator|(parser<A> const& a, char b)
{
return alternative<A, chlit<char> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline alternative<chlit<char>, B>
operator|(char a, parser<B> const& b)
{
return alternative<chlit<char>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline alternative<A, strlit<char const*> >
operator|(parser<A> const& a, char const* b)
{
return alternative<A, strlit<char const*> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline alternative<strlit<char const*>, B>
operator|(char const* a, parser<B> const& b)
{
return alternative<strlit<char const*>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline alternative<A, chlit<wchar_t> >
operator|(parser<A> const& a, wchar_t b)
{
return alternative<A, chlit<wchar_t> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline alternative<chlit<wchar_t>, B>
operator|(wchar_t a, parser<B> const& b)
{
return alternative<chlit<wchar_t>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline alternative<A, strlit<wchar_t const*> >
operator|(parser<A> const& a, wchar_t const* b)
{
return alternative<A, strlit<wchar_t const*> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline alternative<strlit<wchar_t const*>, B>
operator|(wchar_t const* a, parser<B> const& b)
{
return alternative<strlit<wchar_t const*>, B>(a, b.derived());
}
///////////////////////////////////////////////////////////////////////////////
//
// intersection class implementation
//
///////////////////////////////////////////////////////////////////////////////
template <typename A, typename B>
inline intersection<A, B>
operator&(parser<A> const& a, parser<B> const& b)
{
return intersection<A, B>(a.derived(), b.derived());
}
//////////////////////////////////
template <typename A>
inline intersection<A, chlit<char> >
operator&(parser<A> const& a, char b)
{
return intersection<A, chlit<char> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline intersection<chlit<char>, B>
operator&(char a, parser<B> const& b)
{
return intersection<chlit<char>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline intersection<A, strlit<char const*> >
operator&(parser<A> const& a, char const* b)
{
return intersection<A, strlit<char const*> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline intersection<strlit<char const*>, B>
operator&(char const* a, parser<B> const& b)
{
return intersection<strlit<char const*>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline intersection<A, chlit<wchar_t> >
operator&(parser<A> const& a, wchar_t b)
{
return intersection<A, chlit<wchar_t> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline intersection<chlit<wchar_t>, B>
operator&(wchar_t a, parser<B> const& b)
{
return intersection<chlit<wchar_t>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline intersection<A, strlit<wchar_t const*> >
operator&(parser<A> const& a, wchar_t const* b)
{
return intersection<A, strlit<wchar_t const*> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline intersection<strlit<wchar_t const*>, B>
operator&(wchar_t const* a, parser<B> const& b)
{
return intersection<strlit<wchar_t const*>, B>(a, b.derived());
}
///////////////////////////////////////////////////////////////////////////////
//
// difference class implementation
//
///////////////////////////////////////////////////////////////////////////////
template <typename A, typename B>
inline difference<A, B>
operator-(parser<A> const& a, parser<B> const& b)
{
return difference<A, B>(a.derived(), b.derived());
}
//////////////////////////////////
template <typename A>
inline difference<A, chlit<char> >
operator-(parser<A> const& a, char b)
{
return difference<A, chlit<char> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline difference<chlit<char>, B>
operator-(char a, parser<B> const& b)
{
return difference<chlit<char>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline difference<A, strlit<char const*> >
operator-(parser<A> const& a, char const* b)
{
return difference<A, strlit<char const*> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline difference<strlit<char const*>, B>
operator-(char const* a, parser<B> const& b)
{
return difference<strlit<char const*>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline difference<A, chlit<wchar_t> >
operator-(parser<A> const& a, wchar_t b)
{
return difference<A, chlit<wchar_t> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline difference<chlit<wchar_t>, B>
operator-(wchar_t a, parser<B> const& b)
{
return difference<chlit<wchar_t>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline difference<A, strlit<wchar_t const*> >
operator-(parser<A> const& a, wchar_t const* b)
{
return difference<A, strlit<wchar_t const*> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline difference<strlit<wchar_t const*>, B>
operator-(wchar_t const* a, parser<B> const& b)
{
return difference<strlit<wchar_t const*>, B>(a, b.derived());
}
///////////////////////////////////////////////////////////////////////////////
//
// exclusive_or class implementation
//
///////////////////////////////////////////////////////////////////////////////
template <typename A, typename B>
inline exclusive_or<A, B>
operator^(parser<A> const& a, parser<B> const& b)
{
return exclusive_or<A, B>(a.derived(), b.derived());
}
//////////////////////////////////
template <typename A>
inline exclusive_or<A, chlit<char> >
operator^(parser<A> const& a, char b)
{
return exclusive_or<A, chlit<char> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline exclusive_or<chlit<char>, B>
operator^(char a, parser<B> const& b)
{
return exclusive_or<chlit<char>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline exclusive_or<A, strlit<char const*> >
operator^(parser<A> const& a, char const* b)
{
return exclusive_or<A, strlit<char const*> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline exclusive_or<strlit<char const*>, B>
operator^(char const* a, parser<B> const& b)
{
return exclusive_or<strlit<char const*>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline exclusive_or<A, chlit<wchar_t> >
operator^(parser<A> const& a, wchar_t b)
{
return exclusive_or<A, chlit<wchar_t> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline exclusive_or<chlit<wchar_t>, B>
operator^(wchar_t a, parser<B> const& b)
{
return exclusive_or<chlit<wchar_t>, B>(a, b.derived());
}
//////////////////////////////////
template <typename A>
inline exclusive_or<A, strlit<wchar_t const*> >
operator^(parser<A> const& a, wchar_t const* b)
{
return exclusive_or<A, strlit<wchar_t const*> >(a.derived(), b);
}
//////////////////////////////////
template <typename B>
inline exclusive_or<strlit<wchar_t const*>, B>
operator^(wchar_t const* a, parser<B> const& b)
{
return exclusive_or<strlit<wchar_t const*>, B>(a, b.derived());
}
///////////////////////////////////////////////////////////////////////////////
//
// optional class implementation
//
///////////////////////////////////////////////////////////////////////////////
template <typename S>
optional<S>
operator!(parser<S> const& a)
{
return optional<S>(a.derived());
}
///////////////////////////////////////////////////////////////////////////////
//
// kleene_star class implementation
//
///////////////////////////////////////////////////////////////////////////////
template <typename S>
inline kleene_star<S>
operator*(parser<S> const& a)
{
return kleene_star<S>(a.derived());
}
///////////////////////////////////////////////////////////////////////////////
//
// positive class implementation
//
///////////////////////////////////////////////////////////////////////////////
template <typename S>
inline positive<S>
operator+(parser<S> const& a)
{
return positive<S>(a.derived());
}
///////////////////////////////////////////////////////////////////////////////
//
// operator% is defined as:
// a % b ---> a >> *(b >> a)
//
///////////////////////////////////////////////////////////////////////////////
template <typename A, typename B>
inline sequence<A, kleene_star<sequence<B, A> > >
operator%(parser<A> const& a, parser<B> const& b)
{
return a.derived() >> *(b.derived() >> a.derived());
}
//////////////////////////////////
template <typename A>
inline sequence<A, kleene_star<sequence<chlit<char>, A> > >
operator%(parser<A> const& a, char b)
{
return a.derived() >> *(b >> a.derived());
}
//////////////////////////////////
template <typename B>
inline sequence<chlit<char>, kleene_star<sequence<B, chlit<char> > > >
operator%(char a, parser<B> const& b)
{
return a >> *(b.derived() >> a);
}
//////////////////////////////////
template <typename A>
inline sequence<A, kleene_star<sequence<strlit<char const*>, A> > >
operator%(parser<A> const& a, char const* b)
{
return a.derived() >> *(b >> a.derived());
}
//////////////////////////////////
template <typename B>
inline sequence<strlit<char const*>,
kleene_star<sequence<B, strlit<char const*> > > >
operator%(char const* a, parser<B> const& b)
{
return a >> *(b.derived() >> a);
}
//////////////////////////////////
template <typename A>
inline sequence<A, kleene_star<sequence<chlit<wchar_t>, A> > >
operator%(parser<A> const& a, wchar_t b)
{
return a.derived() >> *(b >> a.derived());
}
//////////////////////////////////
template <typename B>
inline sequence<chlit<wchar_t>, kleene_star<sequence<B, chlit<wchar_t> > > >
operator%(wchar_t a, parser<B> const& b)
{
return a >> *(b.derived() >> a);
}
//////////////////////////////////
template <typename A>
inline sequence<A, kleene_star<sequence<strlit<wchar_t const*>, A> > >
operator%(parser<A> const& a, wchar_t const* b)
{
return a.derived() >> *(b >> a.derived());
}
//////////////////////////////////
template <typename B>
inline sequence<strlit<wchar_t const*>,
kleene_star<sequence<B, strlit<wchar_t const*> > > >
operator%(wchar_t const* a, parser<B> const& b)
{
return a >> *(b.derived() >> a);
}
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif

1090
include/boost/spirit/core/composite/operators.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

3
include/boost/spirit/core/impl/Makefile.am Normal file
View File

@@ -0,0 +1,3 @@
#This file generated by Makefileamgen.sh
spiritinclude_HEADERS = basics.ipp match.ipp msvc.hpp parser.ipp
spiritincludedir = $(includedir)/spirit/boost/spirit/core/impl

51
include/boost/spirit/core/impl/basics.ipp Normal file
View File

@@ -0,0 +1,51 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001-2003 Joel de Guzman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined BOOST_SPIRIT_BASICS_IPP
#define BOOST_SPIRIT_BASICS_IPP
///////////////////////////////////////////////////////////////////////////////
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
namespace boost { namespace spirit {
//////////////////////////////////
template <bool C>
struct bool_t;
typedef bool_t<false> false_t;
namespace impl
{
//////////////////////////////////
struct chooser0
{
template <typename A, typename B>
struct result { typedef A type; };
};
//////////////////////////////////
struct chooser1
{
template <typename A, typename B>
struct result { typedef B type; };
};
//////////////////////////////////
template <typename C> struct chooser
{ typedef chooser0 type; };
template <> struct chooser<false_t>
{ typedef chooser1 type; };
}
}} // namespace boost::spirit
#endif
#endif

180
include/boost/spirit/core/impl/match.ipp Normal file
View File

@@ -0,0 +1,180 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_MATCH_IPP)
#define BOOST_SPIRIT_MATCH_IPP
///////////////////////////////////////////////////////////////////////////////
#include <boost/ref.hpp>
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
template <typename T>
class match;
namespace impl
{
///////////////////////////////////////////////////////////////////////
//
// Assignment of the match result
//
// Implementation note: This assignment is wrapped by a
// template to allow its specialization for other types
// elsewhere.
//
///////////////////////////////////////////////////////////////////////
template <typename T1>
struct convert
{
template <typename T>
static T
to_result(T1 const &t) { return T(t); }
};
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
struct match_attr_helper1 // T is not a boost::reference_wrapper
{
template <typename T>
struct apply
{
template <typename MatchT>
static T get(MatchT const& m)
{ return T(m.value()); }
static T get(match<nil_t> const&)
{ return T(); }
static T get_default()
{ return T(); }
};
};
struct match_attr_helper2 // T is a boost::reference_wrapper
{
template <typename T>
struct apply
{
template <typename MatchT>
static T get(MatchT const& m)
{
return convert<typename MatchT::attr_t>
::template to_result<T>(m.value());
}
static T get(match<nil_t> const&)
{
typedef typename T::type plain_type;
static plain_type v;
return T(v);
}
static T get_default()
{
typedef typename T::type plain_type;
static plain_type v;
return T(v);
}
};
};
template <typename T>
struct match_attr
{
typedef if_t<
bool_t<boost::is_reference_wrapper<T>::value>, // IF
match_attr_helper2, // THEN
match_attr_helper1 // ELSE
>::type select_t;
template <typename MatchT>
static T get(MatchT const& m)
{ return select_t::template apply<T>::get(m); }
static T get(match<nil_t> const& m)
{ return select_t::template apply<T>::get(m); }
static T get_default()
{ return select_t::template apply<T>::get_default(); }
};
#else // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template <typename T>
struct match_attr
{
template <typename MatchT>
static T get(MatchT const& m)
{
return convert<typename MatchT::attr_t>
::template to_result<T>(m.value());
}
static T get(match<nil_t> const&)
{ return T(); }
static T get_default()
{ return T(); }
};
template <typename T>
struct match_attr<boost::reference_wrapper<T> >
{
template <typename MatchT>
static boost::reference_wrapper<T>
get(MatchT const& m)
{ return boost::reference_wrapper<T>(m.value()); }
static boost::reference_wrapper<T>
get(match<nil_t> const&)
{
static T v;
return boost::reference_wrapper<T>(v);
}
static boost::reference_wrapper<T>
get_default()
{
static T v;
return boost::reference_wrapper<T>(v);
}
};
#endif // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template <>
struct match_attr<nil_t>
{
template <typename MatchT>
static nil_t get(MatchT const&)
{ return nil_t(); }
static nil_t get_default()
{ return nil_t(); }
};
#if !defined(__BORLANDC__)
struct dummy { void nonnull() {}; };
typedef void (dummy::*safe_bool)();
#else
typedef bool safe_bool;
#endif
#if !defined(__BORLANDC__)
#define BOOST_SPIRIT_SAFE_BOOL(cond) ((cond) ? &impl::dummy::nonnull : 0)
#else
#define BOOST_SPIRIT_SAFE_BOOL(cond) (cond)
#endif
}}} // namespace boost::spirit::impl
#endif

211
include/boost/spirit/core/impl/msvc.hpp Normal file
View File

@@ -0,0 +1,211 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Joel de Guzman
Copyright (c) 2002 Raghavendra Satish
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#ifndef BOOST_SPIRIT_MSVC_HPP
#define BOOST_SPIRIT_MSVC_HPP
#if (defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)) \
|| (defined(BOOST_INTEL_CXX_VERSION) && !defined(_STLPORT_VERSION))
#include <iterator>
namespace boost { namespace spirit { namespace impl {
#if !defined(BOOST_INTEL_CXX_VERSION)
//////////////////////////////////
template< typename T >
struct msvc_never_true
{ enum { value = false }; };
// warning: not a well-formed C++
// workaround for MSVC 6.5's "dependent template typedef bug"
// workaround by Aleksey Gurtovoy (from boost::mpl library)
//////////////////////////////////
#define BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER(name, templ) \
namespace impl \
{ \
template <typename F> \
struct name \
{ \
template <bool> struct f_ : F {}; \
\
template <> struct f_<true> \
{ \
template <typename P> \
struct templ { typedef P param_t; }; \
}; \
\
template <typename T> struct result_ \
: f_<msvc_never_true<F>::value>::template templ<T> \
{ \
typedef f_<msvc_never_true<F>::value>:: \
template templ<T> param_t; \
}; \
}; \
} \
#define BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER2(name, templ) \
namespace impl \
{ \
template <typename F> \
struct name \
{ \
template <bool> struct f_ : F {}; \
\
template <> struct f_<true> \
{ \
template <typename T1, typename T2> \
struct templ { typedef T1 param_t; }; \
}; \
\
template <typename T1, typename T2> struct result_ \
: f_<msvc_never_true<F>::value>::template templ<T1, T2> \
{ \
typedef f_<msvc_never_true<F>::value>:: \
template templ<T1, T2> param_t; \
}; \
}; \
} \
#define BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER3(name, templ) \
namespace impl \
{ \
template <typename F> \
struct name \
{ \
template <bool> struct f_ : F {}; \
\
template <> struct f_<true> \
{ \
template <typename T1, typename T2, typename T3> \
struct templ { typedef T1 param_t; }; \
}; \
\
template <typename T1, typename T2, typename T3> struct result_ \
: f_<msvc_never_true<F>::value>::template templ<T1, T2, T3> \
{ \
typedef f_<msvc_never_true<F>::value>:: \
template templ<T1, T2, T3> param_t; \
}; \
}; \
} \
#define BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER4(name, templ) \
namespace impl \
{ \
template <typename F> \
struct name \
{ \
template <bool> struct f_ : F {}; \
\
template <> struct f_<true> \
{ \
template < \
typename T1, typename T2, typename T3, typename T4> \
struct templ { typedef T1 param_t; }; \
}; \
\
template <typename T1, typename T2, typename T3, typename T4> \
struct result_ \
: f_<msvc_never_true<F>::value>::template templ<T1, T2, T3, T4> \
{ \
typedef f_<msvc_never_true<F>::value>:: \
template templ<T1, T2, T3, T4> param_t; \
}; \
}; \
} \
#endif
///////////////////////////////////////////////////////////////////////
//
// Iterator traits require partial specialization. The VC++
// iterator_traits class in "utility" does not define pointer
// or reference types. The "difference_type" is called the
// distance_type to enure conformity we define an iterator
// traits class inside spirit namespace. The user will have to
// SPECIALIZE this iterator type if they use iterators
//
///////////////////////////////////////////////////////////////////////
template<typename IterT>
struct iterator_traits
{
typedef typename IterT::difference_type difference_type;
typedef typename IterT::value_type value_type;
typedef typename IterT::pointer pointer;
typedef typename IterT::reference reference;
typedef typename IterT::iterator_category iterator_category;
};
//commonly used iterator_traits
template<>
struct iterator_traits<char const*>
{
typedef std::random_access_iterator_tag iterator_category;
typedef char value_type;
typedef ptrdiff_t difference_type;
typedef const char* pointer;
typedef const char& reference;
};
template<>
struct iterator_traits<char*>
{
typedef std::random_access_iterator_tag iterator_category;
typedef char value_type;
typedef ptrdiff_t difference_type;
typedef char* pointer;
typedef char& reference;
};
template<>
struct iterator_traits<wchar_t const*>
{
typedef std::random_access_iterator_tag iterator_category;
typedef wchar_t value_type;
typedef ptrdiff_t difference_type;
typedef const wchar_t* pointer;
typedef const wchar_t& reference;
};
template<>
struct iterator_traits<wchar_t*>
{
typedef std::random_access_iterator_tag iterator_category;
typedef wchar_t value_type;
typedef ptrdiff_t difference_type;
typedef wchar_t* pointer;
typedef wchar_t& reference;
};
// the istream_iterator of VC++6.0 doesn't have the appropriate
// traits classes defined. For supporting multi-pass
template<>
struct iterator_traits<
#if defined (_STLPORT_VERSION)
std::istream_iterator<char> >
#else
std::istream_iterator<unsigned char, char, std::char_traits<char> > >
#endif
{
typedef std::forward_iterator_tag iterator_category;
typedef char* pointer;
typedef char& reference;
typedef char value_type;
typedef ptrdiff_t difference_type;
};
}}} // namespace boost::spirit::impl
#endif
#endif

56
include/boost/spirit/core/impl/parser.ipp Normal file
View File

@@ -0,0 +1,56 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_PARSER_IPP)
#define BOOST_SPIRIT_PARSER_IPP
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////
//
// Generic parse function implementation
//
///////////////////////////////////////////////////////////////////////////
template <typename IteratorT, typename DerivedT>
inline parse_info<IteratorT>
parse(
IteratorT const& first_,
IteratorT const& last,
parser<DerivedT> const& p)
{
IteratorT first = first_;
scanner<IteratorT, scanner_policies<> > scan(first, last);
match<nil_t> hit = p.derived().parse(scan);
return parse_info<IteratorT>(
first, hit, hit && (first == last), hit.length());
}
///////////////////////////////////////////////////////////////////////////
//
// Parse function for null terminated strings implementation
//
///////////////////////////////////////////////////////////////////////////
template <typename CharT, typename DerivedT>
inline parse_info<CharT const*>
parse(
CharT const* str,
parser<DerivedT> const& p)
{
CharT const* last = str;
while (*last)
last++;
return parse(str, last, p);
}
}} // namespace boost::spirit
#endif

162
include/boost/spirit/core/match.hpp Normal file
View File

@@ -0,0 +1,162 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_MATCH_HPP)
#define BOOST_SPIRIT_MATCH_HPP
///////////////////////////////////////////////////////////////////////////////
#include "boost/call_traits.hpp"
#if !defined(BOOST_SPIRIT_BASICS_HPP)
#include "boost/spirit/core/basics.hpp"
#endif
#if !defined(BOOST_SPIRIT_MATCH_IPP)
#include "boost/spirit/core/impl/match.ipp"
#endif
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////
//
// match class
//
// The match holds the result of a parser. A match object evaluates
// to true when a succesful match is found, otherwise false. The
// length of the match is the number of characters (or tokens) that
// is successfully matched. This can be queried through its length()
// member function. A negative value means that the match is
// unsucessful.
//
// Each parser may have an associated attribute. This attribute is
// also returned back to the client on a successful parse through
// the match object. The match's value() member function returns a
// reference to this value.
//
///////////////////////////////////////////////////////////////////////////
template <typename T = nil_t>
class match
{
public:
typedef T attr_t;
typedef typename boost::call_traits<T>::param_type param_type;
typedef typename boost::call_traits<T>::reference reference;
typedef typename boost::call_traits<T>::const_reference const_reference;
match()
: len(-1), val(impl::match_attr<T>::get_default()) {}
explicit
match(unsigned length)
: len(length), val((impl::match_attr<T>::get_default())) {}
match(unsigned length, param_type val_)
: len(length), val(val_) {}
operator impl::safe_bool() const
{ return BOOST_SPIRIT_SAFE_BOOL(len >= 0); }
bool operator!() const
{ return len < 0; }
int length() const { return len; }
const_reference value() const { return val; }
reference value() { return val; }
template <typename T2>
match(match<T2> const& other)
: len(other.length()), val(impl::match_attr<T>::get(other)) {}
template <typename T2>
match&
operator=(match<T2> const& other)
{
len = other.length();
val = impl::match_attr<T>::get(other);
return *this;
}
template <typename MatchT>
void
concat(MatchT const& other)
{
BOOST_SPIRIT_ASSERT(*this && other);
len += other.length();
}
private:
int len;
T val;
};
///////////////////////////////////////////////////////////////////////////
//
// match class specialization for nil_t values
//
///////////////////////////////////////////////////////////////////////////
template <>
class match<nil_t>
{
public:
typedef nil_t attr_t;
match()
: len(-1) {}
explicit
match(unsigned length)
: len(length) {}
match(unsigned length, nil_t)
: len(length) {}
operator impl::safe_bool() const
{ return BOOST_SPIRIT_SAFE_BOOL(len >= 0); }
bool operator!() const
{ return len < 0; }
int length() const { return len; }
nil_t value() const { return nil_t(); }
template <typename T>
match(match<T> const& other)
: len(other.length()) {}
template <typename T>
match<>&
operator=(match<T> const& other)
{
len = other.length();
return *this;
}
template <typename T>
void
concat(match<T> const& other)
{
BOOST_SPIRIT_ASSERT(*this && other);
len += other.length();
}
private:
int len;
};
}} // namespace boost::spirit
#endif

4
include/boost/spirit/core/meta/Makefile.am Normal file
View File

@@ -0,0 +1,4 @@
#This file generated by Makefileamgen.sh
SUBDIRS = impl
spiritinclude_HEADERS = fundamental.hpp parser_traits.hpp traverse.hpp
spiritincludedir = $(includedir)/spirit/boost/spirit/core/meta

93
include/boost/spirit/core/meta/fundamental.hpp Normal file
View File

@@ -0,0 +1,93 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_FUNDAMENTAL_HPP)
#define BOOST_SPIRIT_FUNDAMENTAL_HPP
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/core/meta/impl/fundamental.ipp"
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
//
// Helper template for counting the number of nodes contained in a
// given parser type.
// All parser_category type parsers are counted as nodes.
//
///////////////////////////////////////////////////////////////////////////////
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
template <typename ParserT>
struct node_count {
typedef typename ParserT::parser_category_t parser_category_t;
typedef impl::nodes<parser_category_t> nodes_t;
typedef typename impl::count_wrapper<nodes_t>
::template result_<ParserT, int_t<0> > count_t;
BOOST_STATIC_CONSTANT(int, value = count_t::value);
};
#else
template <typename ParserT>
struct node_count {
typedef typename ParserT::parser_category_t parser_category_t;
typedef typename impl::nodes<parser_category_t>
::template count<ParserT, int_t<0> > count_t;
BOOST_STATIC_CONSTANT(int, value = count_t::value);
};
#endif
///////////////////////////////////////////////////////////////////////////////
//
// Helper template for counting the number of leaf nodes contained in a
// given parser type.
// Only plain_parser_category type parsers are counted as leaf nodes.
//
///////////////////////////////////////////////////////////////////////////////
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
template <typename ParserT>
struct leaf_count {
typedef typename ParserT::parser_category_t parser_category_t;
typedef impl::leafs<parser_category_t> nodes_t;
typedef typename impl::count_wrapper<nodes_t>
::template result_<ParserT, int_t<0> > count_t;
BOOST_STATIC_CONSTANT(int, value = count_t::value);
};
#else
template <typename ParserT>
struct leaf_count {
typedef typename ParserT::parser_category_t parser_category_t;
typedef typename impl::leafs<parser_category_t>
::template count<ParserT, int_t<0> > count_t;
BOOST_STATIC_CONSTANT(int, value = count_t::value);
};
#endif
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif // !defined(BOOST_SPIRIT_FUNDAMENTAL_HPP)

3
include/boost/spirit/core/meta/impl/Makefile.am Normal file
View File

@@ -0,0 +1,3 @@
#This file generated by Makefileamgen.sh
spiritinclude_HEADERS = fundamental.ipp parser_traits.ipp parser_type.hpp traverse.ipp
spiritincludedir = $(includedir)/spirit/boost/spirit/core/meta/impl

306
include/boost/spirit/core/meta/impl/fundamental.ipp Normal file
View File

@@ -0,0 +1,306 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_FUNDAMENTAL_IPP)
#define BOOST_SPIRIT_FUNDAMENTAL_IPP
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER2(count_wrapper, count);
#endif // defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
namespace impl
{
///////////////////////////////////////////////////////////////////////////
//
// Helper template for counting the number of nodes contained in a
// given parser type.
// All parser_category type parsers are counted as nodes.
//
///////////////////////////////////////////////////////////////////////////
template <typename CategoryT>
struct nodes;
template <>
struct nodes<plain_parser_category> {
template <typename ParserT, typename LeafCountT>
struct count {
// __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT
enum { value = (LeafCountT::value + 1) };
};
};
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
template <>
struct nodes<unary_parser_category> {
template <typename ParserT, typename LeafCountT>
struct count {
typedef typename ParserT::subject_t subject_t;
typedef typename subject_t::parser_category_t subject_category_t;
typedef nodes<subject_category_t> nodes_t;
typedef typename count_wrapper<nodes_t>
::template result_<subject_t, LeafCountT> count_t;
BOOST_STATIC_CONSTANT(int, value = count_t::value + 1);
};
};
template <>
struct nodes<action_parser_category> {
template <typename ParserT, typename LeafCountT>
struct count {
typedef typename ParserT::subject_t subject_t;
typedef typename subject_t::parser_category_t subject_category_t;
typedef nodes<subject_category_t> nodes_t;
typedef typename count_wrapper<nodes_t>
::template result_<subject_t, LeafCountT> count_t;
BOOST_STATIC_CONSTANT(int, value = count_t::value + 1);
};
};
template <>
struct nodes<binary_parser_category> {
template <typename ParserT, typename LeafCountT>
struct count {
typedef typename ParserT::left_t left_t;
typedef typename ParserT::right_t right_t;
typedef typename left_t::parser_category_t left_category_t;
typedef typename right_t::parser_category_t right_category_t;
typedef nodes<left_category_t> left_nodes_t;
typedef typename count_wrapper<left_nodes_t>
::template result_<left_t, LeafCountT> left_count_t;
typedef nodes<right_category_t> right_nodes_t;
typedef typename count_wrapper<right_nodes_t>
::template result_<right_t, LeafCountT> right_count_t;
BOOST_STATIC_CONSTANT(int,
value = (left_count_t::value + right_count_t::value + 1));
};
};
#else
template <>
struct nodes<unary_parser_category> {
template <typename ParserT, typename LeafCountT>
struct count {
typedef typename ParserT::subject_t subject_t;
typedef typename subject_t::parser_category_t subject_category_t;
// __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT
enum { value = (nodes<subject_category_t>
::template count<subject_t, LeafCountT>::value + 1) };
};
};
template <>
struct nodes<action_parser_category> {
template <typename ParserT, typename LeafCountT>
struct count {
typedef typename ParserT::subject_t subject_t;
typedef typename subject_t::parser_category_t subject_category_t;
// __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT
enum { value = (nodes<subject_category_t>
::template count<subject_t, LeafCountT>::value + 1) };
};
};
template <>
struct nodes<binary_parser_category> {
template <typename ParserT, typename LeafCountT>
struct count {
typedef typename ParserT::left_t left_t;
typedef typename ParserT::right_t right_t;
typedef typename left_t::parser_category_t left_category_t;
typedef typename right_t::parser_category_t right_category_t;
typedef count self_t;
// __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT
enum {
leftcount = (nodes<left_category_t>
::template count<left_t, LeafCountT>::value),
rightcount = (nodes<right_category_t>
::template count<right_t, LeafCountT>::value),
value = ((self_t::leftcount) + (self_t::rightcount) + 1)
};
};
};
#endif
///////////////////////////////////////////////////////////////////////////
//
// Helper template for counting the number of leaf nodes contained in a
// given parser type.
// Only plain_parser_category type parsers are counted as leaf nodes.
//
///////////////////////////////////////////////////////////////////////////
template <typename CategoryT>
struct leafs;
template <>
struct leafs<plain_parser_category> {
template <typename ParserT, typename LeafCountT>
struct count {
// __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT
enum { value = (LeafCountT::value + 1) };
};
};
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
template <>
struct leafs<unary_parser_category> {
template <typename ParserT, typename LeafCountT>
struct count {
typedef typename ParserT::subject_t subject_t;
typedef typename subject_t::parser_category_t subject_category_t;
typedef leafs<subject_category_t> nodes_t;
typedef typename count_wrapper<nodes_t>
::template result_<subject_t, LeafCountT> count_t;
BOOST_STATIC_CONSTANT(int, value = count_t::value);
};
};
template <>
struct leafs<action_parser_category> {
template <typename ParserT, typename LeafCountT>
struct count {
typedef typename ParserT::subject_t subject_t;
typedef typename subject_t::parser_category_t subject_category_t;
typedef leafs<subject_category_t> nodes_t;
typedef typename count_wrapper<nodes_t>
::template result_<subject_t, LeafCountT> count_t;
BOOST_STATIC_CONSTANT(int, value = count_t::value);
};
};
template <>
struct leafs<binary_parser_category> {
template <typename ParserT, typename LeafCountT>
struct count {
typedef typename ParserT::left_t left_t;
typedef typename ParserT::right_t right_t;
typedef typename left_t::parser_category_t left_category_t;
typedef typename right_t::parser_category_t right_category_t;
typedef leafs<left_category_t> left_nodes_t;
typedef typename count_wrapper<left_nodes_t>
::template result_<left_t, LeafCountT> left_count_t;
typedef leafs<right_category_t> right_nodes_t;
typedef typename count_wrapper<right_nodes_t>
::template result_<right_t, LeafCountT> right_count_t;
BOOST_STATIC_CONSTANT(int,
value = (left_count_t::value + right_count_t::value));
};
};
#else
template <>
struct leafs<unary_parser_category> {
template <typename ParserT, typename LeafCountT>
struct count {
typedef typename ParserT::subject_t subject_t;
typedef typename subject_t::parser_category_t subject_category_t;
// __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT
enum { value = (leafs<subject_category_t>
::template count<subject_t, LeafCountT>::value) };
};
};
template <>
struct leafs<action_parser_category> {
template <typename ParserT, typename LeafCountT>
struct count {
typedef typename ParserT::subject_t subject_t;
typedef typename subject_t::parser_category_t subject_category_t;
// __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT
enum { value = (leafs<subject_category_t>
::template count<subject_t, LeafCountT>::value) };
};
};
template <>
struct leafs<binary_parser_category> {
template <typename ParserT, typename LeafCountT>
struct count {
typedef typename ParserT::left_t left_t;
typedef typename ParserT::right_t right_t;
typedef typename left_t::parser_category_t left_category_t;
typedef typename right_t::parser_category_t right_category_t;
typedef count self_t;
// __BORLANDC__ == 0x0561 isn't happy with BOOST_STATIC_CONSTANT
enum {
leftcount = (leafs<left_category_t>
::template count<left_t, LeafCountT>::value),
rightcount = (leafs<right_category_t>
::template count<right_t, LeafCountT>::value),
value = (self_t::leftcount + self_t::rightcount)
};
};
};
#endif
} // namespace impl
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif // !defined(BOOST_SPIRIT_FUNDAMENTAL_IPP)

200
include/boost/spirit/core/meta/impl/parser_traits.ipp Normal file
View File

@@ -0,0 +1,200 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Joel de Guzman
Copyright (c) 2002-2003 Hartmut Kaiser
Copyright (c) 2003 Martin Wille
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_PARSER_TRAITS_IPP)
#define BOOST_SPIRIT_PARSER_TRAITS_IPP
#include "boost/spirit/core/composite/operators.hpp"
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
namespace impl
{
struct is_parser_helper
{
typedef struct { char dummy[1]; } no;
typedef struct { no dummy[2]; } yes;
template <typename T>
static yes test(parser<T> const *);
static no test(...);
};
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
///////////////////////////////////////////////////////////////////////////
//
// from spirit 1.1 (copyright (c) 2001 Bruce Florman)
// various workarounds to support compile time decisions without partial
// template specialization whether a given type is an instance of a
// concrete parser type.
//
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
template <typename T>
struct parser_type_traits
{
// Determine at compile time (without partial specialization)
// whether a given type is an instance of the alternative<A,B>
static T t();
typedef struct { char dummy[1]; } size1_t;
typedef struct { char dummy[2]; } size2_t;
typedef struct { char dummy[3]; } size3_t;
typedef struct { char dummy[4]; } size4_t;
typedef struct { char dummy[5]; } size5_t;
typedef struct { char dummy[6]; } size6_t;
typedef struct { char dummy[7]; } size7_t;
typedef struct { char dummy[8]; } size8_t;
typedef struct { char dummy[9]; } size9_t;
typedef struct { char dummy[10]; } size10_t;
// the following functions need no implementation
template <typename A, typename B>
static size1_t test_(alternative<A, B> const&);
template <typename A, typename B>
static size2_t test_(sequence<A, B> const&);
template <typename A, typename B>
static size3_t test_(sequential_or<A, B> const&);
template <typename A, typename B>
static size4_t test_(intersection<A, B> const&);
template <typename A, typename B>
static size5_t test_(difference<A, B> const&);
template <typename A, typename B>
static size6_t test_(exclusive_or<A, B> const&);
template <typename S>
static size7_t test_(optional<S> const&);
template <typename S>
static size8_t test_(kleene_star<S> const&);
template <typename S>
static size9_t test_(positive<S> const&);
static size10_t test_(...);
BOOST_STATIC_CONSTANT(bool,
is_alternative = (sizeof(size1_t) == sizeof(test_(t()))) );
BOOST_STATIC_CONSTANT(bool,
is_sequence = (sizeof(size2_t) == sizeof(test_(t()))) );
BOOST_STATIC_CONSTANT(bool,
is_sequential_or = (sizeof(size3_t) == sizeof(test_(t()))) );
BOOST_STATIC_CONSTANT(bool,
is_intersection = (sizeof(size4_t) == sizeof(test_(t()))) );
BOOST_STATIC_CONSTANT(bool,
is_difference = (sizeof(size5_t) == sizeof(test_(t()))) );
BOOST_STATIC_CONSTANT(bool,
is_exclusive_or = (sizeof(size6_t) == sizeof(test_(t()))) );
BOOST_STATIC_CONSTANT(bool,
is_optional = (sizeof(size7_t) == sizeof(test_(t()))) );
BOOST_STATIC_CONSTANT(bool,
is_kleene_star = (sizeof(size8_t) == sizeof(test_(t()))) );
BOOST_STATIC_CONSTANT(bool,
is_positive = (sizeof(size9_t) == sizeof(test_(t()))) );
};
#else
///////////////////////////////////////////////////////////////////////////
struct parser_type_traits_base {
BOOST_STATIC_CONSTANT(bool, is_alternative = false);
BOOST_STATIC_CONSTANT(bool, is_sequence = false);
BOOST_STATIC_CONSTANT(bool, is_sequential_or = false);
BOOST_STATIC_CONSTANT(bool, is_intersection = false);
BOOST_STATIC_CONSTANT(bool, is_difference = false);
BOOST_STATIC_CONSTANT(bool, is_exclusive_or = false);
BOOST_STATIC_CONSTANT(bool, is_optional = false);
BOOST_STATIC_CONSTANT(bool, is_kleene_star = false);
BOOST_STATIC_CONSTANT(bool, is_positive = false);
};
template <typename ParserT>
struct parser_type_traits : public parser_type_traits_base {
// no definition here, fallback for all not explicitly mentioned parser
// types
};
template <typename A, typename B>
struct parser_type_traits<alternative<A, B> >
: public parser_type_traits_base {
BOOST_STATIC_CONSTANT(bool, is_alternative = true);
};
template <typename A, typename B>
struct parser_type_traits<sequence<A, B> >
: public parser_type_traits_base {
BOOST_STATIC_CONSTANT(bool, is_sequence = true);
};
template <typename A, typename B>
struct parser_type_traits<sequential_or<A, B> >
: public parser_type_traits_base {
BOOST_STATIC_CONSTANT(bool, is_sequential_or = true);
};
template <typename A, typename B>
struct parser_type_traits<intersection<A, B> >
: public parser_type_traits_base {
BOOST_STATIC_CONSTANT(bool, is_intersection = true);
};
template <typename A, typename B>
struct parser_type_traits<difference<A, B> >
: public parser_type_traits_base {
BOOST_STATIC_CONSTANT(bool, is_difference = true);
};
template <typename A, typename B>
struct parser_type_traits<exclusive_or<A, B> >
: public parser_type_traits_base {
BOOST_STATIC_CONSTANT(bool, is_exclusive_or = true);
};
template <typename S>
struct parser_type_traits<optional<S> >
: public parser_type_traits_base {
BOOST_STATIC_CONSTANT(bool, is_optional = true);
};
template <typename S>
struct parser_type_traits<kleene_star<S> >
: public parser_type_traits_base {
BOOST_STATIC_CONSTANT(bool, is_kleene_star = true);
};
template <typename S>
struct parser_type_traits<positive<S> >
: public parser_type_traits_base {
BOOST_STATIC_CONSTANT(bool, is_positive = true);
};
#endif // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
} // namespace impl
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif // !defined(BOOST_SPIRIT_PARSER_TRAITS_IPP)

197
include/boost/spirit/core/meta/impl/parser_type.hpp Normal file
View File

@@ -0,0 +1,197 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Joel de Guzman
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_PARSER_TYPE_HPP)
#define BOOST_SPIRIT_PARSER_TYPE_HPP
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/core/primitives/primitives.hpp"
///////////////////////////////////////////////////////////////////////////////
//
// Helper templates to derive the parser type from an auxilliary type and to
// generate an object of the required parser type given an auxilliary object.
// Supported types to convert are parsers, single characters and character
// strings.
//
///////////////////////////////////////////////////////////////////////////////
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
///////////////////////////////////////////////////////////////////////////////
// conformant compilers support PTS
template<typename T>
struct as_parser
{
typedef T type;
static type const& convert(type const& p) { return p; }
};
template<>
struct as_parser<char>
{
typedef chlit<char> type;
static type convert(char ch) { return type(ch); }
};
template<>
struct as_parser<wchar_t>
{
typedef chlit<wchar_t> type;
static type convert(wchar_t ch) { return type(ch); }
};
template<>
struct as_parser<char const *>
{
typedef strlit<char const *> type;
static type convert(char const* str) { return type(str); }
};
template<>
struct as_parser<wchar_t const *>
{
typedef strlit<wchar_t const *> type;
static type convert(wchar_t const* str) { return type(str); }
};
#ifdef __BORLANDC__
template<>
struct as_parser<char*>
{
typedef strlit<char*> type;
static type convert(char* str) { return type(str); }
};
template<>
struct as_parser<wchar_t*>
{
typedef strlit<wchar_t*> type;
static type convert(wchar_t* str) { return type(str); }
};
#endif // __BORLANDC__
template<int N>
struct as_parser<char[N]>
{
typedef strlit<char const *> type;
static type convert(char const str[N]) { return type(str); }
};
template<int N>
struct as_parser<wchar_t[N]>
{
typedef strlit<wchar_t const *> type;
static type convert(wchar_t const str[N]) { return type(str); }
};
#if !defined(__MWERKS__) || (__MWERKS__ > 0x2407)
template<int N>
struct as_parser<char const[N]>
{
typedef strlit<char const *> type;
static type convert(char const str[N]) { return type(str); }
};
template<int N>
struct as_parser<wchar_t const[N]>
{
typedef strlit<wchar_t const *> type;
static type convert(wchar_t const str[N]) { return type(str); }
};
#endif // !defined(__MWERKS__) || (__MWERKS__ > 0x2407)
#else // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
///////////////////////////////////////////////////////////////////////////////
// some compilers do not support PTS
template<typename T>
struct as_parser
{
enum
{
is_cptr = boost::is_convertible<T, char const *>::value,
is_wcptr = boost::is_convertible<T, wchar_t const *>::value
};
// helps to dispatch to the correct version of get for char[] and T
typedef
typename if_t<bool_t<is_cptr || is_wcptr>, int_t<0>, int_t<1> >::type
selector_t;
// return type (type) and formal argument (arg_type) of convert
typedef
typename if_t<
bool_t<is_cptr>, char const *,
typename if_t<bool_t<is_wcptr>, wchar_t const *, T>::type
>::type
arg_type;
typedef
typename if_t<
bool_t<is_cptr>, strlit<char const *>,
typename if_t<bool_t<is_wcptr>, strlit<wchar_t const *>, T>::type
>::type
type;
static as_parser::type::embed_t convert(arg_type const &t)
{ return convert(t, selector_t()); }
private:
static as_parser::type::embed_t convert(arg_type str, int_t<0> sel)
{ return type(str); }
static as_parser::type::embed_t convert(arg_type const &p, int_t<1> sel)
{ return p; }
};
template<>
struct as_parser<char>
{
typedef chlit<char> type;
static type convert(char ch) { return type(ch); }
};
template<>
struct as_parser<wchar_t>
{
typedef chlit<wchar_t> type;
static type convert(wchar_t ch) { return type(ch); }
};
template<>
struct as_parser<char const *>
{
typedef strlit<char const *> type;
static type convert(char const* str) { return type(str);}
};
template<>
struct as_parser<wchar_t const *>
{
typedef strlit<wchar_t const *> type;
static type convert(wchar_t const* str) { return type(str);}
};
#endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif

553
include/boost/spirit/core/meta/impl/traverse.ipp Normal file
View File

@@ -0,0 +1,553 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Joel de Guzman
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_TRAVERSE_IPP)
#define BOOST_SPIRIT_TRAVERSE_IPP
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/core/meta/fundamental.hpp"
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
namespace impl
{
template <typename CategoryT>
struct traverse_post_order_return_category;
} // namespace impl
///////////////////////////////////////////////////////////////////////////////
//
// Environment class for post_order_traversal
//
///////////////////////////////////////////////////////////////////////////////
template <int Level, int Node, int Index, int LastLeft>
struct traverse_post_order_env {
BOOST_STATIC_CONSTANT(int, level = Level);
BOOST_STATIC_CONSTANT(int, node = Node);
BOOST_STATIC_CONSTANT(int, index = Index);
BOOST_STATIC_CONSTANT(int, lastleft = LastLeft);
};
///////////////////////////////////////////////////////////////////////////////
//
// traverse_post_order_return template
//
// This template is a helper for dispatching the calculation of a parser
// type result for a traversal level to the corresponding parser_category
// based specialization.
//
///////////////////////////////////////////////////////////////////////////////
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER3(
traverse_post_order_return_category_wrapper, result);
template <typename MetaT, typename ParserT, typename EnvT>
struct traverse_post_order_return {
typedef typename ParserT::parser_category_t parser_category_t;
typedef impl::traverse_post_order_return_category<parser_category_t> return_t;
typedef typename impl::traverse_post_order_return_category_wrapper<return_t>
::template result_<MetaT, ParserT, EnvT>::type type;
};
#else
template <typename MetaT, typename ParserT, typename EnvT>
struct traverse_post_order_return {
typedef typename ParserT::parser_category_t parser_category_t;
typedef typename impl::traverse_post_order_return_category<parser_category_t>
::template result<MetaT, ParserT, EnvT>::type type;
};
#endif
///////////////////////////////////////////////////////////////////////////////
//
// parser_traversal_..._result templates
//
// These are metafunctions, which calculate the resulting parser type
// for all subparsers and feed these types to the user supplied
// metafunctions to get back the resulting parser type of this traversal
// level.
//
///////////////////////////////////////////////////////////////////////////////
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER2(
parser_traversal_plain_result_wrapper, plain_result);
template <typename MetaT, typename ParserT, typename EnvT>
struct parser_traversal_plain_result {
// actual resulting parser type
typedef typename impl::parser_traversal_plain_result_wrapper<MetaT>
::template result_<ParserT, EnvT>::type nexttype;
typedef typename impl::parser_traversal_plain_result_wrapper<MetaT>
::template result_<ParserT, EnvT>::type type;
};
///////////////////////////////////////////////////////////////////////////////
BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER3(
parser_traversal_unary_result_wrapper, unary_result);
template <typename MetaT, typename UnaryT, typename SubjectT, typename EnvT>
struct parser_traversal_unary_result {
BOOST_STATIC_CONSTANT(int, inclevel = (EnvT::level+1));
BOOST_STATIC_CONSTANT(int, decnode = (EnvT::node-1));
// traversal environment and parser return type for the subject parser
typedef traverse_post_order_env<
inclevel, decnode, EnvT::index, EnvT::lastleft
>
subject_env_t;
typedef typename traverse_post_order_return<
MetaT, SubjectT, subject_env_t
>::type
subject_t;
// actual traversal environment and resulting parser type
typedef typename impl::parser_traversal_unary_result_wrapper<MetaT>
::template result_<UnaryT, subject_t, EnvT>::type nexttype;
typedef typename impl::parser_traversal_unary_result_wrapper<MetaT>
::template result_<UnaryT, SubjectT, EnvT>::type type;
};
///////////////////////////////////////////////////////////////////////////////
BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER3(
parser_traversal_action_result_wrapper, action_result);
template <typename MetaT, typename ActionT, typename SubjectT, typename EnvT>
struct parser_traversal_action_result {
BOOST_STATIC_CONSTANT(int, inclevel = (EnvT::level+1));
BOOST_STATIC_CONSTANT(int, decnode = (EnvT::node-1));
// traversal environment and parser return type for the subject parser
typedef traverse_post_order_env<
inclevel, decnode, EnvT::index, EnvT::lastleft
>
subject_env_t;
typedef typename traverse_post_order_return<
MetaT, SubjectT, subject_env_t
>::type
subject_t;
// actual traversal environment and resulting parser type
typedef typename impl::parser_traversal_action_result_wrapper<MetaT>
::template result_<ActionT, subject_t, EnvT>::type nexttype;
typedef typename impl::parser_traversal_action_result_wrapper<MetaT>
::template result_<ActionT, SubjectT, EnvT>::type type;
};
///////////////////////////////////////////////////////////////////////////////
BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER4(
parser_traversal_binary_result_wrapper, binary_result);
template <
typename MetaT, typename ParserT, typename LeftT,
typename RightT, typename EnvT
>
struct parser_traversal_binary_result {
BOOST_STATIC_CONSTANT(int,
thisnum = (node_count<ParserT>::value + EnvT::lastleft-1));
BOOST_STATIC_CONSTANT(int,
leftnum = (node_count<LeftT>::value + EnvT::lastleft-1));
BOOST_STATIC_CONSTANT(int, rightnum = (thisnum-1));
BOOST_STATIC_CONSTANT(int,
leafnum = (leaf_count<LeftT>::value + EnvT::index));
BOOST_STATIC_CONSTANT(int, inclevel = (EnvT::level+1));
BOOST_STATIC_CONSTANT(int, lastleft = (leftnum+1));
// left traversal environment and resulting parser type
typedef traverse_post_order_env<
inclevel, leftnum, EnvT::index, EnvT::lastleft
> left_sub_env_t;
typedef typename traverse_post_order_return<
MetaT, LeftT, left_sub_env_t
>::type
left_t;
// right traversal environment and resulting parser type
typedef traverse_post_order_env<
inclevel, rightnum, leafnum, lastleft
> right_sub_env_t;
typedef typename traverse_post_order_return<
MetaT, RightT, right_sub_env_t
>::type
right_t;
// actual traversal environment and resulting parser type
typedef traverse_post_order_env<
EnvT::level, thisnum, EnvT::index, EnvT::lastleft
> return_env_t;
typedef typename impl::parser_traversal_binary_result_wrapper<MetaT>
::template result_<ParserT, left_t, right_t, return_env_t>::type nexttype;
typedef typename impl::parser_traversal_binary_result_wrapper<MetaT>
::template result_<ParserT, left_t, right_t, EnvT>::type type;
};
#else
///////////////////////////////////////////////////////////////////////////////
template <typename MetaT, typename ParserT, typename EnvT>
struct parser_traversal_plain_result {
typedef typename MetaT::template plain_result<ParserT, EnvT>::type nexttype;
typedef typename MetaT::template plain_result<ParserT, EnvT>::type type;
};
///////////////////////////////////////////////////////////////////////////////
template <typename MetaT, typename UnaryT, typename SubjectT, typename EnvT>
struct parser_traversal_unary_result {
// traversal environment and parser return type for the subject parser
typedef traverse_post_order_env<
(EnvT::level+1), (EnvT::node-1), (EnvT::index), (EnvT::lastleft)
>
subject_env_t;
typedef typename traverse_post_order_return<
MetaT, SubjectT, subject_env_t
>::type
subject_t;
typedef typename MetaT
::template unary_result<UnaryT, subject_t, EnvT>::type nexttype;
typedef typename MetaT
::template unary_result<UnaryT, SubjectT, EnvT>::type type;
};
///////////////////////////////////////////////////////////////////////////////
template <typename MetaT, typename ActionT, typename SubjectT, typename EnvT>
struct parser_traversal_action_result {
// traversal environment and parser return type for the subject parser
typedef traverse_post_order_env<
(EnvT::level+1), (EnvT::node-1), (EnvT::index), (EnvT::lastleft)
>
subject_env_t;
typedef typename traverse_post_order_return<
MetaT, SubjectT, subject_env_t
>::type
subject_t;
typedef typename MetaT
::template action_result<ActionT, subject_t, EnvT>::type nexttype;
typedef typename MetaT
::template action_result<ActionT, SubjectT, EnvT>::type type;
};
///////////////////////////////////////////////////////////////////////////////
template <
typename MetaT, typename BinaryT, typename LeftT,
typename RightT, typename EnvT
>
struct parser_traversal_binary_result {
BOOST_STATIC_CONSTANT(int,
thisnum = (node_count<BinaryT>::value + EnvT::lastleft-1));
BOOST_STATIC_CONSTANT(int,
leftnum = (node_count<LeftT>::value + EnvT::lastleft-1));
BOOST_STATIC_CONSTANT(int,
leafnum = (leaf_count<LeftT>::value + EnvT::index));
typedef parser_traversal_binary_result self_t;
// left traversal environment and resulting parser type
typedef traverse_post_order_env<
(EnvT::level+1), (self_t::leftnum), (EnvT::index), (EnvT::lastleft)
> left_sub_env_t;
typedef typename traverse_post_order_return<
MetaT, LeftT, left_sub_env_t
>::type
left_t;
// right traversal environment and resulting parser type
typedef traverse_post_order_env<
(EnvT::level+1), (self_t::thisnum-1), (self_t::leafnum), (self_t::leftnum+1)
> right_sub_env_t;
typedef typename traverse_post_order_return<
MetaT, RightT, right_sub_env_t
>::type
right_t;
// actual traversal environment and resulting parser type
typedef traverse_post_order_env<
(EnvT::level), (self_t::thisnum), (EnvT::index), (EnvT::lastleft)
> return_env_t;
typedef typename MetaT::template binary_result<
BinaryT, left_t, right_t, return_env_t
>::type
nexttype;
typedef typename MetaT::template binary_result<
BinaryT, left_t, right_t, EnvT
>::type
type;
};
#endif // defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
///////////////////////////////////////////////////////////////////////////////
namespace impl
{
///////////////////////////////////////////////////////////////////////////
//
// Meta functions, which dispatch the calculation of the return type of
// of the post_order traverse function to the result template of the
// corresponding parser_category based metafunction template.
//
///////////////////////////////////////////////////////////////////////////
template <typename CategoryT>
struct traverse_post_order_return_category;
template <>
struct traverse_post_order_return_category<plain_parser_category> {
template <typename MetaT, typename ParserT, typename EnvT>
struct result {
typedef typename parser_traversal_plain_result<
MetaT, ParserT, EnvT
>::type
type;
};
};
template <>
struct traverse_post_order_return_category<unary_parser_category> {
template <typename MetaT, typename ParserT, typename EnvT>
struct result {
typedef typename parser_traversal_unary_result<
MetaT, ParserT, typename ParserT::subject_t, EnvT
>::type
type;
};
};
template <>
struct traverse_post_order_return_category<action_parser_category> {
template <typename MetaT, typename ParserT, typename EnvT>
struct result {
typedef typename parser_traversal_action_result<
MetaT, ParserT, typename ParserT::subject_t, EnvT
>::type
type;
};
};
template <>
struct traverse_post_order_return_category<binary_parser_category> {
template <typename MetaT, typename ParserT, typename EnvT>
struct result {
typedef typename parser_traversal_binary_result<
MetaT, ParserT, typename ParserT::left_t,
typename ParserT::right_t, EnvT
>::type
type;
};
};
///////////////////////////////////////////////////////////////////////////
//
// Post-order parser traversal
//
// The following templates contain the parser_category based code for
//
// - calculating the type of the resulting parser, which is to be
// returned from a level of traversal
// - traversing down the composite parser structure, this traversal
// returnes a new parser object
//
// Both tasks are delegated to the MetaT metafunction supplied by the
// user.
//
///////////////////////////////////////////////////////////////////////////
template <typename CategoryT>
struct traverse_post_order;
template <>
struct traverse_post_order<plain_parser_category> {
template <typename MetaT, typename ParserT, typename EnvT>
struct result {
typedef
typename parser_traversal_plain_result<MetaT, ParserT, EnvT>::type
type;
};
template <typename MetaT, typename ParserT, typename EnvT>
static
typename parser_traversal_plain_result<MetaT, ParserT, EnvT>::nexttype
generate(MetaT const &meta_, ParserT const &parser_, EnvT const &env)
{
return meta_.generate_plain(parser_, env);
}
};
template <>
struct traverse_post_order<unary_parser_category> {
template <
typename MetaT, typename ParserT, typename SubjectT, typename EnvT
>
struct result {
typedef typename parser_traversal_unary_result<
MetaT, ParserT, SubjectT, EnvT
>::type
type;
};
template <typename MetaT, typename ParserT, typename EnvT>
static
typename parser_traversal_unary_result<
MetaT, ParserT, typename ParserT::subject_t, EnvT
>::nexttype
generate(MetaT const &meta_, ParserT const &unary_, EnvT const &env)
{
typedef typename ParserT::subject_t subject_t;
typedef typename subject_t::parser_category_t subject_category_t;
return meta_.generate_unary(
unary_,
traverse_post_order<subject_category_t>::generate(meta_,
unary_.subject(),
traverse_post_order_env<
EnvT::level+1, EnvT::node-1, EnvT::index, EnvT::lastleft
>()
),
env
);
}
};
template <>
struct traverse_post_order<action_parser_category> {
template <
typename MetaT, typename ParserT, typename SubjectT, typename EnvT
>
struct result {
typedef typename parser_traversal_action_result<
MetaT, ParserT, SubjectT, EnvT
>::type
type;
};
template <typename MetaT, typename ParserT, typename EnvT>
static
typename parser_traversal_action_result<
MetaT, ParserT, typename ParserT::subject_t, EnvT
>::nexttype
generate(MetaT const &meta_, ParserT const &action_, EnvT const &env)
{
typedef typename ParserT::subject_t subject_t;
typedef typename subject_t::parser_category_t subject_category_t;
return meta_.generate_action(
action_,
traverse_post_order<subject_category_t>::generate(meta_,
action_.subject(),
traverse_post_order_env<
EnvT::level+1, EnvT::node-1, EnvT::index, EnvT::lastleft
>()
),
env
);
}
};
template <>
struct traverse_post_order<binary_parser_category> {
template <
typename MetaT, typename ParserT, typename LeftT,
typename RightT, typename EnvT
>
struct result {
typedef typename parser_traversal_binary_result<
MetaT, ParserT, LeftT, RightT, EnvT
>::type
type;
};
template <typename MetaT, typename ParserT, typename EnvT>
static
typename parser_traversal_binary_result<
MetaT, ParserT, typename ParserT::left_t,
typename ParserT::right_t, EnvT
>::nexttype
generate(MetaT const &meta_, ParserT const &binary_, EnvT const &env)
{
typedef typename ParserT::left_t left_t;
typedef typename ParserT::right_t right_t;
typedef typename left_t::parser_category_t left_category_t;
typedef typename right_t::parser_category_t right_category_t;
enum {
leftnum = (node_count<left_t>::value + EnvT::lastleft-1),
thisnum = (node_count<ParserT>::value + EnvT::lastleft-1),
rightnum = (thisnum-1),
leafnum = (leaf_count<left_t>::value + EnvT::index)
};
return meta_.generate_binary(
binary_,
traverse_post_order<left_category_t>::generate(
meta_, binary_.left(),
traverse_post_order_env<
EnvT::level+1, leftnum, EnvT::index, EnvT::lastleft
>()
),
traverse_post_order<right_category_t>::generate(
meta_, binary_.right(),
traverse_post_order_env<
EnvT::level+1, rightnum, leafnum, leftnum+1
>()
),
traverse_post_order_env<
EnvT::level, thisnum, EnvT::index, EnvT::lastleft
>()
);
}
};
} // namespace impl
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif // !defined(BOOST_SPIRIT_TRAVERSE_IPP)

318
include/boost/spirit/core/meta/parser_traits.hpp Normal file
View File

@@ -0,0 +1,318 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Joel de Guzman
Copyright (c) 2002-2003 Hartmut Kaiser
Copyright (c) 2003 Martin Wille
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_PARSER_TRAITS_HPP)
#define BOOST_SPIRIT_PARSER_TRAITS_HPP
#include "boost/type_traits.hpp"
#include "boost/static_assert.hpp"
#include "boost/spirit/core/parser.hpp"
#include "boost/spirit/core/meta/impl/parser_traits.ipp"
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
//
// Parser traits templates
//
// Used to determine the type and several other characteristics of a given
// parser type.
//
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//
// The is_parser traits template can be used to tell wether a given
// class is a parser.
//
///////////////////////////////////////////////////////////////////////////////
template <typename CandidateT>
struct is_parser
{
typedef CandidateT *cptr;
BOOST_STATIC_CONSTANT(bool, value =
(sizeof(impl::is_parser_helper::test(cptr(0))) ==
sizeof(impl::is_parser_helper::yes)));
};
///////////////////////////////////////////////////////////////////////////////
//
// The is_unary_composite traits template can be used to tell if a given
// parser is a unary parser as for instance kleene_star or optional.
//
///////////////////////////////////////////////////////////////////////////////
template <typename UnaryT>
struct is_unary_composite {
BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible<
typename UnaryT::parser_category_t, unary_parser_category>::value));
};
///////////////////////////////////////////////////////////////////////////////
//
// The is_acction_parser traits template can be used to tell if a given
// parser is a action parser, i.e. it is a composite consisting of a
// auxilliary parser and an attached semantic action.
//
///////////////////////////////////////////////////////////////////////////////
template <typename ActionT>
struct is_action_parser {
BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible<
typename ActionT::parser_category_t, action_parser_category>::value));
};
///////////////////////////////////////////////////////////////////////////////
//
// The is_binary_composite traits template can be used to tell if a given
// parser is a binary parser as for instance sequence or difference.
//
///////////////////////////////////////////////////////////////////////////////
template <typename BinaryT>
struct is_binary_composite {
BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible<
typename BinaryT::parser_category_t, binary_parser_category>::value));
};
///////////////////////////////////////////////////////////////////////////////
//
// The is_composite_parser traits template can be used to tell if a given
// parser is a unary or a binary parser composite type.
//
///////////////////////////////////////////////////////////////////////////////
template <typename CompositeT>
struct is_composite_parser {
BOOST_STATIC_CONSTANT(bool, value = (
::boost::spirit::is_unary_composite<CompositeT>::value ||
::boost::spirit::is_binary_composite<CompositeT>::value));
};
///////////////////////////////////////////////////////////////////////////////
template <typename ParserT>
struct is_alternative {
BOOST_STATIC_CONSTANT(bool, value = (
::boost::spirit::impl::parser_type_traits<ParserT>::is_alternative));
};
template <typename ParserT>
struct is_sequence {
BOOST_STATIC_CONSTANT(bool, value = (
::boost::spirit::impl::parser_type_traits<ParserT>::is_sequence));
};
template <typename ParserT>
struct is_sequential_or {
BOOST_STATIC_CONSTANT(bool, value = (
::boost::spirit::impl::parser_type_traits<ParserT>::is_sequential_or));
};
template <typename ParserT>
struct is_intersection {
BOOST_STATIC_CONSTANT(bool, value = (
::boost::spirit::impl::parser_type_traits<ParserT>::is_intersection));
};
template <typename ParserT>
struct is_difference {
BOOST_STATIC_CONSTANT(bool, value = (
::boost::spirit::impl::parser_type_traits<ParserT>::is_difference));
};
template <typename ParserT>
struct is_exclusive_or {
BOOST_STATIC_CONSTANT(bool, value = (
::boost::spirit::impl::parser_type_traits<ParserT>::is_exclusive_or));
};
template <typename ParserT>
struct is_optional {
BOOST_STATIC_CONSTANT(bool, value = (
::boost::spirit::impl::parser_type_traits<ParserT>::is_optional));
};
template <typename ParserT>
struct is_kleene_star {
BOOST_STATIC_CONSTANT(bool, value = (
::boost::spirit::impl::parser_type_traits<ParserT>::is_kleene_star));
};
template <typename ParserT>
struct is_positive {
BOOST_STATIC_CONSTANT(bool, value = (
::boost::spirit::impl::parser_type_traits<ParserT>::is_positive));
};
///////////////////////////////////////////////////////////////////////////////
//
// Parser extraction templates
//
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//
// The unary_subject template can be used to return the type of the
// parser used as the subject of an unary parser.
// If the parser under inspection is not an unary type parser the compilation
// will fail.
//
///////////////////////////////////////////////////////////////////////////////
template <typename UnaryT>
struct unary_subject {
BOOST_STATIC_ASSERT(::boost::spirit::is_unary_composite<UnaryT>::value);
typedef typename UnaryT::subject_t type;
};
///////////////////////////////////////////////////////////////////////////////
//
// The get_unary_subject template function returns the parser object, which
// is used as the subject of an unary parser.
// If the parser under inspection is not an unary type parser the compilation
// will fail.
//
///////////////////////////////////////////////////////////////////////////////
template <typename UnaryT>
inline typename unary_subject<UnaryT>::type const &
get_unary_subject(UnaryT const &unary_)
{
BOOST_STATIC_ASSERT(::boost::spirit::is_unary_composite<UnaryT>::value);
return unary_.subject();
}
///////////////////////////////////////////////////////////////////////////////
//
// The binary_left_subject and binary_right_subject templates can be used to
// return the types of the parsers used as the left and right subject of an
// binary parser.
// If the parser under inspection is not a binary type parser the compilation
// will fail.
//
///////////////////////////////////////////////////////////////////////////////
template <typename BinaryT>
struct binary_left_subject {
BOOST_STATIC_ASSERT(::boost::spirit::is_binary_composite<BinaryT>::value);
typedef typename BinaryT::left_t type;
};
template <typename BinaryT>
struct binary_right_subject {
BOOST_STATIC_ASSERT(::boost::spirit::is_binary_composite<BinaryT>::value);
typedef typename BinaryT::right_t type;
};
///////////////////////////////////////////////////////////////////////////////
//
// The get_binary_left_subject and get_binary_right_subject template functions
// return the parser object, which is used as the left or right subject of a
// binary parser.
// If the parser under inspection is not a binary type parser the compilation
// will fail.
//
///////////////////////////////////////////////////////////////////////////////
template <typename BinaryT>
inline typename binary_left_subject<BinaryT>::type const &
get_binary_left_subject(BinaryT const &binary_)
{
BOOST_STATIC_ASSERT(::boost::spirit::is_binary_composite<BinaryT>::value);
return binary_.left();
}
template <typename BinaryT>
inline typename binary_right_subject<BinaryT>::type const &
get_binary_right_subject(BinaryT const &binary_)
{
BOOST_STATIC_ASSERT(::boost::spirit::is_binary_composite<BinaryT>::value);
return binary_.right();
}
///////////////////////////////////////////////////////////////////////////////
//
// The action_subject template can be used to return the type of the
// parser used as the subject of an action parser.
// If the parser under inspection is not an action type parser the compilation
// will fail.
//
///////////////////////////////////////////////////////////////////////////////
template <typename ActionT>
struct action_subject {
BOOST_STATIC_ASSERT(::boost::spirit::is_action_parser<ActionT>::value);
typedef typename ActionT::subject_t type;
};
///////////////////////////////////////////////////////////////////////////////
//
// The get_action_subject template function returns the parser object, which
// is used as the subject of an action parser.
// If the parser under inspection is not an action type parser the compilation
// will fail.
//
///////////////////////////////////////////////////////////////////////////////
template <typename ActionT>
inline typename action_subject<ActionT>::type const &
get_action_subject(ActionT const &action_)
{
BOOST_STATIC_ASSERT(::boost::spirit::is_action_parser<ActionT>::value);
return action_.subject();
}
///////////////////////////////////////////////////////////////////////////////
//
// The semantic_action template can be used to return the type of the
// attached semantic action of an action parser.
// If the parser under inspection is not an action type parser the compilation
// will fail.
//
///////////////////////////////////////////////////////////////////////////////
template <typename ActionT>
struct semantic_action {
BOOST_STATIC_ASSERT(::boost::spirit::is_action_parser<ActionT>::value);
typedef typename ActionT::predicate_t type;
};
///////////////////////////////////////////////////////////////////////////////
//
// The get_semantic_action template function returns the attached semantic
// action of an action parser.
// If the parser under inspection is not an action type parser the compilation
// will fail.
//
///////////////////////////////////////////////////////////////////////////////
template <typename ActionT>
inline typename semantic_action<ActionT>::type const &
get_semantic_action(ActionT const &action_)
{
BOOST_STATIC_ASSERT(::boost::spirit::is_action_parser<ActionT>::value);
return action_.predicate();
}
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif // !defined(BOOST_SPIRIT_PARSER_TRAITS_HPP)

255
include/boost/spirit/core/meta/traverse.hpp Normal file
View File

@@ -0,0 +1,255 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Joel de Guzman
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_TRAVERSE_HPP)
#define BOOST_SPIRIT_TRAVERSE_HPP
///////////////////////////////////////////////////////////////////////////////
// traverse code isn't supported on the VC6 platform (yet)
#if (!defined(BOOST_MSVC) || (BOOST_MSVC >= 1300))
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/core/meta/impl/traverse.ipp"
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
//
// Post-order traversal of auxilliary parsers.
//
///////////////////////////////////////////////////////////////////////////////
struct post_order {
// Return the parser type, which is generated as the result of the
// traverse function below.
template <typename MetaT, typename ParserT>
struct result {
typedef typename traverse_post_order_return<
MetaT, ParserT, traverse_post_order_env<0, 0, 0, 0>
>::type
type;
};
// Traverse a given parser and refactor it with the help of the given
// MetaT metafunction template.
template <typename MetaT, typename ParserT>
static typename result<MetaT, ParserT>::type
traverse(MetaT const &meta_, ParserT const &parser_)
{
typedef typename ParserT::parser_category_t parser_category_t;
return impl::traverse_post_order<parser_category_t>::generate(
meta_, parser_, traverse_post_order_env<0, 0, 0, 0>());
}
};
///////////////////////////////////////////////////////////////////////////////
//
// Transform policies
//
// The following policy classes could be used to assemble some new
// transformation metafunction which uses identity transformations for
// some parser_category type parsers.
//
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// transform plain parsers
template <typename TransformT>
struct plain_identity_policy {
template <typename ParserT, typename EnvT>
struct plain_result {
// plain parsers should be embedded and returned correctly
typedef typename ParserT::embed_t type;
// typedef ParserT type;
};
template <typename ParserT, typename EnvT>
typename parser_traversal_plain_result<TransformT, ParserT, EnvT>::type
generate_plain(ParserT const &parser_, EnvT const &env) const
{
return parser_;
}
};
//////////////////////////////////
// transform unary parsers
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER(
unary_identity_policy_return_wrapper, result);
template <typename UnaryT, typename SubjectT>
struct unary_identity_policy_return {
typedef typename UnaryT::parser_generator_t parser_generator_t;
typedef typename impl::unary_identity_policy_return_wrapper<parser_generator_t>
::template result_<SubjectT>::type type;
};
#else
template <typename UnaryT, typename SubjectT>
struct unary_identity_policy_return {
typedef typename UnaryT::parser_generator_t parser_generator_t;
typedef typename parser_generator_t::template result<SubjectT>::type type;
};
#endif // defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
template <typename TransformT>
struct unary_identity_policy {
template <typename UnaryT, typename SubjectT, typename EnvT>
struct unary_result {
typedef
typename unary_identity_policy_return<UnaryT, SubjectT>::type
type;
};
template <typename UnaryT, typename SubjectT, typename EnvT>
typename parser_traversal_unary_result<
TransformT, UnaryT, SubjectT, EnvT
>::type
generate_unary(UnaryT const &, SubjectT const &subject_, EnvT const &env) const
{
typedef typename UnaryT::parser_generator_t parser_generator_t;
return parser_generator_t::template generate<SubjectT>(subject_);
}
};
//////////////////////////////////
// transform action parsers
template <typename TransformT>
struct action_identity_policy {
template <typename ActionT, typename SubjectT, typename EnvT>
struct action_result {
typedef action<SubjectT, typename ActionT::predicate_t> type;
};
template <typename ActionT, typename SubjectT, typename EnvT>
typename parser_traversal_action_result<
TransformT, ActionT, SubjectT, EnvT
>::type
generate_action(ActionT const &action_, SubjectT const &subject_,
EnvT const &env) const
{
return subject_[action_.predicate()];
}
};
//////////////////////////////////
// transform binary parsers
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER2(
binary_identity_policy_return_wrapper, result);
template <typename BinaryT, typename LeftT, typename RightT>
struct binary_identity_policy_return {
typedef typename BinaryT::parser_generator_t parser_generator_t;
typedef
typename impl::binary_identity_policy_return_wrapper<parser_generator_t>
::template result_<LeftT, RightT>::type type;
};
#else
template <typename BinaryT, typename LeftT, typename RightT>
struct binary_identity_policy_return {
typedef typename BinaryT::parser_generator_t parser_generator_t;
typedef typename parser_generator_t
::template result<LeftT, RightT>::type type;
};
#endif // defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
template <typename TransformT>
struct binary_identity_policy {
template <typename BinaryT, typename LeftT, typename RightT, typename EnvT>
struct binary_result {
typedef
typename binary_identity_policy_return<BinaryT, LeftT, RightT>::type
type;
};
template <typename BinaryT, typename LeftT, typename RightT, typename EnvT>
typename parser_traversal_binary_result<
TransformT, BinaryT, LeftT, RightT, EnvT
>::type
generate_binary(BinaryT const &, LeftT const& left_, RightT const& right_,
EnvT const &env) const
{
typedef typename BinaryT::parser_generator_t parser_generator_t;
return parser_generator_t::
template generate<LeftT, RightT>(left_, right_);
}
};
///////////////////////////////////////////////////////////////////////////////
//
// transform_policies template
//
// The transform_policies template metafunction could serve as a base
// class for new metafunctions to be passed to the traverse meta template
// (see above), where only minimal parts have to be overwritten.
//
///////////////////////////////////////////////////////////////////////////////
template <
typename TransformT,
typename PlainPolicyT = plain_identity_policy<TransformT>,
typename UnaryPolicyT = unary_identity_policy<TransformT>,
typename ActionPolicyT = action_identity_policy<TransformT>,
typename BinaryPolicyT = binary_identity_policy<TransformT>
>
struct transform_policies :
public PlainPolicyT,
public UnaryPolicyT,
public ActionPolicyT,
public BinaryPolicyT
{
};
///////////////////////////////////////////////////////////////////////////////
//
// Identity transformation
//
// The identity_transform metafunction supplied to the traverse template
// will generate a new parser, which will be exactly identical to the
// parser given as the parameter to the traverse metafunction. I.e. the
// following conceptual 'equation' will be always true:
//
// some_parser == post_order::traverse(identity_transform(), some_parser)
//
///////////////////////////////////////////////////////////////////////////////
struct identity_transform : public transform_policies<identity_transform> {};
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif // (!defined(BOOST_MSVC) || (BOOST_MSVC >= 1300))
#endif // !defined(BOOST_SPIRIT_TRAVERSE_HPP)

4
include/boost/spirit/core/non_terminal/Makefile.am Normal file
View File

@@ -0,0 +1,4 @@
#This file generated by Makefileamgen.sh
SUBDIRS = impl
spiritinclude_HEADERS = grammar.hpp parser_context.hpp parser_id.hpp rule.hpp subrule.hpp
spiritincludedir = $(includedir)/spirit/boost/spirit/core/non_terminal

76
include/boost/spirit/core/non_terminal/grammar.hpp Normal file
View File

@@ -0,0 +1,76 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001-2003 Joel de Guzman
Copyright (c) 2002-2003 Martin Wille
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_GRAMMAR_HPP)
#define BOOST_SPIRIT_GRAMMAR_HPP
///////////////////////////////////////////////////////////////////////////////
#if defined(BOOST_SPIRIT_THREADSAFE) && defined(SPIRIT_SINGLE_GRAMMAR_INSTANCE)
#undef BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE
#endif
#include "boost/spirit/core/parser.hpp"
#include "boost/spirit/core/non_terminal/parser_context.hpp"
#include "boost/spirit/core/non_terminal/impl/grammar.ipp"
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
//
// grammar class
//
///////////////////////////////////////////////////////////////////////////////
template <typename DerivedT, typename ContextT = parser_context>
struct grammar
: public parser<DerivedT>
, public ContextT::base_t
BOOST_SPIRIT_GRAMMAR_ID
{
typedef grammar<DerivedT, ContextT> self_t;
typedef DerivedT const& embed_t;
typedef parser_context_linker<ContextT> context_t;
typedef typename context_t::attr_t attr_t;
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, attr_t>::type type;
};
grammar() {}
~grammar() { impl::grammar_destruct(this); }
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse_main(ScannerT const& scan) const
{ return impl::grammar_parser_parse(this, scan); }
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;
typedef parser_scanner_linker<ScannerT> scanner_t;
BOOST_SPIRIT_CONTEXT_PARSE(scan, *this, scanner_t, context_t, result_t)
}
BOOST_SPIRIT_GRAMMAR_STATE
};
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#undef BOOST_SPIRIT_GRAMMAR_ID
#undef BOOST_SPIRIT_GRAMMAR_ACCESS
#undef BOOST_SPIRIT_GRAMMAR_STATE
#endif

3
include/boost/spirit/core/non_terminal/impl/Makefile.am Normal file
View File

@@ -0,0 +1,3 @@
#This file generated by Makefileamgen.sh
spiritinclude_HEADERS = grammar.ipp object_with_id.ipp rule.ipp subrule.ipp
spiritincludedir = $(includedir)/spirit/boost/spirit/core/non_terminal/impl

301
include/boost/spirit/core/non_terminal/impl/grammar.ipp Normal file
View File

@@ -0,0 +1,301 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001-2003 Joel de Guzman
Copyright (c) 2002-2003 Martin Wille
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined BOOST_SPIRIT_GRAMMAR_IPP
#define BOOST_SPIRIT_GRAMMAR_IPP
#if !defined(BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE)
#include "boost/spirit/core/non_terminal/impl/object_with_id.ipp"
#include <algorithm>
#include <functional>
#include <memory> // for std::auto_ptr
#include <boost/weak_ptr.hpp>
#endif
#ifdef BOOST_SPIRIT_THREADSAFE
#include "boost/thread/tss.hpp"
#include "boost/thread/mutex.hpp"
#endif
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
template <typename DerivedT, typename ContextT>
struct grammar;
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1200)
BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER(grammar_definition_wrapper, definition);
//////////////////////////////////
template <typename GrammarT, typename ScannerT>
struct grammar_definition
{
typedef typename impl::grammar_definition_wrapper<GrammarT>
::template result_<ScannerT>::param_t type;
};
#else
//////////////////////////////////
template <typename GrammarT, typename ScannerT>
struct grammar_definition
{
typedef typename GrammarT::template definition<ScannerT> type;
};
#endif
namespace impl
{
#if !defined(BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE)
struct grammar_tag {};
//////////////////////////////////
template <typename GrammarT>
struct grammar_helper_base
{
virtual int undefine(GrammarT *) = 0;
virtual ~grammar_helper_base() {}
};
//////////////////////////////////
template <typename GrammarT>
struct grammar_helper_list
{
typedef GrammarT grammar_t;
typedef grammar_helper_base<GrammarT> helper_t;
typedef std::vector<helper_t*> vector_t;
grammar_helper_list() {}
grammar_helper_list(grammar_helper_list const& x)
{ // Does _not_ copy the helpers member !
}
grammar_helper_list& operator=(grammar_helper_list const& x)
{ // Does _not_ copy the helpers member !
return *this;
}
void push_back(helper_t *helper)
{ helpers.push_back(helper); }
void pop_back()
{ helpers.pop_back(); }
typename vector_t::size_type
size() const
{ return helpers.size(); }
typename vector_t::reverse_iterator
rbegin()
{ return helpers.rbegin(); }
typename vector_t::reverse_iterator
rend()
{ return helpers.rend(); }
#ifdef BOOST_SPIRIT_THREADSAFE
boost::mutex & mutex()
{ return m; }
#endif
private:
vector_t helpers;
#ifdef BOOST_SPIRIT_THREADSAFE
boost::mutex m;
#endif
};
//////////////////////////////////
struct grammar_extract_helper_list;
#if !defined(BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE) \
&& (!defined(__GNUC__) || (__GNUC__ > 2))
struct grammar_extract_helper_list
{
template<typename GrammarT>
static grammar_helper_list<GrammarT>&
do_(GrammarT const* g)
{
return g->helpers;
}
};
#endif
//////////////////////////////////
template <typename GrammarT, typename DerivedT, typename ScannerT>
struct grammar_helper : private grammar_helper_base<GrammarT>
{
typedef GrammarT grammar_t;
typedef ScannerT scanner_t;
typedef DerivedT derived_t;
typedef typename grammar_definition<DerivedT, ScannerT>::type definition_t;
typedef grammar_helper<grammar_t, derived_t, scanner_t> helper_t;
typedef boost::shared_ptr<helper_t> helper_ptr_t;
typedef boost::weak_ptr<helper_t> helper_weak_ptr_t;
grammar_helper*
this_() { return this; }
grammar_helper(helper_weak_ptr_t& p)
: definitions_cnt(0)
, self(this_())
{ p = self; }
definition_t&
define(grammar_t const* grammar)
{
grammar_helper_list<GrammarT> &helpers =
#if !defined(__GNUC__) || (__GNUC__ > 2)
grammar_extract_helper_list::do_(grammar);
#else
grammar->helpers;
#endif
typename grammar_t::object_id id = grammar->get_object_id();
if (definitions.size()<=id)
definitions.resize(id*3/2+1);
if (definitions[id]!=0)
return *definitions[id];
std::auto_ptr<definition_t>
result(new definition_t(grammar->derived()));
#ifdef BOOST_SPIRIT_THREADSAFE
boost::mutex::scoped_lock(helpers.mutex());
#endif
helpers.push_back(this);
++definitions_cnt;
definitions[id] = result.get();
return *(result.release());
}
int
undefine(grammar_t* grammar)
{
typename grammar_t::object_id id = grammar->get_object_id();
if (definitions.size()<=id)
return 0;
delete definitions[id];
definitions[id] = 0;
if (--definitions_cnt==0)
self.reset();
return 0;
}
private:
std::vector<definition_t*> definitions;
unsigned long definitions_cnt;
helper_ptr_t self;
};
#endif /* defined(BOOST_SPIRIT_NO_MULTIPLE_GRAMMAR_INSTANCES) */
//////////////////////////////////
template<typename DerivedT, typename ContextT, typename ScannerT>
inline typename parser_result<grammar<DerivedT, ContextT>, ScannerT>::type
grammar_parser_parse(
grammar<DerivedT, ContextT> const* self,
ScannerT const &scan)
{
typedef grammar<DerivedT, ContextT> self_t;
typedef typename parser_result<self_t, ScannerT>::type result_t;
typedef typename DerivedT::template definition<ScannerT> definition;
#if defined(BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE)
static definition def(self->derived());
#else
typedef impl::grammar_helper<self_t, DerivedT, ScannerT> helper_t;
typedef typename helper_t::helper_weak_ptr_t ptr_t;
# ifdef BOOST_SPIRIT_THREADSAFE
static boost::thread_specific_ptr<ptr_t> tld_helper;
if (!tld_helper.get())
tld_helper.reset(new ptr_t);
ptr_t &helper = *tld_helper;
# else
static ptr_t helper;
# endif
if (!boost::make_shared(helper).get())
new helper_t(helper);
definition &def = boost::make_shared(helper)->define(self);
#endif
return def.start().parse(scan);
}
//////////////////////////////////
template<typename GrammarT>
inline void
grammar_destruct(GrammarT* self)
{
#if !defined(BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE)
typedef impl::grammar_helper_base<GrammarT> helper_base_t;
typedef grammar_helper_list<GrammarT> helper_list_t;
typedef typename helper_list_t::vector_t::reverse_iterator iterator_t;
helper_list_t& helpers =
# if !defined(__GNUC__) || (__GNUC__ > 2)
grammar_extract_helper_list::do_(self);
# else
self->helpers;
# endif
# if (defined(BOOST_MSVC) && (BOOST_MSVC <= 1200)) \
|| defined(BOOST_INTEL_CXX_VERSION)
for (iterator_t i = helpers.rbegin(); i != helpers.rend(); ++i)
(*i)->undefine(self);
# else
std::for_each(helpers.rbegin(), helpers.rend(),
std::bind2nd(std::mem_fun(&helper_base_t::undefine), self));
# endif
#endif
}
} // namespace impl
///////////////////////////////////////
#if !defined(BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE)
#define BOOST_SPIRIT_GRAMMAR_ID , public impl::object_with_id<impl::grammar_tag>
#else
#define BOOST_SPIRIT_GRAMMAR_ID
#endif
///////////////////////////////////////
#if !defined(__GNUC__) || (__GNUC__ > 2)
#define BOOST_SPIRIT_GRAMMAR_ACCESS private:
#else
#define BOOST_SPIRIT_GRAMMAR_ACCESS
#endif
///////////////////////////////////////
#if !defined(BOOST_SPIRIT_SINGLE_GRAMMAR_INSTANCE)
#define BOOST_SPIRIT_GRAMMAR_STATE \
BOOST_SPIRIT_GRAMMAR_ACCESS \
friend struct impl::grammar_extract_helper_list; \
mutable impl::grammar_helper_list<self_t> helpers;
#else
#define BOOST_SPIRIT_GRAMMAR_STATE
#endif
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif

159
include/boost/spirit/core/non_terminal/impl/object_with_id.ipp Normal file
View File

@@ -0,0 +1,159 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Joel de Guzman
Copyright (c) 2002-2003 Martin Wille
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined BOOST_SPIRIT_OBJECT_WITH_ID_IPP
#define BOOST_SPIRIT_OBJECT_WITH_ID_IPP
#include <vector>
#include <boost/shared_ptr.hpp>
#ifdef BOOST_SPIRIT_THREADSAFE
#include <boost/thread/mutex.hpp>
#endif
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
namespace impl {
//////////////////////////////////
template <typename IdT = unsigned long>
struct object_with_id_base_supply
{
typedef IdT object_id;
typedef std::vector<object_id> id_vector;
object_with_id_base_supply() : max_id(object_id()) {}
#ifdef BOOST_SPIRIT_THREADSAFE
boost::mutex mutex;
#endif
object_id max_id;
id_vector free_ids;
object_id acquire();
void release(object_id);
};
//////////////////////////////////
template <typename TagT, typename IdT = unsigned long>
struct object_with_id_base
{
typedef TagT tag_t;
typedef IdT object_id;
protected:
object_id acquire_object_id();
void release_object_id(object_id);
private:
boost::shared_ptr<object_with_id_base_supply<IdT> > id_supply;
};
//////////////////////////////////
template<class TagT, typename IdT = unsigned long>
struct object_with_id : private object_with_id_base<TagT, IdT>
{
typedef object_with_id<TagT, IdT> self_t;
typedef object_with_id_base<TagT, IdT> base_t;
typedef IdT object_id;
object_with_id() : id(base_t::acquire_object_id()) {}
object_with_id(self_t const &other)
: base_t(other)
, id(base_t::acquire_object_id())
{} // don't copy id
self_t &operator = (self_t const &other)
{ // don't assign id
base_t::operator=(other);
return *this;
}
~object_with_id() { base_t::release_object_id(id); }
object_id get_object_id() const { return id; }
private:
object_id const id;
};
//////////////////////////////////
template <typename IdT>
inline IdT
object_with_id_base_supply<IdT>::acquire()
{
#ifdef BOOST_SPIRIT_THREADSAFE
boost::mutex::scoped_lock lock(mutex);
#endif
if (free_ids.size())
{
object_id id = *free_ids.rbegin();
free_ids.pop_back();
return id;
}
else
{
if (free_ids.capacity()<=max_id)
free_ids.reserve(max_id*3/2+1);
return ++max_id;
}
}
//////////////////////////////////
template <typename IdT>
inline void
object_with_id_base_supply<IdT>::release(IdT id)
{
#ifdef BOOST_SPIRIT_THREADSAFE
boost::mutex::scoped_lock lock(mutex);
#endif
if (max_id == id)
max_id--;
else
free_ids.push_back(id); // doesn't throw
}
//////////////////////////////////
template <typename TagT, typename IdT>
inline IdT
object_with_id_base<TagT, IdT>::acquire_object_id()
{
{
#ifdef BOOST_SPIRIT_THREADSAFE
static boost::mutex mutex;
boost::mutex::scoped_lock lock(mutex);
#endif
static boost::shared_ptr<object_with_id_base_supply<IdT> >
static_supply;
if (!static_supply.get())
static_supply.reset(new object_with_id_base_supply<IdT>());
id_supply = static_supply;
}
return id_supply->acquire();
}
//////////////////////////////////
template <typename TagT, typename IdT>
inline void
object_with_id_base<TagT, IdT>::release_object_id(IdT id)
{
id_supply->release(id);
}
} // namespace impl
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif

101
include/boost/spirit/core/non_terminal/impl/rule.ipp Normal file
View File

@@ -0,0 +1,101 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_RULE_IPP)
#define BOOST_SPIRIT_RULE_IPP
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////
namespace impl
{
///////////////////////////////////////////////////////////////////////
//
// abstract_parser class
//
///////////////////////////////////////////////////////////////////////
template <typename ScannerT, typename RT>
struct abstract_parser
{
abstract_parser() {}
virtual ~abstract_parser() {}
virtual RT
do_parse_virtual(ScannerT const& scan) const = 0;
};
///////////////////////////////////////////////////////////////////////
//
// concrete_parser class
//
///////////////////////////////////////////////////////////////////////
template <typename ParserT, typename ScannerT, typename RT>
struct concrete_parser : public abstract_parser<ScannerT, RT>
{
concrete_parser(ParserT const& p_) : p(p_) {}
virtual ~concrete_parser() {}
virtual RT
do_parse_virtual(ScannerT const& scan) const
{ return p.parse(scan); }
typename ParserT::embed_t p;
};
} // namespace impl
//////////////////////////////////
template <typename ScannerT, typename ContextT, typename TagT>
inline rule<ScannerT, ContextT, TagT>::rule()
: ptr() {}
//////////////////////////////////
template <typename ScannerT, typename ContextT, typename TagT>
inline rule<ScannerT, ContextT, TagT>::~rule() {}
//////////////////////////////////
template <typename ScannerT, typename ContextT, typename TagT>
inline typename rule<ScannerT, ContextT, TagT>::result_t
rule<ScannerT, ContextT, TagT>::parse(ScannerT const& scan) const
{
BOOST_SPIRIT_CONTEXT_PARSE(scan, *this, scanner_t, context_t, result_t)
}
//////////////////////////////////
template <typename ScannerT, typename ContextT, typename TagT>
inline typename rule<ScannerT, ContextT, TagT>::result_t
rule<ScannerT, ContextT, TagT>::parse_main(ScannerT const& scan) const
{
result_t hit;
if (ptr.get())
{
typename ScannerT::iterator_t s(scan.first);
hit = ptr->do_parse_virtual(scan);
scan.group_match(hit, id(), s, scan.first);
}
else
{
hit = scan.no_match();
}
return hit;
}
//////////////////////////////////
template <typename ScannerT, typename ContextT, typename TagT>
inline parser_id
rule<ScannerT, ContextT, TagT>::id() const
{
return TagT::id(*this);
}
}} // namespace boost::spirit
#endif

208
include/boost/spirit/core/non_terminal/impl/subrule.ipp Normal file
View File

@@ -0,0 +1,208 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Joel de Guzman
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_SUBRULE_IPP)
#define BOOST_SPIRIT_SUBRULE_IPP
namespace boost { namespace spirit {
template <typename FirstT, typename RestT>
struct subrule_list;
template <int ID, typename DefT, typename ContextT>
struct subrule_parser;
namespace impl {
#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
template <int N, typename ListT>
struct get_subrule;
template <int N, typename ListT>
struct get_subrule_chooser
{
static ListT t();
static char test(nil_t);
static int test(...);
// Set value to
// 0: ListT is empty
// 1: ListT's first item has same ID
// 2: ListT's first item has a different ID
enum
{
id = ListT::first_t::id,
is_same_id = N == id,
is_nil_t = sizeof(char) == sizeof(test(t())),
value = is_nil_t ? 0 : (is_same_id ? 1 : 2)
};
};
template <int N>
struct subrule_chooser;
template <>
struct subrule_chooser<0>
{
// First case. ListT is empty
template <int N, typename ListT>
struct result
{ typedef nil_t type; };
};
template <>
struct subrule_chooser<1>
{
// Second case. ListT is non-empty and the list's
// first item has the ID we are looking for.
template <int N, typename ListT>
struct result
{ typedef typename ListT::first_t::def_t type; };
};
template <>
struct subrule_chooser<2>
{
// Third case. ListT is non-empty but the list's
// first item does not have the ID we are looking for.
template <int N, typename ListT>
struct result
{ typedef typename get_subrule<N, ListT::rest_t>::type type; };
};
template <int N, typename ListT>
struct get_subrule
{
enum { n = get_subrule_chooser<N, ListT>::value };
typedef typename subrule_chooser<n>::template
result<N, ListT>::type type;
};
#else
template <int N, typename ListT>
struct get_subrule
{
// First case. ListT is non-empty but the list's
// first item does not have the ID we are looking for.
typedef typename get_subrule<N, typename ListT::rest_t>::type type;
};
template <int ID, typename DefT, typename ContextT, typename RestT>
struct get_subrule<
ID,
subrule_list<
subrule_parser<ID, DefT, ContextT>,
RestT> >
{
// Second case. ListT is non-empty and the list's
// first item has the ID we are looking for.
typedef DefT type;
};
template <int ID>
struct get_subrule<ID, nil_t>
{
// Third case. ListT is empty
typedef nil_t type;
};
#endif
template <typename T1, typename T2>
struct get_result_t {
// If the result type dictated by the context is nil_t (no closures
// present), then the whole subrule_parser return type is equal to
// the return type of the right hand side of this subrule_parser,
// otherwise it is equal to the dictated return value.
enum { is_nil_t = (boost::is_same<T1, nil_t>::value) };
typedef typename if_t<
bool_t<is_nil_t>, T2, T1
>::type type;
};
template <int ID, typename ScannerT, typename ContextResultT>
struct get_subrule_result
{
typedef typename
impl::get_subrule<ID, typename ScannerT::list_t>::type
parser_t;
typedef typename parser_result<parser_t, ScannerT>::type
def_result_t;
typedef typename match_result<ScannerT, ContextResultT>::type
context_result_t;
typedef typename get_result_t<context_result_t, def_result_t>::type
type;
};
template <typename DefT, typename ScannerT, typename ContextResultT>
struct get_subrule_parser_result
{
typedef typename parser_result<DefT, ScannerT>::type
def_result_t;
typedef typename match_result<ScannerT, ContextResultT>::type
context_result_t;
typedef typename get_result_t<context_result_t, def_result_t>::type
type;
};
template <typename SubruleT, int ID>
struct same_subrule_id
{
BOOST_STATIC_CONSTANT(bool, value = (SubruleT::id == ID));
};
template <typename RT, typename ScannerT, int ID>
struct parse_subrule
{
template <typename ListT>
static void
do_parse(RT& r, ScannerT const& scan, ListT const& list, true_t)
{
r = list.first.rhs.parse(scan);
}
template <typename ListT>
static void
do_parse(RT& r, ScannerT const& scan, ListT const& list, false_t)
{
typedef typename ListT::rest_t::first_t subrule_t;
bool_t<same_subrule_id<subrule_t, ID>::value> same_id;
do_parse(r, scan, list.rest, same_id);
}
static void
do_(RT& r, ScannerT const& scan)
{
typedef typename ScannerT::list_t::first_t subrule_t;
bool_t<same_subrule_id<subrule_t, ID>::value> same_id;
do_parse(r, scan, scan.list, same_id);
}
};
}}} // namespace boost::spirit::impl
#endif

152
include/boost/spirit/core/non_terminal/parser_context.hpp Normal file
View File

@@ -0,0 +1,152 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Joel de Guzman
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_PARSER_CONTEXT_HPP)
#define BOOST_SPIRIT_PARSER_CONTEXT_HPP
///////////////////////////////////////////////////////////////////////////////
namespace boost
{
namespace spirit
{
///////////////////////////////////////////////////////////////////////////
//
// default_parser_context_base class { default context base }
//
///////////////////////////////////////////////////////////////////////////
struct default_parser_context_base
{
template <typename DerivedT>
struct aux {};
};
///////////////////////////////////////////////////////////////////////////
//
// parser_context class { default context }
//
///////////////////////////////////////////////////////////////////////////
struct nil_t;
struct parser_context
{
typedef nil_t attr_t;
typedef default_parser_context_base base_t;
template <typename ParserT>
parser_context(ParserT const&) {}
template <typename ParserT, typename ScannerT>
void
pre_parse(ParserT const&, ScannerT const&) {}
template <typename ResultT, typename ParserT, typename ScannerT>
ResultT&
post_parse(ResultT& hit, ParserT const&, ScannerT const&)
{ return hit; }
};
///////////////////////////////////////////////////////////////////////////
//
// context_aux class
//
// context_aux<ContextT, DerivedT> is a class derived from the
// ContextT's nested base_t::base<DerivedT> template class. (see
// default_parser_context_base::aux for an example).
//
// Basically, this class provides ContextT dependent optional
// functionality to the derived class DerivedT through the CRTP
// idiom (Curiously recurring template pattern).
//
///////////////////////////////////////////////////////////////////////////
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER(context_base_wrapper, aux);
//////////////////////////////////
template <typename ContextT, typename DerivedT,
typename AuxT =
impl::context_base_wrapper<ContextT::base_t>
::template result_<DerivedT> >
struct context_aux : public AuxT {};
#else
template <typename ContextT, typename DerivedT>
struct context_aux : public ContextT::base_t::template aux<DerivedT> {};
#endif
///////////////////////////////////////////////////////////////////////////
//
// parser_scanner_linker and parser_scanner_linker classes
// { helper templates for the rule extendability }
//
// This classes can be 'overloaded' (defined elsewhere), to plug
// in additional functionality into the rule parsing process.
//
///////////////////////////////////////////////////////////////////////////
#if !defined(BOOST_SPIRIT_PARSER_SCANNER_LINKER_DEFINED)
#define BOOST_SPIRIT_PARSER_SCANNER_LINKER_DEFINED
template<typename ScannerT>
struct parser_scanner_linker : public ScannerT
{
parser_scanner_linker(ScannerT const scan_) : ScannerT(scan_) {}
};
#endif // !defined(BOOST_SPIRIT_PARSER_SCANNER_LINKER_DEFINED)
//////////////////////////////////
#if !defined(BOOST_SPIRIT_PARSER_CONTEXT_LINKER_DEFINED)
#define BOOST_SPIRIT_PARSER_CONTEXT_LINKER_DEFINED
template<typename ContextT>
struct parser_context_linker : public ContextT
{
template <typename ParserT>
parser_context_linker(ParserT const& p)
: ContextT(p) {}
template <typename ParserT, typename ScannerT>
void pre_parse(ParserT const& p, ScannerT const& scan)
{ ContextT::pre_parse(p, scan); }
template <typename ResultT, typename ParserT, typename ScannerT>
ResultT&
post_parse(ResultT& hit, ParserT const& p, ScannerT const& scan)
{ return ContextT::post_parse(hit, p, scan); }
};
#endif // !defined(BOOST_SPIRIT_PARSER_CONTEXT_LINKER_DEFINED)
///////////////////////////////////////////////////////////////////////////
//
// BOOST_SPIRIT_CONTEXT_PARSE helper macro
//
// The original implementation uses a template class. However, we
// need to lessen the template instantiation depth to help inferior
// compilers that sometimes choke on deep template instantiations.
// The objective is to avoid code redundancy. A macro, in this case
// is an obvious solution. Sigh!
//
// WARNING: INTERNAL USE ONLY. NOT FOR PUBLIC CONSUMPTION.
//
///////////////////////////////////////////////////////////////////////////
#define BOOST_SPIRIT_CONTEXT_PARSE(scan, this_, scanner_t, context_t, result_t) \
scanner_t scan_wrap(scan); \
context_t context_wrap(this_); \
context_wrap.pre_parse(this_, scan_wrap); \
result_t hit = parse_main(scan); \
return context_wrap.post_parse(hit, this_, scan_wrap);
} // namespace spirit
} // namespace boost
#endif

77
include/boost/spirit/core/non_terminal/parser_id.hpp Normal file
View File

@@ -0,0 +1,77 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001-2003 Joel de Guzman
Copyright (c) 2001 Daniel Nuffer
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_PARSER_ID_HPP)
#define BOOST_SPIRIT_PARSER_ID_HPP
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
class parser_id
{
public:
parser_id() : p(0) {}
explicit parser_id(void const* prule) : p(prule) {}
parser_id(long l_) : l(l_) {}
bool operator==(parser_id const& x) const { return p == x.p; }
bool operator!=(parser_id const& x) const { return !(*this == x); }
bool operator<(parser_id const& x) const { return p < x.p; }
long to_long() const { return l; }
private:
union
{
void const* p;
long l;
};
};
#if defined(BOOST_SPIRIT_DEBUG)
inline std::ostream&
operator<<(std::ostream& out, parser_id const& rid)
{
out << rid.to_long();
return out;
}
#endif
///////////////////////////////////////////////////////////////////////////
//
// parser_address_tag class: tags a parser with its address
//
///////////////////////////////////////////////////////////////////////////
struct parser_address_tag
{
template <typename ParserT>
static parser_id id(ParserT const& p)
{ return parser_id(&p); }
};
///////////////////////////////////////////////////////////////////////////
//
// parser_tag class: tags a parser with an integer ID
//
///////////////////////////////////////////////////////////////////////////
template <int N>
struct parser_tag
{
template <typename ParserT>
static parser_id id(ParserT const& p)
{ return parser_id(long(N)); }
};
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif

117
include/boost/spirit/core/non_terminal/rule.hpp Normal file
View File

@@ -0,0 +1,117 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_RULE_HPP)
#define BOOST_SPIRIT_RULE_HPP
///////////////////////////////////////////////////////////////////////////////
#include "boost/shared_ptr.hpp"
#include "boost/spirit/core/parser.hpp"
#include "boost/spirit/core/scanner/scanner.hpp"
#include "boost/spirit/core/non_terminal/parser_context.hpp"
#include "boost/spirit/core/non_terminal/parser_id.hpp"
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
namespace impl
{
template <typename ScannerT, typename RT>
struct abstract_parser;
template <typename ParserT, typename ScannerT, typename RT>
struct concrete_parser;
}
///////////////////////////////////////////////////////////////////////////
//
// rule class
//
// The rule is a polymorphic parser that acts as a named place-
// holder capturing the behavior of an EBNF expression assigned to
// it. The rule is a template class parameterized by the type of the
// scanner (ScannerT, see scanner.hpp), the rule's context
// (ContextT, see parser_context.hpp), and an arbitrary tag (TagT,
// see parser_id.hpp) that allows a rule to be tagged for
// identification.
//
// The definition of the rule (its right hand side, RHS) is
// reference counted and held by the rule through a smart pointer.
// When a rule is seen in the the RHS of an assignment or copy
// construction EBNF expression, the rule is held by the LHS rule by
// reference.
//
///////////////////////////////////////////////////////////////////////////
template <
typename ScannerT = scanner<>,
typename ContextT = parser_context,
typename TagT = parser_address_tag>
class rule
: public parser<rule<ScannerT, ContextT, TagT> >
, public ContextT::base_t
, public context_aux<ContextT, rule<ScannerT, ContextT, TagT> >
{
public:
typedef rule<ScannerT, ContextT, TagT> self_t;
typedef rule<ScannerT, ContextT, TagT> const& embed_t;
typedef parser_scanner_linker<ScannerT> scanner_t;
typedef parser_context_linker<ContextT> context_t;
typedef typename context_t::attr_t attr_t;
typedef typename match_result<ScannerT, attr_t>::type result_t;
template <typename ScannerT2>
struct result { typedef result_t type; };
rule();
~rule();
rule(rule const& r)
: ptr(new impl::concrete_parser<rule, ScannerT, result_t>(r)) {}
template <typename ParserT>
rule(ParserT const& p)
: ptr(new impl::concrete_parser<ParserT, ScannerT, result_t>(p)) {}
template <typename ParserT>
rule& operator=(ParserT const& p)
{
ptr.reset(
new impl::concrete_parser<ParserT, ScannerT, result_t>(p));
return *this;
}
// If this is placed above the templatized assignment
// operator, VC6 incorrectly complains ambiguity with
// r1 = r2, where r1 and r2 are both rules.
rule& operator=(rule const& r)
{
ptr.reset(
new impl::concrete_parser<rule, ScannerT, result_t>(r));
return *this;
}
result_t parse(ScannerT const& scan) const;
result_t parse_main(ScannerT const& scan) const;
parser_id id() const;
private:
typedef impl::abstract_parser<ScannerT, result_t> abstract_parser_t;
boost::shared_ptr<abstract_parser_t> ptr;
};
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#include "boost/spirit/core/non_terminal/impl/rule.ipp"
#endif

316
include/boost/spirit/core/non_terminal/subrule.hpp Normal file
View File

@@ -0,0 +1,316 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Joel de Guzman
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_SUBRULE_HPP)
#define BOOST_SPIRIT_SUBRULE_HPP
#include "boost/type_traits.hpp"
#include "boost/static_assert.hpp"
#if !defined(BOOST_SPIRIT_PARSER_HPP)
#include "boost/spirit/core/parser.hpp"
#endif
#if !defined(BOOST_SPIRIT_PARSER_CONTEXT_HPP)
#include "boost/spirit/core/non_terminal/parser_context.hpp"
#endif
#if !defined(BOOST_SPIRIT_SUBRULE_IPP)
#include "boost/spirit/core/non_terminal/impl/subrule.ipp"
#endif
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////
//
// subrules_scanner class
//
///////////////////////////////////////////////////////////////////////////
template <typename ScannerT, typename ListT>
struct subrules_scanner : public ScannerT
{
typedef ScannerT scanner_t;
typedef ListT list_t;
typedef subrules_scanner<ScannerT, ListT> self_t;
subrules_scanner(ScannerT const& scan, ListT const& list_)
: ScannerT(scan), list(list_) {}
template <typename PoliciesT>
struct rebind_policies
{
typedef typename rebind_scanner_policies<ScannerT, PoliciesT>::type
rebind_scanner;
typedef subrules_scanner<rebind_scanner, ListT> type;
};
template <typename PoliciesT>
subrules_scanner<
typename rebind_scanner_policies<ScannerT, PoliciesT>::type,
ListT>
change_policies(PoliciesT const& policies) const
{
typedef subrules_scanner<
BOOST_SPIRIT_TYPENAME
rebind_scanner_policies<ScannerT, PoliciesT>::type,
ListT>
subrules_scanner_t;
return subrules_scanner_t(
ScannerT::change_policies(policies),
list);
}
template <typename IteratorT>
struct rebind_iterator
{
typedef typename rebind_scanner_iterator<ScannerT, IteratorT>::type
rebind_scanner;
typedef subrules_scanner<rebind_scanner, ListT> type;
};
template <typename IteratorT>
subrules_scanner<
typename rebind_scanner_iterator<ScannerT, IteratorT>::type,
ListT>
change_iterator(IteratorT const& first, IteratorT const &last) const
{
typedef subrules_scanner<
BOOST_SPIRIT_TYPENAME
rebind_scanner_iterator<ScannerT, IteratorT>::type,
ListT>
subrules_scanner_t;
return subrules_scanner_t(
ScannerT::change_iterator(first, last),
list);
}
ListT const& list;
};
///////////////////////////////////////////////////////////////////////////
//
// subrule_scanner type computer class
//
// This computer ensures that the scanner will not be recursively
// instantiated if it's not needed.
//
///////////////////////////////////////////////////////////////////////////
template <typename ScannerT, typename ListT>
struct subrules_scanner_finder
{
typedef subrules_scanner<ScannerT, ListT> type;
};
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
//
// MSVC doesn't support PTS. The default implementation
// still works. It just generates a whole lot more
// template instantiations.
template <typename ScannerT, typename ListT>
struct subrules_scanner_finder<subrules_scanner<ScannerT, ListT>, ListT>
{
typedef subrules_scanner<ScannerT, ListT> type;
};
#endif
///////////////////////////////////////////////////////////////////////////
//
// subrule_list class
//
///////////////////////////////////////////////////////////////////////////
template <typename FirstT, typename RestT>
struct subrule_list : public parser<subrule_list<FirstT, RestT> >
{
typedef subrule_list<FirstT, RestT> self_t;
typedef FirstT first_t;
typedef RestT rest_t;
subrule_list(FirstT const& first_, RestT const& rest_)
: first(first_), rest(rest_) {}
template <typename ScannerT>
struct result
{
typedef typename FirstT::def_t parser_t;
typedef typename parser_result<parser_t, ScannerT>::type type;
};
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
typedef typename subrules_scanner_finder<ScannerT, self_t>::type
subrules_scanner_t;
subrules_scanner_t g_arg(scan, *this);
return first.rhs.parse(g_arg);
}
template <int ID, typename DefT, typename ContextT>
subrule_list<
FirstT,
subrule_list<
subrule_parser<ID, DefT, ContextT>,
RestT> >
operator,(subrule_parser<ID, DefT, ContextT> const& rhs)
{
return subrule_list<
FirstT,
subrule_list<
subrule_parser<ID, DefT, ContextT>,
RestT> >(
first,
subrule_list<
subrule_parser<ID, DefT, ContextT>,
RestT>(rhs, rest));
}
FirstT first;
RestT rest;
};
///////////////////////////////////////////////////////////////////////////
//
// subrule_parser class
//
///////////////////////////////////////////////////////////////////////////
template <int ID, typename ContextT = parser_context>
struct subrule; // Forward declaration
template <int ID, typename DefT, typename ContextT>
struct subrule_parser
: public parser<subrule_parser<ID, DefT, ContextT> >
{
typedef subrule_parser<ID, DefT, ContextT> self_t;
typedef subrule<ID, ContextT> subrule_t;
typedef DefT def_t;
BOOST_STATIC_CONSTANT(int, id = ID);
template <typename ScannerT>
struct result
{
typedef typename
impl::get_subrule_parser_result<
DefT, ScannerT, typename subrule_t::attr_t>::type type;
};
subrule_parser(subrule_t const& start_, DefT const& rhs_)
: rhs(rhs_), start(start_) {}
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
// This will only be called when parsing single subrules.
typedef subrule_list<self_t, nil_t> list_t;
typedef subrules_scanner<ScannerT, list_t> scanner_t;
list_t list(*this, nil_t());
scanner_t g_arg(scan, list);
return start.parse(g_arg);
}
template <int ID2, typename DefT2, typename ContextT2>
inline subrule_list<
self_t,
subrule_list<
subrule_parser<ID2, DefT2, ContextT2>,
nil_t> >
operator,(subrule_parser<ID2, DefT2, ContextT2> const& rhs) const
{
return subrule_list<
self_t,
subrule_list<
subrule_parser<ID2, DefT2, ContextT2>,
nil_t> >(
*this,
subrule_list<
subrule_parser<ID2, DefT2, ContextT2>, nil_t>(
rhs, nil_t()));
}
typename DefT::embed_t rhs;
subrule_t const& start;
};
///////////////////////////////////////////////////////////////////////////
//
// subrule class
//
///////////////////////////////////////////////////////////////////////////
template <int ID, typename ContextT>
struct subrule
: public parser<subrule<ID, ContextT> >
, public ContextT::base_t
{
typedef subrule<ID, ContextT> self_t;
typedef subrule<ID, ContextT> const& embed_t;
typedef parser_context_linker<ContextT> context_t;
typedef typename context_t::attr_t attr_t;
BOOST_STATIC_CONSTANT(int, id = ID);
template <typename ScannerT>
struct result
{
typedef typename
impl::get_subrule_result<ID, ScannerT, attr_t>::type type;
};
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse_main(ScannerT const& scan) const
{
typedef typename parser_result<self_t, ScannerT>::type result_t;
result_t result;
impl::parse_subrule<result_t, ScannerT, ID>::
do_(result, scan);
return result;
}
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;
typedef parser_scanner_linker<ScannerT> scanner_t;
BOOST_SPIRIT_CONTEXT_PARSE(
scan, *this, scanner_t, context_t, result_t);
}
template <typename DefT>
subrule_parser<ID, DefT, ContextT>
operator=(parser<DefT> const& rhs) const
{
return subrule_parser<ID, DefT, ContextT>(*this, rhs.derived());
}
private:
// assignment of subrules is not allowed. Use subrules
// with identical IDs if you want to have aliases.
#if !defined(BOOST_MSVC) && (BOOST_MSVC > 1200)
subrule& operator=(subrule const&);
#endif
template <int ID2, typename ContextT2>
subrule& operator=(subrule<ID2, ContextT2> const&);
};
}} // namespace boost::spirit
#endif

247
include/boost/spirit/core/parser.hpp Normal file
View File

@@ -0,0 +1,247 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_PARSER_HPP)
#define BOOST_SPIRIT_PARSER_HPP
///////////////////////////////////////////////////////////////////////////////
#include "boost/config.hpp"
#include "boost/spirit/core/scanner/scanner.hpp"
#if defined(BOOST_MSVC)
#include "boost/spirit/core/impl/msvc.hpp"
#endif
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
#define BOOST_SPIRIT_PARSER_RESULT_ARGS typename ScannerT, typename Pizza = nil_t
#else
#define BOOST_SPIRIT_PARSER_RESULT_ARGS typename ScannerT
#endif
///////////////////////////////////////////////////////////////////////////////
namespace boost
{
namespace spirit
{
template <typename ParserT, typename ActionT>
class action; // forward declaration
///////////////////////////////////////////////////////////////////////////
//
// Parser categories
//
// Helper template classes to distinguish different types of
// parsers. The following categories are the most generic. More
// specific types may inherit from these. Each parser has a typedef
// parser_category_t that defines its category. By default, if one
// is not specified, it will inherit from the base parser class
// which typedefs its parser_category_t as plain_parser_category.
//
// - plain parser has nothing special
// - binary parser has subject a and b (e.g. alternative)
// - unary parser has single subject (e.g. kleene star)
// - action parser has an attached action parser
//
///////////////////////////////////////////////////////////////////////////
struct plain_parser_category {};
struct binary_parser_category : plain_parser_category {};
struct unary_parser_category : plain_parser_category {};
struct action_parser_category : unary_parser_category {};
///////////////////////////////////////////////////////////////////////////
//
// parser_result metafunction
//
// Given a scanner type ScannerT and a parser type ParserT, the
// parser_result metafunction provides the actual result of the
// parser.
//
// Usage:
//
// typename parser_result<ParserT, ScannerT>::type
//
///////////////////////////////////////////////////////////////////////////
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER(parser_result_wrapper, result);
//////////////////////////////////
template <typename ParserT, typename ScannerT>
struct parser_result
{
typedef typename impl::parser_result_wrapper<ParserT>
::template result_<ScannerT>::type type;
};
#else
//////////////////////////////////
template <typename ParserT, typename ScannerT>
struct parser_result
{
typedef typename ParserT::template result<ScannerT>::type type;
};
#endif
///////////////////////////////////////////////////////////////////////////
//
// parser class
//
// This class is a protocol base class for all parsers. This is
// essentially an interface contract. The parser class does not
// really know how to parse anything but instead relies on the
// template parameter DerivedT (which obviously is assumed to be a
// subclass) to do the actual parsing.
//
// Concrete sub-classes inheriting from parser must have a
// corresponding member function parse(...) compatible with the
// conceptual Interface:
//
// template <typename ScannerT>
// RT parse(ScannerT const& scan) const;
//
// where RT is the desired return type of the parser and ScannerT
// scan is the scanner (see scanner.hpp).
//
// Concrete sub-classes inheriting from parser in most cases need to
// have a nested meta-function result that returns the result type
// of the parser's parse member function, given a scanner type. The
// meta- function has the form:
//
// template <typename ScannerT>
// struct result
// {
// typedef RT type;
// };
//
// where RT is the desired return type of the parser. This is
// usually, but not always, dependent on the template parameter
// ScannerT. If a parser does not supply a result metafunction, a
// default is provided by the base parser class.
//
// The parser's derived() member function returns a reference to the
// parser as its derived object.
//
// An operator[] is provided. The operator returns a semantic action
// handler (see actions.hpp).
//
// Each parser has a typedef embed_t. This typedef specifies how a
// parser is embedded in a composite (see composite.hpp). By
// default, if one is not specified, the parser will be embedded by
// value. That is, a copy of the parser is placed as a member
// variable of the composite. Most parsers are embedded by value. In
// certain situations however, this is not desirable or possible.
//
///////////////////////////////////////////////////////////////////////////
template <typename DerivedT>
struct parser
{
typedef DerivedT embed_t;
typedef DerivedT derived_t;
typedef plain_parser_category parser_category_t;
template <BOOST_SPIRIT_PARSER_RESULT_ARGS>
struct result
{
typedef typename match_result<ScannerT, nil_t>::type type;
};
DerivedT& derived()
{ return *static_cast<DerivedT*>(this); }
DerivedT const& derived() const
{ return *static_cast<DerivedT const*>(this); }
template <typename ActionT>
action<DerivedT, ActionT>
operator[](ActionT const& actor) const
{ return action<DerivedT, ActionT>(derived(), actor); }
};
///////////////////////////////////////////////////////////////////////////
//
// parse_info
//
// Results returned by the free parse functions:
//
// stop: points to the final parse position (i.e parsing
// processed the input up to this point).
//
// hit: true if parsing is successful. This may be full:
// the parser consumed all the input, or partial:
// the parser consumed only a portion of the input.
//
// full: true when we have a full hit (i.e the parser
// consumed all the input.
//
// length: The number of characters consumed by the parser.
// This is valid only if we have a successful hit
// (either partial or full). A negative value means
// that the hit is unsucessful.
//
///////////////////////////////////////////////////////////////////////////
template <typename IteratorT = char const*>
struct parse_info
{
IteratorT stop;
bool hit;
bool full;
unsigned length;
parse_info(
IteratorT const& stop_ = IteratorT(),
bool hit_ = false,
bool full_ = false,
unsigned length_ = 0)
: stop(stop_)
, hit(hit_)
, full(full_)
, length(length_) {}
template <typename ParseInfoT>
parse_info(ParseInfoT const& pi)
: stop(pi.stop)
, hit(pi.hit)
, full(pi.full)
, length(pi.length) {}
};
///////////////////////////////////////////////////////////////////////////
//
// Generic parse function
//
///////////////////////////////////////////////////////////////////////////
template <typename IteratorT, typename DerivedT>
parse_info<IteratorT>
parse(
IteratorT const& first,
IteratorT const& last,
parser<DerivedT> const& p);
///////////////////////////////////////////////////////////////////////////
//
// Parse function for null terminated strings
//
///////////////////////////////////////////////////////////////////////////
template <typename CharT, typename DerivedT>
parse_info<CharT const*>
parse(
CharT const* str,
parser<DerivedT> const& p);
} // namespace spirit
} // namespace boost
#endif
#include "boost/spirit/core/impl/parser.ipp"
#undef BOOST_SPIRIT_PARSER_RESULT_ARGS

4
include/boost/spirit/core/primitives/Makefile.am Normal file
View File

@@ -0,0 +1,4 @@
#This file generated by Makefileamgen.sh
SUBDIRS = impl
spiritinclude_HEADERS = numerics.hpp primitives.hpp
spiritincludedir = $(includedir)/spirit/boost/spirit/core/primitives

3
include/boost/spirit/core/primitives/impl/Makefile.am Normal file
View File

@@ -0,0 +1,3 @@
#This file generated by Makefileamgen.sh
spiritinclude_HEADERS = numerics.ipp primitives.ipp
spiritincludedir = $(includedir)/spirit/boost/spirit/core/primitives/impl

480
include/boost/spirit/core/primitives/impl/numerics.ipp Normal file
View File

@@ -0,0 +1,480 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
Copyright (c) 2001-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#ifndef BOOST_SPIRIT_NUMERICS_IPP
#define BOOST_SPIRIT_NUMERICS_IPP
///////////////////////////////////////////////////////////////////////////////
#include <cmath>
#if defined(BOOST_NO_STDC_NAMESPACE)
#define BOOST_SPIRIT_IMPL_STD_NS
#else
#define BOOST_SPIRIT_IMPL_STD_NS std
#endif
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
namespace impl
{
///////////////////////////////////////////////////////////////////////
//
// Extract the prefix sign (- or +)
//
///////////////////////////////////////////////////////////////////////
template <typename ScannerT>
bool
extract_sign(ScannerT const& scan, unsigned& count)
{
// Extract the sign
count = 0;
bool neg = *scan == '-';
if (neg || (*scan == '+'))
{
++scan;
++count;
return neg;
}
return false;
}
///////////////////////////////////////////////////////////////////////
//
// Traits class for radix specific number conversion
//
// Test the validity of a single character:
//
// template<typename CharT> static bool is_valid(CharT ch);
//
// Convert a digit from character representation to binary
// representation:
//
// template<typename CharT> static int digit(CharT ch);
//
///////////////////////////////////////////////////////////////////////
template<const int Radix>
struct radix_traits;
////////////////////////////////// Binary
template<>
struct radix_traits<2>
{
template<typename CharT>
static bool is_valid(CharT ch) { return ('0' == ch || '1' == ch); }
template<typename CharT>
static int digit(CharT ch) { return ch - '0'; }
};
////////////////////////////////// Octal
template<>
struct radix_traits<8>
{
template<typename CharT>
static bool is_valid(CharT ch) { return ('0' <= ch && ch <= '7'); }
template<typename CharT>
static int digit(CharT ch) { return ch - '0'; }
};
////////////////////////////////// Decimal
template<>
struct radix_traits<10>
{
template<typename CharT>
static bool is_valid(CharT ch) { return impl::isdigit_(ch); }
template<typename CharT>
static int digit(CharT ch) { return ch - '0'; }
};
////////////////////////////////// Hexadecimal
template<>
struct radix_traits<16>
{
template<typename CharT>
static bool is_valid(CharT ch) { return impl::isxdigit_(ch); }
template<typename CharT>
static int digit(CharT ch)
{
if (impl::isdigit_(ch))
return ch - '0';
return impl::tolower_(ch) - 'a' + 10;
}
};
///////////////////////////////////////////////////////////////////////////
//
// Helper templates for encapsulation of radix specific conversion
// of an input string to an integral value.
//
// main entry point:
//
// extract_int<Radix, MinDigits, MaxDigits, Accumulate>
// ::f(first, last, n, count);
//
// The template parameter Radix represents the radix of the
// number contained in the parsed string. The template
// parameter MinDigits specifies the minimum digits to accept.
// The template parameter MaxDigits specifies the maximum
// digits to parse. A -1 value for MaxDigits will make it parse
// an arbitrarilly large number as long as the numeric type can
// hold it. Accumulate is either positive_accumulate<Radix>
// (default) for parsing positive numbers or
// negative_accumulate<Radix> otherwise.
//
// scan.first and scan.last are iterators as usual (i.e. first
// is mutable and is moved forward when a match is found), n is
// a variable that holds the number (passed by reference). The
// number of parsed characters is added to count (also passed
// by reference)
//
// NOTE:
// Returns a non-match, if the number to parse
// overflows (or underflows) the used integral type.
// Overflow (or underflow) is detected when an
// operation wraps a value from its maximum to its
// minimum (or vice-versa). For example, overflow
// occurs when the result of the expression n * x is
// less than n (assuming n is positive and x is greater
// than 1).
//
// BEWARE:
// the parameters 'n' and 'count' should be properly
// initialized before calling this function.
//
/////////////////////////////////////////////////////////////////////////////
template <int Radix>
struct positive_accumulate
{
// Use this accumulator if number is positive
template <typename T>
static bool check(T const& n, T const& prev)
{ return n < prev; }
template <typename T, typename CharT>
static void add(T& n, CharT ch)
{ n += radix_traits<Radix>::digit(ch); }
};
//////////////////////////////////
template <int Radix>
struct negative_accumulate
{
// Use this accumulator if number is negative
template <typename T>
static bool check(T const& n, T const& prev)
{ return n > prev; }
template <typename T, typename CharT>
static void add(T& n, CharT ch)
{ n -= radix_traits<Radix>::digit(ch); }
};
//////////////////////////////////
template <int Radix, typename Accumulate>
struct extract_int_base
{
// Common code for extract_int specializations
template <typename ScannerT, typename T>
static bool
f(ScannerT& scan, T& n)
{
T prev = n;
n *= Radix;
if (Accumulate::check(n, prev))
return false; // over/underflow!
prev = n;
Accumulate::add(n, *scan);
if (Accumulate::check(n, prev))
return false; // over/underflow!
return true;
}
};
//////////////////////////////////
template <bool Bounded>
struct extract_int_
{
template <
int Radix,
unsigned MinDigits,
int MaxDigits,
typename Accumulate
>
struct apply
{
typedef extract_int_base<Radix, Accumulate> base;
typedef radix_traits<Radix> check;
template <typename ScannerT, typename T>
static bool
f(ScannerT& scan, T& n, unsigned& count)
{
unsigned i = 0;
for (; (i < MaxDigits) && !scan.at_end()
&& check::is_valid(*scan);
++i, ++scan, ++count)
{
if (!base::f(scan, n))
return false; // over/underflow!
}
return i >= MinDigits;
}
};
};
//////////////////////////////////
template <>
struct extract_int_<false>
{
template <
int Radix,
unsigned MinDigits,
int MaxDigits,
typename Accumulate
>
struct apply
{
typedef extract_int_base<Radix, Accumulate> base;
typedef radix_traits<Radix> check;
template <typename ScannerT, typename T>
static bool
f(ScannerT& scan, T& n, unsigned& count)
{
unsigned i = 0;
for (; !scan.at_end() && check::is_valid(*scan);
++i, ++scan, ++count)
{
if (!base::f(scan, n))
return false; // over/underflow!
}
return i >= MinDigits;
}
};
};
//////////////////////////////////
template <
int Radix, unsigned MinDigits, int MaxDigits,
typename Accumulate = positive_accumulate<Radix>
>
struct extract_int
{
template <typename ScannerT, typename T>
static bool
f(ScannerT& scan, T& n, unsigned& count)
{
return extract_int_<(MaxDigits >= 0)>::template
apply<Radix, MinDigits, MaxDigits, Accumulate>::
f(scan, n, count);
}
};
///////////////////////////////////////////////////////////////////////
//
// uint_parser_impl class
//
///////////////////////////////////////////////////////////////////////
template <
typename T = unsigned,
int Radix = 10,
unsigned MinDigits = 1,
int MaxDigits = -1
>
struct uint_parser_impl
: public parser<uint_parser_impl<T, Radix, MinDigits, MaxDigits> >
{
typedef uint_parser_impl<T, Radix, MinDigits, MaxDigits> self_t;
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, T>::type type;
};
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
if (!scan.at_end())
{
T n = 0;
unsigned count = 0;
typename ScannerT::iterator_t save = scan.first;
if (extract_int<Radix, MinDigits, MaxDigits>::
f(scan, n, count))
{
return scan.create_match(count, n, save, scan.first);
}
// return non-match if number overflows
}
return scan.no_match();
}
};
///////////////////////////////////////////////////////////////////////
//
// int_parser_impl class
//
///////////////////////////////////////////////////////////////////////
template <
typename T = unsigned,
int Radix = 10,
unsigned MinDigits = 1,
int MaxDigits = -1
>
struct int_parser_impl
: public parser<int_parser_impl<T, Radix, MinDigits, MaxDigits> >
{
typedef int_parser_impl<T, Radix, MinDigits, MaxDigits> self_t;
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, T>::type type;
};
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
typedef extract_int<Radix, MinDigits, MaxDigits,
negative_accumulate<Radix> > extract_int_neg_t;
typedef extract_int<Radix, MinDigits, MaxDigits>
extract_int_pos_t;
if (!scan.at_end())
{
T n = 0;
unsigned count = 0;
typename ScannerT::iterator_t save = scan.first;
bool hit = impl::extract_sign(scan, count);
if (hit)
hit = extract_int_neg_t::f(scan, n, count);
else
hit = extract_int_pos_t::f(scan, n, count);
if (hit)
return scan.create_match(count, n, save, scan.first);
else
scan.first = save;
// return non-match if number overflows or underflows
}
return scan.no_match();
}
};
///////////////////////////////////////////////////////////////////////
//
// real_parser_impl class
//
///////////////////////////////////////////////////////////////////////
template <typename RT, typename T, typename RealPoliciesT>
struct real_parser_impl
{
typedef real_parser_impl<RT, T, RealPoliciesT> self_t;
template <typename ScannerT>
RT parse_main(ScannerT const& scan) const
{
if (scan.at_end())
return scan.no_match();
typename ScannerT::iterator_t save = scan.first;
match<bool> sign_match = RealPoliciesT::parse_sign(scan);
unsigned count = sign_match ? sign_match.length() : 0;
bool neg = sign_match.value();
RT n_match = RealPoliciesT::parse_n(scan);
T n = n_match.value();
bool got_a_number = n_match;
if (!got_a_number && !RealPoliciesT::allow_trailing_left_dot)
return scan.no_match();
else
count += n_match.length();
if (neg)
n = -n;
if (RealPoliciesT::parse_dot(scan))
{
// We got the decimal point. Now we will try to parse
// the fraction if it is there. If not, it defaults
// to zero (0) only if we already got a number.
if (RT hit = RealPoliciesT::parse_frac_n(scan))
{
hit.value() *=
BOOST_SPIRIT_IMPL_STD_NS::pow(T(10), T(-hit.length()));
if (neg)
n -= hit.value();
else
n += hit.value();
count += hit.length() + 1;
}
else if (!got_a_number ||
!RealPoliciesT::allow_trailing_right_dot)
return scan.no_match();
}
else
{
if (!got_a_number)
return scan.no_match();
// We have reached a point where we
// still haven't seen a number at all.
// We return early with a no-match.
}
if (match<> e_hit = RealPoliciesT::parse_exp(scan))
{
// We got the exponent prefix. Now we will try to parse the
// actual exponent. It is an error if it is not there.
if (RT e_n_hit = RealPoliciesT::parse_exp_n(scan))
{
n *= BOOST_SPIRIT_IMPL_STD_NS::pow(T(10), T(e_n_hit.value()));
count += e_n_hit.length() + e_hit.length();
}
else
{
// Oops, no exponent, return a no-match
return scan.no_match();
}
}
return scan.create_match(count, n, save, scan.first);
}
template <typename ScannerT>
static RT parse(ScannerT const& scan)
{
static self_t this_;
return impl::implicit_lexeme_parse<RT>(this_, scan, scan);
}
};
} // namespace impl
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif
#undef BOOST_SPIRIT_IMPL_STD_NS

179
include/boost/spirit/core/primitives/impl/primitives.ipp Normal file
View File

@@ -0,0 +1,179 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
Copyright (c) 2003 Martin Wille
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_PRIMITIVES_IPP)
#define BOOST_SPIRIT_PRIMITIVES_IPP
#include <cctype>
#if !defined(BOOST_NO_CWCTYPE)
#include <cwctype>
#endif
#if defined(BOOST_MSVC)
#pragma warning(disable:4800)
#endif
namespace boost { namespace spirit {
template <typename DrivedT> struct char_parser;
namespace impl {
template <typename IteratorT>
inline IteratorT
get_last(IteratorT first)
{
while (*first)
first++;
return first;
}
template<
typename RT,
typename IteratorT,
typename ScannerT>
inline RT
string_parser_parse(
IteratorT str_first,
IteratorT str_last,
ScannerT& scan)
{
typedef typename ScannerT::iterator_t iterator_t;
iterator_t saved = scan.first;
int slen = str_last - str_first;
while (str_first != str_last)
{
if (scan.at_end() || (*str_first != *scan))
return scan.no_match();
++str_first;
++scan;
}
return scan.create_match(slen, nil_t(), saved, scan.first);
}
///////////////////////////////////////////////////////////////////////////
//
// Convenience functions
//
///////////////////////////////////////////////////////////////////////////
inline bool
isalnum_(int c)
{ using namespace std; return isalnum(c); }
inline bool
isalpha_(int c)
{ using namespace std; return isalpha(c); }
inline bool
iscntrl_(int c)
{ using namespace std; return iscntrl(c); }
inline bool
isdigit_(int c)
{ using namespace std; return isdigit(c); }
inline bool
isgraph_(int c)
{ using namespace std; return isgraph(c); }
inline bool
islower_(int c)
{ using namespace std; return islower(c); }
inline bool
isprint_(int c)
{ using namespace std; return isprint(c); }
inline bool
ispunct_(int c)
{ using namespace std; return ispunct(c); }
inline bool
isspace_(int c)
{ using namespace std; return isspace(c); }
inline bool
isupper_(int c)
{ using namespace std; return isupper(c); }
inline bool
isxdigit_(int c)
{ using namespace std; return isxdigit(c); }
inline char
tolower_(int c)
{ using namespace std; return static_cast<char>(tolower(c)); }
inline char
toupper_(int c)
{ using namespace std; return static_cast<char>(toupper(c)); }
#if !defined(BOOST_NO_CWCTYPE)
inline bool
isalnum_(wchar_t c)
{ using namespace std; return iswalnum(c); }
inline bool
isalpha_(wchar_t c)
{ using namespace std; return iswalpha(c); }
inline bool
iscntrl_(wchar_t c)
{ using namespace std; return iswcntrl(c); }
inline bool
isdigit_(wchar_t c)
{ using namespace std; return iswdigit(c); }
inline bool
isgraph_(wchar_t c)
{ using namespace std; return iswgraph(c); }
inline bool
islower_(wchar_t c)
{ using namespace std; return iswlower(c); }
inline bool
isprint_(wchar_t c)
{ using namespace std; return iswprint(c); }
inline bool
ispunct_(wchar_t c)
{ using namespace std; return iswpunct(c); }
inline bool
isspace_(wchar_t c)
{ using namespace std; return iswspace(c); }
inline bool
isupper_(wchar_t c)
{ using namespace std; return iswupper(c); }
inline bool
isxdigit_(wchar_t c)
{ using namespace std; return iswxdigit(c); }
inline wchar_t
tolower_(wchar_t c)
{ using namespace std; return towlower(c); }
inline wchar_t
toupper_(wchar_t c)
{ using namespace std; return towupper(c); }
#endif // !defined(BOOST_NO_CWCTYPE)
}}} // namespace boost::spirit::impl
#endif

279
include/boost/spirit/core/primitives/numerics.hpp Normal file
View File

@@ -0,0 +1,279 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
Copyright (c) 2001-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#ifndef BOOST_SPIRIT_NUMERICS_HPP
#define BOOST_SPIRIT_NUMERICS_HPP
///////////////////////////////////////////////////////////////////////////////
#include "boost/config.hpp"
#include "boost/spirit/core/parser.hpp"
#include "boost/spirit/core/composite/directives.hpp"
#include "boost/spirit/core/primitives/impl/numerics.ipp"
// VC++6 chokes and ICEs with parser_result on the real parser traits when
// the real parser is used inside a grammar. This workaround solves the
// problem
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1200)
#define BOOST_SPIRIT_NUMP_RESULT(parser_t, scanner_t, T) \
typename match_result<scanner_t, T>::type
#else
#define BOOST_SPIRIT_NUMP_RESULT(parser_t, scanner_t, T) \
typename parser_result<parser_t, scanner_t>::type
#endif
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
//
// uint_parser class
//
///////////////////////////////////////////////////////////////////////////////
template <
typename T = unsigned,
int Radix = 10,
unsigned MinDigits = 1,
int MaxDigits = -1
>
struct uint_parser
: public parser<uint_parser<T, Radix, MinDigits, MaxDigits> >
{
typedef uint_parser<T, Radix, MinDigits, MaxDigits> self_t;
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, T>::type type;
};
// Don't take the #if out. VC6 will hate it!
#if defined(__MWERKS__) && (__MWERKS__ <= 0x2407)
// Don't take the empty constructor out line CW7.2 will hate it!
uint_parser() {}
#endif
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
typedef impl::uint_parser_impl<T, Radix, MinDigits, MaxDigits> impl_t;
typedef typename parser_result<impl_t, ScannerT>::type result_t;
return impl::contiguous_parser_parse<result_t>(impl_t(), scan, scan);
}
};
///////////////////////////////////////////////////////////////////////////////
//
// int_parser class
//
///////////////////////////////////////////////////////////////////////////////
template <
typename T = unsigned,
int Radix = 10,
unsigned MinDigits = 1,
int MaxDigits = -1
>
struct int_parser
: public parser<int_parser<T, Radix, MinDigits, MaxDigits> >
{
typedef int_parser<T, Radix, MinDigits, MaxDigits> self_t;
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, T>::type type;
};
// Don't take the #if out. VC6 will hate it!
#if defined(__MWERKS__) && (__MWERKS__ <= 0x2407)
// Don't take the empty constructor out line CW7.2 will hate it!
int_parser() {}
#endif
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
typedef impl::int_parser_impl<T, Radix, MinDigits, MaxDigits> impl_t;
typedef typename parser_result<impl_t, ScannerT>::type result_t;
return impl::contiguous_parser_parse<result_t>(impl_t(), scan, scan);
}
};
///////////////////////////////////////////////////////////////////////////////
//
// uint_parser/int_parser instantiations
//
///////////////////////////////////////////////////////////////////////////////
int_parser<int, 10, 1, -1> const
int_p = int_parser<int, 10, 1, -1>();
uint_parser<unsigned, 10, 1, -1> const
uint_p = uint_parser<unsigned, 10, 1, -1>();
uint_parser<unsigned, 2, 1, -1> const
bin_p = uint_parser<unsigned, 2, 1, -1>();
uint_parser<unsigned, 8, 1, -1> const
oct_p = uint_parser<unsigned, 8, 1, -1>();
uint_parser<unsigned, 16, 1, -1> const
hex_p = uint_parser<unsigned, 16, 1, -1>();
// Borland 5.5 again gets confused if the default template parameters
// are not spelled out explicitly above. Sigh, Borland...
///////////////////////////////////////////////////////////////////////////////
//
// sign_parser class
//
///////////////////////////////////////////////////////////////////////////////
namespace impl
{
// Utility to extract the prefix sign ('-' | '+')
template <typename ScannerT>
bool extract_sign(ScannerT const& scan, unsigned& count);
}
struct sign_parser : public parser<sign_parser>
{
typedef sign_parser self_t;
template <typename ScannerT>
struct result {
typedef typename match_result<ScannerT, bool>::type type;
};
sign_parser() {}
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
if (!scan.at_end())
{
unsigned length;
typename ScannerT::iterator_t save(scan.first);
bool neg = impl::extract_sign(scan, length);
if (length)
return scan.create_match(1, neg, save, scan.first);
}
return scan.no_match();
}
};
///////////////////////////////////////
sign_parser const sign_p = sign_parser();
///////////////////////////////////////////////////////////////////////////////
//
// default real number policies
//
///////////////////////////////////////////////////////////////////////////////
template <typename T>
struct ureal_parser_policies
{
// trailing dot policy suggested suggested by Gustavo Guerra
BOOST_STATIC_CONSTANT(bool, allow_trailing_left_dot = true);
BOOST_STATIC_CONSTANT(bool, allow_trailing_right_dot = true);
typedef uint_parser<T, 10, 1, -1> uint_parser_t;
typedef int_parser<T, 10, 1, -1> int_parser_t;
template <typename ScannerT>
static typename match_result<ScannerT, nil_t>::type
parse_sign(ScannerT& scan)
{ return scan.no_match(); }
template <typename ScannerT>
static BOOST_SPIRIT_NUMP_RESULT(uint_parser_t, ScannerT, T)
parse_n(ScannerT& scan)
{ return uint_parser_t().parse(scan); }
template <typename ScannerT>
static typename parser_result<chlit<>, ScannerT>::type
parse_dot(ScannerT& scan)
{ return ch_p('.').parse(scan); }
template <typename ScannerT>
static BOOST_SPIRIT_NUMP_RESULT(uint_parser_t, ScannerT, T)
parse_frac_n(ScannerT& scan)
{ return uint_parser_t().parse(scan); }
template <typename ScannerT>
static typename parser_result<chlit<>, ScannerT>::type
parse_exp(ScannerT& scan)
{ return nocase_d['e'].parse(scan); }
template <typename ScannerT>
static BOOST_SPIRIT_NUMP_RESULT(int_parser_t, ScannerT, T)
parse_exp_n(ScannerT& scan)
{ return int_parser_t().parse(scan); }
};
//////////////////////////////////
template <typename T>
struct real_parser_policies : public ureal_parser_policies<T>
{
template <typename ScannerT>
static typename parser_result<sign_parser, ScannerT>::type
parse_sign(ScannerT& scan)
{ return sign_p.parse(scan); }
};
///////////////////////////////////////////////////////////////////////////////
//
// real_parser class
//
///////////////////////////////////////////////////////////////////////////////
template <
typename T = double,
typename RealPoliciesT = ureal_parser_policies<T>
>
struct real_parser
: public parser<real_parser<T, RealPoliciesT> >
{
typedef real_parser<T, RealPoliciesT> self_t;
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, T>::type type;
};
real_parser() {}
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::real_parser_impl<result_t, T, RealPoliciesT>::parse(scan);
}
};
///////////////////////////////////////////////////////////////////////////////
//
// real_parser instantiations
//
///////////////////////////////////////////////////////////////////////////////
real_parser<double, ureal_parser_policies<double> > const
ureal_p = real_parser<double, ureal_parser_policies<double> >();
real_parser<double, real_parser_policies<double> > const
real_p = real_parser<double, real_parser_policies<double> >();
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#undef BOOST_SPIRIT_NUMP_RESULT
#endif

567
include/boost/spirit/core/primitives/primitives.hpp Normal file
View File

@@ -0,0 +1,567 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
Copyright (c) 2003 Martin Wille
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_PRIMITIVES_HPP)
#define BOOST_SPIRIT_PRIMITIVES_HPP
#if !defined(BOOST_REF_HPP_INCLUDED)
#include "boost/ref.hpp"
#endif
#if !defined(BOOST_SPIRIT_DEBUG_ASSERT_HPP)
#include "boost/spirit/debug/assert.hpp"
#endif
#if !defined(BOOST_SPIRIT_PARSER_HPP)
#include "boost/spirit/core/parser.hpp"
#endif
#if !defined(BOOST_SPIRIT_DIRECTIVES_HPP)
#include "boost/spirit/core/composite/impl/directives.ipp"
#endif
#if !defined(BOOST_SPIRIT_PRIMITIVES_IPP)
#include "boost/spirit/core/primitives/impl/primitives.ipp"
#endif
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////
//
// char_parser class
//
///////////////////////////////////////////////////////////////////////////
template <typename DerivedT>
struct char_parser : public parser<DerivedT>
{
typedef DerivedT self_t;
template <typename ScannerT>
struct result {
typedef typename match_result<
ScannerT,
typename ScannerT::value_t
>::type type;
};
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;
typedef typename ScannerT::value_t value_t;
typedef typename ScannerT::iterator_t iterator_t;
if (!scan.at_end())
{
value_t ch = *scan;
if (this->derived().test(ch))
{
iterator_t save(scan.first);
++scan;
return scan.create_match(1, ch, save, scan.first);
}
}
return scan.no_match();
}
};
///////////////////////////////////////////////////////////////////////////
//
// negation of char_parsers
//
///////////////////////////////////////////////////////////////////////////
template <typename PositiveT>
struct negated_char_parser
: public char_parser<negated_char_parser<PositiveT> >
{
typedef negated_char_parser<PositiveT> self_t;
typedef PositiveT positive_t;
negated_char_parser(positive_t const& p)
: positive(p.derived()) {}
template <typename T>
bool test(T ch) const
{ return !positive.test(ch); }
positive_t const positive;
};
template <typename ParserT>
inline negated_char_parser<ParserT>
operator~(char_parser<ParserT> const& p)
{
return negated_char_parser<ParserT>(p.derived());
}
template <typename ParserT>
inline ParserT
operator~(negated_char_parser<ParserT> const& n)
{
return n.positive;
}
///////////////////////////////////////////////////////////////////////////
//
// chlit class
//
///////////////////////////////////////////////////////////////////////////
template <typename CharT = char>
struct chlit : public char_parser<chlit<CharT> >
{
chlit(CharT ch_)
: ch(ch_) {}
template <typename T>
bool test(T ch_) const
{ return ch_ == ch; }
CharT ch;
};
template <typename CharT>
inline chlit<CharT>
ch_p(CharT ch)
{ return chlit<CharT>(ch); }
///////////////////////////////////////////////////////////////////////////
//
// range class
//
///////////////////////////////////////////////////////////////////////////
template <typename CharT = char>
struct range : public char_parser<range<CharT> >
{
range(CharT first_, CharT last_)
: first(first_), last(last_)
{ BOOST_SPIRIT_ASSERT(first <= last); }
template <typename T>
bool test(T ch) const
{ return (CharT(ch) >= first) && (CharT(ch) <= last); }
CharT first;
CharT last;
};
template <typename CharT>
inline range<CharT>
range_p(CharT first, CharT last)
{ return range<CharT>(first, last); }
///////////////////////////////////////////////////////////////////////////
//
// chseq class
//
///////////////////////////////////////////////////////////////////////////
template <typename IteratorT = char const*>
class chseq : public parser<chseq<IteratorT> >
{
public:
typedef chseq<IteratorT> self_t;
chseq(IteratorT first_, IteratorT last_)
: first(first_), last(last_) {}
chseq(IteratorT first_)
: first(first_), last(impl::get_last(first_)) {}
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
typedef typename boost::unwrap_reference<IteratorT>::type striter_t;
typedef typename parser_result<self_t, ScannerT>::type result_t;
return impl::string_parser_parse<result_t>(
striter_t(first),
striter_t(last),
scan);
}
private:
IteratorT first;
IteratorT last;
};
template <typename CharT>
inline chseq<CharT const*>
chseq_p(CharT const* str)
{ return chseq<CharT const*>(str); }
template <typename IteratorT>
inline chseq<IteratorT>
chseq_p(IteratorT first, IteratorT last)
{ return chseq<IteratorT>(first, last); }
///////////////////////////////////////////////////////////////////////////
//
// strlit class
//
///////////////////////////////////////////////////////////////////////////
template <typename IteratorT = char const*>
class strlit : public parser<strlit<IteratorT> >
{
public:
typedef strlit<IteratorT> self_t;
strlit(IteratorT first, IteratorT last)
: seq(first, last) {}
strlit(IteratorT first)
: seq(first) {}
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::contiguous_parser_parse<result_t>
(seq, scan, scan);
}
private:
chseq<IteratorT> seq;
};
template <typename CharT>
inline strlit<CharT const*>
str_p(CharT const* str)
{ return strlit<CharT const*>(str); }
template <typename IteratorT>
inline strlit<IteratorT>
str_p(IteratorT first, IteratorT last)
{ return strlit<IteratorT>(first, last); }
///////////////////////////////////////////////////////////////////////////
//
// nothing_parser class
//
///////////////////////////////////////////////////////////////////////////
struct nothing_parser : public parser<nothing_parser>
{
typedef nothing_parser self_t;
nothing_parser() {}
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{ return scan.no_match(); }
};
nothing_parser const nothing_p = nothing_parser();
///////////////////////////////////////////////////////////////////////////
//
// anychar_parser class
//
///////////////////////////////////////////////////////////////////////////
struct anychar_parser : public char_parser<anychar_parser>
{
typedef anychar_parser self_t;
anychar_parser() {}
template <typename CharT>
bool test(CharT) const
{ return true; }
};
anychar_parser const anychar_p = anychar_parser();
///////////////////////////////////////////////////////////////////////////
//
// alnum_parser class
//
///////////////////////////////////////////////////////////////////////////
struct alnum_parser : public char_parser<alnum_parser>
{
typedef alnum_parser self_t;
alnum_parser() {}
template <typename CharT>
bool test(CharT ch) const
{ return impl::isalnum_(ch); }
};
alnum_parser const alnum_p = alnum_parser();
///////////////////////////////////////////////////////////////////////////
//
// alpha_parser class
//
///////////////////////////////////////////////////////////////////////////
struct alpha_parser : public char_parser<alpha_parser>
{
typedef alpha_parser self_t;
alpha_parser() {}
template <typename CharT>
bool test(CharT ch) const
{ return impl::isalpha_(ch); }
};
alpha_parser const alpha_p = alpha_parser();
///////////////////////////////////////////////////////////////////////////
//
// cntrl_parser class
//
///////////////////////////////////////////////////////////////////////////
struct cntrl_parser : public char_parser<cntrl_parser>
{
typedef cntrl_parser self_t;
cntrl_parser() {}
template <typename CharT>
bool test(CharT ch) const
{ return impl::iscntrl_(ch); }
};
cntrl_parser const cntrl_p = cntrl_parser();
///////////////////////////////////////////////////////////////////////////
//
// digit_parser class
//
///////////////////////////////////////////////////////////////////////////
struct digit_parser : public char_parser<digit_parser>
{
typedef digit_parser self_t;
digit_parser() {}
template <typename CharT>
bool test(CharT ch) const
{ return impl::isdigit_(ch); }
};
digit_parser const digit_p = digit_parser();
///////////////////////////////////////////////////////////////////////////
//
// graph_parser class
//
///////////////////////////////////////////////////////////////////////////
struct graph_parser : public char_parser<graph_parser>
{
typedef graph_parser self_t;
graph_parser() {}
template <typename CharT>
bool test(CharT ch) const
{ return impl::isgraph_(ch); }
};
graph_parser const graph_p = graph_parser();
///////////////////////////////////////////////////////////////////////////
//
// lower_parser class
//
///////////////////////////////////////////////////////////////////////////
struct lower_parser : public char_parser<lower_parser>
{
typedef lower_parser self_t;
lower_parser() {}
template <typename CharT>
bool test(CharT ch) const
{ return impl::islower_(ch); }
};
lower_parser const lower_p = lower_parser();
///////////////////////////////////////////////////////////////////////////
//
// print_parser class
//
///////////////////////////////////////////////////////////////////////////
struct print_parser : public char_parser<print_parser>
{
typedef print_parser self_t;
print_parser() {}
template <typename CharT>
bool test(CharT ch) const
{ return impl::isprint_(ch); }
};
print_parser const print_p = print_parser();
///////////////////////////////////////////////////////////////////////////
//
// punct_parser class
//
///////////////////////////////////////////////////////////////////////////
struct punct_parser : public char_parser<punct_parser>
{
typedef punct_parser self_t;
punct_parser() {}
template <typename CharT>
bool test(CharT ch) const
{ return impl::ispunct_(ch); }
};
punct_parser const punct_p = punct_parser();
///////////////////////////////////////////////////////////////////////////
//
// blank_parser class
//
///////////////////////////////////////////////////////////////////////////
struct blank_parser : public char_parser<blank_parser>
{
typedef blank_parser self_t;
blank_parser() {}
template <typename CharT>
bool test(CharT ch) const
{ return ch == ' ' || ch == '\t'; }
// some systems have isblank(), but some don't, so just do it manually.
};
//////////////////////////////////
blank_parser const blank_p = blank_parser();
///////////////////////////////////////////////////////////////////////////
//
// space_parser class
//
///////////////////////////////////////////////////////////////////////////
struct space_parser : public char_parser<space_parser>
{
typedef space_parser self_t;
space_parser() {}
template <typename CharT>
bool test(CharT ch) const
{ return impl::isspace_(ch); }
};
space_parser const space_p = space_parser();
///////////////////////////////////////////////////////////////////////////
//
// upper_parser class
//
///////////////////////////////////////////////////////////////////////////
struct upper_parser : public char_parser<upper_parser>
{
typedef upper_parser self_t;
upper_parser() {}
template <typename CharT>
bool test(CharT ch) const
{ return impl::isupper_(ch); }
};
upper_parser const upper_p = upper_parser();
///////////////////////////////////////////////////////////////////////////
//
// xdigit_parser class
//
///////////////////////////////////////////////////////////////////////////
struct xdigit_parser : public char_parser<xdigit_parser>
{
typedef xdigit_parser self_t;
xdigit_parser() {}
template <typename CharT>
bool test(CharT ch) const
{ return impl::isxdigit_(ch); }
};
xdigit_parser const xdigit_p = xdigit_parser();
///////////////////////////////////////////////////////////////////////////
//
// eol_parser class (contributed by Martin Wille)
//
///////////////////////////////////////////////////////////////////////////
struct eol_parser : public parser<eol_parser>
{
typedef eol_parser self_t;
eol_parser() {}
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
typename ScannerT::iterator_t save = scan.first;
int len = 0;
if (!scan.at_end() && *scan == '\r') // CR
{
++scan;
++len;
}
if (!scan.at_end() && *scan == '\n') // LF
{
++scan;
++len;
}
if (len)
return scan.create_match(len, nil_t(), save, scan.first);
return scan.no_match();
}
};
eol_parser const eol_p = eol_parser();
///////////////////////////////////////////////////////////////////////////
//
// end_parser class (suggested by Markus Schöpflin)
//
///////////////////////////////////////////////////////////////////////////
struct end_parser : public parser<end_parser>
{
typedef end_parser self_t;
end_parser() {}
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
if (scan.at_end())
return scan.empty_match();
return scan.no_match();
}
};
end_parser const end_p = end_parser();
}} // namespace boost::spirit
#endif

4
include/boost/spirit/core/scanner/Makefile.am Normal file
View File

@@ -0,0 +1,4 @@
#This file generated by Makefileamgen.sh
SUBDIRS = impl
spiritinclude_HEADERS = scanner.hpp skipper.hpp
spiritincludedir = $(includedir)/spirit/boost/spirit/core/scanner

3
include/boost/spirit/core/scanner/impl/Makefile.am Normal file
View File

@@ -0,0 +1,3 @@
#This file generated by Makefileamgen.sh
spiritinclude_HEADERS = skipper.ipp
spiritincludedir = $(includedir)/spirit/boost/spirit/core/scanner/impl

178
include/boost/spirit/core/scanner/impl/skipper.ipp Normal file
View File

@@ -0,0 +1,178 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
============================================================================*/
#if !defined(BOOST_SPIRIT_SKIPPER_IPP)
#define BOOST_SPIRIT_SKIPPER_IPP
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
struct space_parser;
template <typename BaseT>
struct no_skipper_iteration_policy;
namespace impl
{
template <typename ST, typename ScannerT, typename BaseT>
inline void
skipper_skip(
ST const& s,
ScannerT const& scan,
skipper_iteration_policy<BaseT> const&)
{
typedef scanner_policies<
no_skipper_iteration_policy<
BOOST_SPIRIT_TYPENAME ScannerT::iteration_policy_t>,
BOOST_SPIRIT_TYPENAME ScannerT::match_policy_t,
BOOST_SPIRIT_TYPENAME ScannerT::action_policy_t
> policies_t;
scanner<BOOST_SPIRIT_TYPENAME ScannerT::iterator_t, policies_t>
scan2(scan.first, scan.last, policies_t(scan));
typedef typename ScannerT::iterator_t iterator_t;
for (;;)
{
iterator_t save = scan.first;
if (!s.parse(scan2))
{
scan.first = save;
break;
}
}
}
template <typename ST, typename ScannerT, typename BaseT>
inline void
skipper_skip(
ST const& s,
ScannerT const& scan,
no_skipper_iteration_policy<BaseT> const&)
{
for (;;)
{
typedef typename ScannerT::iterator_t iterator_t;
iterator_t save = scan.first;
if (!s.parse(scan))
{
scan.first = save;
break;
}
}
}
template <typename ST, typename ScannerT>
inline void
skipper_skip(
ST const& s,
ScannerT const& scan,
iteration_policy const&)
{
for (;;)
{
typedef typename ScannerT::iterator_t iterator_t;
iterator_t save = scan.first;
if (!s.parse(scan))
{
scan.first = save;
break;
}
}
}
template <typename SkipT>
struct phrase_parser
{
template <typename IteratorT, typename ParserT>
static parse_info<IteratorT>
parse(
IteratorT const& first_,
IteratorT const& last,
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;
iter_policy_t iter_policy(skip);
scanner_policies_t policies(iter_policy);
IteratorT first = first_;
scanner_t scan(first, last, policies);
match<nil_t> hit = p.parse(scan);
return parse_info<IteratorT>(
first, hit, hit && (first == last), hit.length());
}
};
template <>
struct phrase_parser<space_parser>
{
template <typename IteratorT, typename ParserT>
static parse_info<IteratorT>
parse(
IteratorT const& first_,
IteratorT const& last,
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;
IteratorT first = first_;
scanner_t scan(first, last);
match<nil_t> hit = p.parse(scan);
return parse_info<IteratorT>(
first, hit, hit && (first == last), hit.length());
}
};
}
///////////////////////////////////////////////////////////////////////////////
//
// Free parse functions using the skippers
//
///////////////////////////////////////////////////////////////////////////////
template <typename IteratorT, typename ParserT, typename SkipT>
inline parse_info<IteratorT>
parse(
IteratorT const& first,
IteratorT const& last,
parser<ParserT> const& p,
parser<SkipT> const& skip)
{
return impl::phrase_parser<SkipT>::
parse(first, last, p.derived(), skip.derived());
}
///////////////////////////////////////////////////////////////////////////////
//
// Parse function for null terminated strings using the skippers
//
///////////////////////////////////////////////////////////////////////////////
template <typename CharT, typename ParserT, typename SkipT>
inline parse_info<CharT const*>
parse(
CharT const* str,
parser<ParserT> const& p,
parser<SkipT> const& skip)
{
CharT const* last = str;
while (*last)
last++;
return parse(str, last, p, skip);
}
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif

373
include/boost/spirit/core/scanner/scanner.hpp Normal file
View File

@@ -0,0 +1,373 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2002 Spirit-Dev
Copyright (c) 2001 Daniel Nuffer
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
See spirit.hpp for full copyright notices.
=============================================================================*/
#if !defined(BOOST_SPIRIT_SCANNER_HPP)
#define BOOST_SPIRIT_SCANNER_HPP
///////////////////////////////////////////////////////////////////////////////
#include <iterator>
#include "boost/config.hpp"
#include "boost/spirit/core/match.hpp"
#include "boost/spirit/core/non_terminal/parser_id.hpp"
#if defined(BOOST_MSVC)
#include "boost/spirit/core/impl/msvc.hpp"
#endif
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
#define BOOST_SPIRIT_IT_NS impl
#define BOOST_SPIRIT_MP_TYPE_COMPUTER_ARGS \
typename T, typename Pizza = nil_t
#define BOOST_SPIRIT_P_TYPE_COMPUTER_ARGS \
typename PoliciesT2, typename Pizza = nil_t
#define BOOST_SPIRIT_I_TYPE_COMPUTER_ARGS \
typename IteratorT2, typename Pizza = nil_t
#else
#define BOOST_SPIRIT_IT_NS std
#define BOOST_SPIRIT_MP_TYPE_COMPUTER_ARGS typename T
#define BOOST_SPIRIT_P_TYPE_COMPUTER_ARGS typename PoliciesT2
#define BOOST_SPIRIT_I_TYPE_COMPUTER_ARGS typename IteratorT2
#endif
#if (defined(BOOST_INTEL_CXX_VERSION) && !defined(_STLPORT_VERSION))
#undef BOOST_SPIRIT_IT_NS
#define BOOST_SPIRIT_IT_NS impl
#endif
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
//
// iteration_policy class
//
///////////////////////////////////////////////////////////////////////////////
struct iteration_policy
{
template <typename ScannerT>
void
advance(ScannerT const& scan) const
{ ++scan.first; }
template <typename ScannerT>
bool at_end(ScannerT const& scan) const
{ return scan.first == scan.last; }
template <typename T>
T filter(T ch) const
{ return ch; }
template <typename ScannerT>
typename ScannerT::ref_t
get(ScannerT const& scan) const
{ return *scan.first; }
};
///////////////////////////////////////////////////////////////////////////////
//
// match_policy class
//
///////////////////////////////////////////////////////////////////////////////
struct match_policy
{
template <BOOST_SPIRIT_MP_TYPE_COMPUTER_ARGS>
struct result { typedef match<T> type; };
const match<nil_t>
no_match() const
{ return match<nil_t>(); }
const match<nil_t>
empty_match() const
{ return match<nil_t>(0, nil_t()); }
template <typename AttrT, typename IteratorT>
match<AttrT>
create_match(
unsigned length,
AttrT const& val,
IteratorT const& /*first*/,
IteratorT const& /*last*/) const
{ return match<AttrT>(length, val); }
template <typename MatchT, typename IteratorT>
void
group_match(
MatchT& /*m*/,
parser_id const& /*id*/,
IteratorT const& /*first*/,
IteratorT const& /*last*/) const {}
template <typename Match1T, typename Match2T>
void
concat_match(Match1T& l, Match2T const& r) const
{ l.concat(r); }
};
///////////////////////////////////////////////////////////////////////////////
//
// match_result class
//
///////////////////////////////////////////////////////////////////////////////
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER(match_result_wrapper, result);
//////////////////////////////////
template <typename MatchPolicyT, typename T>
struct match_result
{
typedef typename impl::match_result_wrapper<MatchPolicyT>
::template result_<T>::type type;
};
#else
//////////////////////////////////
template <typename MatchPolicyT, typename T>
struct match_result
{
typedef typename MatchPolicyT::template result<T>::type type;
};
#endif
///////////////////////////////////////////////////////////////////////////////
//
// action_policy class
//
///////////////////////////////////////////////////////////////////////////////
template <typename AttrT>
struct attributed_action_policy
{
template <typename ActorT, typename IteratorT>
static void
call(
ActorT const& actor,
AttrT const& val,
IteratorT const&,
IteratorT const&)
{ actor(val); }
};
//////////////////////////////////
template <>
struct attributed_action_policy<nil_t>
{
template <typename ActorT, typename IteratorT>
static void
call(
ActorT const& actor,
nil_t,
IteratorT const& first,
IteratorT const& last)
{ actor(first, last); }
};
//////////////////////////////////
struct action_policy
{
template <typename ActorT, typename AttrT, typename IteratorT>
void
do_action(
ActorT const& actor,
AttrT const& val,
IteratorT const& first,
IteratorT const& last) const
{ attributed_action_policy<AttrT>::call(actor, val, first, last); }
};
///////////////////////////////////////////////////////////////////////////////
//
// scanner_policies class
//
///////////////////////////////////////////////////////////////////////////////
template <
typename IterationPolicyT = iteration_policy,
typename MatchPolicyT = match_policy,
typename ActionPolicyT = action_policy>
struct scanner_policies :
public IterationPolicyT,
public MatchPolicyT,
public ActionPolicyT
{
typedef IterationPolicyT iteration_policy_t;
typedef MatchPolicyT match_policy_t;
typedef ActionPolicyT action_policy_t;
scanner_policies(
IterationPolicyT const& i_policy = IterationPolicyT(),
MatchPolicyT const& m_policy = MatchPolicyT(),
ActionPolicyT const& a_policy = ActionPolicyT())
: IterationPolicyT(i_policy)
, MatchPolicyT(m_policy)
, ActionPolicyT(a_policy) {}
template <typename ScannerPoliciesT>
scanner_policies(ScannerPoliciesT const& policies)
: IterationPolicyT(policies)
, MatchPolicyT(policies)
, ActionPolicyT(policies) {}
};
///////////////////////////////////////////////////////////////////////////////
//
// scanner class
//
///////////////////////////////////////////////////////////////////////////////
template <
typename IteratorT = char const*,
typename PoliciesT = scanner_policies<> >
class scanner : public PoliciesT {
public:
typedef IteratorT iterator_t;
typedef PoliciesT policies_t;
typedef typename BOOST_SPIRIT_IT_NS::iterator_traits<IteratorT>::value_type
value_t;
typedef typename BOOST_SPIRIT_IT_NS::iterator_traits<IteratorT>::reference
ref_t;
typedef typename boost::call_traits<IteratorT>::param_type
iter_param_t;
scanner(
IteratorT& first_,
iter_param_t last_,
PoliciesT const& policies = PoliciesT())
: PoliciesT(policies), first(first_), last(last_) {
at_end();
}
scanner(scanner const& other)
: PoliciesT(other), first(other.first), last(other.last) {}
scanner(scanner const& other, IteratorT& first_)
: PoliciesT(other), first(first_), last(other.last) {}
bool
at_end() const
{
typedef typename PoliciesT::iteration_policy_t iteration_policy_t;
return iteration_policy_t::at_end(*this);
}
value_t
operator*() const
{
typedef typename PoliciesT::iteration_policy_t iteration_policy_t;
return iteration_policy_t::filter(iteration_policy_t::get(*this));
}
scanner const&
operator++() const
{
typedef typename PoliciesT::iteration_policy_t iteration_policy_t;
iteration_policy_t::advance(*this);
return *this;
}
template <BOOST_SPIRIT_P_TYPE_COMPUTER_ARGS>
struct rebind_policies {
typedef scanner<IteratorT, PoliciesT2> type;
};
template <typename PoliciesT2>
scanner<IteratorT, PoliciesT2>
change_policies(PoliciesT2 const& policies) const
{
return scanner<IteratorT, PoliciesT2>(first, last, policies);
}
template <BOOST_SPIRIT_I_TYPE_COMPUTER_ARGS>
struct rebind_iterator {
typedef scanner<IteratorT2, PoliciesT> type;
};
template <typename IteratorT2>
scanner<IteratorT2, PoliciesT>
change_iterator(IteratorT2 const& first_, IteratorT2 const &last_) const
{
return scanner<IteratorT2, PoliciesT>(first_, last_, *this);
}
IteratorT& first;
IteratorT const last;
private:
scanner&
operator=(scanner const& other);
};
///////////////////////////////////////////////////////////////////////////////
//
// rebind_scanner_policies class
//
///////////////////////////////////////////////////////////////////////////////
#if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)
BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER(
rebind_scanner_policies_wrapper, rebind_policies);
//////////////////////////////////
template <typename ScannerT, typename PoliciesT>
struct rebind_scanner_policies
{
typedef typename impl::rebind_scanner_policies_wrapper<ScannerT>
::template result_<PoliciesT>::type type;
};
//////////////////////////////////
BOOST_SPIRIT_DEPENDENT_TEMPLATE_WRAPPER(
rebind_scanner_iterator_wrapper, rebind_iterator);
template <typename ScannerT, typename IteratorT>
struct rebind_scanner_iterator
{
typedef typename impl::rebind_scanner_iterator_wrapper<ScannerT>
::template result_<IteratorT>::type type;
};
#else
//////////////////////////////////
template <typename ScannerT, typename PoliciesT>
struct rebind_scanner_policies
{
typedef typename ScannerT::template
rebind_policies<PoliciesT>::type type;
};
//////////////////////////////////
template <typename ScannerT, typename IteratorT>
struct rebind_scanner_iterator
{
typedef typename ScannerT::template
rebind_iterator<IteratorT>::type type;
};
#endif
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif
#undef BOOST_SPIRIT_IT_NS
#undef BOOST_SPIRIT_MP_TYPE_COMPUTER_ARGS
#undef BOOST_SPIRIT_P_TYPE_COMPUTER_ARGS

171
include/boost/spirit/core/scanner/skipper.hpp Normal file
View File

@@ -0,0 +1,171 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 1998-2003 Joel de Guzman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_SKIPPER_HPP)
#define BOOST_SPIRIT_SKIPPER_HPP
///////////////////////////////////////////////////////////////////////////////
#include <cctype>
#include "boost/spirit/core/scanner/scanner.hpp"
#include "boost/spirit/core/primitives/impl/primitives.ipp"
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
template <typename BaseT>
struct no_skipper_iteration_policy; // forward
///////////////////////////////////////////////////////////////////////////////
//
// skipper_iteration_policy class
//
///////////////////////////////////////////////////////////////////////////////
template <typename BaseT = iteration_policy>
struct skipper_iteration_policy : public BaseT
{
typedef BaseT base_t;
skipper_iteration_policy()
: BaseT() {}
template <typename PolicyT>
skipper_iteration_policy(PolicyT const& other)
: BaseT(other) {}
template <typename ScannerT>
void
advance(ScannerT const& scan) const
{
BaseT::advance(scan);
scan.skip(scan);
}
template <typename ScannerT>
bool
at_end(ScannerT const& scan) const
{
scan.skip(scan);
return BaseT::at_end(scan);
}
template <typename ScannerT>
void
skip(ScannerT const& scan) const
{
while (!BaseT::at_end(scan) && impl::isspace_(BaseT::get(scan)))
BaseT::advance(scan);
}
};
///////////////////////////////////////////////////////////////////////////////
//
// skipper_iteration_policy class
//
///////////////////////////////////////////////////////////////////////////////
namespace impl
{
template <typename ST, typename ScannerT, typename BaseT>
void
skipper_skip(
ST const& s,
ScannerT const& scan,
skipper_iteration_policy<BaseT> const&);
template <typename ST, typename ScannerT, typename BaseT>
void
skipper_skip(
ST const& s,
ScannerT const& scan,
no_skipper_iteration_policy<BaseT> const&);
template <typename ST, typename ScannerT>
void
skipper_skip(
ST const& s,
ScannerT const& scan,
iteration_policy const&);
}
template <typename ParserT, typename BaseT = iteration_policy>
class skip_parser_iteration_policy : public skipper_iteration_policy<BaseT>
{
public:
typedef skipper_iteration_policy<BaseT> base_t;
skip_parser_iteration_policy(
ParserT const& skip_parser,
base_t const& base = base_t())
: base_t(base), subject(skip_parser) {}
template <typename PolicyT>
skip_parser_iteration_policy(PolicyT const& other)
: base_t(other), subject(other.skipper()) {}
template <typename ScannerT>
void
skip(ScannerT const& scan) const
{
impl::skipper_skip(subject, scan, scan);
}
ParserT const&
skipper() const
{ return subject; }
private:
ParserT const& subject;
};
///////////////////////////////////////////////////////////////////////////////
//
// Free parse functions using the skippers
//
///////////////////////////////////////////////////////////////////////////////
template <typename IteratorT, typename ParserT, typename SkipT>
parse_info<IteratorT>
parse(
IteratorT const& first,
IteratorT const& last,
parser<ParserT> const& p,
parser<SkipT> const& skip);
///////////////////////////////////////////////////////////////////////////////
//
// Parse function for null terminated strings using the skippers
//
///////////////////////////////////////////////////////////////////////////////
template <typename CharT, typename ParserT, typename SkipT>
parse_info<CharT const*>
parse(
CharT const* str,
parser<ParserT> const& p,
parser<SkipT> const& skip);
///////////////////////////////////////////////////////////////////////////////
//
// phrase_scanner_t
//
// The most common scanner. Use this typedef when you need
// a scanner that skips white spaces.
//
///////////////////////////////////////////////////////////////////////////////
typedef skipper_iteration_policy<> iter_policy_t;
typedef scanner_policies<iter_policy_t> scanner_policies_t;
typedef scanner<char const*, scanner_policies_t> phrase_scanner_t;
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#include "boost/spirit/core/scanner/impl/skipper.ipp"
#endif

146
include/boost/spirit/debug.hpp Normal file
View File

@@ -0,0 +1,146 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001-2003 Joel de Guzman
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_DEBUG_MAIN_HPP)
#define BOOST_SPIRIT_DEBUG_MAIN_HPP
#include "boost/spirit/debug/assert.hpp"
///////////////////////////////////////////////////////////////////////////
#if defined(BOOST_SPIRIT_DEBUG)
///////////////////////////////////////////////////////////////////////////////
//
// Spirit.Debug includes and defines
//
///////////////////////////////////////////////////////////////////////////////
#include <iostream>
///////////////////////////////////////////////////////////////////////////
//
// The BOOST_SPIRIT_DEBUG_OUT defines the stream object, which should be used
// for debug diagnostics. This defaults to std::cout.
//
///////////////////////////////////////////////////////////////////////////
#if !defined(BOOST_SPIRIT_DEBUG_OUT)
#define BOOST_SPIRIT_DEBUG_OUT std::cout
#endif
///////////////////////////////////////////////////////////////////////////
//
// The BOOST_SPIRIT_DEBUG_PRINT_SOME constant defines the number of characters
// from the stream to be printed for diagnosis. This defaults to the first
// 20 characters.
//
///////////////////////////////////////////////////////////////////////////
#if !defined(BOOST_SPIRIT_DEBUG_PRINT_SOME)
#define BOOST_SPIRIT_DEBUG_PRINT_SOME 20
#endif
///////////////////////////////////////////////////////////////////////////
//
// Additional BOOST_SPIRIT_DEBUG_FLAGS control the level of diagnostics printed
// Basic constants are defined in debug/minimal.hpp.
//
///////////////////////////////////////////////////////////////////////////
#define BOOST_SPIRIT_DEBUG_FLAGS_NODES 0x0001 // node diagnostics
#define BOOST_SPIRIT_DEBUG_FLAGS_ESCAPE_CHAR 0x0002 // escape_char_parse diagnostics
#define BOOST_SPIRIT_DEBUG_FLAGS_TREES 0x0004 // parse tree/ast diagnostics
#define BOOST_SPIRIT_DEBUG_FLAGS_SLEX 0x8000 // slex diagnostics
#define BOOST_SPIRIT_DEBUG_FLAGS_MAX 0xFFFF // print maximal diagnostics
#if !defined(BOOST_SPIRIT_DEBUG_FLAGS)
#define BOOST_SPIRIT_DEBUG_FLAGS BOOST_SPIRIT_DEBUG_FLAGS_MAX
#endif
///////////////////////////////////////////////////////////////////////////
//
// By default all nodes are traced (even those, not registered with
// BOOST_SPIRIT_DEBUG_RULE et.al. - see below). The following constant may be
// used to redefine this default.
//
///////////////////////////////////////////////////////////////////////////
#if !defined(BOOST_SPIRIT_DEBUG_TRACENODE)
#define BOOST_SPIRIT_DEBUG_TRACENODE (true)
#endif // !defined(BOOST_SPIRIT_DEBUG_TRACENODE)
///////////////////////////////////////////////////////////////////////////
//
// Helper macros for giving rules and subrules a name accessible through
// parser_name() functions (see parser_names.hpp).
//
// Additionally, the macros BOOST_SPIRIT_DEBUG_RULE, SPIRIT_DEBUG_NODE and
// BOOST_SPIRIT_DEBUG_GRAMMAR enable/disable the tracing of the corresponding
// node accordingly to the PP constant BOOST_SPIRIT_DEBUG_TRACENODE.
//
// The macros BOOST_SPIRIT_TRACE_RULE, SPIRIT_TRACE_NODE and
// BOOST_SPIRIT_TRACE_GRAMMAR allow to specify a flag to define, if the
// corresponding node is to be traced or not.
//
///////////////////////////////////////////////////////////////////////////
#if !defined(BOOST_SPIRIT_DEBUG_RULE)
#define BOOST_SPIRIT_DEBUG_RULE(r) \
::boost::spirit::impl::get_node_registry().register_node(&r, #r, BOOST_SPIRIT_DEBUG_TRACENODE)
#endif // !defined(BOOST_SPIRIT_DEBUG_RULE)
#if !defined(BOOST_SPIRIT_DEBUG_NODE)
#define BOOST_SPIRIT_DEBUG_NODE(r) \
::boost::spirit::impl::get_node_registry().register_node(&r, #r, BOOST_SPIRIT_DEBUG_TRACENODE)
#endif // !defined(BOOST_SPIRIT_DEBUG_NODE)
#if !defined(BOOST_SPIRIT_DEBUG_GRAMMAR)
#define BOOST_SPIRIT_DEBUG_GRAMMAR(r) \
::boost::spirit::impl::get_node_registry().register_node(&r, #r, BOOST_SPIRIT_DEBUG_TRACENODE)
#endif // !defined(BOOST_SPIRIT_DEBUG_GRAMMAR)
#if !defined(BOOST_SPIRIT_TRACE_RULE)
#define BOOST_SPIRIT_TRACE_RULE(r, t) \
::boost::spirit::impl::get_node_registry().register_node(&r, #r, (t))
#endif // !defined(BOOST_SPIRIT_TRACE_RULE)
#if !defined(BOOST_SPIRIT_TRACE_NODE)
#define BOOST_SPIRIT_TRACE_NODE(r, t) \
::boost::spirit::impl::get_node_registry().register_node(&r, #r, (t))
#endif // !defined(BOOST_SPIRIT_TRACE_NODE)
#if !defined(BOOST_SPIRIT_TRACE_GRAMMAR)
#define BOOST_SPIRIT_TRACE_GRAMMAR(r, t) \
::boost::spirit::impl::get_node_registry().register_node(&r, #r, (t))
#endif // !defined(BOOST_SPIRIT_TRACE_GRAMMAR)
#if !defined(BOOST_SPIRIT_TRACE_RULE_NAME)
#define BOOST_SPIRIT_TRACE_RULE_NAME(r, n, t) \
::boost::spirit::impl::get_node_registry().register_node(&r, (n), (t))
#endif // !defined(BOOST_SPIRIT_TRACE_RULE_NAME)
#if !defined(BOOST_SPIRIT_TRACE_NODE_NAME)
#define BOOST_SPIRIT_TRACE_NODE_NAME(r, n, t) \
::boost::spirit::impl::get_node_registry().register_node(&r, (n), (t))
#endif // !defined(BOOST_SPIRIT_TRACE_NODE_NAME)
#if !defined(BOOST_SPIRIT_TRACE_GRAMMAR_NAME)
#define BOOST_SPIRIT_TRACE_GRAMMAR_NAME(r, t) \
::boost::spirit::impl::get_node_registry().register_node(&r, (n), (t))
#endif // !defined(BOOST_SPIRIT_TRACE_GRAMMAR_NAME)
//////////////////////////////////
#include "boost/spirit/debug/debug_node.hpp"
#else
//////////////////////////////////
#include "boost/spirit/debug/minimal.hpp"
#endif // BOOST_SPIRIT_DEBUG
#endif

4
include/boost/spirit/debug/Makefile.am Normal file
View File

@@ -0,0 +1,4 @@
#This file generated by Makefileamgen.sh
SUBDIRS = impl
spiritinclude_HEADERS = debug_node.hpp minimal.hpp parser_names.hpp
spiritincludedir = $(includedir)/spirit/boost/spirit/debug

36
include/boost/spirit/debug/assert.hpp Normal file
View File

@@ -0,0 +1,36 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001-2003 Joel de Guzman
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_DEBUG_ASSERT_HPP)
#define BOOST_SPIRIT_DEBUG_ASSERT_HPP
///////////////////////////////////////////////////////////////////////////
//
// BOOST_SPIRIT_ASSERT is used throughout the framework. It can be overridden
// by the user. If BOOST_SPIRIT_ASSERT_EXCEPTION is defined, then that will
// be thrown, otherwise, BOOST_SPIRIT_ASSERT simply turns into a plain assert()
//
///////////////////////////////////////////////////////////////////////////
#if !defined(BOOST_SPIRIT_ASSERT)
#if defined(NDEBUG)
#define BOOST_SPIRIT_ASSERT(x)
#elif defined (BOOST_SPIRIT_ASSERT_EXCEPTION)
#define BOOST_SPIRIT_ASSERT_AUX(f, l, x) \
do{ if (!(x)) throw BOOST_SPIRIT_ASSERT_EXCEPTION(f "(" #l "): " #x); } while(0)
#define BOOST_SPIRIT_ASSERT(x) SPIRIT_ASSERT_AUX(__FILE__, __LINE__, x)
#else
#include <cassert>
#define BOOST_SPIRIT_ASSERT(x) assert(x)
#endif
#endif // !defined(BOOST_SPIRIT_ASSERT)
#endif // BOOST_SPIRIT_DEBUG_ASSERT_HPP

181
include/boost/spirit/debug/debug_node.hpp Normal file
View File

@@ -0,0 +1,181 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001-2003 Joel de Guzman
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_DEBUG_NODE_HPP)
#define BOOST_SPIRIT_DEBUG_NODE_HPP
#if !defined(BOOST_SPIRIT_DEBUG_MAIN_HPP)
#error "You must include boost/spirit/debug.hpp, not boost/spirit/debug/debug_node.hpp"
#endif
#if defined(BOOST_SPIRIT_DEBUG)
#include <string>
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
//
// Debug helper classes for rules, which ensure maximum non-intrusiveness of
// the Spirit debug support
//
///////////////////////////////////////////////////////////////////////////////
namespace impl {
///////////////////////////////////////////////////////////////////////////////
//
// Dump infos about the parsing state of a rule
//
///////////////////////////////////////////////////////////////////////////////
#if BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_NODES
template <typename IteratorT>
inline void
print_node_info(bool hit, int level, bool close, std::string const& name,
IteratorT first, IteratorT last)
{
if (!name.empty())
{
for (int i = 0; i < level; ++i)
BOOST_SPIRIT_DEBUG_OUT << " ";
if (close)
{
if (hit)
BOOST_SPIRIT_DEBUG_OUT << "/";
else
BOOST_SPIRIT_DEBUG_OUT << "#";
}
BOOST_SPIRIT_DEBUG_OUT << name << ":\t\"";
IteratorT iter = first;
IteratorT ilast = last;
for (int j = 0; j < BOOST_SPIRIT_DEBUG_PRINT_SOME; ++j)
{
if (iter == ilast)
break;
switch (*iter) {
case '\r': BOOST_SPIRIT_DEBUG_OUT << "\\r"; break;
case '\n': BOOST_SPIRIT_DEBUG_OUT << "\\n"; break;
case '\0': BOOST_SPIRIT_DEBUG_OUT << "\\0"; break;
default: BOOST_SPIRIT_DEBUG_OUT << *iter; break;
}
++iter;
}
BOOST_SPIRIT_DEBUG_OUT << " \"\n";
}
}
#endif // BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_NODES
}
///////////////////////////////////////////////////////////////////////////////
//
// Implementation note: The parser_context_linker and parser_scanner_linker
// classes are wrapped by a PP constant to allow redefinition of this class
// outside of Spirit
//
///////////////////////////////////////////////////////////////////////////////
#if !defined(BOOST_SPIRIT_PARSER_CONTEXT_LINKER_DEFINED)
#define BOOST_SPIRIT_PARSER_CONTEXT_LINKER_DEFINED
///////////////////////////////////////////////////////////////////////////
//
// parser_context_linker is a debug wrapper for the ContextT template
// parameter of the rule<> class
//
///////////////////////////////////////////////////////////////////////////
template<typename ContextT>
struct parser_context_linker : public ContextT
{
typedef ContextT base_t;
template <typename ParserT>
parser_context_linker(ParserT const& p)
: ContextT(p) {}
template <typename ParserT, typename ScannerT>
void pre_parse(ParserT const& p, ScannerT &scan)
{
this->base_t::pre_parse(p, scan);
#if BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_NODES
if (trace_parser(p)) {
impl::print_node_info(
false,
scan.get_level(),
false,
parser_name(p),
scan.first,
scan.last);
}
scan.get_level()++;
#endif // BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_NODES
}
template <typename ResultT, typename ParserT, typename ScannerT>
ResultT& post_parse(ResultT& hit, ParserT const& p, ScannerT &scan)
{
#if BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_NODES
--scan.get_level();
if (trace_parser(p)) {
impl::print_node_info(
hit,
scan.get_level(),
true,
parser_name(p),
scan.first,
scan.last);
}
#endif // BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_NODES
return this->base_t::post_parse(hit, p, scan);
}
};
#endif // !defined(BOOST_SPIRIT_PARSER_CONTEXT_LINKER_DEFINED)
#if !defined(BOOST_SPIRIT_PARSER_SCANNER_LINKER_DEFINED)
#define BOOST_SPIRIT_PARSER_SCANNER_LINKER_DEFINED
///////////////////////////////////////////////////////////////////////////////
// This class is to avoid linker problems and to ensure a real singleton
// 'level' variable
struct debug_support {
int &get_level() {
static int level = 0;
return level;
}
};
template<typename ScannerT>
struct parser_scanner_linker : public ScannerT {
parser_scanner_linker(ScannerT const &scan_) : ScannerT(scan_)
{}
int &get_level()
{ return debug.get_level(); }
private:
debug_support debug;
};
#endif // !defined(BOOST_SPIRIT_PARSER_SCANNER_LINKER_DEFINED)
}} // namespace boost::spirit
#endif // defined(BOOST_SPIRIT_DEBUG)
#endif // !defined(BOOST_SPIRIT_DEBUG_NODE_HPP)

3
include/boost/spirit/debug/impl/Makefile.am Normal file
View File

@@ -0,0 +1,3 @@
#This file generated by Makefileamgen.sh
spiritinclude_HEADERS = parser_names.ipp
spiritincludedir = $(includedir)/spirit/boost/spirit/debug/impl

515
include/boost/spirit/debug/impl/parser_names.ipp Normal file
View File

@@ -0,0 +1,515 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001-2003 Joel de Guzman
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_PARSER_NAMES_IPP)
#define BOOST_SPIRIT_PARSER_NAMES_IPP
#if defined(BOOST_SPIRIT_DEBUG)
#include <string>
#include <iostream>
#include <map>
#include "boost/config.hpp"
#ifdef BOOST_NO_STRINGSTREAM
#include <strstream>
#define BOOST_SPIRIT_SSTREAM std::strstream
std::string BOOST_SPIRIT_GETSTRING(std::strstream& ss)
{
ss << ends;
std::string rval = ss.str();
ss.freeze(false);
return rval;
}
#else
#include <sstream>
#define BOOST_SPIRIT_GETSTRING(ss) ss.str()
#define BOOST_SPIRIT_SSTREAM std::stringstream
#endif
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
// from actions.hpp
template <typename ParserT, typename ActionT>
inline std::string
parser_name(action<ParserT, ActionT> const& p)
{
return std::string("action")
+ std::string("[")
+ parser_name(p.subject())
+ std::string("]");
}
///////////////////////////////////////////////////////////////////////////////
// from directives.hpp
template <typename ParserT>
inline std::string
parser_name(contiguous<ParserT> const& p)
{
return std::string("contiguous")
+ std::string("[")
+ parser_name(p.subject())
+ std::string("]");
}
template <typename ParserT>
inline std::string
parser_name(inhibit_case<ParserT> const& p)
{
return std::string("inhibit_case")
+ std::string("[")
+ parser_name(p.subject())
+ std::string("]");
}
template <typename A, typename B>
inline std::string
parser_name(longest_alternative<A, B> const& p)
{
return std::string("longest_alternative")
+ std::string("[")
+ parser_name(p.left()) + std::string(", ") + parser_name(p.right())
+ std::string("]");
}
template <typename A, typename B>
inline std::string
parser_name(shortest_alternative<A, B> const& p)
{
return std::string("shortest_alternative")
+ std::string("[")
+ parser_name(p.left()) + std::string(", ") + parser_name(p.right())
+ std::string("]");
}
///////////////////////////////////////////////////////////////////////////////
// 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)
{
BOOST_SPIRIT_SSTREAM stream;
stream << Radix << ", " << MinDigits << ", " << MaxDigits;
return std::string("uint_parser<")
+ BOOST_SPIRIT_GETSTRING(stream)
+ std::string(">");
}
template <typename T, int Radix, unsigned MinDigits, int MaxDigits>
inline std::string
parser_name(int_parser<T, Radix, MinDigits, MaxDigits> const& p)
{
BOOST_SPIRIT_SSTREAM stream;
stream << Radix << ", " << MinDigits << ", " << MaxDigits;
return std::string("int_parser<")
+ BOOST_SPIRIT_GETSTRING(stream)
+ std::string(">");
}
template <typename T, typename RealPoliciesT>
inline std::string
parser_name(real_parser<T, RealPoliciesT> const& p)
{
return std::string("real_parser");
}
///////////////////////////////////////////////////////////////////////////////
// from operators.hpp
template <typename A, typename B>
inline std::string
parser_name(sequence<A, B> const& p)
{
return std::string("sequence")
+ std::string("[")
+ parser_name(p.left()) + std::string(", ") + parser_name(p.right())
+ std::string("]");
}
template <typename A, typename B>
inline std::string
parser_name(sequential_or<A, B> const& p)
{
return std::string("sequential_or")
+ std::string("[")
+ parser_name(p.left()) + std::string(", ") + parser_name(p.right())
+ std::string("]");
}
template <typename A, typename B>
inline std::string
parser_name(alternative<A, B> const& p)
{
return std::string("alternative")
+ std::string("[")
+ parser_name(p.left()) + std::string(", ") + parser_name(p.right())
+ std::string("]");
}
template <typename A, typename B>
inline std::string
parser_name(intersection<A, B> const& p)
{
return std::string("intersection")
+ std::string("[")
+ parser_name(p.left()) + std::string(", ") + parser_name(p.right())
+ std::string("]");
}
template <typename A, typename B>
inline std::string
parser_name(difference<A, B> const& p)
{
return std::string("difference")
+ std::string("[")
+ parser_name(p.left()) + std::string(", ") + parser_name(p.right())
+ std::string("]");
}
template <typename A, typename B>
inline std::string
parser_name(exclusive_or<A, B> const& p)
{
return std::string("exclusive_or")
+ std::string("[")
+ parser_name(p.left()) + std::string(", ") + parser_name(p.right())
+ std::string("]");
}
template <typename S>
inline std::string
parser_name(optional<S> const& p)
{
return std::string("optional")
+ std::string("[")
+ parser_name(p.subject())
+ std::string("]");
}
template <typename S>
inline std::string
parser_name(kleene_star<S> const& p)
{
return std::string("kleene_star")
+ std::string("[")
+ parser_name(p.subject())
+ std::string("]");
}
template <typename S>
inline std::string
parser_name(positive<S> const& p)
{
return std::string("positive")
+ std::string("[")
+ parser_name(p.subject())
+ std::string("]");
}
///////////////////////////////////////////////////////////////////////////////
// from parser.hpp
template <typename DerivedT>
inline std::string
parser_name(parser<DerivedT> const& p)
{
return std::string("parser");
}
///////////////////////////////////////////////////////////////////////////////
// from primitives.hpp
template <typename DerivedT>
inline std::string
parser_name(char_parser<DerivedT> const &p)
{
return std::string("char_parser");
}
template <typename CharT>
inline std::string
parser_name(chlit<CharT> const &p)
{
return std::string("chlit(\'")
+ std::string(1, p.ch)
+ std::string("\')");
}
template <typename CharT>
inline std::string
parser_name(range<CharT> const &p)
{
return std::string("range(")
+ std::string(1, p.first) + std::string(", ") + std::string(1, p.last)
+ std::string(")");
}
template <typename IteratorT>
inline std::string
parser_name(chseq<IteratorT> const &p)
{
return std::string("chseq(\"")
+ std::string(p.first, p.last)
+ std::string("\")");
}
template <typename IteratorT>
inline std::string
parser_name(strlit<IteratorT> const &p)
{
return std::string("strlit(\"")
+ std::string(p.seq.first, p.seq.last)
+ std::string("\")");
}
inline std::string
parser_name(nothing_parser const&)
{
return std::string("nothing");
}
inline std::string
parser_name(epsilon_parser const&)
{
return std::string("epsilon");
}
inline std::string
parser_name(anychar_parser const&)
{
return std::string("anychar");
}
inline std::string
parser_name(alnum_parser const&)
{
return std::string("alnum");
}
inline std::string
parser_name(alpha_parser const&)
{
return std::string("alpha");
}
inline std::string
parser_name(cntrl_parser const&)
{
return std::string("cntrl");
}
inline std::string
parser_name(digit_parser const&)
{
return std::string("digit");
}
inline std::string
parser_name(graph_parser const&)
{
return std::string("graph");
}
inline std::string
parser_name(lower_parser const&)
{
return std::string("lower");
}
inline std::string
parser_name(print_parser const&)
{
return std::string("print");
}
inline std::string
parser_name(punct_parser const&)
{
return std::string("punct");
}
inline std::string
parser_name(blank_parser const&)
{
return std::string("blank");
}
inline std::string
parser_name(space_parser const&)
{
return std::string("space");
}
inline std::string
parser_name(upper_parser const&)
{
return std::string("upper");
}
inline std::string
parser_name(xdigit_parser const&)
{
return std::string("xdigit");
}
inline std::string
parser_name(eol_parser const&)
{
return std::string("eol");
}
inline std::string
parser_name(end_parser const&)
{
return std::string("end");
}
///////////////////////////////////////////////////////////////////////////////
// from rule.hpp
namespace impl {
struct node_registry
{
typedef std::pair<std::string, bool> rule_info;
typedef std::map<void const *, rule_info> rule_infos;
std::string find_node(void const *r)
{
rule_infos::const_iterator cit = infos.find(r);
if (cit != infos.end())
return (*cit).second.first;
return std::string("<unknown>");
}
bool trace_node(void const *r)
{
rule_infos::const_iterator cit = infos.find(r);
if (cit != infos.end())
return (*cit).second.second;
return BOOST_SPIRIT_DEBUG_TRACENODE;
}
bool register_node(void const *r, char const *name_to_register,
bool trace_node)
{
if (infos.find(r) != infos.end())
return false;
return infos.insert(rule_infos::value_type(r,
rule_info(std::string(name_to_register), trace_node))
).second;
}
bool unregister_node(void const *r)
{
if (infos.find(r) == infos.end())
return false;
return (1 == infos.erase(r));
}
private:
rule_infos infos;
};
inline node_registry &
get_node_registry()
{
static node_registry node_infos;
return node_infos;
}
} // namespace impl
template<typename ContextT, typename ScannerT>
inline std::string
parser_name(rule<ContextT, ScannerT> const& p)
{
return std::string("rule")
+ std::string("(")
+ impl::get_node_registry().find_node(&p)
+ std::string(")");
}
///////////////////////////////////////////////////////////////////////////////
// from subrule.hpp
template <typename FirstT, typename RestT>
inline std::string
parser_name(subrule_list<FirstT, RestT> const &p)
{
return std::string("subrule_list")
+ std::string("(")
+ impl::get_node_registry().find_node(&p)
+ std::string(")");
}
template <int ID, typename DefT, typename ContextT>
inline std::string
parser_name(subrule_parser<ID, DefT, ContextT> const &p)
{
return std::string("subrule_parser")
+ std::string("(")
+ impl::get_node_registry().find_node(&p)
+ std::string(")");
}
template <int ID, typename ContextT>
inline std::string
parser_name(subrule<ID, ContextT> const &p)
{
BOOST_SPIRIT_SSTREAM stream;
stream << ID;
return std::string("subrule<")
+ BOOST_SPIRIT_GETSTRING(stream)
+ std::string(">(")
+ impl::get_node_registry().find_node(&p)
+ std::string(")");
}
///////////////////////////////////////////////////////////////////////////////
// from grammar.hpp
template <typename DerivedT, typename ContextT>
inline std::string
parser_name(grammar<DerivedT, ContextT> const& p)
{
return std::string("grammar")
+ std::string("(")
+ impl::get_node_registry().find_node(&p)
+ std::string(")");
}
///////////////////////////////////////////////////////////////////////////////
// decide, if a node is to be traced or not
template<typename ContextT, typename ScannerT>
inline bool
trace_parser(rule<ContextT, ScannerT> const& p)
{
return impl::get_node_registry().trace_node(&p);
}
template <typename DerivedT, typename ContextT>
inline bool
trace_parser(grammar<DerivedT, ContextT> const& p)
{
return impl::get_node_registry().trace_node(&p);
}
template <int ID, typename ContextT>
bool
trace_parser(subrule<ID, ContextT> const& p)
{
return impl::get_node_registry().trace_node(&p);
}
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#undef BOOST_SPIRIT_SSTREAM
#undef BOOST_SPIRIT_GETSTRING
#endif // defined(BOOST_SPIRIT_DEBUG)
#endif // !defined(BOOST_SPIRIT_PARSER_NAMES_IPP)

84
include/boost/spirit/debug/minimal.hpp Normal file
View File

@@ -0,0 +1,84 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001-2003 Joel de Guzman
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_MINIMAL_DEBUG_HPP)
#define BOOST_SPIRIT_MINIMAL_DEBUG_HPP
#if !defined(BOOST_SPIRIT_DEBUG_MAIN_HPP)
#error "You must include boost/spirit/debug.hpp, not boost/spirit/debug/minimal.hpp"
#endif
///////////////////////////////////////////////////////////////////////////////
//
// Minimum debugging tools support
//
///////////////////////////////////////////////////////////////////////////////
#if !defined(BOOST_SPIRIT_DEBUG_OUT)
#define BOOST_SPIRIT_DEBUG_OUT std::cout
#endif
///////////////////////////////////////////////////////////////////////////
//
// BOOST_SPIRIT_DEBUG_FLAGS controls the level of diagnostics printed
//
///////////////////////////////////////////////////////////////////////////
#if !defined(BOOST_SPIRIT_DEBUG_FLAGS_NONE)
#define BOOST_SPIRIT_DEBUG_FLAGS_NONE 0x0000 // no diagnostics at all
#endif
#if !defined(BOOST_SPIRIT_DEBUG_FLAGS_MAX)
#define BOOST_SPIRIT_DEBUG_FLAGS_MAX 0xFFFF // print maximal diagnostics
#endif
#if !defined(BOOST_SPIRIT_DEBUG_FLAGS)
#define BOOST_SPIRIT_DEBUG_FLAGS SPIRIT_DEBUG_FLAGS_MAX
#endif
#if !defined(BOOST_SPIRIT_DEBUG_PRINT_SOME)
#define BOOST_SPIRIT_DEBUG_PRINT_SOME 20
#endif
#if !defined(BOOST_SPIRIT_DEBUG_RULE)
#define BOOST_SPIRIT_DEBUG_RULE(r)
#endif // !defined(BOOST_SPIRIT_DEBUG_RULE)
#if !defined(BOOST_SPIRIT_DEBUG_NODE)
#define BOOST_SPIRIT_DEBUG_NODE(r)
#endif // !defined(BOOST_SPIRIT_DEBUG_NODE)
#if !defined(BOOST_SPIRIT_DEBUG_GRAMMAR)
#define BOOST_SPIRIT_DEBUG_GRAMMAR(r)
#endif // !defined(BOOST_SPIRIT_DEBUG_GRAMMAR)
#if !defined(BOOST_SPIRIT_TRACE_RULE)
#define BOOST_SPIRIT_TRACE_RULE(r, t)
#endif // !defined(BOOST_SPIRIT_TRACE_RULE)
#if !defined(BOOST_SPIRIT_TRACE_NODE)
#define BOOST_SPIRIT_TRACE_NODE(r, t)
#endif // !defined(BOOST_SPIRIT_TRACE_NODE)
#if !defined(BOOST_SPIRIT_TRACE_GRAMMAR)
#define BOOST_SPIRIT_TRACE_GRAMMAR(r, t)
#endif // !defined(BOOST_SPIRIT_TRACE_GRAMMAR)
#if !defined(BOOST_SPIRIT_TRACE_RULE_NAME)
#define BOOST_SPIRIT_TRACE_RULE_NAME(r, n, t)
#endif // !defined(BOOST_SPIRIT_TRACE_RULE_NAME)
#if !defined(BOOST_SPIRIT_TRACE_NODE_NAME)
#define BOOST_SPIRIT_TRACE_NODE_NAME(r, n, t)
#endif // !defined(BOOST_SPIRIT_TRACE_NODE_NAME)
#if !defined(BOOST_SPIRIT_TRACE_GRAMMAR_NAME)
#define BOOST_SPIRIT_TRACE_GRAMMAR_NAME(r, n, t)
#endif // !defined(BOOST_SPIRIT_TRACE_GRAMMAR_NAME)
#endif // !defined(BOOST_SPIRIT_MINIMAL_DEBUG_HPP)

243
include/boost/spirit/debug/parser_names.hpp Normal file
View File

@@ -0,0 +1,243 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001-2003 Joel de Guzman
Copyright (c) 2002-2003 Hartmut Kaiser
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_PARSER_NAMES_HPP)
#define BOOST_SPIRIT_PARSER_NAMES_HPP
#if defined(BOOST_SPIRIT_DEBUG)
//////////////////////////////////
#include "boost/spirit/core.hpp"
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
//
// Declaration of helper functions, which return the name of a concrete
// parser instance. The functions are specialized on the parser types. The
// functions declared in this file are for the predefined parser types from
// the Spirit core library only, so additional functions might be provided as
// needed.
//
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// from actions.hpp
template <typename ParserT, typename ActionT>
std::string
parser_name(action<ParserT, ActionT> const& p);
///////////////////////////////////////////////////////////////////////////////
// from directives.hpp
template <typename ParserT>
std::string
parser_name(contiguous<ParserT> const& p);
template <typename ParserT>
std::string
parser_name(inhibit_case<ParserT> const& p);
template <typename A, typename B>
std::string
parser_name(longest_alternative<A, B> const& p);
template <typename A, typename B>
std::string
parser_name(shortest_alternative<A, B> const& p);
///////////////////////////////////////////////////////////////////////////////
// from grammar.hpp
template <typename DerivedT, typename ContextT>
std::string
parser_name(grammar<DerivedT, ContextT> const& p);
///////////////////////////////////////////////////////////////////////////////
// from numerics.hpp
template <typename T, int Radix, unsigned MinDigits, int MaxDigits>
std::string
parser_name(uint_parser<T, Radix, MinDigits, MaxDigits> const& p);
template <typename T, int Radix, unsigned MinDigits, int MaxDigits>
std::string
parser_name(int_parser<T, Radix, MinDigits, MaxDigits> const& p);
template <typename T, typename RealPoliciesT>
std::string
parser_name(real_parser<T, RealPoliciesT> const& p);
///////////////////////////////////////////////////////////////////////////////
// from operators.hpp
template <typename A, typename B>
std::string
parser_name(sequence<A, B> const& p);
template <typename A, typename B>
std::string
parser_name(sequential_or<A, B> const& p);
template <typename A, typename B>
std::string
parser_name(alternative<A, B> const& p);
template <typename A, typename B>
std::string
parser_name(intersection<A, B> const& p);
template <typename A, typename B>
std::string
parser_name(difference<A, B> const& p);
template <typename A, typename B>
std::string
parser_name(exclusive_or<A, B> const& p);
template <typename S>
std::string
parser_name(optional<S> const& p);
template <typename S>
std::string
parser_name(kleene_star<S> const& p);
template <typename S>
std::string
parser_name(positive<S> const& p);
///////////////////////////////////////////////////////////////////////////////
// from parser.hpp
template <typename DerivedT>
std::string
parser_name(parser<DerivedT> const& p);
///////////////////////////////////////////////////////////////////////////////
// from primitives.hpp
template <typename DerivedT>
std::string
parser_name(char_parser<DerivedT> const &p);
template <typename CharT>
std::string
parser_name(chlit<CharT> const &p);
template <typename CharT>
std::string
parser_name(range<CharT> const &p);
template <typename IteratorT>
std::string
parser_name(chseq<IteratorT> const &p);
template <typename IteratorT>
std::string
parser_name(strlit<IteratorT> const &p);
std::string
parser_name(nothing_parser const &p);
std::string
parser_name(epsilon_parser const &p);
std::string
parser_name(anychar_parser const &p);
std::string
parser_name(alnum_parser const &p);
std::string
parser_name(alpha_parser const &p);
std::string
parser_name(cntrl_parser const &p);
std::string
parser_name(digit_parser const &p);
std::string
parser_name(graph_parser const &p);
std::string
parser_name(lower_parser const &p);
std::string
parser_name(print_parser const &p);
std::string
parser_name(punct_parser const &p);
std::string
parser_name(blank_parser const &p);
std::string
parser_name(space_parser const &p);
std::string
parser_name(upper_parser const &p);
std::string
parser_name(xdigit_parser const &p);
std::string
parser_name(eol_parser const &p);
std::string
parser_name(end_parser const &p);
///////////////////////////////////////////////////////////////////////////////
// from rule.hpp
template<typename ContextT, typename ScannerT>
std::string
parser_name(rule<ContextT, ScannerT> const& p);
///////////////////////////////////////////////////////////////////////////////
// from subrule.hpp
template <typename FirstT, typename RestT>
std::string
parser_name(subrule_list<FirstT, RestT> const &p);
template <int ID, typename DefT, typename ContextT>
std::string
parser_name(subrule_parser<ID, DefT, ContextT> const &p);
template <int ID, typename ContextT>
std::string
parser_name(subrule<ID, ContextT> const &p);
///////////////////////////////////////////////////////////////////////////////
// from chset.hpp
///////////////////////////////////////////////////////////////////////////////
//
// Decide, if a node is to be traced or not
//
///////////////////////////////////////////////////////////////////////////////
template<typename ContextT, typename ScannerT>
bool
trace_parser(rule<ContextT, ScannerT> const& p);
template <typename DerivedT, typename ContextT>
bool
trace_parser(grammar<DerivedT, ContextT> const& p);
template <int ID, typename ContextT>
bool
trace_parser(subrule<ID, ContextT> const& p);
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
//////////////////////////////////
#if !defined(BOOST_SPIRIT_PARSER_NAMES_IPP)
#include "boost/spirit/debug/impl/parser_names.ipp"
#endif
#endif // defined(BOOST_SPIRIT_DEBUG)
#endif // !defined(BOOST_SPIRIT_PARSER_NAMES_HPP)

34
include/boost/spirit/dynamic.hpp Normal file
View File

@@ -0,0 +1,34 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Joel de Guzman
Copyright (c) 2002 Juan Carlos Arevalo-Baeza
Copyright (c) 2002-2003 Martin Wille
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#ifndef BOOST_SPIRIT_DYNAMIC_HPP
#define BOOST_SPIRIT_DYNAMIC_HPP
///////////////////////////////////////////////////////////////////////////////
//
// Master header for Spirit.Dynamic
//
///////////////////////////////////////////////////////////////////////////////
#if !defined(BOOST_SPIRIT_IF_HPP)
#include "boost/spirit/dynamic/if.hpp"
#endif
#if !defined(BOOST_SPIRIT_FOR_HPP)
#include "boost/spirit/dynamic/for.hpp"
#endif
#if !defined(BOOST_SPIRIT_WHILE_HPP)
#include "boost/spirit/dynamic/while.hpp"
#endif
////////////////////////////////////////////////////////////////////////////////
#endif // BOOST_SPIRIT_DYNAMIC_HPP

203
include/boost/spirit/dynamic/for.hpp Normal file
View File

@@ -0,0 +1,203 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Joel de Guzman
Copyright (c) 2002-2003 Martin Wille
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#ifndef BOOST_SPIRIT_FOR_HPP
#define BOOST_SPIRIT_FOR_HPP
////////////////////////////////////////////////////////////////////////////////
#if !defined(BOOST_SPIRIT_PARSER_HPP)
#include "boost/spirit/core/parser.hpp"
#endif
#if !defined(BOOST_SPIRIT_COMPOSITE_HPP)
#include "boost/spirit/core/composite/composite.hpp"
#endif
#if !defined(BOOST_SPIRIT_CONDITIONS_IPP)
#include "boost/spirit/dynamic/impl/conditions.ipp"
#endif
////////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit
{
namespace impl
{
template <typename FuncT>
struct for_functor : private subject_type<FuncT, nil_t>::type
{
typedef typename subject_type<FuncT, nil_t>::type base_t;
typedef typename boost::call_traits<FuncT>::param_type param_t;
typedef typename base_t::return_t return_t;
for_functor(param_t f) : base_t(f) {}
for_functor() : base_t() {}
return_t get() const { return base_t::get(); }
};
template <typename InitF>
struct for_init_functor : for_functor<InitF>
{
typedef for_functor<InitF> base_t;
typedef typename base_t::param_t param_t;
for_init_functor(param_t f) : base_t(f) {}
for_init_functor() : base_t() {}
void init() const { return base_t::get()(); }
};
template <typename StepF>
struct for_step_functor : for_functor<StepF>
{
typedef for_functor<StepF> base_t;
typedef typename base_t::param_t param_t;
for_step_functor(param_t f) : base_t(f) {}
for_step_functor() : base_t() {}
void step() const { return base_t::get()(); }
};
//////////////////////////////////
// for_parser
template
<
typename InitF, typename CondT, typename StepF,
typename ParserT
>
struct for_parser
: private for_init_functor<InitF>
, private for_step_functor<StepF>
, private condition_evaluator<CondT>
, public unary
<
ParserT,
parser< for_parser<InitF, CondT, StepF, ParserT> >
>
{
typedef for_parser< InitF, CondT, StepF, ParserT > self_t;
typedef condition_evaluator<CondT> eval_t;
typedef unary< ParserT, parser< self_t > > base_t;
//////////////////////////////
// constructor, saves init, condition and step functors
// for later use the parse member function
for_parser
(
InitF const &i, CondT const &c, StepF const &s,
ParserT const &p
)
: for_init_functor<InitF>(i)
, for_step_functor<StepF>(s)
, eval_t(c)
, base_t(p)
{ }
for_parser()
: for_init_functor<InitF>()
, for_step_functor<StepF>()
, eval_t()
, base_t()
{}
//////////////////////////////
// parse member function
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;
typedef typename parser_result<ParserT, ScannerT>::type sresult_t;
typename ScannerT::iterator_t save(scan.first);
int length = 0;
int eval_length = 0;
init();
while ((eval_length = evaluate(scan))>=0)
{
length += eval_length;
sresult_t tmp(this->subject().parse(scan));
if (tmp)
{
length+=tmp.length();
}
else
{
return scan.no_match();
}
step();
}
return scan.create_match(length, nil_t(), save, scan.first);
}
};
//////////////////////////////////
// for_parser_gen generates takes the body parser in brackets
// and returns the for_parser
template <typename InitF, typename CondT, typename StepF>
struct for_parser_gen
{
for_parser_gen(InitF const &i, CondT const &c, StepF const &s)
: init(i)
, condition(c)
, step(s)
{}
typedef ::boost::spirit::as_parser<CondT> cond_as_parser_t;
typedef typename cond_as_parser_t::type cond_p;
template <typename ParserT>
for_parser
<
InitF, cond_p, StepF,
typename ::boost::spirit::as_parser<ParserT>::type
>
operator[](ParserT const &p) const
{
typedef ::boost::spirit::as_parser<ParserT> as_parser_t;
typedef typename as_parser_t::type parser_t;
typedef char assert_argument_must_be_a_parser
[::boost::spirit::is_parser<parser_t>::value];
return for_parser<InitF, cond_p, StepF, parser_t>
(
init,
cond_as_parser_t::convert(condition),
step,
as_parser_t::convert(p)
);
}
InitF const &init;
CondT const &condition;
StepF const &step;
};
} // namespace impl
//////////////////////////////
// for_p, returns for-parser generator
// Usage: spirit::for_p(init-ftor, condition, step-ftor)[body]
template
<
typename InitF, typename ConditionT, typename StepF
>
impl::for_parser_gen<InitF, ConditionT, StepF>
for_p(InitF const &init_f, ConditionT const &condition, StepF const &step_f)
{
return impl::for_parser_gen<InitF, ConditionT, StepF>
(init_f, condition, step_f);
}
}} // namespace boost::spirit
#endif // BOOST_SPIRIT_FOR_HPP

207
include/boost/spirit/dynamic/if.hpp Normal file
View File

@@ -0,0 +1,207 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Joel de Guzman
Copyright (c) 2002 Juan Carlos Arevalo-Baeza
Copyright (c) 2002-2003 Martin Wille
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#ifndef BOOST_SPIRIT_IF_HPP
#define BOOST_SPIRIT_IF_HPP
#if !defined(BOOST_SPIRIT_PARSER_HPP)
#include "boost/spirit/core/parser.hpp"
#endif
#if !defined(BOOST_SPIRIT_COMPOSITE_HPP)
#include "boost/spirit/core/composite/composite.hpp"
#endif
#if !defined(BOOST_SPIRIT_CONDITIONS_IPP)
#include "boost/spirit/dynamic/impl/conditions.ipp"
#endif
namespace boost { namespace spirit {
namespace impl {
//////////////////////////////////
// if-else-parser, holds two alternative parsers and a conditional functor
// that selects between them.
template <typename ParserT_true, typename ParserT_false, typename CondT>
struct if_else_parser
: public condition_evaluator<CondT>
, public binary
<
ParserT_true,
ParserT_false,
parser<if_else_parser<ParserT_true, ParserT_false, CondT> >
>
{
typedef if_else_parser<ParserT_true, ParserT_false, CondT> self_t;
typedef condition_evaluator<CondT> eval_t;
typedef binary<ParserT_true, ParserT_false, parser<self_t> >base_t;
typedef CondT condition_t;
if_else_parser
(
ParserT_true const& p_true,
ParserT_false const& p_false,
CondT const& cond_
)
: eval_t(cond_)
, base_t(p_true, p_false)
{ }
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, nil_t>::type type;
};
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
if (evaluate(scan) >= 0)
{
return this->left().parse(scan);
}
else
{
return this->right().parse(scan);
}
}
};
//////////////////////////////////
// if-else-parser generator, takes the false-parser in brackets
// and returns the if-else-parser.
template <typename ParserT_true, typename CondT>
struct if_else_parser_gen
{
if_else_parser_gen(ParserT_true const& p_true_, CondT const& cond_)
: p_true(p_true_)
, cond(cond_) {}
template <typename ParserT_false>
if_else_parser
<
ParserT_true,
typename ::boost::spirit::as_parser<ParserT_false>::type,
CondT
>
operator[](ParserT_false const& subject) const
{
typedef ::boost::spirit::as_parser<ParserT_false> as_parser_t;
typedef typename as_parser_t::type parser_t;
typedef char assert_argument_must_be_a_parser
[::boost::spirit::is_parser<parser_t>::value];
return if_else_parser<ParserT_true, parser_t, CondT>
(
p_true,
as_parser_t::convert(subject),
cond
);
}
//typename ParserT_true::embed_t p_true;
ParserT_true const &p_true;
CondT const &cond;
};
//////////////////////////////////
// if-parser, conditionally runs a parser is a functor condition is true.
// If the condition is fales, it fails the parse.
// It can optionally become an if-else-parser through the member else_p.
template <typename ParserT, typename CondT>
struct if_parser
: public condition_evaluator<CondT>
, public unary<ParserT, parser<if_parser<ParserT, CondT> > >
{
typedef if_parser<ParserT, CondT> self_t;
typedef condition_evaluator<CondT> eval_t;
typedef unary<ParserT, parser<self_t> > base_t;
if_parser(ParserT const& p, CondT const& cond_)
: eval_t(cond_)
, base_t(p)
, else_p(p, cond_)
{}
template <typename ScannerT>
struct result
{
typedef typename match_result<ScannerT, nil_t>::type type;
};
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
if (evaluate(scan) >= 0)
{
return this->subject().parse(scan);
}
return scan.empty_match();
}
if_else_parser_gen<ParserT, CondT> else_p;
};
//////////////////////////////////
// if-parser generator, takes the true-parser in brackets and returns the
// if-parser.
template <typename CondT>
struct if_parser_gen
{
typedef ::boost::spirit::as_parser<CondT> c_as_parser_t;
typedef typename c_as_parser_t::type condition_t;
if_parser_gen(CondT const& cond_) : cond(cond_) {}
template <typename ParserT>
if_parser
<
typename ::boost::spirit::as_parser<ParserT>::type,
condition_t
>
operator[](ParserT const& subject) const
{
typedef ::boost::spirit::as_parser<ParserT> p_as_parser_t;
typedef typename p_as_parser_t::type parser_t;
typedef char assert_argument_must_be_a_parser
[::boost::spirit::is_parser<parser_t>::value];
return if_parser<parser_t, condition_t>
(
p_as_parser_t::convert(subject),
c_as_parser_t::convert(cond)
);
}
CondT const &cond;
};
} // namespace impl
//////////////////////////////////
// if_p function, returns "if" parser generator
template <typename CondT>
impl::if_parser_gen<CondT>
if_p(CondT const& cond)
{
return impl::if_parser_gen<CondT>(cond);
}
}} // namespace boost::spirit
#endif // BOOST_SPIRIT_IF_HPP

126
include/boost/spirit/dynamic/impl/conditions.ipp Normal file
View File

@@ -0,0 +1,126 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Martin Wille
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#ifndef BOOST_SPIRIT_CONDITIONS_IPP
#define BOOST_SPIRIT_CONDITIONS_IPP
///////////////////////////////////////////////////////////////////////////////
#if !defined(BOOST_SPIRIT_PARSER_TRAITS_HPP)
#include "boost/spirit/core/meta/parser_traits.hpp"
#endif
#if !defined(BOOST_SPIRIT_EPSILON_HPP)
#include "boost/spirit/core/composite/epsilon.hpp"
#endif
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
namespace impl {
///////////////////////////////////////////////////////////////////////////////
//
// condition evaluation
//
///////////////////////////////////////////////////////////////////////////////
//////////////////////////////////
// condition_parser_selector, decides which parser to use for a condition
// If the template argument is a parser then that parser is used.
// If the template argument is a functor then a condition parser using
// the functor is chosen
struct select_identity
{
template <typename ConditionT>
struct result
{
typedef ConditionT type;
};
};
struct select_condition_parser
{
template <typename ConditionT>
struct result
{
typedef condition_parser<ConditionT> type;
};
};
template <typename ConditionT>
struct condition_parser_selector
{
private:
typedef
typename if_t<
bool_t< ::boost::spirit::is_parser<ConditionT>::value >,
select_identity,
select_condition_parser
>::type
func_;
public:
typedef typename func_::template result<ConditionT>::type type;
typedef typename type::embed_t embed_t;
};
//////////////////////////////////
// condition_evaluator, uses a parser to check wether a condition is met
// takes a parser or a functor that can be evaluated in boolean context
// as template parameter.
template <typename ConditionT>
struct condition_evaluator
: private subject_type
<
typename condition_parser_selector<ConditionT>::embed_t,
nil_t
>::type
{
typedef condition_parser_selector<ConditionT> selector_t;
typedef typename selector_t::type selected_t;
typedef typename selector_t::embed_t cond_embed_t;
typedef typename subject_type<cond_embed_t, nil_t>::type base_t;
typedef typename base_t::param_t param_t;
typedef typename base_t::return_t return_t;
condition_evaluator(param_t s) : base_t(s) {}
condition_evaluator() : base_t() {}
/////////////////////////////
// evaluate, checks wether condition is met
// returns length of a match or a negative number for no-match
template <typename ScannerT>
int
evaluate(ScannerT const &scan) const
{
typedef typename ScannerT::iterator_t iterator_t;
typedef typename parser_result<selected_t, ScannerT>::type cres_t;
iterator_t save(scan.first);
cres_t result = condition().parse(scan);
if (!result) // reset the position if evaluation
scan.first = save; // fails.
return result.length();
}
/////////////////////////////
// condition
// returns the parser used for the condition
inline return_t condition() const
{
return base_t::get();
}
};
///////////////////////////////////////////////////////////////////////////////
} // namespace impl
}} // namespace boost::spirit
#endif

229
include/boost/spirit/dynamic/while.hpp Normal file
View File

@@ -0,0 +1,229 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002-2003 Joel de Guzman
Copyright (c) 2002-2003 Martin Wille
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#ifndef BOOST_SPIRIT_WHILE_HPP
#define BOOST_SPIRIT_WHILE_HPP
#if !defined(BOOST_SPIRIT_PARSER_HPP)
#include "boost/spirit/core/parser.hpp"
#endif
#if !defined(BOOST_SPIRIT_COMPOSITE_HPP)
#include "boost/spirit/core/composite/composite.hpp"
#endif
#if !defined(BOOST_SPIRIT_CONDITIONS_IPP)
#include "boost/spirit/dynamic/impl/conditions.ipp"
#endif
////////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
namespace impl {
//////////////////////////////////
// while parser
// object are created by while_parser_gen and do_parser_gen
template <typename ParserT, typename CondT, bool is_do_parser>
struct while_parser
: public condition_evaluator<CondT>
, public unary // the parent stores a copy of the body parser
<
ParserT,
parser<while_parser<ParserT, CondT, is_do_parser> >
>
{
typedef unary
<
ParserT,
parser<while_parser<ParserT, CondT, is_do_parser> >
> parent_t;
typedef while_parser<ParserT, CondT, is_do_parser> self_t;
typedef condition_evaluator<CondT> cond_t;
typedef CondT condition_t;
//////////////////////////////
// constructor, saves condition and body parser
while_parser(ParserT const &p_body, CondT const &cond_)
: cond_t(cond_)
, parent_t(p_body)
{}
//////////////////////////////
// result type computer.
template <typename ScannerT>
struct result
{
typedef typename match_result
<ScannerT, nil_t>::type type;
};
//////////////////////////////
// parse member function
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
parse(ScannerT const& scan) const
{
typedef typename parser_result<ParserT, ScannerT>::type sresult_t;
typedef typename ScannerT::iterator_t iterator_t;
iterator_t save(scan.first);
int length = 0;
int eval_length = 0;
bool dont_check_condition = is_do_parser;
while (dont_check_condition || (eval_length=evaluate(scan))>=0)
{
dont_check_condition = false;
length += eval_length;
sresult_t tmp(this->subject().parse(scan));
if (tmp)
{
length+=tmp.length();
}
else
{
return scan.no_match();
}
}
return scan.create_match(length, nil_t(), save, scan.first);
}
};
//////////////////////////////////
// while-parser generator, takes the body-parser in brackets
// and returns the actual while-parser.
template <typename CondT>
struct while_parser_gen
{
typedef typename ::boost::spirit::as_parser<CondT>::type condition_t;
//////////////////////////////
// constructor, saves the condition for use by operator[]
while_parser_gen(CondT const& cond_) : cond(cond_) {}
//////////////////////////////
// operator[] returns the actual while-parser object
template <typename ParserT>
while_parser
<
typename ::boost::spirit::as_parser<ParserT>::type,
condition_t,
false
>
operator[](ParserT const &subject) const
{
typedef typename ::boost::spirit::as_parser<ParserT>::type parser_t;
typedef char assert_argument_must_be_a_parser
[::boost::spirit::is_parser<parser_t>::value];
return while_parser<parser_t, condition_t, false>
(
::boost::spirit::as_parser<ParserT>::convert(subject),
::boost::spirit::as_parser<CondT>::convert(cond)
);
}
private:
//////////////////////////////
// the condition is stored by reference here.
// this should not cause any harm since object of type
// while_parser_gen<> are only used as temporaries
// the while-parser object constructed by the operator[]
// stores a copy of the condition.
CondT const &cond;
};
//////////////////////////////////
// do-while-parser generator, takes the condition as
// parameter to while_p member function and returns the
// actual do-while-parser.
template <typename ParserT>
struct do_while_parser_gen
{
//////////////////////////////
// constructor. saves the body parser for use by while_p.
explicit do_while_parser_gen(ParserT const &body_parser)
: body(body_parser)
{}
//////////////////////////////
// while_p returns the actual while-parser object
template <typename CondT>
while_parser
<
ParserT,
typename ::boost::spirit::as_parser<CondT>::type,
true
>
while_p(CondT cond) const
{
typedef typename ::boost::spirit::as_parser<CondT> cond_as_parser_t;
typedef typename cond_as_parser_t::type condition_t;
return while_parser<ParserT, condition_t, true>
(body, ::boost::spirit::as_parser<CondT>::convert(cond));
}
private:
//////////////////////////////
// the body is stored by reference here
// this should not cause any harm since object of type
// do_while_parser_gen<> are only used as temporaries
// the while-parser object constructed by the while_p
// member function stores a copy of the body parser.
ParserT const &body;
};
struct do_parser_gen
{
inline do_parser_gen() {}
template <typename ParserT>
impl::do_while_parser_gen
<
typename ::boost::spirit::as_parser<ParserT>::type
>
operator[](ParserT const& body) const
{
typedef typename ::boost::spirit::as_parser<ParserT>::type parser_t;
typedef char assert_argument_must_be_a_parser
[::boost::spirit::is_parser<parser_t>::value];
return impl::do_while_parser_gen<parser_t>
(::boost::spirit::as_parser<ParserT>::convert(body));
}
};
} // namespace impl
//////////////////////////////////
// while_p function, while-parser generator
// Usage: spirit::while_p(Condition)[Body]
template <typename CondT>
impl::while_parser_gen<CondT>
while_p(CondT const& cond)
{
return impl::while_parser_gen<CondT>(cond);
}
//////////////////////////////////
// do_p functor, do-while-parser generator
// Usage: spirit::do_p[Body].while_p(Condition)
impl::do_parser_gen const do_p = impl::do_parser_gen();
}} // namespace boost::spirit
#endif // BOOST_SPIRIT_WHILE_HPP

22
include/boost/spirit/error_handling.hpp Normal file
View File

@@ -0,0 +1,22 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001-2003 Joel de Guzman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_ERROR_HANDLING_MAIN_HPP)
#define BOOST_SPIRIT_ERROR_HANDLING_MAIN_HPP
///////////////////////////////////////////////////////////////////////////////
//
// Master header for Spirit.ErrorHandling
//
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/error_handling/exceptions.hpp"
#endif // !defined(BOOST_SPIRIT_ERROR_HANDLING_MAIN_HPP)

4
include/boost/spirit/error_handling/Makefile.am Normal file
View File

@@ -0,0 +1,4 @@
#This file generated by Makefileamgen.sh
SUBDIRS = impl
spiritinclude_HEADERS = exceptions.hpp
spiritincludedir = $(includedir)/spirit/boost/spirit/error_handling

345
include/boost/spirit/error_handling/exceptions.hpp Normal file
View File

@@ -0,0 +1,345 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001-2003 Joel de Guzman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#ifndef BOOST_SPIRIT_EXCEPTIONS_HPP
#define BOOST_SPIRIT_EXCEPTIONS_HPP
#if !defined(BOOST_SPIRIT_PARSER_HPP)
#include "boost/spirit/core/parser.hpp"
#endif
#if !defined(BOOST_SPIRIT_COMPOSITE_HPP)
#include "boost/spirit/core/composite/composite.hpp"
#endif
#include <exception>
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////
//
// parser_error_base class
//
// This is the base class of parser_error (see below). This may be
// used to catch any type of parser error.
//
// This exception shouldn't propagate outside the parser. However to
// avoid quirks of many platforms/implementations which fall outside
// the C++ standard, we derive parser_error_base from std::exception
// to allow a single catch handler to catch all exceptions.
//
///////////////////////////////////////////////////////////////////////////
class parser_error_base : public std::exception
{
protected:
parser_error_base() {}
virtual ~parser_error_base() throw() {}
parser_error_base(parser_error_base const&) {}
parser_error_base& operator=(parser_error_base const&)
{ return *this; }
};
///////////////////////////////////////////////////////////////////////////
//
// parser_error class
//
// Generic parser exception class. This is the base class for all
// parser exceptions. The exception holds the iterator position
// where the error was encountered in its member variable "where".
// The parser_error also holds information regarding the error
// (error descriptor) in its member variable "descriptor".
//
// The throw_ function creates and throws a parser_error given
// an iterator and an error descriptor.
//
///////////////////////////////////////////////////////////////////////////
template <typename ErrorDescrT, typename IteratorT = char const*>
struct parser_error : public parser_error_base
{
typedef ErrorDescrT error_descr_t;
typedef IteratorT iterator_t;
parser_error(IteratorT where_, ErrorDescrT descriptor_)
: where(where_), descriptor(descriptor_) {}
virtual
~parser_error() throw() {}
virtual const char*
what() const throw()
{ return "boost::spirit::parser_error"; }
IteratorT const where;
ErrorDescrT const descriptor;
};
//////////////////////////////////
template <typename ErrorDescrT, typename IteratorT>
inline void
throw_(IteratorT where, ErrorDescrT descriptor)
{
throw parser_error<ErrorDescrT, IteratorT>(where, descriptor);
}
///////////////////////////////////////////////////////////////////////////
//
// assertive_parser class
//
// An assertive_parser class is a parser that throws an exception
// in response to a parsing failure. The assertive_parser throws a
// parser_error exception rather than returning an unsuccessful
// match to signal that the parser failed to match the input.
//
///////////////////////////////////////////////////////////////////////////
template <typename ErrorDescrT, typename ParserT>
struct assertive_parser
: public unary<ParserT, parser<assertive_parser<ErrorDescrT, ParserT> > >
{
typedef assertive_parser<ErrorDescrT, ParserT> self_t;
typedef unary<ParserT, parser<self_t> > base_t;
typedef unary_parser_category parser_category_t;
assertive_parser(ParserT const& parser, ErrorDescrT descriptor)
: base_t(parser), descriptor(descriptor) {}
template <typename ScannerT>
struct result
{ typedef typename parser_result<ParserT, ScannerT>::type type; };
template <typename ScannerT>
typename parser_result<self_t, ScannerT>::type
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)
{
#ifndef __BORLANDC__
throw_(scan.first, descriptor);
#else
throw_(scan.first, const_cast<ErrorDescrT &>(descriptor));
#endif
}
return hit;
}
ErrorDescrT descriptor;
};
///////////////////////////////////////////////////////////////////////////
//
// assertion class
//
// assertive_parsers are never instantiated directly. The assertion
// class is used to indirectly create an assertive_parser object.
// Before declaring the grammar, we declare some assertion objects.
// Examples:
//
// enum Errors
// {
// program_expected, begin_expected, end_expected
// };
//
// assertion<Errors> expect_program(program_expected);
// assertion<Errors> expect_begin(begin_expected);
// assertion<Errors> expect_end(end_expected);
//
// Now, we can use these assertions as wrappers around parsers:
//
// expect_end(str_p("end"))
//
// Take note that although the example uses enums to hold the
// information regarding the error (error desccriptor), we are free
// to use other types such as integers and strings. Enums are
// convenient for error handlers to easily catch since C++ treats
// enums as unique types.
//
///////////////////////////////////////////////////////////////////////////
template <typename ErrorDescrT>
struct assertion
{
assertion(ErrorDescrT descriptor_)
: descriptor(descriptor_) {}
template <typename ParserT>
assertive_parser<ErrorDescrT, ParserT>
operator()(ParserT const& parser) const
{ return assertive_parser<ErrorDescrT, ParserT>(parser, descriptor); }
ErrorDescrT descriptor;
};
///////////////////////////////////////////////////////////////////////////
//
// error_status<T>
//
// Where T is an attribute type compatible with the match attribute
// of the fallback_parser's subject (defaults to nil_t). The class
// error_status reports the result of an error handler (see
// fallback_parser). result can be one of:
//
// fail: quit and fail (return a no_match)
// retry: attempt error recovery, possibly moving the scanner
// accept: force success returning a matching length, moving
// the scanner appropriately and returning an attribute
// value
// rethrow: rethrows the error.
//
///////////////////////////////////////////////////////////////////////////
template <typename T = nil_t>
struct error_status
{
enum result_t { fail, retry, accept, rethrow };
error_status(
result_t result_ = fail,
int length = -1,
T const& value_ = T())
: result(result_), length(length), value(value_) {}
result_t result;
int length;
T value;
};
///////////////////////////////////////////////////////////////////////////
//
// fallback_parser class
//
// Handles exceptions of type parser_error<ErrorDescrT, IteratorT>
// thrown somewhere inside its embedded ParserT object. The class
// sets up a try block before delegating parsing to its subject.
// When an exception is caught, the catch block then calls the
// HandlerT object. HandlerT may be a function or a functor (with
// an operator() member function) compatible with the interface:
//
// error_status<T>
// handler(ScannerT const& scan, ErrorT error);
//
// Where scan points to the scanner state prior to parsing and error
// is the error that arose (see parser_error). The handler must
// return an error_status<T> object (see above).
//
///////////////////////////////////////////////////////////////////////////
namespace impl
{
template <typename RT, typename ParserT, typename ScannerT>
RT fallback_parser_parse(ParserT const& p, ScannerT const& scan);
}
template <typename ErrorDescrT, typename ParserT, typename HandlerT>
struct fallback_parser
: public unary<ParserT,
parser<fallback_parser<ErrorDescrT, ParserT, HandlerT> > >
{
typedef fallback_parser<ErrorDescrT, ParserT, HandlerT>
self_t;
typedef ErrorDescrT
error_descr_t;
typedef unary<ParserT, parser<self_t> >
base_t;
typedef unary_parser_category
parser_category_t;
fallback_parser(ParserT const& parser, HandlerT const& handler_)
: base_t(parser), handler(handler_) {}
template <typename ScannerT>
struct result
{ typedef typename parser_result<ParserT, ScannerT>::type type; };
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::fallback_parser_parse<result_t>(*this, scan);
}
HandlerT handler;
};
///////////////////////////////////////////////////////////////////////////
//
// guard class
//
// fallback_parser objects are not instantiated directly. The guard
// class is used to indirectly create a fallback_parser object.
// guards are typically predeclared just like assertions (see the
// assertion class above; the example extends the previous example
// introduced in the assertion class above):
//
// guard<Errors> my_guard;
//
// Errors, in this example is the error descriptor type we want to
// detect; This is essentially the ErrorDescrT template parameter
// of the fallback_parser class.
//
// my_guard may now be used in a grammar declaration as:
//
// my_guard(p)[h]
//
// where p is a parser, h is a function or functor compatible with
// fallback_parser's HandlerT (see above).
//
///////////////////////////////////////////////////////////////////////////
template <typename ErrorDescrT>
struct guard;
template <typename ErrorDescrT, typename ParserT>
struct guard_gen : public unary<ParserT, nil_t>
{
typedef guard<ErrorDescrT> parser_generator_t;
typedef unary_parser_category parser_category_t;
guard_gen(ParserT const& p)
: unary<ParserT, nil_t>(p) {}
template <typename HandlerT>
fallback_parser<ErrorDescrT, ParserT, HandlerT>
operator[](HandlerT const& handler) const
{
return fallback_parser<ErrorDescrT, ParserT, HandlerT>
(this->subject(), handler);
}
};
template <typename ErrorDescrT>
struct guard
{
template <typename ParserT>
struct result {
typedef guard_gen<ErrorDescrT, ParserT> type;
};
template <typename ParserT>
static guard_gen<ErrorDescrT, ParserT>
generate(ParserT const& parser)
{
return guard_gen<ErrorDescrT, ParserT>(parser);
}
template <typename ParserT>
guard_gen<ErrorDescrT, ParserT>
operator()(ParserT const& parser) const
{
return guard_gen<ErrorDescrT, ParserT>(parser);
}
};
}} // namespace boost::spirit
#include "boost/spirit/error_handling/impl/exceptions.ipp"
#endif

3
include/boost/spirit/error_handling/impl/Makefile.am Normal file
View File

@@ -0,0 +1,3 @@
#This file generated by Makefileamgen.sh
spiritinclude_HEADERS = exceptions.ipp
spiritincludedir = $(includedir)/spirit/boost/spirit/error_handling/impl

85
include/boost/spirit/error_handling/impl/exceptions.ipp Normal file
View File

@@ -0,0 +1,85 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001-2003 Joel de Guzman
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#ifndef BOOST_SPIRIT_EXCEPTIONS_IPP
#define BOOST_SPIRIT_EXCEPTIONS_IPP
namespace boost { namespace spirit { namespace impl {
#ifdef __BORLANDC__
template <typename ParserT, typename ScannerT>
typename parser_result<ParserT, ScannerT>::type
fallback_parser_helper(ParserT const& subject, ScannerT const& scan);
#endif
template <typename RT, typename ParserT, typename ScannerT>
RT fallback_parser_parse(ParserT const& p, ScannerT const& scan)
{
typedef typename ScannerT::iterator_t iterator_t;
typedef typename RT::attr_t attr_t;
typedef error_status<attr_t> error_status_t;
typedef typename ParserT::error_descr_t error_descr_t;
iterator_t save = scan.first;
error_status_t hr(error_status_t::retry);
while (hr.result == error_status_t::retry)
{
try
{
#ifndef __BORLANDC__
return p.subject().parse(scan);
#else
return impl::fallback_parser_helper(p, scan);
#endif
}
catch (parser_error<error_descr_t, iterator_t> error)
{
scan.first = save;
hr = p.handler(scan, error);
switch (hr.result)
{
case error_status_t::fail:
return scan.no_match();
case error_status_t::accept:
return scan.create_match
(hr.length, hr.value, save, scan.first);
case error_status_t::rethrow:
throw;
default:
continue;
}
}
}
return scan.no_match();
}
///////////////////////////////////////////////////////////////////////////
//
// Borland does not like calling the subject directly in the try block.
// Removing the #ifdef __BORLANDC__ code makes Borland complain that
// some variables and types cannot be found in the catch block. Weird!
//
///////////////////////////////////////////////////////////////////////////
#ifdef __BORLANDC__
template <typename ParserT, typename ScannerT>
typename parser_result<ParserT, ScannerT>::type
fallback_parser_helper(ParserT const& p, ScannerT const& scan)
{ return p.subject().parse(scan); }
#endif
}}} // namespace boost::spirit::impl
///////////////////////////////////////////////////////////////////////////////
#endif

30
include/boost/spirit/iterator.hpp Normal file
View File

@@ -0,0 +1,30 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001-2003 Daniel Nuffer
Copyright (c) 2002 Jeff Westfahl
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#if !defined(BOOST_SPIRIT_ITERATOR_MAIN_HPP)
#define BOOST_SPIRIT_ITERATOR_MAIN_HPP
///////////////////////////////////////////////////////////////////////////////
//
// Master header for Spirit.Iterators
//
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/iterator/file_iterator.hpp"
#include "boost/spirit/iterator/fixed_size_queue.hpp"
#include "boost/spirit/iterator/position_iterator.hpp"
#include "boost/config.hpp"
#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1300)
#include "boost/spirit/iterator/multi_pass.hpp"
#endif
#endif // !defined(BOOST_SPIRIT_ITERATOR_MAIN_HPP)

4
include/boost/spirit/iterator/Makefile.am Normal file
View File

@@ -0,0 +1,4 @@
#This file generated by Makefileamgen.sh
SUBDIRS = impl
spiritinclude_HEADERS = file_iterator.hpp fixed_size_queue.hpp multi_pass.hpp position_iterator.hpp
spiritincludedir = $(includedir)/spirit/boost/spirit/iterator

304
include/boost/spirit/iterator/file_iterator.hpp Normal file
View File

@@ -0,0 +1,304 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002 Jeff Westfahl
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
// This code is inspired by FILEiter.h by Stephen Cleary, and is basically a
// superset of the functionality provided there. FILEiter.h is available from
// http://groups.yahoo.com/group/boost/files/2000/IOGlue/IOGlue.zip and has
// the following copyright notice:
// FILEiter: Input and Output iterators for FILE * objects
// (C) Copyright Stephen Cleary 2000. Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
// Notes on 64-bit file access:
//
// The following systems are known to have 64-bit lseek support. Note that on
// Linux, you must define _FILE_OFFSET_BITS=64 and _LARGEFILE_SOURCE. This
// should be done on the compiler command line so that it is used globally.
//
// MSVC (tested on VC6 SP4)
// MINGW (tested on recent CYGWIN)
// Linux (recent, tested on Mandrake Linux 8.2 X86 and PPC)
// Intel C++ (untested, but it uses system headers and libraries)
//
// The following systems are known to not have 64-bit lseek support, and do
// not seem to export any 64-bit file access functions. This may or may not
// be a problem for you. I know that I don't have a lot of files larger than
// 2GB laying around on my hard drives, except for testing. But, you never
// can tell how people might want to use your software.
//
// Borland 5.5.1
// CYGWIN
//
// Basically, this iterator should work fine on any files < 2GB in size on any
// system.
#if !defined FILE_ITERATOR_HPP
#define FILE_ITERATOR_HPP
///////////////////////////////////////////////////////////////////////////////
#include <boost/config.hpp>
#include <boost/iterator.hpp>
#include <cstdio>
#include <sys/types.h>
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
namespace impl {
// Systems that don't have a 64-bit off_t, but do have a 64-bit lseek
#if defined BOOST_MSVC \
|| defined __MINGW32_VERSION \
|| defined BOOST_INTEL_CXX_VERSION
// Always use 64-bit file access
typedef __int64 off_t;
#else
// Use the system defined offset size
using ::off_t;
#endif
///////////////////////////////////////////////////////////////////////////////
} // namespace impl
///////////////////////////////////////////////////////////////////////////////
// warning C4284: return type for 'boost::spirit::file_iterator<char>::operator ->'
// is 'const char *'
#if defined BOOST_MSVC
#pragma warning ( push )
#pragma warning ( disable : 4284 )
#endif
///////////////////////////////////////////////////////////////////////////////
template <typename CharT = char>
class file_iterator
: public boost::iterator <
std::random_access_iterator_tag,
CharT,
impl::off_t,
CharT const *,
CharT const &
>
{
public:
// Iterator traits
typedef impl::off_t difference_type;
typedef CharT value_type;
typedef CharT const * pointer;
typedef CharT const & reference;
// Standard constructor. Opens the specified file.
explicit file_iterator (char const * pFilename);
// Destructor
~file_iterator ();
// Make an end of file iterator for the current file
file_iterator make_end ();
// Returns false if no file is associated with this iterator
operator bool () const;
// Returns file size in bytes
difference_type size () const;
//
// Default Constructible
//
// Default constructor
file_iterator ();
//
// Assignable
//
// Copy constructor
file_iterator (file_iterator const & rCopyMe);
// Assignment operator
file_iterator & operator = (file_iterator const & rAssignMe);
// Swap
void swap (file_iterator & rA, file_iterator & rB);
//
// Trivial Iterator
//
// Dereference
//
// Note: Assigning to this will not fail, but is pointless as this
// iterator is only meant to be read from.
reference operator * () const;
// Member access
pointer operator -> () const;
//
// Input and Forward Iterator
//
// Preincrement
file_iterator const & operator ++ () const;
// Postincrement
file_iterator const operator ++ (int) const;
//
// Bidirectional Iterator
//
// Predecrement
file_iterator const & operator -- () const;
// Postdecrement
file_iterator const operator -- (int) const;
//
// Random Access Iterator
//
// Iterator addition (i += n)
file_iterator const & operator += (difference_type Distance) const;
// Iterator addition (i + n)
file_iterator const operator + (difference_type Distance) const;
// Iterator subtraction (i -= n)
file_iterator const & operator -= (difference_type Distance) const;
// Iterator subtraction (i - n)
file_iterator const operator - (difference_type Distance) const;
// Difference (i - j)
difference_type operator - (file_iterator const & rIterator) const;
// Element
value_type operator [] (difference_type Index) const;
//
// Equality Comparable
//
bool operator_equal_to (file_iterator const & rOther) const;
//
// LessThan Comparable
//
bool operator_less_than (file_iterator const & rOther) const;
bool operator_greater_than (file_iterator const & rOther) const;
private:
// Character size
BOOST_STATIC_CONSTANT (int, kCharSize = sizeof (CharT));
// Length of the file in bytes
difference_type m_Filesize;
// File descriptor
int m_File;
// Current offset into the file
mutable difference_type m_Offset;
// The next character to be returned
mutable CharT m_NextChar;
// True if this instance is responsible for closing the file
bool m_CloseFile;
};
// Iterator addition (n + i)
template <typename CharT>
file_iterator <CharT> const operator + (
typename file_iterator <CharT>::difference_type Distance,
file_iterator <CharT> const & rIterator
);
//
// Equality Comparable
//
// Equality
template <typename CharT>
bool operator == (
file_iterator <CharT> const & rA,
file_iterator <CharT> const & rB
);
// Inequality
template <typename CharT>
bool operator != (
file_iterator <CharT> const & rA,
file_iterator <CharT> const & rB
);
//
// LessThan Comparable
//
// Less
template <typename CharT>
bool operator < (
file_iterator <CharT> const & rA,
file_iterator <CharT> const & rB
);
// Greater
template <typename CharT>
bool operator > (
file_iterator <CharT> const & rA,
file_iterator <CharT> const & rB
);
// Less or equal
template <typename CharT>
bool operator <= (
file_iterator <CharT> const & rA,
file_iterator <CharT> const & rB
);
// Greater or equal
template <typename CharT>
bool operator >= (
file_iterator <CharT> const & rA,
file_iterator <CharT> const & rB
);
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
///////////////////////////////////////////////////////////////////////////////
#if defined BOOST_MSVC
#pragma warning ( pop )
#endif
///////////////////////////////////////////////////////////////////////////////
#endif // #if !defined FILE_ITERATOR_HPP
///////////////////////////////////////////////////////////////////////////////
#if !defined FILE_ITERATOR_IPP
#include "boost/spirit/iterator/impl/file_iterator.ipp"
#endif

306
include/boost/spirit/iterator/fixed_size_queue.hpp Normal file
View File

@@ -0,0 +1,306 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2001, Daniel C. Nuffer
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
#ifndef FIXED_SIZE_QUEUE
#define FIXED_SIZE_QUEUE
#include <cstdlib>
#include <iterator>
#include <cstddef>
#include "boost/spirit/debug/assert.hpp" // for BOOST_SPIRIT_ASSERT
// FIXES for broken compilers
#include <boost/config.hpp>
//// fix for cygwin
//#ifdef size_t
//#undef size_t
//namespace std { typedef unsigned size_t; }
//#endif
#define BOOST_SPIRIT_ASSERT_FSQ_SIZE \
BOOST_SPIRIT_ASSERT(((m_tail + N + 1) - m_head) % (N+1) == m_size % (N+1)) \
/**/
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
template <typename T, std::size_t N>
class fixed_size_queue_iterator;
template <typename T, std::size_t N>
class fixed_size_queue
{
public:
fixed_size_queue();
fixed_size_queue(const fixed_size_queue& x);
fixed_size_queue& operator=(const fixed_size_queue& x);
~fixed_size_queue();
void push_back(const T& e);
void push_front(const T& e);
void serve(T& e);
void pop_front();
bool empty()
{
return m_size == 0;
}
bool full()
{
return m_size == N;
}
typedef fixed_size_queue_iterator<T, N> iterator;
iterator begin()
{
return iterator(this, m_head);
}
iterator end()
{
return iterator(this, m_tail);
}
std::size_t size()
{
return m_size;
}
T& front()
{
return m_queue[m_head];
}
private:
//friend class iterator;
friend class fixed_size_queue_iterator<T, N>;
std::size_t m_head;
std::size_t m_tail;
std::size_t m_size;
T m_queue[N+1];
};
template <typename T, std::size_t N>
class fixed_size_queue_iterator
{
public:
typedef std::forward_iterator_tag iterator_category;
typedef T value_type;
typedef std::ptrdiff_t difference_type;
typedef T* pointer;
typedef T& reference;
typedef fixed_size_queue<T, N> queue;
fixed_size_queue_iterator(queue* q, std::size_t p)
: m_queue(q)
, pos(p)
{}
fixed_size_queue_iterator& operator++()
{
++pos;
if (pos == N+1)
pos = 0;
return *this;
}
fixed_size_queue_iterator operator++(int)
{
fixed_size_queue_iterator tmp = *this;
++*this;
return tmp;
}
T& operator*()
{
return m_queue->m_queue[pos];
}
bool operator==(const fixed_size_queue_iterator& x)
{
return pos == x.pos && m_queue == x.m_queue;
}
bool operator<(const fixed_size_queue_iterator& x)
{
std::size_t p1 = pos < m_queue->m_head ? pos + N : pos;
std::size_t p2 = x.pos < x.m_queue->m_head ? x.pos + N : x.pos;
return p1 < p2;
}
bool operator!=(const fixed_size_queue_iterator& x)
{
return !(*this == x);
}
private:
queue* m_queue;
std::size_t pos;
};
template <typename T, std::size_t N>
inline
fixed_size_queue<T, N>::fixed_size_queue()
: m_head(0)
, m_tail(0)
, m_size(0)
{
BOOST_SPIRIT_ASSERT(m_size <= N+1);
BOOST_SPIRIT_ASSERT_FSQ_SIZE;
BOOST_SPIRIT_ASSERT(m_head <= N+1);
BOOST_SPIRIT_ASSERT(m_tail <= N+1);
}
template <typename T, std::size_t N>
inline
fixed_size_queue<T, N>::fixed_size_queue(const fixed_size_queue& x)
: m_head(x.m_head)
, m_tail(x.m_tail)
, m_size(x.m_size)
{
copy(x.begin(), x.end(), begin());
BOOST_SPIRIT_ASSERT(m_size <= N+1);
BOOST_SPIRIT_ASSERT_FSQ_SIZE;
BOOST_SPIRIT_ASSERT(m_head <= N+1);
BOOST_SPIRIT_ASSERT(m_tail <= N+1);
}
template <typename T, std::size_t N>
inline fixed_size_queue<T, N>&
fixed_size_queue<T, N>::operator=(const fixed_size_queue& x)
{
if (this != &x)
{
m_head = x.m_head;
m_tail = x.m_tail;
m_size = x.m_size;
copy(x.begin(), x.end(), begin());
}
BOOST_SPIRIT_ASSERT(m_size <= N+1);
BOOST_SPIRIT_ASSERT_FSQ_SIZE;
BOOST_SPIRIT_ASSERT(m_head <= N+1);
BOOST_SPIRIT_ASSERT(m_tail <= N+1);
return *this;
}
template <typename T, std::size_t N>
inline
fixed_size_queue<T, N>::~fixed_size_queue()
{
BOOST_SPIRIT_ASSERT(m_size <= N+1);
BOOST_SPIRIT_ASSERT_FSQ_SIZE;
BOOST_SPIRIT_ASSERT(m_head <= N+1);
BOOST_SPIRIT_ASSERT(m_tail <= N+1);
}
template <typename T, std::size_t N>
inline void
fixed_size_queue<T, N>::push_back(const T& e)
{
BOOST_SPIRIT_ASSERT(m_size <= N+1);
BOOST_SPIRIT_ASSERT_FSQ_SIZE;
BOOST_SPIRIT_ASSERT(m_head <= N+1);
BOOST_SPIRIT_ASSERT(m_tail <= N+1);
BOOST_SPIRIT_ASSERT(!full());
m_queue[m_tail] = e;
++m_size;
++m_tail;
if (m_tail == N+1)
m_tail = 0;
BOOST_SPIRIT_ASSERT(m_size <= N+1);
BOOST_SPIRIT_ASSERT_FSQ_SIZE;
BOOST_SPIRIT_ASSERT(m_head <= N+1);
BOOST_SPIRIT_ASSERT(m_tail <= N+1);
}
template <typename T, std::size_t N>
inline void
fixed_size_queue<T, N>::push_front(const T& e)
{
BOOST_SPIRIT_ASSERT(m_size <= N+1);
BOOST_SPIRIT_ASSERT_FSQ_SIZE;
BOOST_SPIRIT_ASSERT(m_head <= N+1);
BOOST_SPIRIT_ASSERT(m_tail <= N+1);
BOOST_SPIRIT_ASSERT(!full());
if (m_head == 0)
m_head = N;
else
--m_head;
m_queue[m_head] = e;
++m_size;
BOOST_SPIRIT_ASSERT(m_size <= N+1);
BOOST_SPIRIT_ASSERT_FSQ_SIZE;
BOOST_SPIRIT_ASSERT(m_head <= N+1);
BOOST_SPIRIT_ASSERT(m_tail <= N+1);
}
template <typename T, std::size_t N>
inline void
fixed_size_queue<T, N>::serve(T& e)
{
BOOST_SPIRIT_ASSERT(m_size <= N+1);
BOOST_SPIRIT_ASSERT_FSQ_SIZE;
BOOST_SPIRIT_ASSERT(m_head <= N+1);
BOOST_SPIRIT_ASSERT(m_tail <= N+1);
e = m_queue[m_head];
pop_front();
}
template <typename T, std::size_t N>
inline void
fixed_size_queue<T, N>::pop_front()
{
BOOST_SPIRIT_ASSERT(m_size <= N+1);
BOOST_SPIRIT_ASSERT_FSQ_SIZE;
BOOST_SPIRIT_ASSERT(m_head <= N+1);
BOOST_SPIRIT_ASSERT(m_tail <= N+1);
++m_head;
if (m_head == N+1)
m_head = 0;
--m_size;
BOOST_SPIRIT_ASSERT(m_size <= N+1);
BOOST_SPIRIT_ASSERT_FSQ_SIZE;
BOOST_SPIRIT_ASSERT(m_head <= N+1);
BOOST_SPIRIT_ASSERT(m_tail <= N+1);
}
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#undef BOOST_SPIRIT_ASSERT_FSQ_SIZE
#endif

3
include/boost/spirit/iterator/impl/Makefile.am Normal file
View File

@@ -0,0 +1,3 @@
#This file generated by Makefileamgen.sh
spiritinclude_HEADERS = file_iterator.ipp msvc_ps_helper.hpp multi_pass_msvc.hpp
spiritincludedir = $(includedir)/spirit/boost/spirit/iterator/impl

514
include/boost/spirit/iterator/impl/file_iterator.ipp Normal file
View File

@@ -0,0 +1,514 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002 Jeff Westfahl
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software is
granted provided this copyright notice appears in all copies. This
software is provided "as is" without express or implied warranty, and
with no claim as to its suitability for any purpose.
=============================================================================*/
// This code is inspired by FILEiter.h by Stephen Cleary, and is basically a
// superset of the functionality provided there. FILEiter.h is available from
// http://groups.yahoo.com/group/boost/files/2000/IOGlue/IOGlue.zip and has
// the following copyright notice:
// FILEiter: Input and Output iterators for FILE * objects
// (C) Copyright Stephen Cleary 2000. Permission to copy, use, modify, sell and
// distribute this software is granted provided this copyright notice appears
// in all copies. This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
#if !defined FILE_ITERATOR_IPP
#define FILE_ITERATOR_IPP
///////////////////////////////////////////////////////////////////////////////
#include <cassert>
#include <fcntl.h>
#if (defined (__COMO_VERSION__) && defined (BOOST_MSVC)) \
|| defined __BORLANDC__ || defined BOOST_INTEL_CXX_VERSION \
|| defined BOOST_MSVC
#include <io.h>
#elif defined (__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 3)
#include <unistd.h>
#endif
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
namespace impl {
// Systems that have _lseeki64, such as Win32.
#if defined BOOST_MSVC \
|| defined __MINGW32_VERSION \
|| defined BOOST_INTEL_CXX_VERSION
// These systems default to CR-LF translation for opened files. Using
// O_BINARY turns off this translation.
static const int kOpenFlags = O_RDONLY | O_BINARY;
// Import _lseeki64 into this namespace under the name lseek
inline off_t lseek (int File, off_t Offset, int Whence)
{
return _lseeki64 (File, Offset, Whence);
}
// Systems that have lseek, whether it is 64-bit or 32-bit
#else
// Some non-POSIX systems default to CR-LF translation for opened
// files. Using O_BINARY turns off this translation.
#if defined __CYGWIN__ || defined __BORLANDC__
static const int kOpenFlags = O_RDONLY | O_BINARY;
// POSIX systems don't do any CR-LF translation, and don't have an
// O_BINARY flag. POSIX systems don't do this because it is ignored
// on all POSIX conforming systems, according to the Linux man page
// for fopen.
#else
static const int kOpenFlags = O_RDONLY;
#endif
// Import lseek into this namespace
using ::lseek;
#endif
///////////////////////////////////////////////////////////////////////////////
} // namespace impl
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline file_iterator <CharT>::file_iterator (char const * pFilename)
: m_Filesize (0),
m_File (-1),
m_Offset (0),
m_NextChar (),
m_CloseFile (false)
{
assert (NULL != pFilename);
m_File = open (pFilename, impl::kOpenFlags);
if (-1 != m_File)
{
// This instance is responsible for closing the file
m_CloseFile = true;
// Get the file size in bytes
m_Filesize = impl::lseek (m_File, 0, SEEK_END);
// The above shouldn't fail, but you never know...
if (0 > m_Filesize)
{
close (m_File);
m_CloseFile = false;
m_File = -1;
}
// Move the file pointer back to the beginning
impl::lseek (m_File, 0, SEEK_SET);
// Read the first character
read (m_File, &m_NextChar, kCharSize);
}
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline file_iterator <CharT>::~file_iterator ()
{
if (
m_CloseFile
&& (-1 != m_File)
)
{
close (m_File);
}
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline file_iterator <CharT> file_iterator <CharT>::make_end ()
{
file_iterator <CharT> _Iterator (*this);
// Make sure the offset is correctly aligned
_Iterator.m_Offset = m_Filesize - (m_Filesize % kCharSize);
return _Iterator;
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline file_iterator <CharT>::operator bool () const
{
return (-1 != m_File);
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline typename file_iterator <CharT>::difference_type
file_iterator <CharT>::size () const
{
return m_Filesize;
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline file_iterator <CharT>::file_iterator ()
: m_Filesize (0),
m_File (-1),
m_Offset (-1),
m_NextChar (),
m_CloseFile (false)
{
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline file_iterator <CharT>::file_iterator (
file_iterator const & rCopyMe
)
: m_Filesize (rCopyMe.m_Filesize),
m_File (rCopyMe.m_File),
m_Offset (rCopyMe.m_Offset),
m_NextChar (rCopyMe.m_NextChar),
m_CloseFile (false)
{
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline file_iterator <CharT> & file_iterator <CharT>::operator = (
file_iterator const & rAssignMe
)
{
// Clean up previous file if necessary
if (
m_CloseFile
&& (-1 != m_File)
&& (m_File != rAssignMe.m_File)
)
{
close (m_File);
}
m_File = rAssignMe.m_File;
m_Offset = rAssignMe.m_Offset;
m_Filesize = rAssignMe.m_Filesize;
m_NextChar = rAssignMe.m_NextChar;
return *this;
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline void file_iterator <CharT>::swap (
file_iterator <CharT> & rA,
file_iterator <CharT> & rB
)
{
file_iterator <CharT> _Temp (rA);
rA = rB;
rB = _Temp;
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline typename file_iterator <CharT>::reference
file_iterator <CharT>::operator * () const
{
assert (-1 != m_File);
return m_NextChar;
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline typename file_iterator <CharT>::pointer
file_iterator <CharT>::operator -> () const
{
assert (-1 != m_File);
return &m_NextChar;
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline file_iterator <CharT> const &
file_iterator <CharT>::operator ++ () const
{
assert (-1 != m_File);
m_Offset += kCharSize;
impl::lseek (m_File, m_Offset, SEEK_SET);
read (m_File, &m_NextChar, kCharSize);
return *this;
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline file_iterator <CharT> const
file_iterator <CharT>::operator ++ (int) const
{
assert (-1 != m_File);
file_iterator _Temp (*this);
m_Offset += kCharSize;
impl::lseek (m_File, m_Offset, SEEK_SET);
read (m_File, &m_NextChar, kCharSize);
return _Temp;
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline file_iterator <CharT> const &
file_iterator <CharT>::operator -- () const
{
assert (-1 != m_File);
m_Offset -= kCharSize;
impl::lseek (m_File, m_Offset, SEEK_SET);
read (m_File, &m_NextChar, kCharSize);
return *this;
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline file_iterator <CharT> const
file_iterator <CharT>::operator -- (int) const
{
assert (-1 != m_File);
file_iterator _Temp (*this);
m_Offset -= kCharSize;
impl::lseek (m_File, m_Offset, SEEK_SET);
read (m_File, &m_NextChar, kCharSize);
return _Temp;
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
file_iterator <CharT> const & file_iterator <CharT>::operator += (
difference_type Distance
) const
{
assert (-1 != m_File);
m_Offset += Distance * kCharSize;
impl::lseek (m_File, m_Offset, SEEK_SET);
read (m_File, &m_NextChar, kCharSize);
return *this;
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
file_iterator <CharT> const file_iterator <CharT>::operator + (
difference_type Distance
) const
{
file_iterator <CharT> _Temp (*this);
_Temp += Distance;
return _Temp;
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
file_iterator <CharT> const & file_iterator <CharT>::operator -= (
difference_type Distance
) const
{
assert (-1 != m_File);
m_Offset -= Distance * kCharSize;
impl::lseek (m_File, m_Offset, SEEK_SET);
read (m_File, &m_NextChar, kCharSize);
return *this;
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
file_iterator <CharT> const file_iterator <CharT>::operator - (
difference_type Distance
) const
{
file_iterator <CharT> _Temp (*this);
_Temp -= Distance;
return _Temp;
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
typename file_iterator <CharT>::difference_type
file_iterator <CharT>::operator - (
file_iterator <CharT> const & rIterator
) const
{
return ((m_Offset - rIterator.m_Offset) / kCharSize);
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline typename file_iterator <CharT>::value_type
file_iterator <CharT>::operator [] (difference_type Index) const
{
assert (-1 != m_File);
CharT _ReturnValue;
impl::lseek (m_File, m_Offset, SEEK_SET);
read (m_File, &m_NextChar, kCharSize);
return _ReturnValue;
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
file_iterator <CharT> const operator + (
typename file_iterator <CharT>::difference_type Distance,
file_iterator <CharT> const & rIterator
)
{
file_iterator <CharT> _Temp (rIterator);
_Temp += Distance;
return _Temp;
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline bool file_iterator <CharT>::operator_equal_to (
const file_iterator <CharT> & rOther
) const
{
// assert (m_File == rOther.m_File);
return (m_Offset == rOther.m_Offset);
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline bool operator == (
file_iterator <CharT> const & rA,
file_iterator <CharT> const & rB
)
{
return rA.operator_equal_to (rB);
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline bool operator != (
file_iterator <CharT> const & rA,
file_iterator <CharT> const & rB
)
{
return !(rA.operator_equal_to (rB));
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline bool file_iterator <CharT>::operator_less_than (
file_iterator <CharT> const & rOther
) const
{
assert (m_File == rOther.m_File);
return (m_Offset < rOther.m_Offset);
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline bool operator < (
file_iterator <CharT> const & rA,
file_iterator <CharT> const & rB
)
{
return rA.operator_less_than (rB);
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline bool operator >= (
file_iterator <CharT> const & rA,
file_iterator <CharT> const & rB
)
{
return !(rA.operator_less_than (rB));
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline bool file_iterator <CharT>::operator_greater_than (
file_iterator <CharT> const & rOther
) const
{
assert (m_File == rOther.m_File);
return (m_Offset > rOther.m_Offset);
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline bool operator > (
file_iterator <CharT> const & rA,
file_iterator <CharT> const & rB
)
{
return (rA.operator_greater_than (rB));
}
///////////////////////////////////////////////////////////////////////////////
template <typename CharT>
inline bool operator <= (
file_iterator <CharT> const & rA,
file_iterator <CharT> const & rB
)
{
return !(rA.operator_greater_than (rB));
}
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif // #if !defined FILE_ITERATOR_IPP

1224
include/boost/spirit/iterator/multi_pass.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

195
include/boost/spirit/iterator/position_iterator.hpp Normal file
View File

@@ -0,0 +1,195 @@
/*=============================================================================
Spirit V1.5.2
Copyright (c) 2002 Juan Carlos Arevalo-Baeza
http://spirit.sourceforge.net/
Permission to copy, use, modify, sell and distribute this software
is granted provided this copyright notice appears in all copies.
This software is provided "as is" without express or implied
warranty, and with no claim as to its suitability for any purpose.
See spirit.hpp for full copyright notices.
=============================================================================*/
#ifndef BOOST_SPIRIT_POSITION_ITERATOR_HPP
#define BOOST_SPIRIT_POSITION_ITERATOR_HPP
///////////////////////////////////////////////////////////////////////////////
#include <string>
#include <iterator>
#include "boost/config.hpp"
#include "boost/spirit/core/impl/msvc.hpp"
///////////////////////////////////////////////////////////////////////////////
namespace boost { namespace spirit {
///////////////////////////////////////////////////////////////////////////////
//
// file_position
//
// A structure to hold positional information. This includes the file,
// line and column
//
///////////////////////////////////////////////////////////////////////////////
struct file_position {
std::string file;
int line;
int column;
file_position(std::string const& file_ = std::string(),
int line_ = 1, int column_ = 1):
file (file_),
line (line_),
column (column_)
{}
};
///////////////////////////////////////////////////////////////////////////////
//
// position_iterator
//
// It wraps an iterator, and keeps track of the current position in the input,
// as it gets incremented.
//
// The default tab size is 4. You can change this with the set_tabchars member
// function.
//
// In order to have begin/end iterators constructed, the end iterator must be
// empty constructed. Similar to what happens with stream iterators. Note that,
// if the wrapped iterator is a forward iterator, this one will work as a
// forward iterator too. The begin iterator must be constructed from both, the
// begin and end iterators of the wrapped iterator type. This is necessary to
// implement the lookahead of characters necessary to parse CRLF sequences.
//
// In order to extract the current positional data from the iterator, you may
// use the get_position member function.
//
// You can also use the set_position member function to reset the current
// position to something new.
//
///////////////////////////////////////////////////////////////////////////////
template < class IteratorT >
class position_iterator {
#if (defined(BOOST_MSVC) && (BOOST_MSVC <= 1300)) \
|| (defined(BOOST_INTEL_CXX_VERSION) && !defined(_STLPORT_VERSION))
typedef impl::iterator_traits<IteratorT> traits_t;
#else
typedef std::iterator_traits<IteratorT> traits_t;
#endif
public:
typedef typename traits_t::value_type value_type;
typedef typename traits_t::pointer pointer;
typedef typename traits_t::reference reference;
typedef typename traits_t::difference_type difference_type;
// regardless of the underlying iterator type the position_iterator is a
// forward iterator only
typedef typename std::forward_iterator_tag iterator_category;
position_iterator(): m_CharsPerTab(4), m_IsAtEnd(true) {}
position_iterator(IteratorT const& iter, IteratorT const& iterend,
std::string const& file, int line = 1, int column = 1):
m_Iter(iter),
m_IterEnd(iterend),
m_Pos(file, line, column),
m_CharsPerTab(4),
m_IsAtEnd(m_Iter == m_IterEnd)
{
}
reference operator *() const { return *m_Iter; }
pointer operator ->() const { return &*m_Iter; }
bool is_equal(const position_iterator& i2) const {
return (m_IsAtEnd && i2.m_IsAtEnd) ||
(!m_IsAtEnd && !i2.m_IsAtEnd && m_Iter == i2.m_Iter);
}
void set_position(file_position const& newpos) {
m_Pos = newpos;
}
file_position& get_position() {
return m_Pos;
}
file_position const& get_position() const {
return m_Pos;
}
position_iterator& operator ++() {
inc_current();
return *this;
}
position_iterator operator ++(int) {
const position_iterator result = *this;
inc_current();
return result;
}
friend difference_type operator -(const position_iterator& i1,
const position_iterator& i2) {
return i1.m_Iter - i2.m_Iter;
}
void set_tabchars(unsigned int chars) {
m_CharsPerTab = chars;
}
private:
IteratorT m_Iter;
IteratorT m_IterEnd;
file_position m_Pos;
unsigned int m_CharsPerTab;
bool m_IsAtEnd;
void inc_current() {
if (!m_IsAtEnd) {
value_type val = *m_Iter;
if (val == '\n' || val == '\r') {
++m_Pos.line;
m_Pos.column = 1;
++m_Iter;
if (m_Iter != m_IterEnd) {
value_type val2 = *m_Iter;
if ((val == '\n' && val2 == '\r')
|| (val == '\r' && val2 == '\n')) {
++m_Iter;
}
}
} else if (val == '\t') {
m_Pos.column += m_CharsPerTab - (m_Pos.column - 1) % m_CharsPerTab;
++m_Iter;
} else {
++m_Pos.column;
++m_Iter;
}
if (m_Iter == m_IterEnd) {
m_IsAtEnd = true;
}
}
}
};
template < class IteratorT >
class position_iterator;
template < class IteratorT >
inline bool operator ==(
const position_iterator<IteratorT>& i1,
const position_iterator<IteratorT>& i2)
{
return i1.is_equal(i2);
}
template < class IteratorT >
inline bool operator !=(
const position_iterator<IteratorT>& i1,
const position_iterator<IteratorT>& i2)
{
return !(i1 == i2);
}
///////////////////////////////////////////////////////////////////////////////
}} // namespace boost::spirit
#endif

3
include/boost/spirit/phoenix/Makefile.am Normal file
View File

@@ -0,0 +1,3 @@
#This file generated by Makefileamgen.sh
spiritinclude_HEADERS = actor.hpp binders.hpp casts.hpp closures.hpp composite.hpp functions.hpp operators.hpp primitives.hpp special_ops.hpp statements.hpp tuple_helpers.hpp tuples.hpp
spiritincludedir = $(includedir)/spirit/boost/phoenix

614
include/boost/spirit/phoenix/actor.hpp Normal file
View File

@@ -0,0 +1,614 @@
/*=============================================================================
Phoenix V1.0
Copyright (c) 2001-2002 Joel de Guzman
Permission to copy, use, modify, sell and distribute this software
is granted provided this copyright notice appears in all copies.
This software is provided "as is" without express or implied
warranty, and with no claim as to its suitability for any purpose.
==============================================================================*/
#ifndef PHOENIX_ACTOR_HPP
#define PHOENIX_ACTOR_HPP
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/phoenix/tuples.hpp"
///////////////////////////////////////////////////////////////////////////////
namespace phoenix {
// These are forward declared here because we cannot include impl.hpp
// or operators.hpp yet but the actor's assignment operator and index
// operator are required to be members.
//////////////////////////////////
struct assign_op;
struct index_op;
//////////////////////////////////
namespace impl {
template <typename OperationT, typename BaseT, typename B>
struct make_binary1;
}
namespace impl {
///////////////////////////////////////////////////////////////////////////
//
// if_t selects type A or B depending on the condition C If C is of
// type char[2], B is selected, otherwise A
//
// TODO: This should be part of a common meta-library
//
///////////////////////////////////////////////////////////////////////////
template <typename C, typename A, typename B>
struct if_t { typedef A type; };
template <typename A, typename B>
struct if_t<char[2], A, B> { typedef B type; };
}
///////////////////////////////////////////////////////////////////////////////
//
// unpack_tuple class
//
// This class is used to unpack a supplied tuple such, that the members of
// this tuple will be handled as if they would be supplied separately.
//
///////////////////////////////////////////////////////////////////////////////
template <typename TupleT>
struct unpack_tuple : public TupleT {
typedef TupleT tuple_t;
unpack_tuple() {}
unpack_tuple(tuple_t const &tuple_) : TupleT(tuple_) {}
};
///////////////////////////////////////////////////////////////////////////////
//
// actor class
//
// This class is a protocol class for all actors. This class is
// essentially an interface contract. The actor class does not
// really know how how to act on anything but instead relies on the
// template parameter BaseT (from which the actor will derive from)
// to do the actual action.
//
// An actor is a functor that is capable of accepting arguments up
// to a predefined maximum. It is up to the base class to do the
// actual processing or possibly to limit the arity (no. of
// arguments) passed in. Upon invocation of the functor through a
// supplied operator(), the actor funnels the arguments passed in
// by the client into a tuple and calls the base eval member
// function.
//
// Schematically:
//
// arg0 ---------|
// arg1 ---------|
// arg3 ---------|---> tupled_args ---> base.eval
// ... |
// argN ---------|
//
// actor::operator()(arg0, arg1... argN)
// ---> BaseT::eval(tupled_args);
//
// Actor base classes from which this class inherits from are
// expected to have a corresponding member function eval compatible
// with the conceptual Interface:
//
// template <typename TupleT>
// actor_return_type
// eval(TupleT const& args) const;
//
// where args are the actual arguments passed in by the client
// funneled into a tuple (see tuple.hpp for details).
//
// The actor_return_type can be anything. Base classes are free to
// return any type, even argument dependent types (types that are
// deduced from the types of the arguments). After evaluating the
// parameters and doing some computations or actions, the eval
// member function concludes by returning something back to the
// client. To do this, the forwarding function (the actor's
// operator()) needs to know the return type of the eval member
// function that it is calling. For this purpose, actor base
// classes are required to provide a nested template class:
//
// template <typename TupleT>
// struct result;
//
// This auxiliary class provides the result type information
// returned by the eval member function of a base actor class. The
// nested template class result should have a typedef 'type' that
// reflects the return type of its member function eval. It is
// basically a type computer that answers the question "given
// arguments packed into a TupleT type, what will be the result
// type of the eval member function of ActorT?". The template class
// actor_result queries this to extract the return type of an
// actor. Example:
//
// typedef typename actor_result<ActorT, TupleT>::type
// actor_return_type;
//
// where actor_return_type is the actual type returned by ActorT's
// eval member function given some arguments in a TupleT.
//
///////////////////////////////////////////////////////////////////////////////
template <typename ActorT, typename TupleT>
struct actor_result {
typedef typename ActorT::template result<TupleT>::type type;
typedef typename remove_reference<type>::type plain_type;
};
//////////////////////////////////
template <typename BaseT>
struct actor : public BaseT {
actor();
actor(BaseT const& base);
typename actor_result<BaseT, tuple<> >::type
operator()() const;
template <typename A>
typename actor_result<BaseT, tuple<A&> >::type
operator()(A& a) const;
template <typename A, typename B>
typename actor_result<BaseT, tuple<A&, B&> >::type
operator()(A& a, B& b) const;
template <typename A, typename B, typename C>
typename actor_result<BaseT, tuple<A&, B&, C&> >::type
operator()(A& a, B& b, C& c) const;
#if PHOENIX_LIMIT > 3
template <typename A, typename B, typename C, typename D>
typename actor_result<BaseT, tuple<A&, B&, C&, D&> >::type
operator()(A& a, B& b, C& c, D& d) const;
template <typename A, typename B, typename C, typename D, typename E>
typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&> >::type
operator()(A& a, B& b, C& c, D& d, E& e) const;
template <
typename A, typename B, typename C, typename D, typename E,
typename F>
typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&, F&> >::type
operator()(A& a, B& b, C& c, D& d, E& e, F& f) const;
#if PHOENIX_LIMIT > 6
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G>
typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&, F&, G&> >::type
operator()(A& a, B& b, C& c, D& d, E& e, F& f, G& g) const;
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H>
typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&, G&, H&>
>::type
operator()(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h) const;
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I>
typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&>
>::type
operator()(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i) const;
#if PHOENIX_LIMIT > 9
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J>
typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&>
>::type
operator()(
A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j) const;
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K>
typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&>
>::type
operator()(
A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
K& k) const;
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K, typename L>
typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&>
>::type
operator()(
A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
K& k, L& l) const;
#if PHOENIX_LIMIT > 12
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K, typename L, typename M>
typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&>
>::type
operator()(
A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
K& k, L& l, M& m) const;
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K, typename L, typename M, typename N>
typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&>
>::type
operator()(
A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
K& k, L& l, M& m, N& n) const;
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K, typename L, typename M, typename N, typename O>
typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&, O&>
>::type
operator()(
A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
K& k, L& l, M& m, N& n, O& o) const;
#endif
#endif
#endif
#endif
template <typename TupleT>
typename actor_result<BaseT, unpack_tuple<TupleT> >::type
operator()(unpack_tuple<TupleT> const &t) const;
template <typename B>
typename impl::make_binary1<assign_op, BaseT, B>::type
operator=(B const& b) const;
template <typename B>
typename impl::make_binary1<index_op, BaseT, B>::type
operator[](B const& b) const;
};
///////////////////////////////////////////////////////////////////////////
//
// as_actor
//
// as_actor is a meta-program that converts an arbitrary type into
// an actor. All participants in the framework must be first-class
// actors. This meta-program is used all throughout the framework
// whenever an unknown type needs to be converted to an actor.
// as_actor specializations are expected to have a typedef 'type'.
// This is the destination actor type. A static member function
// 'convert' converts an object to this target type.
//
// The meta-program does no conversion if the object to be
// converted is already an actor.
//
///////////////////////////////////////////////////////////////////////////
template <typename T>
struct as_actor;
//////////////////////////////////
template <typename BaseT>
struct as_actor<actor<BaseT> > {
typedef actor<BaseT> type;
static type convert(actor<BaseT> const& x) { return x; }
};
//////////////////////////////////
template <>
struct as_actor<nil_t> {
typedef nil_t type;
static nil_t convert(nil_t /*x*/)
{ return nil_t(); }
};
//////////////////////////////////
template <>
struct as_actor<void> {
typedef void type;
// ERROR!!!
};
///////////////////////////////////////////////////////////////////////////////
//
// actor class implementation
//
///////////////////////////////////////////////////////////////////////////////
template <typename BaseT>
actor<BaseT>::actor()
: BaseT() {}
//////////////////////////////////
template <typename BaseT>
actor<BaseT>::actor(BaseT const& base)
: BaseT(base) {}
//////////////////////////////////
template <typename BaseT>
inline typename actor_result<BaseT, tuple<> >::type
actor<BaseT>::operator()() const
{
return BaseT::eval(tuple<>());
}
//////////////////////////////////
template <typename BaseT>
template <typename A>
inline typename actor_result<BaseT, tuple<A&> >::type
actor<BaseT>::operator()(A& a) const
{
return BaseT::eval(tuple<A&>(a));
}
//////////////////////////////////
template <typename BaseT>
template <typename A, typename B>
inline typename actor_result<BaseT, tuple<A&, B&> >::type
actor<BaseT>::operator()(A& a, B& b) const
{
return BaseT::eval(tuple<A&, B&>(a, b));
}
//////////////////////////////////
template <typename BaseT>
template <typename A, typename B, typename C>
inline typename actor_result<BaseT, tuple<A&, B&, C&> >::type
actor<BaseT>::operator()(A& a, B& b, C& c) const
{
return BaseT::eval(tuple<A&, B&, C&>(a, b, c));
}
#if PHOENIX_LIMIT > 3
//////////////////////////////////
template <typename BaseT>
template <typename A, typename B, typename C, typename D>
inline typename actor_result<BaseT, tuple<A&, B&, C&, D&> >::type
actor<BaseT>::operator()(A& a, B& b, C& c, D& d) const
{
return BaseT::eval(tuple<A&, B&, C&, D&>(a, b, c, d));
}
//////////////////////////////////
template <typename BaseT>
template <typename A, typename B, typename C, typename D, typename E>
inline typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&> >::type
actor<BaseT>::operator()(A& a, B& b, C& c, D& d, E& e) const
{
return BaseT::eval(tuple<A&, B&, C&, D&, E&>(a, b, c, d, e));
}
//////////////////////////////////
template <typename BaseT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F>
inline typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&>
>::type
actor<BaseT>::operator()(
A& a, B& b, C& c, D& d, E& e, F& f
) const
{
return BaseT::eval(
tuple<A&, B&, C&, D&, E&, F&>
(a, b, c, d, e, f)
);
}
#if PHOENIX_LIMIT > 6
//////////////////////////////////
template <typename BaseT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G>
inline typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&, G&>
>::type
actor<BaseT>::operator()(
A& a, B& b, C& c, D& d, E& e, F& f, G& g
) const
{
return BaseT::eval(
tuple<A&, B&, C&, D&, E&, F&, G&>
(a, b, c, d, e, f, g)
);
}
//////////////////////////////////
template <typename BaseT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H>
inline typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&, G&, H&>
>::type
actor<BaseT>::operator()(
A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h
) const
{
return BaseT::eval(
tuple<A&, B&, C&, D&, E&, F&, G&, H&>
(a, b, c, d, e, f, g, h)
);
}
//////////////////////////////////
template <typename BaseT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I>
inline typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&>
>::type
actor<BaseT>::operator()(
A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i
) const
{
return BaseT::eval(
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&>
(a, b, c, d, e, f, g, h, i)
);
}
#if PHOENIX_LIMIT > 9
//////////////////////////////////
template <typename BaseT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J>
inline typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&>
>::type
actor<BaseT>::operator()(
A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j
) const
{
return BaseT::eval(
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&>
(a, b, c, d, e, f, g, h, i, j)
);
}
//////////////////////////////////
template <typename BaseT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K>
inline typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&>
>::type
actor<BaseT>::operator()(
A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
K& k
) const
{
return BaseT::eval(
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&>
(a, b, c, d, e, f, g, h, i, j, k)
);
}
//////////////////////////////////
template <typename BaseT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K, typename L>
inline typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&>
>::type
actor<BaseT>::operator()(
A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
K& k, L& l
) const
{
return BaseT::eval(
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&>
(a, b, c, d, e, f, g, h, i, j, k, l)
);
}
#if PHOENIX_LIMIT > 12
//////////////////////////////////
template <typename BaseT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K, typename L, typename M>
inline typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&>
>::type
actor<BaseT>::operator()(
A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
K& k, L& l, M& m
) const
{
return BaseT::eval(
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&>
(a, b, c, d, e, f, g, h, i, j, k, l, m)
);
}
//////////////////////////////////
template <typename BaseT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K, typename L, typename M, typename N>
inline typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&>
>::type
actor<BaseT>::operator()(
A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
K& k, L& l, M& m, N& n
) const
{
return BaseT::eval(
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&>
(a, b, c, d, e, f, g, h, i, j, k, l, m, n)
);
}
//////////////////////////////////
template <typename BaseT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K, typename L, typename M, typename N, typename O>
inline typename actor_result<BaseT,
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&, O&>
>::type
actor<BaseT>::operator()(
A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h, I& i, J& j,
K& k, L& l, M& m, N& n, O& o
) const
{
return BaseT::eval(
tuple<A&, B&, C&, D&, E&, F&, G&, H&, I&, J&, K&, L&, M&, N&, O&>
(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
);
}
#endif
#endif
#endif
#endif
//////////////////////////////////
template <typename BaseT>
template <typename TupleT>
typename actor_result<BaseT, unpack_tuple<TupleT> >::type
actor<BaseT>::operator()(unpack_tuple<TupleT> const &t) const
{
return BaseT::eval(t);
}
///////////////////////////////////////////////////////////////////////////////
} // namespace phoenix
#endif

3450
include/boost/spirit/phoenix/binders.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

1292
include/boost/spirit/phoenix/casts.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

359
include/boost/spirit/phoenix/closures.hpp Normal file
View File

@@ -0,0 +1,359 @@
/*=============================================================================
Phoenix V1.0
Copyright (c) 2001-2002 Joel de Guzman
MT code Copyright (c) 2002 Martin Wille
Permission to copy, use, modify, sell and distribute this software
is granted provided this copyright notice appears in all copies.
This software is provided "as is" without express or implied
warranty, and with no claim as to its suitability for any purpose.
==============================================================================*/
#ifndef PHOENIX_CLOSURES_HPP
#define PHOENIX_CLOSURES_HPP
///////////////////////////////////////////////////////////////////////////////
#include "actor.hpp"
#include <cassert>
#ifdef PHOENIX_THREADSAFE
#include <boost/thread/tss.hpp>
#endif
///////////////////////////////////////////////////////////////////////////////
namespace phoenix {
///////////////////////////////////////////////////////////////////////////////
//
// Adaptable closures
//
// The framework will not be complete without some form of closures
// support. Closures encapsulate a stack frame where local
// variables are created upon entering a function and destructed
// upon exiting. Closures provide an environment for local
// variables to reside. Closures can hold heterogeneous types.
//
// Phoenix closures are true hardware stack based closures. At the
// very least, closures enable true reentrancy in lambda functions.
// A closure provides access to a function stack frame where local
// variables reside. Modeled after Pascal nested stack frames,
// closures can be nested just like nested functions where code in
// inner closures may access local variables from in-scope outer
// closures (accessing inner scopes from outer scopes is an error
// and will cause a run-time assertion failure).
//
// There are three (3) interacting classes:
//
// 1) closure:
//
// At the point of declaration, a closure does not yet create a
// stack frame nor instantiate any variables. A closure declaration
// declares the types and names[note] of the local variables. The
// closure class is meant to be subclassed. It is the
// responsibility of a closure subclass to supply the names for
// each of the local variable in the closure. Example:
//
// struct my_closure : closure<int, string, double> {
//
// member1 num; // names the 1st (int) local variable
// member2 message; // names the 2nd (string) local variable
// member3 real; // names the 3rd (double) local variable
// };
//
// my_closure clos;
//
// Now that we have a closure 'clos', its local variables can be
// accessed lazily using the dot notation. Each qualified local
// variable can be used just like any primitive actor (see
// primitives.hpp). Examples:
//
// clos.num = 30
// clos.message = arg1
// clos.real = clos.num * 1e6
//
// The examples above are lazily evaluated. As usual, these
// expressions return composite actors that will be evaluated
// through a second function call invocation (see operators.hpp).
// Each of the members (clos.xxx) is an actor. As such, applying
// the operator() will reveal its identity:
//
// clos.num() // will return the current value of clos.num
//
// *** [note] Acknowledgement: Juan Carlos Arevalo-Baeza (JCAB)
// introduced and initilally implemented the closure member names
// that uses the dot notation.
//
// 2) closure_member
//
// The named local variables of closure 'clos' above are actually
// closure members. The closure_member class is an actor and
// conforms to its conceptual interface. member1..memberN are
// predefined typedefs that correspond to each of the listed types
// in the closure template parameters.
//
// 3) closure_frame
//
// When a closure member is finally evaluated, it should refer to
// an actual instance of the variable in the hardware stack.
// Without doing so, the process is not complete and the evaluated
// member will result to an assertion failure. Remember that the
// closure is just a declaration. The local variables that a
// closure refers to must still be instantiated.
//
// The closure_frame class does the actual instantiation of the
// local variables and links these variables with the closure and
// all its members. There can be multiple instances of
// closure_frames typically situated in the stack inside a
// function. Each closure_frame instance initiates a stack frame
// with a new set of closure local variables. Example:
//
// void foo()
// {
// closure_frame<my_closure> frame(clos);
// /* do something */
// }
//
// where 'clos' is an instance of our closure 'my_closure' above.
// Take note that the usage above precludes locally declared
// classes. If my_closure is a locally declared type, we can still
// use its self_type as a paramater to closure_frame:
//
// closure_frame<my_closure::self_type> frame(clos);
//
// Upon instantiation, the closure_frame links the local variables
// to the closure. The previous link to another closure_frame
// instance created before is saved. Upon destruction, the
// closure_frame unlinks itself from the closure and relinks the
// preceding closure_frame prior to this instance.
//
// The local variables in the closure 'clos' above is default
// constructed in the stack inside function 'foo'. Once 'foo' is
// exited, all of these local variables are destructed. In some
// cases, default construction is not desirable and we need to
// initialize the local closure variables with some values. This
// can be done by passing in the initializers in a compatible
// tuple. A compatible tuple is one with the same number of
// elements as the destination and where each element from the
// destination can be constructed from each corresponding element
// in the source. Example:
//
// tuple<int, char const*, int> init(123, "Hello", 1000);
// closure_frame<my_closure> frame(clos, init);
//
// Here now, our closure_frame's variables are initialized with
// int: 123, char const*: "Hello" and int: 1000.
//
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//
// closure_frame class
//
///////////////////////////////////////////////////////////////////////////////
template <typename ClosureT>
class closure_frame : public ClosureT::tuple_t {
public:
closure_frame(ClosureT const& clos)
: ClosureT::tuple_t(), save(clos.frame), frame(clos.frame)
{ clos.frame = this; }
template <typename TupleT>
closure_frame(ClosureT const& clos, TupleT const& init)
: ClosureT::tuple_t(init), save(clos.frame), frame(clos.frame)
{ clos.frame = this; }
~closure_frame()
{ frame = save; }
private:
closure_frame(closure_frame const&); // no copy
closure_frame& operator=(closure_frame const&); // no assign
closure_frame* save;
closure_frame*& frame;
};
///////////////////////////////////////////////////////////////////////////////
//
// closure_member class
//
///////////////////////////////////////////////////////////////////////////////
template <int N, typename ClosureT>
class closure_member {
public:
typedef typename ClosureT::tuple_t tuple_t;
closure_member()
: frame(ClosureT::closure_frame_ref()) {}
template <typename TupleT>
struct result {
typedef typename tuple_element<
N, typename ClosureT::tuple_t
>::rtype type;
};
template <typename TupleT>
typename tuple_element<N, typename ClosureT::tuple_t>::rtype
eval(TupleT const& /*args*/) const
{
using namespace std;
assert(frame != 0);
return (*frame)[tuple_index<N>()];
}
private:
typename ClosureT::closure_frame_t*& frame;
};
///////////////////////////////////////////////////////////////////////////////
//
// closure class
//
///////////////////////////////////////////////////////////////////////////////
template <
typename T0 = nil_t
, typename T1 = nil_t
, typename T2 = nil_t
#if PHOENIX_LIMIT > 3
, typename T3 = nil_t
, typename T4 = nil_t
, typename T5 = nil_t
#if PHOENIX_LIMIT > 6
, typename T6 = nil_t
, typename T7 = nil_t
, typename T8 = nil_t
#if PHOENIX_LIMIT > 9
, typename T9 = nil_t
, typename T10 = nil_t
, typename T11 = nil_t
#if PHOENIX_LIMIT > 12
, typename T12 = nil_t
, typename T13 = nil_t
, typename T14 = nil_t
#endif
#endif
#endif
#endif
>
class closure {
public:
typedef tuple<
T0, T1, T2
#if PHOENIX_LIMIT > 3
, T3, T4, T5
#if PHOENIX_LIMIT > 6
, T6, T7, T8
#if PHOENIX_LIMIT > 9
, T9, T10, T11
#if PHOENIX_LIMIT > 12
, T12, T13, T14
#endif
#endif
#endif
#endif
> tuple_t;
typedef closure<
T0, T1, T2
#if PHOENIX_LIMIT > 3
, T3, T4, T5
#if PHOENIX_LIMIT > 6
, T6, T7, T8
#if PHOENIX_LIMIT > 9
, T9, T10, T11
#if PHOENIX_LIMIT > 12
, T12, T13, T14
#endif
#endif
#endif
#endif
> self_t;
typedef closure_frame<self_t> closure_frame_t;
closure()
: frame(0) { closure_frame_ref(&frame); }
closure_frame_t& context() { assert(frame!=0); return frame; }
closure_frame_t const& context() const { assert(frame!=0); return frame; }
typedef actor<closure_member<0, self_t> > member1;
typedef actor<closure_member<1, self_t> > member2;
typedef actor<closure_member<2, self_t> > member3;
#if PHOENIX_LIMIT > 3
typedef actor<closure_member<3, self_t> > member4;
typedef actor<closure_member<4, self_t> > member5;
typedef actor<closure_member<5, self_t> > member6;
#if PHOENIX_LIMIT > 6
typedef actor<closure_member<6, self_t> > member7;
typedef actor<closure_member<7, self_t> > member8;
typedef actor<closure_member<8, self_t> > member9;
#if PHOENIX_LIMIT > 9
typedef actor<closure_member<9, self_t> > member10;
typedef actor<closure_member<10, self_t> > member11;
typedef actor<closure_member<11, self_t> > member12;
#if PHOENIX_LIMIT > 12
typedef actor<closure_member<12, self_t> > member13;
typedef actor<closure_member<13, self_t> > member14;
typedef actor<closure_member<14, self_t> > member15;
#endif
#endif
#endif
#endif
#if !defined(__MWERKS__) || (__MWERKS__ > 0x3002)
private:
#endif
closure(closure const&); // no copy
closure& operator=(closure const&); // no assign
#if !defined(__MWERKS__) || (__MWERKS__ > 0x3002)
template <int N, typename ClosureT>
friend class closure_member;
template <typename ClosureT>
friend class closure_frame;
#endif
static closure_frame_t*&
closure_frame_ref(closure_frame_t** frame_ = 0)
{
#ifdef PHOENIX_THREADSAFE
static boost::thread_specific_ptr<closure_frame_t **> tsp_frame;
if (!tsp_frame.get())
tsp_frame.reset(new closure_frame_t **(0));
closure_frame_t **& frame = *tsp_frame;
#else
static closure_frame_t** frame = 0;
#endif
if (frame_ != 0)
frame = frame_;
return *frame;
}
mutable closure_frame_t* frame;
};
}
// namespace phoenix
#endif

1415
include/boost/spirit/phoenix/composite.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

743
include/boost/spirit/phoenix/functions.hpp Normal file
View File

@@ -0,0 +1,743 @@
/*=============================================================================
Phoenix V1.0
Copyright (c) 2001-2002 Joel de Guzman
Permission to copy, use, modify, sell and distribute this software
is granted provided this copyright notice appears in all copies.
This software is provided "as is" without express or implied
warranty, and with no claim as to its suitability for any purpose.
==============================================================================*/
#ifndef PHOENIX_FUNCTIONS_HPP
#define PHOENIX_FUNCTIONS_HPP
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/phoenix/actor.hpp"
#include "boost/spirit/phoenix/composite.hpp"
///////////////////////////////////////////////////////////////////////////////
namespace phoenix {
///////////////////////////////////////////////////////////////////////////////
//
// function class
//
// Lazy functions
//
// This class provides a mechanism for lazily evaluating functions.
// Syntactically, a lazy function looks like an ordinary C/C++
// function. The function call looks the same. However, unlike
// ordinary functions, the actual function execution is deferred.
// (see actor.hpp, primitives.hpp and composite.hpp for an
// overview). For example here are sample factorial function calls:
//
// factorial(4)
// factorial(arg1)
// factorial(arg1 * 6)
//
// These functions are automatically lazily bound unlike ordinary
// function pointers or functor objects that need to be explicitly
// bound through the bind function (see binders.hpp).
//
// A lazy function works in conjunction with a user defined functor
// (as usual with a member operator()). Only special forms of
// functor objects are allowed. This is required to enable true
// polymorphism (STL style monomorphic functors and function
// pointers can still be used through the bind facility in
// binders.hpp).
//
// This special functor is expected to have a nested template class
// result<A...TN> (where N is the number of arguments of its
// member operator()). The nested template class result should have
// a typedef 'type' that reflects the return type of its member
// operator(). This is essentially a type computer that answers the
// metaprogramming question "Given arguments of type A...TN, what
// will be the operator()'s return type?".
//
// There is a special case for functors that accept no arguments.
// Such nullary functors are only required to define a typedef
// result_type that reflects the return type of its operator().
//
// Here's an example of a simple functor that computes the
// factorial of a number:
//
// struct factorial_impl {
//
// template <typename Arg>
// struct result { typedef Arg type; };
//
// template <typename Arg>
// Arg operator()(Arg n) const
// { return (n <= 0) ? 1 : n * this->operator()(n-1); }
// };
//
// As can be seen, the functor can be polymorphic. Its arguments
// and return type are not fixed to a particular type. The example
// above for example, can handle any type as long as it can carry
// out the required operations (i.e. <=, * and -).
//
// We can now declare and instantiate a lazy 'factorial' function:
//
// function<factorial_impl> factorial;
//
// Invoking a lazy function 'factorial' does not immediately
// execute the functor factorial_impl. Instead, a composite (see
// composite.hpp) object is created and returned to the caller.
// Example:
//
// factorial(arg1)
//
// does nothing more than return a composite. A second function
// call will invoke the actual factorial function. Example:
//
// int i = 4;
// cout << factorial(arg1)(i);
//
// will print out "24".
//
// Take note that in certain cases (e.g. for functors with state),
// an instance may be passed on to the constructor. Example:
//
// function<factorial_impl> factorial(ftor);
//
// where ftor is an instance of factorial_impl (this is not
// necessary in this case since factorial is a simple stateless
// functor). Take care though when using functors with state
// because the functors are taken in by value. It is best to keep
// the data manipulated by a functor outside the functor itself and
// keep a reference to this data inside the functor. Also, it is
// best to keep functors as small as possible.
//
///////////////////////////////////////////////////////////////////////////////
template <typename OperationT>
struct function {
function() : op() {}
function(OperationT const& op_) : op(op_) {}
actor<composite<OperationT> >
operator()() const;
template <typename A>
typename impl::make_composite<OperationT, A>::type
operator()(A const& a) const;
template <typename A, typename B>
typename impl::make_composite<OperationT, A, B>::type
operator()(A const& a, B const& b) const;
template <typename A, typename B, typename C>
typename impl::make_composite<OperationT, A, B, C>::type
operator()(A const& a, B const& b, C const& c) const;
#if PHOENIX_LIMIT > 3
template <typename A, typename B, typename C, typename D>
typename impl::make_composite<OperationT, A, B, C, D>::type
operator()(A const& a, B const& b, C const& c, D const& d) const;
template <typename A, typename B, typename C, typename D, typename E>
typename impl::make_composite<
OperationT, A, B, C, D, E
>::type
operator()(
A const& a, B const& b, C const& c, D const& d, E const& e
) const;
template <
typename A, typename B, typename C, typename D, typename E,
typename F
>
typename impl::make_composite<
OperationT, A, B, C, D, E, F
>::type
operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f
) const;
#if PHOENIX_LIMIT > 6
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G
>
typename impl::make_composite<
OperationT, A, B, C, D, E, F, G
>::type
operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g
) const;
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H
>
typename impl::make_composite<
OperationT, A, B, C, D, E, F, G, H
>::type
operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g, H const& h
) const;
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I
>
typename impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I
>::type
operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g, H const& h, I const& i
) const;
#if PHOENIX_LIMIT > 9
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J
>
typename impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J
>::type
operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g, H const& h, I const& i, J const& j
) const;
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K
>
typename impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J, K
>::type
operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g, H const& h, I const& i, J const& j,
K const& k
) const;
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K, typename L
>
typename impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J, K, L
>::type
operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g, H const& h, I const& i, J const& j,
K const& k, L const& l
) const;
#if PHOENIX_LIMIT > 12
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K, typename L, typename M
>
typename impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M
>::type
operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g, H const& h, I const& i, J const& j,
K const& k, L const& l, M const& m
) const;
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K, typename L, typename M, typename N
>
typename impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
>::type
operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g, H const& h, I const& i, J const& j,
K const& k, L const& l, M const& m, N const& n
) const;
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K, typename L, typename M, typename N, typename O
>
typename impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
>::type
operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g, H const& h, I const& i, J const& j,
K const& k, L const& l, M const& m, N const& n, O const& o
) const;
#endif
#endif
#endif
#endif
OperationT op;
};
///////////////////////////////////////////////////////////////////////////////
//
// function class implementation
//
///////////////////////////////////////////////////////////////////////////////
template <typename OperationT>
inline actor<composite<OperationT> >
function<OperationT>::operator()() const
{
return actor<composite<OperationT> >(op);
}
//////////////////////////////////
template <typename OperationT>
template <typename A>
inline typename impl::make_composite<OperationT, A>::type
function<OperationT>::operator()(A const& a) const
{
return impl::make_composite<OperationT, A>::composite_type
(
op,
as_actor<A>::convert(a)
);
}
//////////////////////////////////
template <typename OperationT>
template <typename A, typename B>
inline typename impl::make_composite<OperationT, A, B>::type
function<OperationT>::operator()(A const& a, B const& b) const
{
return impl::make_composite<OperationT, A, B>::composite_type
(
op,
as_actor<A>::convert(a),
as_actor<B>::convert(b)
);
}
//////////////////////////////////
template <typename OperationT>
template <typename A, typename B, typename C>
inline typename impl::make_composite<OperationT, A, B, C>::type
function<OperationT>::operator()(A const& a, B const& b, C const& c) const
{
return impl::make_composite<OperationT, A, B, C>::composite_type
(
op,
as_actor<A>::convert(a),
as_actor<B>::convert(b),
as_actor<C>::convert(c)
);
}
#if PHOENIX_LIMIT > 3
//////////////////////////////////
template <typename OperationT>
template <
typename A, typename B, typename C, typename D
>
inline typename impl::make_composite<
OperationT, A, B, C, D
>::type
function<OperationT>::operator()(
A const& a, B const& b, C const& c, D const& d
) const
{
return impl::make_composite<
OperationT, A, B, C, D
>::composite_type
(
op,
as_actor<A>::convert(a),
as_actor<B>::convert(b),
as_actor<C>::convert(c),
as_actor<D>::convert(d)
);
}
//////////////////////////////////
template <typename OperationT>
template <
typename A, typename B, typename C, typename D, typename E
>
inline typename impl::make_composite<
OperationT, A, B, C, D, E
>::type
function<OperationT>::operator()(
A const& a, B const& b, C const& c, D const& d, E const& e
) const
{
return impl::make_composite<
OperationT, A, B, C, D, E
>::composite_type
(
op,
as_actor<A>::convert(a),
as_actor<B>::convert(b),
as_actor<C>::convert(c),
as_actor<D>::convert(d),
as_actor<E>::convert(e)
);
}
//////////////////////////////////
template <typename OperationT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F
>
inline typename impl::make_composite<
OperationT, A, B, C, D, E, F
>::type
function<OperationT>::operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f
) const
{
return impl::make_composite<
OperationT, A, B, C, D, E, F
>::composite_type
(
op,
as_actor<A>::convert(a),
as_actor<B>::convert(b),
as_actor<C>::convert(c),
as_actor<D>::convert(d),
as_actor<E>::convert(e),
as_actor<F>::convert(f)
);
}
#if PHOENIX_LIMIT > 6
//////////////////////////////////
template <typename OperationT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G
>
inline typename impl::make_composite<
OperationT, A, B, C, D, E, F, G
>::type
function<OperationT>::operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g
) const
{
return impl::make_composite<
OperationT, A, B, C, D, E, F, G
>::composite_type
(
op,
as_actor<A>::convert(a),
as_actor<B>::convert(b),
as_actor<C>::convert(c),
as_actor<D>::convert(d),
as_actor<E>::convert(e),
as_actor<F>::convert(f),
as_actor<G>::convert(g)
);
}
//////////////////////////////////
template <typename OperationT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H
>
inline typename impl::make_composite<
OperationT, A, B, C, D, E, F, G, H
>::type
function<OperationT>::operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g, H const& h
) const
{
return impl::make_composite<
OperationT, A, B, C, D, E, F, G, H
>::composite_type
(
op,
as_actor<A>::convert(a),
as_actor<B>::convert(b),
as_actor<C>::convert(c),
as_actor<D>::convert(d),
as_actor<E>::convert(e),
as_actor<F>::convert(f),
as_actor<G>::convert(g),
as_actor<H>::convert(h)
);
}
//////////////////////////////////
template <typename OperationT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I
>
inline typename impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I
>::type
function<OperationT>::operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g, H const& h, I const& i
) const
{
return impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I
>::composite_type
(
op,
as_actor<A>::convert(a),
as_actor<B>::convert(b),
as_actor<C>::convert(c),
as_actor<D>::convert(d),
as_actor<E>::convert(e),
as_actor<F>::convert(f),
as_actor<G>::convert(g),
as_actor<H>::convert(h),
as_actor<I>::convert(i)
);
}
#if PHOENIX_LIMIT > 9
//////////////////////////////////
template <typename OperationT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J
>
inline typename impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J
>::type
function<OperationT>::operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g, H const& h, I const& i, J const& j
) const
{
return impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J
>::composite_type
(
op,
as_actor<A>::convert(a),
as_actor<B>::convert(b),
as_actor<C>::convert(c),
as_actor<D>::convert(d),
as_actor<E>::convert(e),
as_actor<F>::convert(f),
as_actor<G>::convert(g),
as_actor<H>::convert(h),
as_actor<I>::convert(i),
as_actor<J>::convert(j)
);
}
//////////////////////////////////
template <typename OperationT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K
>
inline typename impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J, K
>::type
function<OperationT>::operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g, H const& h, I const& i, J const& j,
K const& k
) const
{
return impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J, K
>::composite_type
(
op,
as_actor<A>::convert(a),
as_actor<B>::convert(b),
as_actor<C>::convert(c),
as_actor<D>::convert(d),
as_actor<E>::convert(e),
as_actor<F>::convert(f),
as_actor<G>::convert(g),
as_actor<H>::convert(h),
as_actor<I>::convert(i),
as_actor<J>::convert(j),
as_actor<K>::convert(k)
);
}
//////////////////////////////////
template <typename OperationT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K, typename L
>
inline typename impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J, K, L
>::type
function<OperationT>::operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g, H const& h, I const& i, J const& j,
K const& k, L const& l
) const
{
return impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J, K, L
>::composite_type
(
op,
as_actor<A>::convert(a),
as_actor<B>::convert(b),
as_actor<C>::convert(c),
as_actor<D>::convert(d),
as_actor<E>::convert(e),
as_actor<F>::convert(f),
as_actor<G>::convert(g),
as_actor<H>::convert(h),
as_actor<I>::convert(i),
as_actor<J>::convert(j),
as_actor<K>::convert(k),
as_actor<L>::convert(l)
);
}
#if PHOENIX_LIMIT > 12
//////////////////////////////////
template <typename OperationT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K, typename L, typename M
>
inline typename impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M
>::type
function<OperationT>::operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g, H const& h, I const& i, J const& j,
K const& k, L const& l, M const& m
) const
{
return impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M
>::composite_type
(
op,
as_actor<A>::convert(a),
as_actor<B>::convert(b),
as_actor<C>::convert(c),
as_actor<D>::convert(d),
as_actor<E>::convert(e),
as_actor<F>::convert(f),
as_actor<G>::convert(g),
as_actor<H>::convert(h),
as_actor<I>::convert(i),
as_actor<J>::convert(j),
as_actor<K>::convert(k),
as_actor<L>::convert(l),
as_actor<M>::convert(m)
);
}
//////////////////////////////////
template <typename OperationT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K, typename L, typename M, typename N
>
inline typename impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
>::type
function<OperationT>::operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g, H const& h, I const& i, J const& j,
K const& k, L const& l, M const& m, N const& n
) const
{
return impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N
>::composite_type
(
op,
as_actor<A>::convert(a),
as_actor<B>::convert(b),
as_actor<C>::convert(c),
as_actor<D>::convert(d),
as_actor<E>::convert(e),
as_actor<F>::convert(f),
as_actor<G>::convert(g),
as_actor<H>::convert(h),
as_actor<I>::convert(i),
as_actor<J>::convert(j),
as_actor<K>::convert(k),
as_actor<L>::convert(l),
as_actor<M>::convert(m),
as_actor<N>::convert(n)
);
}
//////////////////////////////////
template <typename OperationT>
template <
typename A, typename B, typename C, typename D, typename E,
typename F, typename G, typename H, typename I, typename J,
typename K, typename L, typename M, typename N, typename O
>
inline typename impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
>::type
function<OperationT>::operator()(
A const& a, B const& b, C const& c, D const& d, E const& e,
F const& f, G const& g, H const& h, I const& i, J const& j,
K const& k, L const& l, M const& m, N const& n, O const& o
) const
{
return impl::make_composite<
OperationT, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O
>::composite_type
(
op,
as_actor<A>::convert(a),
as_actor<B>::convert(b),
as_actor<C>::convert(c),
as_actor<D>::convert(d),
as_actor<E>::convert(e),
as_actor<F>::convert(f),
as_actor<G>::convert(g),
as_actor<H>::convert(h),
as_actor<I>::convert(i),
as_actor<J>::convert(j),
as_actor<K>::convert(k),
as_actor<L>::convert(l),
as_actor<M>::convert(m),
as_actor<N>::convert(n),
as_actor<O>::convert(o)
);
}
#endif
#endif
#endif
#endif
///////////////////////////////////////////////////////////////////////////////
} // namespace phoenix
#endif

2215
include/boost/spirit/phoenix/operators.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

249
include/boost/spirit/phoenix/primitives.hpp Normal file
View File

@@ -0,0 +1,249 @@
/*=============================================================================
Phoenix V1.0
Copyright (c) 2001-2002 Joel de Guzman
Permission to copy, use, modify, sell and distribute this software
is granted provided this copyright notice appears in all copies.
This software is provided "as is" without express or implied
warranty, and with no claim as to its suitability for any purpose.
==============================================================================*/
#ifndef PHOENIX_PRIMITIVES_HPP
#define PHOENIX_PRIMITIVES_HPP
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/phoenix/actor.hpp"
///////////////////////////////////////////////////////////////////////////////
namespace phoenix {
///////////////////////////////////////////////////////////////////////////////
//
// argument class
//
// Lazy arguments
//
// An actor base class that extracts and returns the Nth argument
// from the argument list passed in the 'args' tuple in the eval
// member function (see actor.hpp). There are some predefined
// argument constants that can be used as actors (arg1..argN).
//
// The argument actor is a place-holder for the actual arguments
// passed by the client. For example, wherever arg1 is seen placed
// in a lazy function (see functions.hpp) or lazy operator (see
// operators.hpp), this will be replaced by the actual first
// argument in the actual function evaluation. Argument actors are
// essentially lazy arguments. A lazy argument is a full actor in
// its own right and can be evaluated through the actor's operator().
//
// Example:
//
// char c = 'A';
// int i = 123;
// const char* s = "Hello World";
//
// cout << arg1(c) << ' ';
// cout << arg1(i, s) << ' ';
// cout << arg2(i, s) << ' ';
//
// will print out "A 123 Hello World"
//
///////////////////////////////////////////////////////////////////////////////
template <int N>
struct argument {
template <typename TupleT>
struct result { typedef typename tuple_element<N, TupleT>::type type; };
template <typename TupleT>
typename tuple_element<N, TupleT>::type
eval(TupleT const& args) const
{
return args[tuple_index<N>()];
}
};
//////////////////////////////////
actor<argument<0> > const arg1 = argument<0>();
actor<argument<1> > const arg2 = argument<1>();
actor<argument<2> > const arg3 = argument<2>();
#if PHOENIX_LIMIT > 3
actor<argument<3> > const arg4 = argument<3>();
actor<argument<4> > const arg5 = argument<4>();
actor<argument<5> > const arg6 = argument<5>();
#if PHOENIX_LIMIT > 6
actor<argument<6> > const arg7 = argument<6>();
actor<argument<7> > const arg8 = argument<7>();
actor<argument<8> > const arg9 = argument<8>();
#if PHOENIX_LIMIT > 9
actor<argument<9> > const arg10 = argument<9>();
actor<argument<10> > const arg11 = argument<10>();
actor<argument<11> > const arg12 = argument<11>();
#if PHOENIX_LIMIT > 12
actor<argument<12> > const arg13 = argument<12>();
actor<argument<13> > const arg14 = argument<13>();
actor<argument<14> > const arg15 = argument<14>();
#endif
#endif
#endif
#endif
///////////////////////////////////////////////////////////////////////////////
//
// value class
//
// Lazy values
//
// A bound actual parameter is kept in a value class for deferred
// access later when needed. A value object is immutable. Value
// objects are typically created through the val(x) free function
// which returns a value<T> with T deduced from the type of x. x is
// held in the value<T> object by value.
//
// Lazy values are actors. As such, lazy values can be evaluated
// through the actor's operator(). Such invocation gives the value's
// identity. Example:
//
// cout << val(3)() << val("Hello World")();
//
// prints out "3 Hello World"
//
///////////////////////////////////////////////////////////////////////////////
template <typename T>
struct value {
typedef typename boost::remove_reference<T>::type plain_t;
template <typename TupleT>
struct result { typedef plain_t const type; };
value(plain_t val_)
: val(val_) {}
template <typename TupleT>
plain_t const
eval(TupleT const& /*args*/) const
{
return val;
}
plain_t val;
};
//////////////////////////////////
template <typename T>
inline actor<value<T> > const
val(T v)
{
return value<T>(v);
}
//////////////////////////////////
template <typename BaseT>
void
val(actor<BaseT> const& v); // This is undefined and not allowed.
///////////////////////////////////////////////////////////////////////////
//
// Arbitrary types T are typically converted to a actor<value<T> >
// (see as_actor<T> in actor.hpp). A specialization is also provided
// for arrays. T[N] arrays are converted to actor<value<T const*> >.
//
///////////////////////////////////////////////////////////////////////////
template <typename T>
struct as_actor {
typedef actor<value<T> > type;
static type convert(T const& x)
{ return value<T>(x); }
};
//////////////////////////////////
template <typename T, int N>
struct as_actor<T[N]> {
typedef actor<value<T const*> > type;
static type convert(T const x[N])
{ return value<T const*>(x); }
};
///////////////////////////////////////////////////////////////////////////////
//
// variable class
//
// Lazy variables
//
// A bound actual parameter may also be held by non-const reference
// in a variable class for deferred access later when needed. A
// variable object is mutable, i.e. its referenced variable can be
// modified. Variable objects are typically created through the
// var(x) free function which returns a variable<T> with T deduced
// from the type of x. x is held in the value<T> object by
// reference.
//
// Lazy variables are actors. As such, lazy variables can be
// evaluated through the actor's operator(). Such invocation gives
// the variables's identity. Example:
//
// int i = 3;
// char const* s = "Hello World";
// cout << var(i)() << var(s)();
//
// prints out "3 Hello World"
//
// Another free function const_(x) may also be used. const_(x) creates
// a variable<T const&> object using a constant reference.
//
///////////////////////////////////////////////////////////////////////////////
template <typename T>
struct variable {
template <typename TupleT>
struct result { typedef T& type; };
variable(T& var_)
: var(var_) {}
template <typename TupleT>
T&
eval(TupleT const& /*args*/) const
{
return var;
}
T& var;
};
//////////////////////////////////
template <typename T>
inline actor<variable<T> > const
var(T& v)
{
return variable<T>(v);
}
//////////////////////////////////
template <typename T>
inline actor<variable<T const> > const
const_(T const& v)
{
return variable<T const>(v);
}
//////////////////////////////////
template <typename BaseT>
void
var(actor<BaseT> const& v); // This is undefined and not allowed.
//////////////////////////////////
template <typename BaseT>
void
const_(actor<BaseT> const& v); // This is undefined and not allowed.
///////////////////////////////////////////////////////////////////////////////
} // namespace phoenix
#endif

343
include/boost/spirit/phoenix/special_ops.hpp Normal file
View File

@@ -0,0 +1,343 @@
/*=============================================================================
Phoenix V1.0
Copyright (c) 2001-2002 Joel de Guzman
Permission to copy, use, modify, sell and distribute this software
is granted provided this copyright notice appears in all copies.
This software is provided "as is" without express or implied
warranty, and with no claim as to its suitability for any purpose.
==============================================================================*/
#ifndef PHOENIX_SPECIAL_OPS_HPP
#define PHOENIX_SPECIAL_OPS_HPP
#include "boost/config.hpp"
#ifdef BOOST_NO_STRINGSTREAM
#include <strstream>
#define PHOENIX_SSTREAM strstream
#else
#include <sstream>
#define PHOENIX_SSTREAM stringstream
#endif
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/phoenix/operators.hpp"
#include <iosfwd>
///////////////////////////////////////////////////////////////////////////////
#if defined(_STLPORT_VERSION) && defined(__STL_USE_OWN_NAMESPACE)
#define PHOENIX_STD _STLP_STD
#define PHOENIX_NO_STD_NAMESPACE
#else
#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
{
///////////////////////////////////////////////////////////////////////////////
//
// The following specializations take into account the C++ standard
// library components. There are a couple of issues that has to be
// dealt with to enable lazy operator overloads for the standard
// library classes.
//
// *iostream (e.g. cout, cin, strstream/ stringstream) uses non-
// canonical shift operator overloads where the lhs is taken in
// by reference.
//
// *I/O manipulators overloads for the RHS of the << and >>
// operators.
//
// *STL iterators can be objects that conform to pointer semantics.
// Some operators need to be specialized for these.
//
// *std::complex is given a rank (see rank class in operators.hpp)
//
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//
// specialization for rank<std::complex>
//
///////////////////////////////////////////////////////////////////////////////
template <typename T> struct rank<PHOENIX_STD::complex<T> >
{ static int const value = 170 + rank<T>::value; };
///////////////////////////////////////////////////////////////////////////////
//
// specializations for std::istream
//
///////////////////////////////////////////////////////////////////////////////
#if defined(__GNUC__) && (__GNUC__ < 3)
#if defined(_STLPORT_VERSION)
#define PHOENIX_ISTREAM _IO_istream_withassign
#else
#define PHOENIX_ISTREAM PHOENIX_STD::_IO_istream_withassign
#endif
#else
#if (defined(__ICL) && defined(_STLPORT_VERSION))
#define PHOENIX_ISTREAM istream_withassign
#else
#define PHOENIX_ISTREAM PHOENIX_STD::istream
#endif
#endif
//////////////////////////////////
#if defined(__GNUC__) && (__GNUC__ < 3) \
|| (defined(__ICL) && defined(_STLPORT_VERSION))
template <typename T1>
struct binary_operator<shift_r_op, PHOENIX_ISTREAM, T1>
{
typedef PHOENIX_STD::istream& result_type;
static result_type eval(PHOENIX_STD::istream& out, T1& rhs)
{ return out >> rhs; }
};
#endif
//////////////////////////////////
template <typename T1>
struct binary_operator<shift_r_op, PHOENIX_STD::istream, T1>
{
typedef PHOENIX_STD::istream& result_type;
static result_type eval(PHOENIX_STD::istream& out, T1& rhs)
{ return out >> rhs; }
};
//////////////////////////////////
template <typename BaseT>
inline typename impl::make_binary3
<shift_r_op, variable<PHOENIX_ISTREAM>, BaseT>::type
operator>>(PHOENIX_ISTREAM& _0, actor<BaseT> const& _1)
{
return impl::make_binary3
<shift_r_op, variable<PHOENIX_ISTREAM>, BaseT>
::construct(var(_0), _1);
}
#undef PHOENIX_ISTREAM
///////////////////////////////////////////////////////////////////////////////
//
// specializations for std::ostream
//
///////////////////////////////////////////////////////////////////////////////
#if defined(__GNUC__) && (__GNUC__ < 3)
#if defined(_STLPORT_VERSION)
#define PHOENIX_OSTREAM _IO_ostream_withassign
#else
#define PHOENIX_OSTREAM PHOENIX_STD::_IO_ostream_withassign
#endif
#else
#if (defined(__ICL) && defined(_STLPORT_VERSION))
#define PHOENIX_OSTREAM ostream_withassign
#else
#define PHOENIX_OSTREAM PHOENIX_STD::ostream
#endif
#endif
//////////////////////////////////
#if defined(__GNUC__) && (__GNUC__ < 3) \
|| (defined(__ICL) && defined(_STLPORT_VERSION))
template <typename T1>
struct binary_operator<shift_l_op, PHOENIX_OSTREAM, T1>
{
typedef PHOENIX_STD::ostream& result_type;
static result_type eval(PHOENIX_STD::ostream& out, T1 const& rhs)
{ return out << rhs; }
};
#endif
//////////////////////////////////
template <typename T1>
struct binary_operator<shift_l_op, PHOENIX_STD::ostream, T1>
{
typedef PHOENIX_STD::ostream& result_type;
static result_type eval(PHOENIX_STD::ostream& out, T1 const& rhs)
{ return out << rhs; }
};
//////////////////////////////////
template <typename BaseT>
inline typename impl::make_binary3
<shift_l_op, variable<PHOENIX_OSTREAM>, BaseT>::type
operator<<(PHOENIX_OSTREAM& _0, actor<BaseT> const& _1)
{
return impl::make_binary3
<shift_l_op, variable<PHOENIX_OSTREAM>, BaseT>
::construct(var(_0), _1);
}
#undef PHOENIX_OSTREAM
///////////////////////////////////////////////////////////////////////////////
//
// specializations for std::strstream / stringstream
//
///////////////////////////////////////////////////////////////////////////////
template <typename T1>
struct binary_operator<shift_r_op, PHOENIX_STD::PHOENIX_SSTREAM, T1>
{
typedef PHOENIX_STD::istream& result_type;
static result_type eval(PHOENIX_STD::istream& out, T1& rhs)
{ return out >> rhs; }
};
//////////////////////////////////
template <typename BaseT>
inline typename impl::make_binary3
<shift_r_op, variable<PHOENIX_STD::PHOENIX_SSTREAM>, BaseT>::type
operator>>(PHOENIX_STD::PHOENIX_SSTREAM& _0, actor<BaseT> const& _1)
{
return impl::make_binary3
<shift_r_op, variable<PHOENIX_STD::PHOENIX_SSTREAM>, BaseT>
::construct(var(_0), _1);
}
//////////////////////////////////
template <typename T1>
struct binary_operator<shift_l_op, PHOENIX_STD::PHOENIX_SSTREAM, T1>
{
typedef PHOENIX_STD::ostream& result_type;
static result_type eval(PHOENIX_STD::ostream& out, T1 const& rhs)
{ return out << rhs; }
};
//////////////////////////////////
template <typename BaseT>
inline typename impl::make_binary3
<shift_l_op, variable<PHOENIX_STD::PHOENIX_SSTREAM>, BaseT>::type
operator<<(PHOENIX_STD::PHOENIX_SSTREAM& _0, actor<BaseT> const& _1)
{
return impl::make_binary3
<shift_l_op, variable<PHOENIX_STD::PHOENIX_SSTREAM>, BaseT>
::construct(var(_0), _1);
}
///////////////////////////////////////////////////////////////////////////////
//
// I/O manipulator specializations
//
///////////////////////////////////////////////////////////////////////////////
#if (!defined(__GNUC__) || (__GNUC__ > 2)) \
&& !(defined(__ICL) && defined(_STLPORT_VERSION))
typedef PHOENIX_STD::ios_base& (*iomanip_t)(PHOENIX_STD::ios_base&);
typedef PHOENIX_STD::istream& (*imanip_t)(PHOENIX_STD::istream&);
typedef PHOENIX_STD::ostream& (*omanip_t)(PHOENIX_STD::ostream&);
#if defined(__BORLANDC__)
///////////////////////////////////////////////////////////////////////////////
//
// Borland does not like i/o manipulators functions such as endl to
// be the rhs of a lazy << operator (Borland incorrectly reports
// ambiguity). To get around the problem, we provide function
// pointer versions of the same name with a single trailing
// underscore.
//
// You can use the same trick for other i/o manipulators.
// Alternatively, you can prefix the manipulator with a '&'
// operator. Example:
//
// cout << arg1 << &endl
//
///////////////////////////////////////////////////////////////////////////////
imanip_t ws_ = &PHOENIX_STD::ws;
iomanip_t dec_ = &PHOENIX_STD::dec;
iomanip_t hex_ = &PHOENIX_STD::hex;
iomanip_t oct_ = &PHOENIX_STD::oct;
omanip_t endl_ = &PHOENIX_STD::endl;
omanip_t ends_ = &PHOENIX_STD::ends;
omanip_t flush_ = &PHOENIX_STD::flush;
#else // __BORLANDC__
///////////////////////////////////////////////////////////////////////////////
//
// The following are overloads for I/O manipulators.
//
///////////////////////////////////////////////////////////////////////////////
template <typename BaseT>
inline typename impl::make_binary1<shift_l_op, BaseT, imanip_t>::type
operator>>(actor<BaseT> const& _0, imanip_t _1)
{
return impl::make_binary1<shift_l_op, BaseT, imanip_t>::construct(_0, _1);
}
//////////////////////////////////
template <typename BaseT>
inline typename impl::make_binary1<shift_l_op, BaseT, iomanip_t>::type
operator>>(actor<BaseT> const& _0, iomanip_t _1)
{
return impl::make_binary1<shift_l_op, BaseT, iomanip_t>::construct(_0, _1);
}
//////////////////////////////////
template <typename BaseT>
inline typename impl::make_binary1<shift_l_op, BaseT, omanip_t>::type
operator<<(actor<BaseT> const& _0, omanip_t _1)
{
return impl::make_binary1<shift_l_op, BaseT, omanip_t>::construct(_0, _1);
}
//////////////////////////////////
template <typename BaseT>
inline typename impl::make_binary1<shift_l_op, BaseT, iomanip_t>::type
operator<<(actor<BaseT> const& _0, iomanip_t _1)
{
return impl::make_binary1<shift_l_op, BaseT, iomanip_t>::construct(_0, _1);
}
#endif // __BORLANDC__
#endif // !defined(__GNUC__) || (__GNUC__ > 2)
///////////////////////////////////////////////////////////////////////////////
//
// specializations for stl iterators and containers
//
///////////////////////////////////////////////////////////////////////////////
template <typename T>
struct unary_operator<dereference_op, T>
{
typedef typename T::reference result_type;
static result_type eval(T const& iter)
{ return *iter; }
};
//////////////////////////////////
template <typename T0, typename T1>
struct binary_operator<index_op, T0, T1>
{
typedef typename T0::reference result_type;
static result_type eval(T0& container, T1 const& index)
{ return container[index]; }
};
//////////////////////////////////
template <typename T0, typename T1>
struct binary_operator<index_op, T0 const, T1>
{
typedef typename T0::const_reference result_type;
static result_type eval(T0 const& container, T1 const& index)
{ return container[index]; }
};
///////////////////////////////////////////////////////////////////////////////
} // namespace phoenix
#undef PHOENIX_SSTREAM
#undef PHOENIX_STD
#endif

445
include/boost/spirit/phoenix/statements.hpp Normal file
View File

@@ -0,0 +1,445 @@
/*=============================================================================
Phoenix V1.0
Copyright (c) 2001-2002 Joel de Guzman
Permission to copy, use, modify, sell and distribute this software
is granted provided this copyright notice appears in all copies.
This software is provided "as is" without express or implied
warranty, and with no claim as to its suitability for any purpose.
==============================================================================*/
#ifndef PHOENIX_STATEMENTS_HPP
#define PHOENIX_STATEMENTS_HPP
///////////////////////////////////////////////////////////////////////////////
#include "boost/spirit/phoenix/composite.hpp"
///////////////////////////////////////////////////////////////////////////////
namespace phoenix {
///////////////////////////////////////////////////////////////////////////////
//
// sequential_composite
//
// Two or more actors separated by the comma generates a
// sequential_composite which is a composite actor. Example:
//
// actor,
// actor,
// actor
//
// The actors are evaluated sequentially. The result type of this
// is void. Note that the last actor should not have a trailing
// comma.
//
///////////////////////////////////////////////////////////////////////////////
template <typename A0, typename A1>
struct sequential_composite {
typedef sequential_composite<A0, A1> self_t;
template <typename TupleT>
struct result { typedef void type; };
sequential_composite(A0 const& _0, A1 const& _1)
: a0(_0), a1(_1) {}
template <typename TupleT>
void
eval(TupleT const& args) const
{
a0.eval(args);
a1.eval(args);
}
A0 a0; A1 a1; // actors
};
//////////////////////////////////
template <typename BaseT0, typename BaseT1>
inline actor<sequential_composite<actor<BaseT0>, actor<BaseT1> > >
operator,(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
{
return sequential_composite<actor<BaseT0>, actor<BaseT1> >(_0, _1);
}
///////////////////////////////////////////////////////////////////////////////
//
// if_then_else_composite
//
// This composite has two (2) forms:
//
// if_(condition)
// [
// statement
// ]
//
// and
//
// if_(condition)
// [
// true_statement
// ]
// .else_
// [
// false_statement
// ]
//
// where condition is an actor that evaluates to bool. If condition
// is true, the true_statement (again an actor) is executed
// otherwise, the false_statement (another actor) is executed. The
// result type of this is void. Note the trailing underscore after
// if_ and the the leading dot and the trailing underscore before
// and after .else_.
//
///////////////////////////////////////////////////////////////////////////////
template <typename CondT, typename ThenT, typename ElseT>
struct if_then_else_composite {
typedef if_then_else_composite<CondT, ThenT, ElseT> self_t;
template <typename TupleT>
struct result {
typedef void type;
};
if_then_else_composite(
CondT const& cond_,
ThenT const& then_,
ElseT const& else__)
: cond(cond_), then(then_), else_(else__) {}
template <typename TupleT>
void eval(TupleT const& args) const
{
if (cond.eval(args))
then.eval(args);
else
else_.eval(args);
}
CondT cond; ThenT then; ElseT else_; // actors
};
//////////////////////////////////
template <typename CondT, typename ThenT>
struct else_gen {
else_gen(CondT const& cond_, ThenT const& then_)
: cond(cond_), then(then_) {}
template <typename ElseT>
actor<if_then_else_composite<CondT, ThenT,
typename as_actor<ElseT>::type> >
operator[](ElseT const& else_)
{
typedef if_then_else_composite<CondT, ThenT,
typename as_actor<ElseT>::type>
result;
return result(cond, then, as_actor<ElseT>::convert(else_));
}
CondT cond; ThenT then;
};
//////////////////////////////////
template <typename CondT, typename ThenT>
struct if_then_composite {
typedef if_then_composite<CondT, ThenT> self_t;
template <typename TupleT>
struct result { typedef void type; };
if_then_composite(CondT const& cond_, ThenT const& then_)
: cond(cond_), then(then_), else_(cond, then) {}
template <typename TupleT>
void eval(TupleT const& args) const
{
if (cond.eval(args))
then.eval(args);
}
CondT cond; ThenT then; // actors
else_gen<CondT, ThenT> else_;
};
//////////////////////////////////
template <typename CondT>
struct if_gen {
if_gen(CondT const& cond_)
: cond(cond_) {}
template <typename ThenT>
actor<if_then_composite<
typename as_actor<CondT>::type,
typename as_actor<ThenT>::type> >
operator[](ThenT const& then) const
{
typedef if_then_composite<
typename as_actor<CondT>::type,
typename as_actor<ThenT>::type>
result;
return result(
as_actor<CondT>::convert(cond),
as_actor<ThenT>::convert(then));
}
CondT cond;
};
//////////////////////////////////
template <typename CondT>
inline if_gen<CondT>
if_(CondT const& cond)
{
return if_gen<CondT>(cond);
}
///////////////////////////////////////////////////////////////////////////////
//
// while_composite
//
// This composite has the form:
//
// while_(condition)
// [
// statement
// ]
//
// While the condition (an actor) evaluates to true, statement
// (another actor) is executed. The result type of this is void.
// Note the trailing underscore after while_.
//
///////////////////////////////////////////////////////////////////////////////
template <typename CondT, typename DoT>
struct while_composite {
typedef while_composite<CondT, DoT> self_t;
template <typename TupleT>
struct result { typedef void type; };
while_composite(CondT const& cond_, DoT const& do__)
: cond(cond_), do_(do__) {}
template <typename TupleT>
void eval(TupleT const& args) const
{
while (cond.eval(args))
do_.eval(args);
}
CondT cond;
DoT do_;
};
//////////////////////////////////
template <typename CondT>
struct while_gen {
while_gen(CondT const& cond_)
: cond(cond_) {}
template <typename DoT>
actor<while_composite<
typename as_actor<CondT>::type,
typename as_actor<DoT>::type> >
operator[](DoT const& do_) const
{
typedef while_composite<
typename as_actor<CondT>::type,
typename as_actor<DoT>::type>
result;
return result(
as_actor<CondT>::convert(cond),
as_actor<DoT>::convert(do_));
}
CondT cond;
};
//////////////////////////////////
template <typename CondT>
inline while_gen<CondT>
while_(CondT const& cond)
{
return while_gen<CondT>(cond);
}
///////////////////////////////////////////////////////////////////////////////
//
// do_composite
//
// This composite has the form:
//
// do_
// [
// statement
// ]
// .while_(condition)
//
// While the condition (an actor) evaluates to true, statement
// (another actor) is executed. The statement is executed at least
// once. The result type of this is void. Note the trailing
// underscore after do_ and the the leading dot and the trailing
// underscore before and after .while_.
//
///////////////////////////////////////////////////////////////////////////////
template <typename DoT, typename CondT>
struct do_composite {
typedef do_composite<DoT, CondT> self_t;
template <typename TupleT>
struct result { typedef void type; };
do_composite(DoT const& do__, CondT const& cond_)
: do_(do__), cond(cond_) {}
template <typename TupleT>
void eval(TupleT const& args) const
{
do
do_.eval(args);
while (cond.eval(args));
}
DoT do_;
CondT cond;
};
////////////////////////////////////
template <typename DoT>
struct do_gen2 {
do_gen2(DoT const& do__)
: do_(do__) {}
template <typename CondT>
actor<do_composite<
typename as_actor<DoT>::type,
typename as_actor<CondT>::type> >
while_(CondT const& cond) const
{
typedef do_composite<
typename as_actor<DoT>::type,
typename as_actor<CondT>::type>
result;
return result(
as_actor<DoT>::convert(do_),
as_actor<CondT>::convert(cond));
}
DoT do_;
};
////////////////////////////////////
struct do_gen {
template <typename DoT>
do_gen2<DoT>
operator[](DoT const& do_) const
{
return do_gen2<DoT>(do_);
}
};
do_gen const do_ = do_gen();
///////////////////////////////////////////////////////////////////////////////
//
// for_composite
//
// This statement has the form:
//
// for_(init, condition, step)
// [
// statement
// ]
//
// Where init, condition, step and statement are all actors. init
// is executed once before entering the for-loop. The for-loop
// exits once condition evaluates to false. At each loop iteration,
// step and statement is called. The result of this statement is
// void. Note the trailing underscore after for_.
//
///////////////////////////////////////////////////////////////////////////////
template <typename InitT, typename CondT, typename StepT, typename DoT>
struct for_composite {
typedef composite<InitT, CondT, StepT, DoT> self_t;
template <typename TupleT>
struct result { typedef void type; };
for_composite(
InitT const& init_,
CondT const& cond_,
StepT const& step_,
DoT const& do__)
: init(init_), cond(cond_), step(step_), do_(do__) {}
template <typename TupleT>
void
eval(TupleT const& args) const
{
for (init.eval(args); cond.eval(args); step.eval(args))
do_.eval(args);
}
InitT init; CondT cond; StepT step; DoT do_; // actors
};
//////////////////////////////////
template <typename InitT, typename CondT, typename StepT>
struct for_gen {
for_gen(
InitT const& init_,
CondT const& cond_,
StepT const& step_)
: init(init_), cond(cond_), step(step_) {}
template <typename DoT>
actor<for_composite<
typename as_actor<InitT>::type,
typename as_actor<CondT>::type,
typename as_actor<StepT>::type,
typename as_actor<DoT>::type> >
operator[](DoT const& do_) const
{
typedef for_composite<
typename as_actor<InitT>::type,
typename as_actor<CondT>::type,
typename as_actor<StepT>::type,
typename as_actor<DoT>::type>
result;
return result(
as_actor<InitT>::convert(init),
as_actor<CondT>::convert(cond),
as_actor<StepT>::convert(step),
as_actor<DoT>::convert(do_));
}
InitT init; CondT cond; StepT step;
};
//////////////////////////////////
template <typename InitT, typename CondT, typename StepT>
inline for_gen<InitT, CondT, StepT>
for_(InitT const& init, CondT const& cond, StepT const& step)
{
return for_gen<InitT, CondT, StepT>(init, cond, step);
}
} // namespace phoenix
#endif

1077
include/boost/spirit/phoenix/tuple_helpers.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

1297
include/boost/spirit/phoenix/tuples.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More