tree.hpp

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

#ifndef TREE_HPP_
#define TREE_HPP_

#include "defs.hpp"
#include "parser_stack.hpp"

using namespace std;

namespace jdl{

//template <class Ret, class Arg>
//class arg_visitor;

void print_tree(component *root);

// Composite pattern
class component {
public:

        virtual void accept(const_visitor &v) const = 0;
        
        virtual void accept(visitor &v) = 0;
                
        virtual string to_string() const = 0;
        
        virtual component* clone() const = 0;
        
        friend ostream& operator<<(ostream &out, component *c) {        return out << c->to_string(); }
                
        virtual ~component(){};
};

// ABSTRACT LEAF
template <class T>
class abstract_leaf : public component{
        T _data;
public:
        abstract_leaf(T data) : _data(data){}
                
        T data() const { return _data; }
                
        void accept(const_visitor &v) const = 0;
        
        void accept(visitor &v) = 0;
        
//      template<class Ret, class Arg>
//      Ret accept(arg_visitor<Ret,Arg> &v, Arg &arg) = 0;
                
        ~abstract_leaf(){}
};

// INTEGER NODE
class int_node : public abstract_leaf<int>{
public:
        int_node(const char* begin, const char* end) : 
                abstract_leaf<int>(boost::lexical_cast<int>(string(begin,end))){ }
        
        int_node(int val): abstract_leaf<int>(val){ } 
        
        bool operator==(int val){ return data() == val; }
        
        void accept(const_visitor &v) const;
        
        void accept(visitor &v);
        
        component* clone() const { return new int_node(data()); }
        
//      template<class Ret, class Arg>
//      Ret accept(arg_visitor<Ret,Arg> &v, Arg &arg);
                
        string to_string() const {      return "" + data(); }
};

// FLOAT NODE
class float_node : public abstract_leaf<double>{
public:
        float_node(const char* begin, const char* end) : 
                abstract_leaf<double>(boost::lexical_cast<double>(string(begin,end))){ }
        
        float_node(float_node const& node): abstract_leaf<double>(node.data()){ } 
        
        bool operator==(float val){ return data() == val; }
        
        void accept(const_visitor &v) const;
        
        void accept(visitor &v);
        
        component* clone() const { return new float_node(*this); }
        
//      template<class Ret, class Arg>
//      Ret accept(arg_visitor<Ret,Arg> &v, Arg &arg);
                
        string to_string() const {
                return boost::lexical_cast<string>(data());     
        }
};

// STRING NODE
class string_node : public abstract_leaf<string>{
public:
        string_node(const char* begin, const char* end) : 
                abstract_leaf<string>(string(begin, end)){}
        
        string_node(string_node const& node): abstract_leaf<string>(node.data()){ } 
        
        bool operator==(string const& val){ return data() == val; }
        
        void accept(const_visitor &v) const;
        
        void accept(visitor &v);
                
        component* clone() const { return new string_node(*this); }
        
//      template<class Ret, class Arg>
//      Ret accept(arg_visitor<Ret,Arg> &v, Arg &arg);
                
        string to_string() const {      return data(); }
};

// STRING NODE
class string_literal_node : public abstract_leaf<string>{
public:
        string_literal_node(const char* begin, const char* end) : 
                abstract_leaf<string>(string(begin, end)){}
        
        string_literal_node(string_literal_node const& node): abstract_leaf<string>(node.data()){}
        
        bool operator==(string const& val){ return data() == val; }
        
        void accept(const_visitor &v) const;
        
        void accept(visitor &v);
        
        component* clone() const { return new string_literal_node(*this); }
        
//      template<class Ret, class Arg>
//      Ret accept(arg_visitor<Ret,Arg> &v, Arg &arg);
                
        string to_string() const {      return "\"" + data() + "\""; }
};

// ABSTRACT NODE
class abstract_node : public component{
protected:
        vector<boost::shared_ptr<component> > children;
public:
        abstract_node(){}
        
        abstract_node(abstract_node const& node){
                vector<boost::shared_ptr<component> >::const_iterator it = node.get_children().begin();
                for(; it != node.get_children().end(); it++ )
                        children.push_back(boost::shared_ptr<component>((*it)->clone()));
        }
        
