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