doładowania duch dostać cały mecz jako ciąg

Question

próbuję zdefiniować własną gramatykę używając ramy ducha doładowania i mam taką zasadę definiowania pasujący:

value = (
     char_('"') >> 
     (*qi::lexeme[ 
       char_('\\') >> char_('\\') | 
       char_('\\') >> char_('"') | 
       graph - char_('"') | 
       char_(' ') 
     ])[some_func] >> 
     char_('"') 
); 

chciałbym assing akcję - some_func - do części i przekazuje cały pasujący ciąg jako parametr. Ale niestety otrzymam coś w rodzaju vector<boost::variant<boost::fusion::vector2 ..a lot of stuff...)...>. Czy mogę w jakiś sposób uzyskać wszystkie dane jako char *, std :: string lub nawet void * o rozmiarze?

Answer 1

Spójrz na qi::as_string:

Wyjście z programu demonstracyjnego:

DEBUG: 'some\\"quoted\\"string.' 
parse success 

Szczerze mówiąc, wygląda na to są naprawdę starają się analizować "Verbatim sznurki z możliwych znaków ewakuacyjnych. Pod tym względem użycie lexeme wydaje się błędne (miejsca zostają zjedzone). Jeśli chcesz zobaczyć próbki z interpretowanym łańcuchem znaków, zobacz np.

• Boost Spirit Implement small one-line DSL on a server application (w tym stylu)
• Compiling a simple parser with Boost.Spirit (na ucieczkę przez powielanie)
• Parsing escaped strings with boost spirit
• Parse quoted strings with boost::spirit

_{Prosty przegrupowanie, które myślę, że może być dokonane, co najmniej może wyglądać następująco:}

value = qi::lexeme [ 
      char_('"') >> 
      qi::as_string [ 
      *(
       string("\\\\") 
       | string("\\\"") 
       | (graph | ' ') - '"' 
      ) 
      ] [some_func(_1)] >> 
      char_('"') 
     ]; 

Uwaga jednak, że można po prostu zadeklarować regułę bez skipera i upuść lexeme alltogether: http://liveworkspace.org/code/1oEhei$0

Code (żyć na liveworkspace)

#include <boost/fusion/adapted.hpp> 
#include <boost/spirit/include/qi.hpp> 
#include <boost/spirit/include/phoenix.hpp> 

namespace qi = boost::spirit::qi; 
namespace phx = boost::phoenix; 

struct some_func_t 
{ 
    template <typename> struct result { typedef void type; }; 
    template <typename T> 
     void operator()(T const& s) const 
     { 
      std::cout << "DEBUG: '" << s << "'\n"; 
     } 
}; 

template <typename It, typename Skipper = qi::space_type> 
    struct parser : qi::grammar<It, Skipper> 
{ 
    parser() : parser::base_type(value) 
    { 
     using namespace qi; 
     // using phx::bind; using phx::ref; using phx::val; 

     value = (
       char_('"') >> 
        qi::as_string 
        [ 
         (*qi::lexeme[ 
          char_('\\') >> char_('\\') | 
          char_('\\') >> char_('"') | 
          graph - char_('"') | 
          char_(' ') 
          ]) 
        ] [some_func(_1)] >> 
       char_('"') 
      ); 
     BOOST_SPIRIT_DEBUG_NODE(value); 
    } 

    private: 
    qi::rule<It, Skipper> value; 
    phx::function<some_func_t> some_func; 
}; 

bool doParse(const std::string& input) 
{ 
    typedef std::string::const_iterator It; 
    auto f(begin(input)), l(end(input)); 

    parser<It, qi::space_type> p; 

    try 
    { 
     bool ok = qi::phrase_parse(f,l,p,qi::space); 
     if (ok) 
     { 
      std::cout << "parse success\n"; 
     } 
     else  std::cerr << "parse failed: '" << std::string(f,l) << "'\n"; 

     if (f!=l) std::cerr << "trailing unparsed: '" << std::string(f,l) << "'\n"; 
     return ok; 
    } catch(const qi::expectation_failure<It>& e) 
    { 
     std::string frag(e.first, e.last); 
     std::cerr << e.what() << "'" << frag << "'\n"; 
    } 

    return false; 
} 

int main() 
{ 
    bool ok = doParse("\"some \\\"quoted\\\" string.\""); 
    return ok? 0 : 255; 
}