Boost.Spirit Grammar. Attributes and _val Questions

Question

I'm attempting to create a Boost::Spirit grammar class that can read a fairly simple grammar.

start   = roster;
roster  = *student;
student = int >> string;

The goal of the code is create a tree of command objects based on an input file that is being parsed. The Iterator that this grammar is being created with is the given spirit file iterator.

Basically, what I am having trouble doing is moving and using the synthesized attributes of each rule. What I need to to create a tree of objects based on this data, and the only functions to create said objects require the parent object to be known at that time. I'm using the command pattern to delay the creation until I have parsed all data and can correctly build the tree. The way I have implemented this so far is my commands all contain a vector of other commands. When a command is executed, it requires only the parent object, and will create and attach the child object accordingly. Then the object will execute each of the commands in it's own vector, passing itself as the parent. This creates the tree structure I need with the data in tact.

The Issue:

The Issue I am having is how to build the commands when the data is parsed, and how to load them into the appropriate vector. I've tried 3 different ways so far.

I tried to alter the attribute of each rule to an std::vector and parse the attributes in as commands one at a time. The issue with this is it nests the vectors into std::vector> type data, which I couldn't work with.
I tried using boost::phoenix placehold _val as a surrogate for the command being created. I was proud of this solution and a bit upset that it didn't work. I overloaded the += operator for all commands so that when A and B are both commands, A += B pushed B into A's command vector. _val isn't a Command so the compiler didn't like this. I couldn't seem to tinker anything into a more workable status. If at all possible, this was the cleanest solution and I would love for this to be able to work.
The code in it's current form has me attempting to bind the actions together. If I were to have a member function pointer to _val and pass it the created command It would push it back. Again _val isn't actually a Command so that didn't work out.

I'm going to post this wall of code, it's the grammar I've written cleaned up a bit, as well as the point where it is invoked.

template 
struct roster_grammar : qi::grammar
{   
//roster_grammar constructor
roster_grammar() : 
    roster_grammar::base_type(start_)
{
    using qi::lit;
    using qi::int_;
    using qi::char_;
    using qi::lexeme;

    start_ = student[boost::bind(&T3_Command::add_command, qi::_val, _1)];

    //I removed the roster for the time being to simplify the grammar
    //it still containes my second solution that I detailed above. This 
    //would be my ideal solution if it could work this way.
    //roster = *(student[qi::_val += _1]);

    student = 
        qi::eps       [ boost::bind(&T3_Command::set_identity, qi::_val, "Student") ]
        >>
        int_age       [ boost::bind(&T3_Command::add_command, qi::_val, _1) ]
        >>
        string_name   [ boost::bind(&T3_Command::add_command, qi::_val, _1) ];

    int_age     =
        int_          [ boost::bind(&Command_Factory::create_int_comm, &cmd_creator, "Age", _1) ];
    string_name =
        string_p      [ boost::bind(&Command_Factory::create_string_comm, &cmd_creator, "Name", _1) ];

    //The string parser. Returns type std::string
    string_p %= +qi::alnum;
}

qi::rule  roster;
qi::rule   student;
qi::rule    int_age;
qi::rule string_name;
qi::rule        start_;
qi::rule  string_p;
Command_Factory cmd_creator;
};

This is how the grammar is being instantiated and used.

typedef boost::spirit::istream_iterator iter_type;
typedef roster_grammar student_p;
student_p my_parser;

//open the target file and wrap istream into the iterator
std::ifstream in = std::ifstream(path);
in.unsetf(std::ios::skipws);//Disable Whitespace Skipping
iter_type begin(in);
iter_type end;

using boost::spirit::qi::space;
using boost::spirit::qi::phrase_parse;
bool r = phrase_parse(begin, end, my_parser, space);

So long story short, I have a grammar that I want to build commands out of (call T3_Command). Commands have a std:Vector data member that holds other commands beneath it in the tree.

What I need is a clean way to create a Command as a semantic action, I need to be able to load that into the vector of other commands (By way of attributes or just straight function calls). Commands have a type that is supposed to be specified at creation (will define the type of tree node it makes) and some commands have a data value (an int, string or float, all named value in their respective commands).

Or If there might be a better way to build a tree, I'd be open to suggestion. Thank you so much for any help you're able to give!

EDIT: I'll try to be more clear about the original problem I'm trying to solve. Thanks for the patience.

Given that grammar (or any grammar actually) I want to be able to parse through it and create a command tree based on the semantic actions taken within the parser. So using my sample grammar, and the input

"23 Bryan 45 Tyler 4 Stephen"

I would like the final tree to result in the following data structure.

Command with type = "Roster" holding 3 "Student" type commands.
Command with type = "Student" each holding an Int_Command and a String_Command
Int_Command holds the stored integer and String_Command the stored string.

E.g.

r1 - Roster - [s1][s2][s3]
s1 - Student - [int 23][string Bryan]
s2 - Student - [int 45][string Tyler]
s3 - Student - [int 4][string Stephen]

This is the current structure of the commands I've written (The implementation is all trivial).

class T3_Command
{
    public:
        T3_Command(void);
        T3_Command(const std::string &type);
        ~T3_Command(void);

        //Executes this command and all subsequent commands in the command vector.
        void Execute(/*const Folder_in parent AND const Model_in parent*/);

        //Pushes the passed T3_Command into the Command Vector
        //@param comm - The command to be pushed.
        void add_command(const T3_Command &comm);

        //Sets the Identity of the command.
        //@param ID - the new identity to be set.
        void set_identity(std::string &ID);

    private:    

        const std::string ident;
        std::vector  command_vec;
        T3_Command& operator+=(const T3_Command& rhs);
};

#pragma once
#include "T3_command.h"
class T3_Int_Command :
        public T3_Command
{
public:
        T3_Int_Command();
        T3_Int_Command(const std::string &type, const int val);
        ~T3_Int_Command(void);
        void Execute();
        void setValue(int val);
private:
        int value;
};

So the problem I am having is I would like to be able to create a data structure of various commands that represent the parse tree as spirit parses through it.

Boost.Spirit Grammar. Attributes and _val Questions

Answers (1)

OLD ANSWER

1. "The issue with this is it nests the vectors into std::vector> type data, which I couldn't work with"

2. Calling factory methods from semantic actions

Related Questions