variable/variable.cpp

   1 #include <ail/string.hpp>
   2 #include <fridh/symbol.hpp>
   3
   4 namespace fridh
   5 {
   6         namespace
   7         {
   8                 std::string const zero_division_error_message = "Zero division error";
   9         }
  10
  11         variable::variable():
  12                 type(variable_type_identifier::undefined)
  13         {
  14         }
  15
  16         variable::variable(variable const & other):
  17                 type(other.type)
  18         {
  19                 switch(type)
  20                 {
  21                 case variable_type_identifier::boolean:
  22                         boolean = other.boolean;
  23                         break;
  24
  25                 case variable_type_identifier::signed_integer:
  26                         signed_integer = other.signed_integer;
  27                         break;
  28
  29                 case variable_type_identifier::unsigned_integer:
  30                         unsigned_integer = other.unsigned_integer;
  31                         break;
  32
  33                 case variable_type_identifier::floating_point_value:
  34                         floating_point_value = other.floating_point_value;
  35                         break;
  36
  37                 case variable_type_identifier::string:
  38                         string = new std::string(*other.string);
  39                         break;
  40
  41                 case variable_type_identifier::array:
  42                         array = new types::vector(*other.array);
  43                         break;
  44
  45                 case variable_type_identifier::map:
  46                         map = new types::map(*other.map);
  47                         break;
  48                 }
  49         }
  50
  51         variable::~variable()
  52         {
  53                 switch(type)
  54                 {
  55                 case variable_type_identifier::string:
  56                         delete string;
  57                         break;
  58
  59                 case variable_type_identifier::array:
  60                         delete array;
  61                         break;
  62
  63                 case variable_type_identifier::map:
  64                         delete map;
  65                         break;
  66                 }
  67         }
  68
  69         types::floating_point_value variable::get_floating_point_value() const
  70         {
  71                 switch(type)
  72                 {
  73                 case variable_type_identifier::signed_integer:
  74                         return signed_integer;
  75
  76                 case variable_type_identifier::unsigned_integer:
  77                         return unsigned_integer;
  78
  79                 case variable_type_identifier::floating_point_value:
  80                         return floating_point_value;
  81                 }
  82
  83                 throw ail::exception("Failed to retrieve floating point value");
  84         }
  85
  86         std::string variable::get_string_representation() const
  87         {
  88                 switch(type)
  89                 {
  90                 case variable_type_identifier::boolean:
  91                         return ail::bool_to_string(boolean);
  92
  93                 case variable_type_identifier::signed_integer:
  94                         return ail::number_to_string<types::signed_integer>(signed_integer);
  95
  96                 case variable_type_identifier::unsigned_integer:
  97                         return ail::number_to_string<types::unsigned_integer>(unsigned_integer);
  98
  99                 case variable_type_identifier::floating_point_value:
 100                         return ail::number_to_string<types::floating_point_value>(floating_point_value);
 101
 102                 case variable_type_identifier::string:
 103                         return *string;
 104                 }
 105
 106                 get_unary_argument_type_error("String representation", type);
 107         }
 108
 109         bool variable::get_boolean_value() const
 110         {
 111                 switch(type)
 112                 {
 113                 case variable_type_identifier::boolean:
 114                         return boolean;
 115
 116                 case variable_type_identifier::signed_integer:
 117                         return signed_integer != 0;
 118
 119                 case variable_type_identifier::unsigned_integer:
 120                         return unsigned_integer != 0;
 121                 }
 122
 123                 get_unary_argument_type_error("Boolean representation", type);
 124         }
 125
 126         bool variable::is_zero() const
 127         {
 128                 switch(type)
 129                 {
 130                 case variable_type_identifier::signed_integer:
 131                         return signed_integer == 0;
 132
 133                 case variable_type_identifier::unsigned_integer:
 134                         return unsigned_integer == 0;
 135
 136                 case variable_type_identifier::floating_point_value:
 137                         return floating_point_value == 0.0;
 138                 }
 139
 140                 throw ail::exception("Unable to check if variable is zero");
 141         }
 142
 143         bool variable::operator<(variable const & other) const
 144         {
 145                 if(is_numeric_type() && other.is_numeric_type())
 146                 {
 147                         if
 148                         (
 149                                 type == variable_type_identifier::floating_point_value ||
 150                                 other.type == variable_type_identifier::floating_point_value
 151                         )
 152                                 return get_floating_point_value() < other.get_floating_point_value();
 153                         else if
 154                         (
 155                                 type == variable_type_identifier::unsigned_integer &&
 156                                 other.type == variable_type_identifier::unsigned_integer
 157                         )
 158                                 return unsigned_integer < other.unsigned_integer;
 159                         else
 160                                 return signed_integer < other.signed_integer;
 161                 }
 162                 else if(type != other.type)
 163                         return static_cast<word>(type) < static_cast<word>(other.type);
 164                 else
 165                 {
 166                         if(type == variable_type_identifier::string)
 167                                 return *string < *other.string;
 168                         else
 169                                 return hash() < other.hash();
 170                 }
 171         }
 172
 173         std::string get_type_string(variable_type type)
 174         {
 175                 switch(type)
 176                 {
 177                 case variable_type_identifier::undefined:
 178                         return "undefined";
 179
 180                 case variable_type_identifier::nil:
 181                         return "nil";
 182
 183                 case variable_type_identifier::none:
 184                         return "none";
 185
 186                 case variable_type_identifier::boolean:
 187                         return "boolean";
 188
 189                 case variable_type_identifier::signed_integer:
 190                         return "integer";
 191
 192                 case variable_type_identifier::unsigned_integer:
 193                         return "unsigned-integer";
 194
 195                 case variable_type_identifier::floating_point_value:
 196                         return "float";
 197
 198                 case variable_type_identifier::string:
 199                         return "string";
 200
 201                 case variable_type_identifier::array:
 202                         return "array";
 203
 204                 case variable_type_identifier::map:
 205                         return "map";
 206
 207                 case variable_type_identifier::function:
 208                         return "function";
 209
 210                 case variable_type_identifier::object:
 211                         return "object";
 212                 }
 213
 214                 return "unknown";
 215         }
 216 }