Парсер строк с рекурсивной оболочкой варианта boost

Я бы предположил, что проблема заключается в совместимости атрибутов. Вопреки документации , синтаксический анализатор ascii::string предоставляет диапазон итераторов вместо строки.

name = string("no way");

не проблема, потому что атрибут, предоставляемый ascii::string, можно без труда преобразовать в тип атрибута правила.

Однако тип атрибута правила brac — ast_branch, что является лишь вариантом с одним из возможных содержащихся типов. Следовательно, тип ast_branch имеет несколько конструкторов, и Spirit не ясно, какой из них подходит для данного конкретного преобразования.

Есть несколько способов сделать это (помимо подходов, которые вы уже показали):

• использовать attr_cast

  brac = qi::attr_cast( string("no way") );
  

• использовать as_string

  brac = qi::as_string[ string("no way") ];
  

• использовать точки настройки

  namespace boost { namespace spirit { namespace traits {
      template <typename It>
          struct assign_to_attribute_from_iterators<client::ast_branch, It>
          {
              static void call(It const& f, It const& l, client::ast_branch& val)
              {
                  val = std::string(f, l);
              }
          };
  }}}
  

Каждый из них имеет одинаковый эффект: заставляет Spirit понять, какое преобразование атрибута использовать.

Вот полный рабочий образец, показывающий все три:

// #define BOOST_SPIRIT_ACTIONS_ALLOW_ATTR_COMPAT
#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/fusion/adapted.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/variant/recursive_variant.hpp>

#include <string>
#include <vector>

namespace client
{
   namespace fusion  = boost::fusion;
   namespace phoenix = boost::phoenix;
   namespace qi      = boost::spirit::qi;
   namespace ascii   = boost::spirit::ascii;

   struct ast_node;

   typedef boost::variant<
      boost::recursive_wrapper<ast_node>,
      std::string
   > ast_branch;

   struct ast_node
   {
      std::string text;
      std::vector<ast_branch> children;
   };
}

namespace boost { namespace spirit { namespace traits {
    template <typename It>
        struct assign_to_attribute_from_iterators<client::ast_branch, It>
        {
            static void call(It const& f, It const& l, client::ast_branch& val)
            {
                val = std::string(f, l);
            }
        };
}}}

BOOST_FUSION_ADAPT_STRUCT(
      client::ast_node,
      (std::string, text)
      (std::vector<client::ast_branch>, children)
)

namespace client
{
    template <typename Iterator>
        struct ast_node_grammar : qi::grammar<Iterator, ast_branch(), ascii::space_type>
    {
        ast_node_grammar()
            : ast_node_grammar::base_type(brac)
        {
            using qi::_1;
            using qi::_val;
            using ascii::char_;
            using ascii::string;

            name %= *char_;

            brac = string("works");
            brac = string("works")[_val = _1] ;
            brac %= string("this") | string("works");
            brac %= name ; // works
            brac %= *char_ ; // works

            brac = qi::as_string[ string("no way") ];
            brac = qi::attr_cast( string("no way") );
        }
        qi::rule<Iterator, std::string()> name;
        qi::rule<Iterator, ast_branch(), ascii::space_type> brac;
    };
}


int main(int argc, char **argv)
{
   typedef client::ast_node_grammar<std::string::const_iterator> ast_node_grammar;
   ast_node_grammar gram;
   client::ast_branch ast;

   std::string text("dummy");
   using boost::spirit::ascii::space;
   std::string::const_iterator iter = text.begin();
   std::string::const_iterator end = text.end();
   bool r = phrase_parse(iter, end, gram, space, ast);
   return r ? 0 : 1;
}