interpreter/symbol.cpp

   1 #include <iostream>
   2
   3 #include <fridh/symbol.hpp>
   4
   5 namespace fridh
   6 {
   7         symbol_tree_node::symbol_tree_node():
   8                 type(symbol::uninitialised),
   9                 parent(0)
  10         {
  11                 std::cout << "new symbol_tree_node default " << (void *)this << std::endl;
  12         }
  13
  14         symbol_tree_node::symbol_tree_node(symbol_tree_node const & other)
  15         {
  16                 copy(other);
  17         }
  18
  19         symbol_tree_node::symbol_tree_node(symbol::type type):
  20                 type(type),
  21                 parent(0)
  22         {
  23                 std::cout << "new symbol_tree_node " << (void *)this << std::endl;
  24
  25                 switch(type)
  26                 {
  27                         case symbol::function:
  28                                 function_pointer = new function;
  29                                 break;
  30
  31                         case symbol::class_symbol:
  32                                 class_pointer = new class_type;
  33                                 break;
  34                 }
  35         }
  36
  37         symbol_tree_node::~symbol_tree_node()
  38         {
  39                 destroy();
  40         }
  41
  42         symbol_tree_node & symbol_tree_node::operator=(symbol_tree_node const & other)
  43         {
  44                 destroy();
  45                 copy(other);
  46                 return *this;
  47         }
  48
  49         void symbol_tree_node::copy(symbol_tree_node const & other)
  50         {
  51                 std::cout << "symbol_tree_node " << (void *)this << " from " << (void *)&other << std::endl;
  52
  53                 type = other.type;
  54                 parent = other.parent;
  55
  56                 for(node_children::const_iterator i = other.children.begin(), end = other.children.end(); i != end; i++)
  57                 {
  58                         symbol_tree_node * & node_pointer = children[i->first];
  59                         node_pointer = new symbol_tree_node(*i->second);
  60                         node_pointer->parent = this;
  61                 }
  62
  63 #define COPY_MEMBER(type, member_type, member) \
  64                 case symbol::type: \
  65                         member = new member_type(*other.member); \
  66                         break;
  67
  68                 switch(type)
  69                 {
  70                         COPY_MEMBER(function, function, function_pointer);
  71                         COPY_MEMBER(class_symbol, class_type, class_pointer);
  72                         COPY_MEMBER(module, module, module_pointer);
  73                 }
  74
  75 #undef COPY_MEMBER
  76
  77         }
  78
  79         void symbol_tree_node::destroy()
  80         {
  81                 std::cout << "~symbol_tree_node " << (void *)this << std::endl;
  82
  83                 for(node_children::iterator i = children.begin(), end = children.end(); i != end; i++)
  84                         delete i->second;
  85
  86 #define DELETE_MEMBER(type, member) \
  87                         case symbol::type: \
  88                                 delete member; \
  89                                 break;
  90
  91                 switch(type)
  92                 {
  93                         DELETE_MEMBER(function, function_pointer);
  94                         DELETE_MEMBER(class_symbol, class_pointer);
  95                         DELETE_MEMBER(module, module_pointer);
  96                 }
  97
  98                 type = symbol::uninitialised;
  99
 100 #undef DELETE_MEMBER
 101
 102         }
 103
 104         bool symbol_tree_node::exists(std::string const & name)
 105         {
 106                 std::cout << "exists " << (void *)this << std::endl;
 107                 node_children::iterator iterator = children.find(name);
 108                 return iterator != children.end();
 109         }
 110
 111         bool symbol_tree_node::find_entity(std::string const & name, symbol_tree_node * & output)
 112         {
 113                 node_children::iterator iterator = children.find(name);
 114                 if(iterator == children.end())
 115                 {
 116                         if(parent == 0)
 117                                 return false;
 118                         return parent->find_entity(name, output);
 119                 }
 120
 121                 output = iterator->second;
 122                 return true;
 123         }
 124 }