Passing file-path string to semantic action in Boost.Spirit

I am new to Boost.Spirit, and I have a question related to a mini-interpreter I am trying to implement using the library. As a sub-task of parsing my language, I need to extract a file-path from an input of the form:

"path = \"/path/to/file\""

and pass it as a string (without quotes) to a semantic action.

I wrote some code which can parse this type of input, but passing the parsed string does not work as expected, probably due to my lack of experience with Boost.Spirit.

Can anyone help?

In reality, my grammar is more complex, but I have isolated the problem to:

#include <string>
#include "boost/spirit/include/qi.hpp"
#include "boost/spirit/include/phoenix_core.hpp"
#include "boost/spirit/include/phoenix_operator.hpp"
namespace qi      = boost::spirit::qi;
namespace ascii   = boost::spirit::ascii;
namespace phoenix = boost::phoenix;

namespace parser {
    // Semantic action (note: in reality, this would use file_path_string in non-trivial way)
    void display_path(std::string file_path_string) {
        std::cout << "Detected file-path: " << file_path_string << std::endl;
    }

    // Grammar
    template <typename Iterator>
        struct path_command : qi::grammar<Iterator, ascii::space_type> {
            path_command() : path_command::base_type(path_specifier) {
                using qi::string;
                using qi::lit;

                path = +(qi::char_("/") >> *qi::char_("a-zA-Z_0-9"));
                quoted_path_string = lit('"') >> (path- lit('"')) >> lit('"');
                path_specifier = lit("path") >> qi::lit("=")
                                 >> quoted_path_string[&display_path];
            }

            qi::rule<Iterator, ascii::space_type> path_specifier;
            qi::rule<Iterator, std::string()> path, quoted_path_string;
        };
}

int main() {
    using ascii::space;
    typedef std::string::const_iterator iterator_type;
    typedef parser::path_command<iterator_type> path_command;

    bool parse_res;
    path_command command_instance;   // Instance of our Grammar
    iterator_type iter, end;

    std::string test_command1 = "path = \"/file1\"";
    std::string test_command2 = "path = \"/dirname1/dirname2/file2\"";

    // Testing example command 1
    iter      = test_command1.begin();
    end       = test_command1.end();
    parse_res = phrase_parse(iter, end, command_instance, space);
    std::cout << "Parse result for test 1: " << parse_res << std::endl;

    // Testing example command 2
    iter      = test_command2.begin();
    end       = test_command2.end();
    parse_res = phrase_parse(iter, end, command_instance, space);
    std::cout << "Parse result for test 2: " << parse_res << std::endl;

    return EXIT_SUCCESS;
}

The output is:

Detected file-path: /
Parse result for test 1: 1
Detected file-path: ///
Parse result for test 2: 1

but I would like to obtain:

Detected file-path: /file1
Parse result for test 1: 1
Detected file-path: /dirname1/dirname2/file2
Parse result for test 2: 1

Solution

Almost everything is fine with your parser. The problem is a bug in Spirit (upto Boost V1.46) preventing the correct handling of the attribute in cases like this. This has been recently fixed in SVN and will be available in Boost V1.47 (I tried running your unchanged program with this version and everything works just fine).

For now, you can work around this problem by utilizing the raw[] directive (see below).

I said 'almost' above, because you can a) simplify what you have, b) you should use no_skip[] to avoid invoking the skip parser in between the qutoes.

path = raw[+(qi::char_("/") >> *qi::char_("a-zA-Z_0-9"))];
quoted_path_string = no_skip['"' >> path >> '"'];
path_specifier = lit("path") >> qi::lit("=")
    >> quoted_path_string[&display_path];

You can omit the - lit('"') part because your path parser does not recognize quotes in the first place.