Hi!
Though I appreciate simple examples in the docs it is indeed
helpful to have examples with fully qualified names.
I am having hard times figuring out which versions of "_1", "at_c", etc.
are in use. the fusion/phoenix/proto/mpl chaos is hard to keep track of.
In summary: using declaratives are nice for toy examples but drive
you nuts, once you #include more files and have ADL destroying the idyll
of simplicity.
Below is a piece of code that nearly compiles. One line has a problem:
A semantic action, namely a push_back fails under vc8 and the error
message is far from being helpful.
So could you please be so nice and give me some hint on how to fix this.
(BTW, Joel: "iter+30" directives from the spirit2 examples are
assert-catched by the VC8 debugging STL, so I changed that part
a little bit to first check the distance and doing iterator
arithmetics afterwards. See below.)
best regards,
Markus
---snip---
#define BOOST_SPIRIT_DEBUG_OUT std::cerr
#define BOOST_SPIRIT_DEBUG
#include "Enforce.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include <list>
#include <string>
#include <vector>
#include <iostream>
#include <iterator>
using namespace boost::spirit;
using namespace boost::spirit::qi;
using namespace boost::spirit::ascii;
using namespace boost::spirit::arg_names;
using boost::phoenix::push_back;
namespace fusion = boost::fusion;
namespace phoenix = boost::phoenix;
namespace
{
////////////////////////////////////////////////////////////////////////////////
// parser traits
struct parser_traits
{
template struct parser;
#define PARSER_TRAITS(TYPE, PARSER_T) \
template <int Dummy> struct parser \
{ \
typedef PARSER_T type; \
\
static inline \
PARSER_T p() \
{ \
PARSER_T result; \
return result; \
} \
}
// int
PARSER_TRAITS(int, int_type);
// unsigned int
PARSER_TRAITS(unsigned int, uint_type);
// double
PARSER_TRAITS(double, double_type);
};
////////////////////////////////////////////////////////////////////////////////
// parser
template struct tuple_grammar;
template
struct
tuple_grammar >
: grammar >(),
space_type>
{
typename parser_traits::parser<T1>::type p1;
typename parser_traits::parser<T2>::type p2;
typedef typename std::tr1::tuple tuple_t;
tuple_grammar()
: tuple_grammar::base_type(rule_tuple_list)
{
using phoenix::at_c;
using boost::spirit::arg_names::_1;
// using boost::spirit::container::push_back;
using boost::phoenix::push_back;
rule_tuple =
'('
>> p1[at_c<0>(_val) = _1]
>> ','
>> p2[at_c<1>(_val) = _1]
>> ')'
;
rule_tuple_list =
// COMPILER FALS ON THIS SEMANTIC ACTION - WHY?
*(rule_tuple[push_back(ref(_val), _1)])
;
}
rule rule_tuple;
rule(), space_type> rule_tuple_list;
};
////////////////////////////////////////////////////////////////////////////////
// string_to_list_of_tuples
template <typename Tuple> struct string_to_list_of_tuples;
template
struct
string_to_list_of_tuples >
{
typedef std::tr1::tuple tuple_t;
static
std::list
apply(std::string const & s)
{
std::list result;
typedef tuple_grammar
tuple_grammar;
tuple_grammar tg;
std::string::const_iterator iter = s.begin();
std::string::const_iterator end = s.end();
bool r = phrase_parse(iter, end, tg, result, space);
if (r && iter == end)
{
std::cout << "-------------------------\n";
std::cout << "Parsing succeeded\n";
std::cout << "-------------------------\n";
}
else
{
std::size_t dist = std::distance(iter, end);
std::string::const_iterator some = dist > 30 ? iter+30 : end;
std::string context(iter, some);
std::cout << "-------------------------\n";
std::cout << "Parsing failed\n";
std::cout << "stopped at: \"" << context << "...\"\n";
std::cout << "-------------------------\n";
}
return result;
}
};
} // namespace
int main()
{
try
{
{
typedef std::tr1::tuple tuple_t;
std::list test =
string_to_list_of_tuples::apply
(" ( 1, 2 ) ( 3, 4)(5,6)");
std::copy(test.begin(), test.end(),
std::ostream_iterator(std::cout, "\n"));
}
// {
// typedef std::tr1::tuple tuple_t;
// std::list test =
// string_to_list_of_tuples::apply
// (" ( 1, -2 , 5.123) ( 3, 4,7.9)(5,6,8.6789)");
// std::copy(test.begin(), test.end(),
// std::ostream_iterator(std::cout, "\n"));
// }
}
catch (std::exception const & e)
{
std::cerr << e.what() << std::endl;
}
}
