interpreter/function.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         void parse_tree_node::copy(parse_tree_node const & other)
  25         {
  26                 std::cout << "parse_tree_node copy " << (void *)this << " from " << (void *)&other << std::endl;
  27
  28                 //std::cout << (int)other.type << std::endl;
  29
  30                 //std::cout << "Copying " << other.to_string() << std::endl;
  31
  32 #define COPY_MEMBER(type, member_type, member) \
  33                 case parse_tree_node_type::type: \
  34                         member = new member_type(*other.member); \
  35                         break;
  36
  37                 type = other.type;
  38
  39                 switch(other.type)
  40                 {
  41                         COPY_MEMBER(variable, variable, variable_pointer)
  42                         COPY_MEMBER(symbol, parse_tree_symbol, symbol_pointer)
  43                         COPY_MEMBER(unary_operator_node, parse_tree_unary_operator_node, unary_operator_pointer)
  44                         COPY_MEMBER(binary_operator_node, parse_tree_binary_operator_node, binary_operator_pointer)
  45                         COPY_MEMBER(call, parse_tree_call, call_pointer)
  46                         COPY_MEMBER(array, parse_tree_array, array_pointer)
  47                 }
  48
  49 #undef COPY_MEMBER
  50
  51                 //std::cout << "Result: " << to_string() << std::endl;
  52         }
  53
  54         void parse_tree_node::destroy()
  55         {
  56                 std::cout << "parse_tree_node destroy " << (void *)this << std::endl;
  57
  58 #define DELETE_MEMBER(type, member) \
  59                         case parse_tree_node_type::type: \
  60                                 delete member; \
  61                                 break;
  62
  63                 switch(type)
  64                 {
  65                         DELETE_MEMBER(variable, variable_pointer)
  66                         DELETE_MEMBER(symbol, symbol_pointer)
  67                         DELETE_MEMBER(unary_operator_node, unary_operator_pointer)
  68                         DELETE_MEMBER(binary_operator_node, binary_operator_pointer)
  69                         DELETE_MEMBER(call, call_pointer)
  70                         DELETE_MEMBER(array, array_pointer)
  71                 }
  72
  73                 type = parse_tree_node_type::uninitialised;
  74
  75 #undef DELETE_MEMBER
  76
  77         }
  78
  79         parse_tree_node & parse_tree_node::operator=(parse_tree_node const & other)
  80         {
  81                 destroy();
  82                 copy(other);
  83                 return *this;
  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
 175         parse_tree_symbol::parse_tree_symbol():
 176                 type(symbol_prefix::none)
 177         {
 178                 std::cout << "parse_tree_symbol " << (void *)this << std::endl;
 179         }
 180
 181         parse_tree_symbol::parse_tree_symbol(parse_tree_symbol const & other):
 182                 name(other.name),
 183                 type(other.type)
 184         {
 185                 std::cout << "parse_tree_symbol " << (void *)this << " from " << (void *)&other << std::endl;
 186         }
 187
 188         parse_tree_symbol::~parse_tree_symbol()
 189         {
 190                 std::cout << "~parse_tree_symbol " << (void *)this << std::endl;
 191         }
 192 }