        void accept(const_visitor &v) const = 0;
                
        void accept(visitor &v) = 0;
        
        vector<boost::shared_ptr<component> > const& get_children() const { return children; }
        
        vector<boost::shared_ptr<component> >& get_children() { return children; }
                
//      template<class Ret, class Arg>
//      Ret accept(arg_visitor<Ret,Arg> &v, Arg &arg) = 0;
                
        ~abstract_node();
};

// BINARY EXPRESSION
class binary_expr_node : public abstract_node{
        string _op;
public:
        binary_expr_node(){ children.resize(2); }
        
        binary_expr_node(binary_expr_node const& node): abstract_node(node){ 
                _op = node.get_operator();
        }
                
        void left_operand(boost::shared_ptr<component> comp){ children[0] = comp; }
                
        boost::shared_ptr<component> get_left_operand() const { return children[0]; }
                
        void right_operand(boost::shared_ptr<component> comp){ children[1] = comp; }
                
        boost::shared_ptr<component> get_right_operand() const {        return children[1];     }
                
        void set_operator(string op){ _op = op; }
                
        const string &get_operator() const { return _op; }
                
        string to_string() const;
        
        component* clone() const{ return new binary_expr_node(*this); }
        
        void accept(const_visitor &v) const; 
        
        void accept(visitor &v);
        
//      template<class Ret, class Arg>
//      Ret accept(arg_visitor<Ret,Arg> &v, Arg &arg);
};

// UNARY EXPRESSION
class unary_expr_node : public abstract_node{
        string _op;
public:
        unary_expr_node(){
#ifdef DEBUG
                cout << "Creating UNARY_EXPR_NODE" << endl; 
#endif
                children.resize(1); 
        }
        
        unary_expr_node(unary_expr_node const& node): abstract_node(node){
                _op = node.get_operator();
        }
        
        void operand(boost::shared_ptr<component> comp){ children[0] = comp; }
                
        boost::shared_ptr<component> get_operand() const { return children[0]; }
                
        void set_operator(string op){ _op = op; }
                
        const string &get_operator() const { return _op; }
                
        string to_string() const;
        
        component* clone() const{ return new unary_expr_node(*this); }
        
        void accept(const_visitor &v) const;
        
        void accept(visitor &v);
        
//      template<class Ret, class Arg>
//      Ret accept(arg_visitor<Ret,Arg> &v, Arg &arg);
};

// ATTRIBUTE DEFINITION NODE
class attribute_definition_node : public abstract_node{
public:
        attribute_definition_node() { 
#ifdef DEBUG
                cout << "Created ATTRIBUTE_DEFINITION_NODE!" << endl;
#endif
                children.resize(2); 
        }
        
        attribute_definition_node(attribute_definition_node const& node): abstract_node(node) { }
        
        void set_name(boost::shared_ptr<string_node> comp){ children[0] = comp; }
                
        boost::shared_ptr<string_node> get_name() const { return boost::dynamic_pointer_cast<string_node>(children[0]); }
                
        void set_value(boost::shared_ptr<component> comp){ children[1] = comp; }
                
        boost::shared_ptr<component> get_value() const { return children[1]; }
                
        string to_string() const;
        
        component* clone() const{ return new attribute_definition_node(*this); }
        
        void accept(const_visitor &v) const;
        
        void accept(visitor &v);
        
//      template<class Ret, class Arg>
//      Ret accept(arg_visitor<Ret,Arg> &v, Arg &arg);
};

// CONDITIONAL EXPRESSION
class conditional_expr: public abstract_node{
public:
        conditional_expr() { 
#ifdef DEBUG
                cout << "Created CONDITIONAL_EXPRESSION_NODE." << endl;
#endif
                children.resize(3); 
        }
        
        conditional_expr(conditional_expr const& node): abstract_node(node) { }
        
        void set_condition(boost::shared_ptr<component> comp){ children[0] = comp; }
                
        boost::shared_ptr<component> get_condition() const { return children[0];        }
                
        void set_then(boost::shared_ptr<component> comp){       children[1] = comp;     }
                
        boost::shared_ptr<component> get_then() const { return children[1]; }
                
