как заставить дух qi :: as_string работать с повтором?

По какой-то странной причине я не могу получить qi::as_string[] работать с repeat()[],

анализ std::string str = { "{ +100S+++ ;\n }" };Я получаю следующее ВЫХОД

PLUS OR MINUS+
THREE PLUS OR MINUS
PARSED FINE
-------------------------
Parsing succeeded
-------------------------

который показывает, что разбор был в порядке, первый + был захвачен, но не последующие три +++,

НОТА Я просто пытаюсь получить three_plus_or_minus захватить от одного до трех плюсов или минусов подряд в виде строки. Альтернативные решения, которые не используют as_string[] будет также оценен.

Я извиняюсь за длинный список, но мне нужно использовать и лексер, и парсер в моем реальном коде.

КОД

// --------------  Third Party  --------------
#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/lex_lexertl.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>

// --------------  C++ stdlib   --------------
#include <iostream>
#include <fstream>
#include <string>

using namespace boost::spirit;
using boost::phoenix::val;

enum token_ids
{
ID_CONSTANT = 1000,
ID_INTEGER,
ID_TAG,
ID_IDENTIFIER
};

template <typename Lexer>
struct example6_tokens : lex::lexer<Lexer>
{
example6_tokens()
{
identifier = "[a-zA-Z_][a-zA-Z0-9_]*";
constant   = "[0-9]+";

tag           = "sl|s|l|tl|SL|S|L|TSL|""z|r|i|Z|R|I|""<>|><|<<>>|>><<|><><|<><>";

this->self = lex::token_def<>('(') | ')' | '{' | '}'
| '=' | ';' | ':' | '+' | '-';

this->self.add
(constant,        ID_CONSTANT       )
(tag,             ID_TAG            )
(identifier,      ID_IDENTIFIER     )
;

this->self("WS")
=   lex::token_def<>("[ \\t\\n]+")
|   "\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\/"|   "\\/\\/[^\n]*";
}
lex::token_def<std::string>   identifier, tag;
lex::token_def<unsigned int>  constant;
};

// ----------------------------------------------------------------------------
template <typename Iterator, typename Lexer>
struct example6_grammar
: qi::grammar<Iterator, qi::in_state_skipper<Lexer> >
{
template <typename TokenDef>
example6_grammar(TokenDef const& tok)
: example6_grammar::base_type(program)
{
using boost::spirit::_val;

program
=  +block
;

block
=   '{' >> *slsltl_stmt >> '}'
;

plus_or_minus
%=   ( qi::as_string[ qi::lit( '+' ) ] | qi::as_string[ '-' ])
[
std::cout << val("PLUS OR MINUS") << val( _1 ) << "\n"]
;

three_plus_or_minus
%=   ( qi::as_string[ repeat(1,3)['+'] ] | qi::as_string[ repeat(1,3)['-'] ] )
[
std::cout << val("THREE PLUS OR MINUS") << val( _1 ) << "\n"]
;

slsltl_stmt
=  (  - plus_or_minus
>> token(ID_CONSTANT)
>> token(ID_TAG)
>> three_plus_or_minus
>> ';'
)
[
std::cout << val("PARSED FINE") << "\n"]
;

expression
=   tok.identifier [ _val = _1 ]
|   tok.constant   [ _val = _1 ]
;
}

typedef boost::variant<unsigned int, std::string> expression_type;

qi::rule<Iterator, qi::in_state_skipper<Lexer> > program, block;
qi::rule<Iterator, std::string(), qi::in_state_skipper<Lexer> >
plus_or_minus, three_plus_or_minus;
qi::rule<Iterator, std::string(), qi::in_state_skipper<Lexer> > slsltl_stmt;
qi::rule<Iterator, expression_type(), qi::in_state_skipper<Lexer> >  expression;
};

int
main( int argv, char* argc[] )
{
typedef std::string::iterator base_iterator_type;
typedef lex::lexertl::token<
base_iterator_type, boost::mpl::vector<unsigned int, std::string>
> token_type;

typedef lex::lexertl::lexer<token_type> lexer_type;
typedef example6_tokens<lexer_type> example6_tokens;
typedef example6_tokens::iterator_type iterator_type;
typedef example6_grammar<iterator_type, example6_tokens::lexer_def> example6_grammar;

example6_tokens tokens;                         // Our lexer
example6_grammar calc(tokens);                  // Our parser
std::string str = { "{ +100S+++ ;\n }" };

std::string::iterator it = str.begin();
iterator_type iter = tokens.begin(it, str.end());
iterator_type end = tokens.end();

std::string ws("WS");
bool r = qi::phrase_parse(iter, end, calc, qi::in_state(ws)[tokens.self]);
if (r && iter == end)
{
std::cout << "-------------------------\n";
std::cout << "Parsing succeeded\n";
std::cout << "-------------------------\n";
}
else
{
std::cout << "-------------------------\n";
std::cout << "Parsing failed\n";
std::cout << "-------------------------\n";
}
}