tree.cpp

Go to the documentation of this file.

//  This file is part of jdl_parser.
//
//  jdl_parser is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  jdl_parser is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with jdl_parser.  If not, see <http://www.gnu.org/licenses/>.

// Copyright Simone Pellegrini 2007-2008; e-mail: motonacciu@gmail.com

#include "tree.hpp"
#include "visitor.hpp"

#include <cctype>
#include <algorithm>

#include <boost/ref.hpp>

namespace jdl{

void create_activation_record(parser_stack<boost::shared_ptr<component> >& node_stack){
#ifdef DEBUG
        cout << "Pushing new Activation Record." << endl;
#endif
        node_stack.new_ar();
}

void reduce_stack(parser_stack<boost::shared_ptr<component> >& node_stack){
#ifdef DEBUG
        cout << "Reducing stack." << endl;
#endif
    vector<boost::shared_ptr<component> > &v = node_stack.pop();
        assert(v.size() == 1);
        node_stack.push(v[0]);
        delete &v;
}

void discard_activation_record(parser_stack<boost::shared_ptr<component> >& node_stack){
        vector<boost::shared_ptr<component> > &v = node_stack.pop();
//      vector<boost::shared_ptr<component> >::iterator it = v.begin();
//      while(it != v.end())
//              delete *(it++);
        delete &v;
}

void create(attribute_definition_node &node, parser_stack<boost::shared_ptr<component> >& stack){
        vector<boost::shared_ptr<component> > &v = stack.pop();
//      cout << "Activation record size: " << v.size() << endl;
        assert(v.size() == 2);
        
        boost::shared_ptr<string_node> sn = boost::dynamic_pointer_cast<string_node>(v[1]);
        assert(sn != NULL);
        node.set_name(sn);
        node.set_value(v[0]);
        delete &v;
}

void create(conditional_expr &node, parser_stack<boost::shared_ptr<component> >& stack){
        // else
        vector<boost::shared_ptr<component> > &v = stack.pop();
        assert(v.size() == 3);
        node.set_else(v[0]);
        // then
        node.set_then(v[1]);
        // if
        node.set_condition(v[2]);
        //cout << node.to_string() << endl;
        stack.new_ar();
        delete &v;
}

void create(binary_expr_node &node, parser_stack<boost::shared_ptr<component> >& stack){
        vector<boost::shared_ptr<component> > &v = stack.pop();
//      cout << "Activation record size: " << v.size() << endl;
        assert(v.size() == 3);
        
        node.left_operand(v[2]);
        node.set_operator(boost::dynamic_pointer_cast<abstract_leaf<string> >(v[1])->data());
        node.right_operand(v[0]);
        
        stack.new_ar();
        delete &v;
}

void create(bracket_node &node, parser_stack<boost::shared_ptr<component> >& stack){
        vector<boost::shared_ptr<component> > &v = stack.pop();
        assert(v.size() == 2);
        
        node.left(v[1]);
        node.right(v[0]);
        
        stack.new_ar();
        delete &v;
}

void create(dot_node &node, parser_stack<boost::shared_ptr<component> >& stack){
        vector<boost::shared_ptr<component> > &v = stack.pop();
        assert(v.size() == 2);
        
        node.left(v[1]);
        node.right(v[0]);
        
        stack.new_ar();
        delete &v;
}

void create(term_node &node, parser_stack<boost::shared_ptr<component> >& stack){
        vector<boost::shared_ptr<component> > &v = stack.pop();
//      assert(v.size() == 1);
        vector<boost::shared_ptr<component> >::reverse_iterator it = v.rbegin();
        while(it != v.rend())
                node.add_child(*(it++));
        stack.new_ar();
        delete &v;
}

void create(list_node &node, parser_stack<boost::shared_ptr<component> >& stack){
        vector<boost::shared_ptr<component> > &v = stack.pop();
//      assert(v.size() == 1);
        vector<boost::shared_ptr<component> >::reverse_iterator it = v.rbegin();
        while(it != v.rend())
                node.add_child(*(it++));
        stack.new_ar();
        delete &v;
}

void create(func_call_node &node, parser_stack<boost::shared_ptr<component> >& stack){
        vector<boost::shared_ptr<component> > &v = stack.pop();
        assert(v.size() == 2);
        
        node.func_name(v[1]);
        node.args(v[0]);
        stack.new_ar();
        delete &v;
}

void create(unary_expr_node &node, parser_stack<boost::shared_ptr<component> >& stack){
        vector<boost::shared_ptr<component> > &v = stack.pop();
        assert(v.size() == 2);
        
        node.operand(v[0]);
        node.set_operator((boost::dynamic_pointer_cast<string_node>(v[1]))->data());
        stack.new_ar();
        delete &v;
}

abstract_node::~abstract_node(){
        //#ifdef DEGUG
//              cout << "Invoking COMPONENT DESTRUCTOR (node: " << endl;
        //#endif
//      vector<component *>::const_iterator it = children.begin();
//      while(it != children.end())
//              delete *(it++);
} 
}
// binary_expr_node
string binary_expr_node::to_string() const{
        return "BIN_EXPR:{ " + 
                children[0]->to_string() + 
                " " + _op + " "  + children[1]->to_string() + " }";
}
void binary_expr_node::accept(const_visitor &v) const{
        v.visit(*this);
}

