ast.h

Go to the documentation of this file.

#ifndef AST_H
#define AST_H    
#include <string>
#include <vector>
#include <map>
#include "attributeproxy.h"
/*
 * \file Contains defines of the various types of astnodes and the fromASTFile function
 */
using namespace std;
namespace AST { 
class Node {
protected:
    
    enum {  
        NODE_BRANCH,
        NODE_LIST,
        NODE_LEAF,
        NODE_ID,
        NODE_CONSTANT,
    } nodeType; 
public:
    Node(string new_name):
        name(new_name),
        nodeType(NODE_BRANCH)
    {
    }
public:
    virtual void to3ACFile(FILE* f) = 0;                               
    void toASTFile(FILE* f);                                           
    void set_attribute(string attributeName, Node* child);             
    void set_attribute(string attributeName, string value);            
    void set_attribute(string attributeName, vector<Node*> vec_nodes); 
    AttributeProxy operator[](string attributeName);                   
    const char* get_name(){ return this->name.c_str(); }

protected:
    AttributeProxy addAttribute(const char* attributeName);            
protected:
    
    map<string, Node*> attributes;                                     
    string name;
private:
    vector<string> orderedAttributes;                                  
};


Node* fromASTFile(FILE* f);                                            

class List : public Node { 
    typedef Node super;
public:
    List():
        super("List") 
    {
        this->nodeType = NODE_LIST;
    }
    List(vector<Node*> vec):
        super("List")
    {
        this->nodeType = NODE_LIST;
        for( int i = 0; i < vec.size(); i ++){
            this->addChild(vec[i]);
        }
    }
    void addChild(Node* child){
        list.push_back(child);
    }
    virtual void to3ACFile(FILE* f){}
    vector<Node*> list;
protected:
};

class Leaf : public Node {
    typedef Node super;
public:
    Leaf(string new_value):
        super("Leaf"),
        value(new_value) 
    {
        this->nodeType = NODE_LEAF;
    }
    string value;
    virtual void to3ACFile(FILE* f){}
};

class Program : public Node {
    typedef Node super;
public:
    Program():
        super("Program"),
        statements(this->addAttribute("statements"))
    {
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy statements;
};

class Def_Function : public Node {
    typedef Node super;
public:
    Def_Function():
        super("Def_Function"),
        handle    (this->addAttribute("handle")),
        arguments (this->addAttribute("arguments")),
        statements(this->addAttribute("statements"))
    {
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy handle;
    AttributeProxy arguments;
    AttributeProxy statements;
};

class Def_Struct : public Node {
    typedef Node super;
public:
    Def_Struct():
        super("Def_Struct"),
        list_variables (this->addAttribute("handle"))
    {
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy list_variables;
};

class If : public Node {
    typedef Node super;
public:
    If():
        super("If"),
        condition(this->addAttribute("condition")),
        statements_then(this->addAttribute("statements_then")),
        statements_else(this->addAttribute("statements_else"))
    {
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy condition;
    AttributeProxy statements_then;
    AttributeProxy statements_else;
};

class Jump : public Node {
    typedef Node super;
public:
    Jump():
        super("Jump"),
        type(this->addAttribute("type"))
    {
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy type;
};

class Loop : public Node {
    typedef Node super;
public:
    Loop():
        super("Conditional"),
        type       (this->addAttribute("type")),
        declaration(this->addAttribute("declaration")),
        condition  (this->addAttribute("condition")),
        increment  (this->addAttribute("increment")),
        statements (this->addAttribute("statements"))
    {
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy type;
    AttributeProxy declaration;
    AttributeProxy condition;
    AttributeProxy increment;
    AttributeProxy statements;
};

class Return : public Node {
    typedef Node super;
public:
    Return():
        super("Return"),
        value(this->addAttribute("value"))
    {
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy value;
};

class Op_Unary : public Node {
    typedef Node super;
public:
    Op_Unary():
        super("Op_Unary"),
        id(this->addAttribute("id")),
        op(this->addAttribute("op"))
    {
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy id;
    AttributeProxy op;
};

class Op_Binary : public Node {
    typedef Node super;
public:
    Op_Binary():
        super("Op_Binary"),
        lhs(this->addAttribute("lhs")),
        op (this->addAttribute("op")),
        rhs(this->addAttribute("rhs"))
    {
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy lhs;
    AttributeProxy op;
    AttributeProxy rhs;
};

class Op_Ternary : public Node {
    typedef Node super;
public:
    Op_Ternary():
        super("Op_Ternary"),
        condition (this->addAttribute("conditon")),
        trueValue (this->addAttribute("trueValue")),
        falseValue(this->addAttribute("falseValue"))
    {
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy condition;
    AttributeProxy trueValue;
    AttributeProxy falseValue;
};

class Assignment : public Node {
    typedef Node super;
public:
    Assignment():
        super("Assignment"),
        lhs(this->addAttribute("lhs")),
        op (this->addAttribute("op")),
        rhs(this->addAttribute("rhs"))
    {
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy lhs;
    AttributeProxy op;
    AttributeProxy rhs;
};

class Constant : public Node {
    typedef Node super;
public:
    Constant():
        super("Constant"),
        type (this->addAttribute("type")),
        value(this->addAttribute("value"))
    {
        this->nodeType = NODE_CONSTANT;
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy type;
    AttributeProxy value;
};

class FunctionCall : public Node {
    typedef Node super;
public:
    FunctionCall():
        super("FunctionCall"),
        handle(this->addAttribute("handle")),
        arguments(this->addAttribute("arguments"))
    {
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy handle;
    AttributeProxy arguments;
};

class Identifier : public Node {
    typedef Node super;
public:
    Identifier():
        super("Identifier"),
        handle(this->addAttribute("handle"))
    {
        this->nodeType = NODE_ID;
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy handle;
};


class Op_Bracket : public Node {
    typedef Node super;
public:
    Op_Bracket():
        super("Op_Bracket"),
        handle    (this->addAttribute("handle")),
        list_index(this->addAttribute("list_index"))
    {
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy handle;
    AttributeProxy list_index;
};

class Op_Dot : public Node {
    typedef Node super;
public:
    Op_Dot():
        super("Op_Dot"),
        handle  (this->addAttribute("handle")),
        variable(this->addAttribute("variable"))
    {
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy handle;
    AttributeProxy variable;
};

class Def_Var : public Node {
    typedef Node super;
public:
    Def_Var():
        super("Def_Var"),
        type   (this->addAttribute("handle")),
        handles(this->addAttribute("variable"))
    {
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy type;
    AttributeProxy handles;
};

class Def_Array : public Node {
    typedef Node super;
public:
    Def_Array():
        super("Def_Array"),
        type          (this->addAttribute("handle")),
        handle        (this->addAttribute("variable")),
        list_dimension(this->addAttribute("list_dimension"))
    {
    }
    virtual void to3ACFile(FILE* f){}
    AttributeProxy type;
    AttributeProxy handle;
    AttributeProxy list_dimension;
};

};
#endif /* ASTNODE_H */

---