ast_fromastfile.cc

Go to the documentation of this file.

#include <boost/spirit/core.hpp>
#include <boost/spirit/actor/push_back_actor.hpp>

#include "ast.h"
#include "ifprintf.h"

using namespace std;
using namespace boost::spirit;
using namespace AST;
vector<Node*> stack_node;                                                                                      
vector<Node*> stack_wrapped_node;                                                                              
vector<List*>         stack_list_nodes;                                                                        
string constant_type, constant_value;                                                                          
vector<AttributeProxy*> stack_attribute_proxy;                                                                 
vector<Node*> stack_attribute_value;                                                                           

void pop_stack_node(){
    stack_node.pop_back();
}
void pop_stack_wrapped_nodes(){
    stack_wrapped_node.pop_back();
}
void pop_stack_list_nodes(){
    stack_list_nodes.pop_back();
}
void pop_stack_attribute_proxy(){
    delete stack_attribute_proxy.back();
    stack_attribute_proxy.pop_back();
}
void pop_stack_attribute_value(){
    stack_attribute_value.pop_back();
}
#define create_create_node_func(CLASSNAME) \
    struct Creator_##CLASSNAME {\
        static Node* create() { return new CLASSNAME(); }\
    };\
    create_node_funcs[#CLASSNAME] = Creator_##CLASSNAME::create;

typedef Node* (*create_node_func)(void);
static map<string, create_node_func> create_create_node_funcs(){                                               
    printf("create_create_node_funcs\n");
    map<string, create_node_func> create_node_funcs;
    create_create_node_func(Program);
    create_create_node_func(If);
    create_create_node_func(Op_Binary);
    create_create_node_func(Identifier);
    create_create_node_func(Constant);
    create_create_node_func(FunctionCall);
    return create_node_funcs;
}
static map<string, create_node_func> create_node_funcs = create_create_node_funcs();                           

void start_node(char const* start, char const* end){
    string str(start, end);
    printf("start_node:%s\n", str.c_str());
    create_node_func func = create_node_funcs[str];
    assert(func && "undefined function for some type");
    Node* n = func();
    assert(n && "func failed");
    stack_node.push_back(n);
}
void end_node(char const* start, char const* end){
    string str(start, end);
    printf("end_node:%s\n", str.c_str());
    Node* n = stack_node.back();
    stack_wrapped_node.push_back(n);
    pop_stack_node();
}

void start_attribute(char const* start, char const* end){
    string str(start, end);
    //printf("new attrib %s.%s\n", stack_node.back()->get_name(), str.c_str());
    AttributeProxy* attrib = new AttributeProxy(stack_node.back(), str);
    stack_attribute_proxy.push_back(attrib);
}
void end_attribute(char const* start, char const* end){
    string str(start, end);
    *(stack_attribute_proxy.back()) = stack_attribute_value.back();
    pop_stack_attribute_proxy();
    pop_stack_attribute_value();
}

void do_value_string(char const* start, char const* end){
    string str(start, end);
    Leaf* leaf = new Leaf(str);
    stack_attribute_value.push_back(leaf);
}
void do_value_id(char const* start, char const* end){
    string str(start, end);
    Identifier* identifier    = new Identifier();
    identifier->handle        = str;
    stack_attribute_value.push_back(identifier);
}
void do_const_type(char const* start, char const* end){
    string str(start, end);
    constant_value = str;
}
void do_const_value(char const* start, char const* end){
    string str(start, end);
    constant_value = str;
}
void do_value_const(char const* start, char const* end){
    string str(start, end);
    Constant* constant        = new Constant();
    constant->type            = constant_type;
    constant->value           = constant_value;
    stack_attribute_value.push_back(constant);
}
void start_list(char const* start, char const* end){
    printf("start_list\n");
    stack_list_nodes.push_back(new List());
}
void do_list_node(char const* start, char const* end){
    printf("list.push_back(%s)\n", stack_attribute_value.back()->get_name());
    stack_list_nodes.back()->addChild(stack_attribute_value.back());
    pop_stack_attribute_value();
}
void end_list(char const* start, char const* end){
    printf("end_list\n");
    stack_attribute_value.push_back(stack_list_nodes.back());
    pop_stack_list_nodes();
}
void do_wrapped_node(const char* start, const char* end){
    //*(stack_attribute.back()) = stack_wrapped_node.back();
    stack_attribute_value.push_back(stack_wrapped_node.back());
    pop_stack_wrapped_nodes();
}
struct ASTreeGrammar : public grammar<ASTreeGrammar>
{
    ASTreeGrammar(){}

    template <typename ScannerT>
    struct definition
    {
        definition(ASTreeGrammar const& self)
        {
            node =
                (str[&start_node] >> +(attributePair))[&end_node]
                ;

            attributePair =
                str[&start_attribute] >> attributeValue[&end_attribute]
                ;

            attributeValue = 
                  value_node
                | value_id
                | value_const
                | value_list 
                | value_string
                ;

            value_node = 
                ("{" >> node >> "}")[&do_wrapped_node]                                                         
                ;

            value_list = 
                str_p("[")[&start_list] >> *(value_node[&do_list_node]) >> str_p("]")[&end_list]               
                ;

            value_string = 
                lexeme_d[(+(~space_p))][&do_value_string]
                ;

            value_id = 
                str_p("id") >> ':' >> str[&do_value_id]                                                        
                ;

            value_const = 
                (str_p("const") >> ':' >> str[&do_const_type] >> ':' >> str[&do_const_value])[&do_value_const] 
                ;

            str = 
                (lexeme_d[(+(alnum_p | ch_p('_')))])
                ;

            BOOST_SPIRIT_DEBUG_NODE(node);
            BOOST_SPIRIT_DEBUG_NODE(name_node);
            BOOST_SPIRIT_DEBUG_NODE(attributePair);
            BOOST_SPIRIT_DEBUG_NODE(name_attribute);
            BOOST_SPIRIT_DEBUG_NODE(attributeValue);
            BOOST_SPIRIT_DEBUG_NODE(value_node);
            BOOST_SPIRIT_DEBUG_NODE(value_list);
            BOOST_SPIRIT_DEBUG_NODE(value_string);
            BOOST_SPIRIT_DEBUG_NODE(value_id);
            BOOST_SPIRIT_DEBUG_NODE(value_const);
        }

        rule<ScannerT> node, name_node, attributePair, name_attribute, attributeValue, value_node, value_list, value_string, value_id, value_const, str;
        rule<ScannerT> const& start() const { return node; }
    };
};
Node* AST::fromASTFile(FILE* f){
    printf("fromASTFile(%p)\n", f);
    string str;
    char s[1024];
    vector<string> v;
    while (fgets(s, 1024, f)) {
        if (s[0] == '\0')
            break;
        str += s;
    }
    ASTreeGrammar grammar;

    bool b = parse(str.c_str(), grammar, space_p).full;
    printf(b ? "ParsingSuccesful\n" : "Parsing Failed\n");
    Node* root = stack_wrapped_node.back();
    return root;
}

---