parser/tree/node.cpp

   1 #include <iostream>
   2 #include <map>
   3 #include <fridh/symbol.hpp>
   4 #include <ail/string.hpp>
   5
   6 namespace fridh
   7 {
   8         parse_tree_node::parse_tree_node():
   9                 type(parse_tree_node_type::uninitialised)
  10         {
  11                 std::cout << "parse_tree_node " << (void *)this << std::endl;
  12         }
  13
  14         parse_tree_node::parse_tree_node(parse_tree_node const & other)
  15         {
  16                 copy(other);
  17         }
  18
  19         parse_tree_node::~parse_tree_node()
  20         {
  21                 destroy();
  22         }
  23
  24         parse_tree_node & parse_tree_node::operator=(parse_tree_node const & other)
  25         {
  26                 destroy();
  27                 copy(other);
  28                 return *this;
  29         }
  30
  31         void parse_tree_node::copy(parse_tree_node const & other)
  32         {
  33                 std::cout << "parse_tree_node copy " << (void *)this << " from " << (void *)&other << std::endl;
  34
  35                 //std::cout << (int)other.type << std::endl;
  36
  37                 //std::cout << "Copying " << other.to_string() << std::endl;
  38
  39 #define COPY_MEMBER(type, member_type, member) \
  40                 case parse_tree_node_type::type: \
  41                         member = new member_type(*other.member); \
  42                         break;
  43
  44                 type = other.type;
  45
  46                 switch(other.type)
  47                 {
  48                         COPY_MEMBER(variable, variable, variable_pointer)
  49                         COPY_MEMBER(symbol, parse_tree_symbol, symbol_pointer)
  50                         COPY_MEMBER(unary_operator_node, parse_tree_unary_operator_node, unary_operator_pointer)
  51                         COPY_MEMBER(binary_operator_node, parse_tree_binary_operator_node, binary_operator_pointer)
  52                         COPY_MEMBER(call, parse_tree_call, call_pointer)
  53                         COPY_MEMBER(array, parse_tree_array, array_pointer)
  54                 }
  55
  56 #undef COPY_MEMBER
  57
  58                 //std::cout << "Result: " << to_string() << std::endl;
  59         }
  60
  61         void parse_tree_node::destroy()
  62         {
  63                 std::cout << "parse_tree_node destroy " << (void *)this << std::endl;
  64
  65 #define DELETE_MEMBER(type, member) \
  66                         case parse_tree_node_type::type: \
  67                                 delete member; \
  68                                 break;
  69
  70                 switch(type)
  71                 {
  72                         DELETE_MEMBER(variable, variable_pointer)
  73                         DELETE_MEMBER(symbol, symbol_pointer)
  74                         DELETE_MEMBER(unary_operator_node, unary_operator_pointer)
  75                         DELETE_MEMBER(binary_operator_node, binary_operator_pointer)
  76                         DELETE_MEMBER(call, call_pointer)
  77                         DELETE_MEMBER(array, array_pointer)
  78                 }
  79
  80                 type = parse_tree_node_type::uninitialised;
  81
  82 #undef DELETE_MEMBER
  83
  84         }
  85
  86         parse_tree_node::parse_tree_node(parse_tree_node_type::type type):
  87                 type(type)
  88         {
  89         }
  90
  91         parse_tree_node::parse_tree_node(variable * variable_pointer):
  92                 type(parse_tree_node_type::variable),
  93                 variable_pointer(variable_pointer)
  94         {
  95         }
  96
  97         parse_tree_node::parse_tree_node(unary_operator_type::type unary_operator):
  98                 type(parse_tree_node_type::unary_operator_node)
  99         {
 100                 unary_operator_pointer = new parse_tree_unary_operator_node;
 101                 unary_operator_pointer->type = unary_operator;
 102         }
 103
 104         parse_tree_node::parse_tree_node(binary_operator_type::type binary_operator):
 105                 type(parse_tree_node_type::binary_operator_node)
 106         {
 107                 binary_operator_pointer = new parse_tree_binary_operator_node;
 108                 binary_operator_pointer->type = binary_operator;
 109         }
 110
 111         parse_tree_node::parse_tree_node(parse_tree_nodes & elements):
 112                 type(parse_tree_node_type::array)
 113         {
 114                 array_pointer = new parse_tree_array;
 115                 array_pointer->elements = elements;
 116         }
 117
 118         void parse_tree_node::is_call()
 119         {
 120                 type = parse_tree_node_type::call;
 121                 call_pointer = new parse_tree_call;
 122         }
 123
 124         bool parse_tree_node::is_post_fix() const
 125         {
 126                 if(type != parse_tree_node_type::unary_operator_node)
 127                         throw ail::exception("Tried to retrieve post fix node properties of a non-post-fix node");
 128
 129                 unary_operator_type::type unary_type = unary_operator_pointer->type;
 130                 return
 131                         unary_type == unary_operator_type::increment ||
 132                         unary_type == unary_operator_type::decrement
 133                 ;
 134         }
 135
 136         std::string parse_tree_node::to_string() const
 137         {
 138                 switch(type)
 139                 {
 140                         case parse_tree_node_type::uninitialised:
 141                                 return "uninitialised";
 142
 143                         case parse_tree_node_type::variable:
 144                                 return "variable";
 145
 146                         case parse_tree_node_type::symbol:
 147                                 return "symbol: " + symbol_pointer->name + " (" + ail::hex_string_32((ulong)symbol_pointer) + ")";
 148
 149                         case parse_tree_node_type::unary_operator_node:
 150                                 return "unary operator (" + unary_operator_pointer->argument.to_string() + ")";
 151
 152                         case parse_tree_node_type::binary_operator_node:
 153                                 return "binary operator (" + binary_operator_pointer->left_argument.to_string() + ", " + binary_operator_pointer->right_argument.to_string() + ")";
 154
 155                         case parse_tree_node_type::call:
 156                                 return "call";
 157
 158                         case parse_tree_node_type::array:
 159                                 return "array";
 160
 161                         case parse_tree_node_type::call_operator:
 162                                 return "call operator";
 163
 164                         case parse_tree_node_type::spaced_call_operator:
 165                                 return "spaced call operator";
 166
 167                         case parse_tree_node_type::iterator:
 168                                 return "iterator";
 169
 170                         default:
 171                                 return "unknown (" + ail::number_to_string(static_cast<int>(type)) + ")";
 172                 }
 173         }
 174 }