void binary_expr_node::accept(visitor &v){
        v.visit(*this);
}
// unary_expr_node
string unary_expr_node::to_string() const{
        return "UNARY_EXPR: [ " + _op +
                children[0]->to_string() +  " ]";
}               
void unary_expr_node::accept(const_visitor &v) const{
        v.visit(*this);
}

void unary_expr_node::accept(visitor &v){
        v.visit(*this);
}
// attribute_definition_node
string attribute_definition_node::to_string() const{
        return "ATTR_DEF_NODE( NAME: " + 
                children[0]->to_string() + 
                " VAL: " + children[1]->to_string() + " )";
}
void attribute_definition_node::accept(const_visitor &v) const{
        v.visit(*this);
}

void attribute_definition_node::accept(visitor &v){
        v.visit(*this);
}
// conditional_expr
string conditional_expr::to_string() const{
        return "CONDITIONAL_EXPR: " + 
                children[0]->to_string() + " ? " + 
                children[1]->to_string() + " : " + 
                children[2]->to_string();
}
void conditional_expr::accept(const_visitor &v) const{
        v.visit(*this);
}
void conditional_expr::accept(visitor &v){
        v.visit(*this);
}
// dot_node
string dot_node::to_string() const{ 
        return "DOT_NODE: " + children[0]->to_string() + "." + children[1]->to_string(); 
}
void dot_node::accept(const_visitor &v) const{
        v.visit(*this);
}
void dot_node::accept(visitor &v){
        v.visit(*this);
}
// bracket_node
string bracket_node::to_string() const{ 
        return "BRAKET_NODE: " + children[0]->to_string() + "[" + children[1]->to_string() + "]"; 
}
void bracket_node::accept(const_visitor &v) const{
        v.visit(*this);
}
void bracket_node::accept(visitor &v){
        v.visit(*this);
}
// term_node
string term_node::to_string() const{
        string s("TERM_NODE: {");
        vector<boost::shared_ptr<component> >::const_iterator it = children.begin();
        while(it != children.end()){
                s += (*(it++))->to_string();
                if(it != children.end())
                        s += ", ";
        }
        s+=" }";
        return s;
}
void term_node::accept(const_visitor &v) const{
        v.visit(*this);
}
void term_node::accept(visitor &v){
        v.visit(*this);
}
// list_node
string list_node::to_string() const{
        string s("LIST_NODE: {");
        vector<boost::shared_ptr<component> >::const_iterator it = children.begin();
        while(it != children.end()){
                s += (*(it++))->to_string();
                if(it != children.end())
                        s += ", ";
        }
        s+=" }";
        return s;
}
void list_node::accept(const_visitor &v) const{
        v.visit(*this);
}
void list_node::accept(visitor &v){
        v.visit(*this);
}
// func_call_node
string func_call_node::to_string() const {
        string s("FUNC_CALL_NODE: ");
        s += children[0]->to_string() + "(" + children[1]->to_string() + ")";
        return s;
}
void func_call_node::accept(const_visitor &v) const{
        v.visit(*this);
}
void func_call_node::accept(visitor &v){
        v.visit(*this);
}
// int_node
void int_node::accept(const_visitor &v) const{
        v.visit(*this);
}
void int_node::accept(visitor &v){
        v.visit(*this);
}
// string_node
void string_node::accept(const_visitor &v) const{
        v.visit(*this);
}
void string_node::accept(visitor &v) {
        v.visit(*this);
}
// string_literal_node
void string_literal_node::accept(const_visitor &v) const{
        v.visit(*this);
}
void string_literal_node::accept(visitor &v){
        v.visit(*this);
}
// float_node
void float_node::accept(const_visitor &v) const{
        v.visit(*this);
}
void float_node::accept(visitor &v){
        v.visit(*this);
}

---