        void set_else(boost::shared_ptr<component> comp){       children[2] = comp; }
                
        boost::shared_ptr<component> get_else() const { return children[2]; }
                
        string to_string() const;
        
        component* clone() const{ return new conditional_expr(*this); }
        
        void accept(const_visitor &v) const;
        
        void accept(visitor &v);
        
//      template<class Ret, class Arg>
//      Ret accept(arg_visitor<Ret,Arg> &v, Arg &arg);
};

// DOT NODE
class dot_node : public abstract_node{
public:
        dot_node(){
#ifdef DEBUG
                cout << "Creating DOT_NODE." << endl;
#endif 
                children.resize(2); 
        }
        
        dot_node(dot_node const& node): abstract_node(node){}
        
        void left(boost::shared_ptr<component> node){ children[0] = node; }
                
        boost::shared_ptr<component> get_left() const { return children[0]; }
                
        void right(boost::shared_ptr<component> node){ children[1] = node; }
                
        boost::shared_ptr<component> get_right() const { return children[1]; }
                
        string to_string() const;
        
        component* clone() const{ return new dot_node(*this); }
        
        void accept(const_visitor &v) const;
        
        void accept(visitor &v);
        
//      template<class Ret, class Arg>
//      Ret accept(arg_visitor<Ret,Arg> &v, Arg &arg);
};

// BRACKET NODE
class bracket_node : public abstract_node{
public:
        bracket_node(){
#ifdef DEBUG
                cout << "Created BRACKET_NODE." << endl;
#endif 
                children.resize(2); 
        }
        
        bracket_node(bracket_node const& node): abstract_node(node){ }
        
        void left(boost::shared_ptr<component> node){ children[0] = node; }
                
        boost::shared_ptr<component> get_left() const { return children[0]; }
                
        void right(boost::shared_ptr<component> node){ children[1] = node; }
                
        boost::shared_ptr<component> get_right() const { return children[1]; }
                
        string to_string() const;
        
        component* clone() const{ return new bracket_node(*this); }
        
        void accept(const_visitor &v) const;
        
        void accept(visitor &v);
        
//      template<class Ret, class Arg>
//      Ret accept(arg_visitor<Ret,Arg> &v, Arg &arg);
};

// TERM NODE
class term_node: public abstract_node{
public:
        term_node(){
#ifdef DEBUG
                cout << "Created TERM_NODE." << endl;
#endif
        }
        
        term_node(term_node const& node): abstract_node(node){}
        
        void add_child(boost::shared_ptr<component> comp){ children.push_back(comp); }
                
        string to_string() const;
        
        component* clone() const{ return new term_node(*this); }
        
        void accept(const_visitor &v) const;
        
        void accept(visitor &v);
        
//      template<class Ret, class Arg>
//      Ret accept(arg_visitor<Ret,Arg> &v, Arg &arg);
};

// LIST NODE
class list_node: public abstract_node{
public:
        list_node(){
#ifdef DEBUG
                cout << "Created LIST_NODE." << endl;
#endif
        }
        
        list_node(list_node const& node): abstract_node(node) {}
        
        void add_child(boost::shared_ptr<component> comp){ children.push_back(comp); }
                
        string to_string() const;
        
        component* clone() const{ return new list_node(*this); }
        
        void accept(const_visitor &v) const;
        
        void accept(visitor &v);
        
//      template<class Ret, class Arg>
//      Ret accept(arg_visitor<Ret,Arg> &v, Arg &arg);
};

// FUNCTION CALL NODE
class func_call_node: public abstract_node{
public:
        func_call_node(){
#ifdef DEBUG 
                cout << "Creating function call node." << endl;
#endif
                children.resize(2); 
        }
        
        void func_name(boost::shared_ptr<component> comp){ children[0] = comp; }
                
        boost::shared_ptr<component> get_func_name() const { return children[0]; }
                
        void args(boost::shared_ptr<component> comp){ children[1] = comp; }
                
        boost::shared_ptr<component> get_args() const { return children[1]; }
                
        string to_string() const;
        
        component* clone() const{ return new func_call_node(*this); }
        
        void accept(const_visitor &v) const;
        
        void accept(visitor &v);
};

}

#endif /*TREE_HPP_*/

---