frith/variable.cpp

   1 #include <ail/string.hpp>
   2 #include <frith/variable.hpp>
   3
   4 namespace frith
   5 {
   6         namespace
   7         {
   8                 std::string const zero_division_error_message = "Zero division error";
   9         }
  10
  11         unary_argument::unary_argument(variable & output, std::string & error_message):
  12                 output(output),
  13                 error_message(error_message)
  14         {
  15         }
  16
  17         binary_argument::binary_argument(variable const & other, variable & output, std::string & error_message)
  18                 other(other),
  19                 output(output),
  20                 error_message(error_message)
  21         {
  22         }
  23
  24         variable::variable():
  25                 type(variable_type::undefined)
  26         {
  27         }
  28
  29         variable::variable(variable const & other):
  30                 type(other.type)
  31         {
  32                 switch(type)
  33                 {
  34                 case variable_type::boolean:
  35                         boolean = other.boolean;
  36                         break;
  37
  38                 case variable_type::signed_integer:
  39                         signed_integer = other.signed_integer;
  40                         break;
  41
  42                 case variable_type::unsigned_integer:
  43                         unsigned_integer = other.unsigned_integer;
  44                         break;
  45
  46                 case variable_type::floating_point_value:
  47                         floating_point_value = other.floating_point_value;
  48                         break;
  49
  50                 case variable_type::string:
  51                         string = new string(*other.string);
  52                         break;
  53
  54                 case variable_type::array:
  55                         array = new variable_vector(*other.array);
  56                         break;
  57
  58                 case variable_type::map:
  59                         map = new variable_map(*other.map);
  60                         break;
  61                 }
  62         }
  63
  64         variable::~variable()
  65         {
  66                 switch(type)
  67                 {
  68                 case variable_type::string:
  69                         delete string;
  70                         break;
  71
  72                 case variable_type::array:
  73                         delete array;
  74                         break;
  75
  76                 case variable_type::map:
  77                         delete map;
  78                         break;
  79                 }
  80         }
  81
  82         variable_type variable::get_type() const
  83         {
  84                 return type;
  85         }
  86
  87         void variable::nil()
  88         {
  89                 type = variable_type::nil;
  90         }
  91
  92         void variable::new_boolean(types::boolean new_boolean)
  93         {
  94                 type = variable_type::boolean;
  95                 boolean = new_boolean;
  96         }
  97
  98         void variable::new_signed_integer(types::signed_integer new_signed_integer)
  99         {
 100                 type = variable_type::signed_integer;
 101                 signed_integer = new_signed_integer;
 102         }
 103
 104         void variable::new_unsigned_integer(types::unsigned_integer new_unsigned_integer)
 105         {
 106                 type = variable_type::unsigned_integer;
 107                 unsigned_integer = new_unsigned_integer;
 108         }
 109
 110         void variable::new_floating_point_value(types::floating_point_value new_floating_point_value)
 111         {
 112                 type = variable_type::floating_point_value;
 113                 floating_point_value = new_floating_point_value;
 114         }
 115
 116         void variable::new_string(types::string const & new_string)
 117         {
 118                 type = variable_type::string;
 119                 string = new std::string(new_string);
 120         }
 121
 122         void variable::new_array()
 123         {
 124                 type = variable_type::array;
 125                 array = new variable_vector();
 126         }
 127
 128         void variable::new_map()
 129         {
 130                 type = variable_type::map;
 131                 map = new variable_map();
 132         }
 133
 134         bool variable::array_addition(binary_argument & argument) const
 135         {
 136                 bool left_is_array = type == variable_type::array;
 137                 bool right_is_array = argument.other.type == variable_type::array;
 138
 139                 if(left_is_array || right_is_array)
 140                 {
 141                         argument.output.type = variable_type::array;
 142                         argument.output.array = new types::variable_vector;
 143                         types::variable_vector & vector = *argument.output.array;
 144
 145                         if(left_is_array && right_is_array)
 146                         {
 147                                 vector = *array;
 148                                 vector.append(*argument.other.array);
 149                         }
 150                         else if(left_is_array && !right_is_array)
 151                         {
 152                                 vector = *array;
 153                                 vector.push_back(argument.other);
 154                         }
 155                         else if(!left_is_array && right_is_array)
 156                         {
 157                                 vector = *argument.other.array;
 158                                 vector.push_back(*this);
 159                         }
 160                 }
 161                 else
 162                         return false;
 163
 164                 return true;
 165         }
 166
 167         bool variable::perform_string_conversion(std::string & output, bool & error)
 168         {
 169                 if(!get_string_representation(output_string))
 170                 {
 171                         error = true;
 172                         return false;
 173                 }
 174                 else
 175                         return true;
 176         }
 177
 178         bool variable::string_addition(binary_argument & argument, bool & error) const
 179         {
 180                 bool left_is_string = type == variable_type::string;
 181                 bool right_is_string = argument.other.type == variable_type::string;
 182
 183                 error = false;
 184
 185                 if(left_is_string || right_is_string)
 186                 {
 187                         argument.output.type = variable_type::string;
 188                         argument.output.string = new std::string;
 189                         std::string & output_string = *argument.output.string;
 190                         if(left_is_string && right_is_string)
 191                                 output_string = *string + *argument.other.string;
 192                         else if(left_is_string && !right_is_string)
 193                                 return other.argument.perform_string_conversion(output_string, error);
 194                         else if(!left_is_string && right_is_string)
 195                                 return perform_string_conversion(output_string, error);
 196                 }
 197                 else
 198                         return false;
 199
 200                 return true;
 201         }
 202
 203 #define ARITHMETIC_OPERATION(operator) \
 204                 if(is_numeric_type() && argument.other.is_numeric_type()) \
 205                 { \
 206                         if(is_floating_point_operation(argument)) \
 207                                 argument.output.new_floating_point_value(get_floating_point_value() operator argument.other.get_floating_point_value()); \
 208                         else \
 209                                 unsigned_integer = unsigned_integer operator argument.other.unsigned_integer; \
 210                 } \
 211                 else \
 212                 { \
 213                         argument.error_message = get_binary_argument_type_error(name_of_operation, type, argument.other.type); \
 214                         return false; \
 215                 } \
 216                 return true;
 217
 218         bool variable::addition(binary_argument & argument) const
 219         {
 220                 std::string const name_of_operation = "Addition";
 221
 222                 if(array_addition(argument))
 223                         return true;
 224
 225                 bool string_error;
 226                 if(string_addition(argument, string_error))
 227                         return true;
 228
 229                 if(string_error)
 230                 {
 231                         argument.error_message = get_binary_argument_type_error(name_of_operation, type, argument.other.type);
 232                         return false;
 233                 }
 234
 235                 ARITHMETIC_OPERATION(+)
 236         }
 237
 238         bool variable::subtraction(binary_argument & argument) const
 239         {
 240                 std::string const name_of_operation = "Subtraction";
 241                 ARITHMETIC_OPERATION(-)
 242         }
 243
 244         bool variable::multiplication(binary_argument & argument) const
 245         {
 246                 std::string const name_of_operation = "Multiplication";
 247                 ARITHMETIC_OPERATION(*)
 248         }
 249
 250         bool variable::division(binary_argument & argument) const
 251         {
 252                 std::string const name_of_operation = "Division";
 253                 if(argument.other.is_zero())
 254                 {
 255                         argument.error_message = zero_division_error_message;
 256                         return false;
 257                 }
 258                 ARITHMETIC_OPERATION(/)
 259         }
 260
 261         bool variable::modulo(binary_argument & argument) const
 262         {
 263                 std::string const name_of_operation = "Modulo";
 264                 if(argument.other.is_zero())
 265                 {
 266                         argument.error_message = zero_division_error_message;
 267                         return false;
 268                 }
 269                 ARITHMETIC_OPERATION(%)
 270         }
 271
 272         bool variable::negative(unary_argument & argument) const
 273         {
 274         }
 275
 276         bool variable::less_than(binary_argument & argument) const
 277         {
 278         }
 279
 280         bool variable::less_than_or_equal(binary_argument & argument) const
 281         {
 282         }
 283
 284         bool variable::greater_than(binary_argument & argument) const
 285         {
 286         }
 287
 288         bool variable::greater_than_or_equal(binary_argument & argument) const
 289         {
 290         }
 291
 292         bool variable::unequal(binary_argument & argument) const
 293         {
 294         }
 295
 296         bool variable::equal(binary_argument & argument) const
 297         {
 298         }
 299
 300         bool variable::logical_not(unary_argument & argument) const
 301         {
 302         }
 303
 304         bool variable::logical_and(binary_argument & argument) const
 305         {
 306         }
 307
 308         bool variable::logical_or(binary_argument & argument) const
 309         {
 310         }
 311
 312         bool variable::shift_left(binary_argument & argument) const
 313         {
 314         }
 315
 316         bool variable::shift_right(binary_argument & argument) const
 317         {
 318         }
 319
 320         bool variable::binary_and(binary_argument & argument) const
 321         {
 322         }
 323
 324         bool variable::binary_or(binary_argument & argument) const
 325         {
 326         }
 327
 328         bool variable::binary_xor(binary_argument & argument) const
 329         {
 330         }
 331
 332         bool variable::binary_not(unary_argument & argument) const
 333         {
 334         }
 335
 336         bool variabe::is_floating_point_operation(binary_argument & argument) const
 337         {
 338                 return type == variable_type::floating_point_value || argument.other.type == variable_type::floating_point_value;
 339         }
 340
 341         bool variabe::is_numeric_type(binary_argument & argument) const
 342         {
 343                 return
 344                         type == variable_type::signed_integer ||
 345                         type == variable_type::unsigned_integer ||
 346                         type == variable_type::floating_point_value;
 347         }
 348
 349         types::floating_point_value variable::get_floating_point_value() const
 350         {
 351                 switch(type)
 352                 {
 353                 case variable_type::signed_integer:
 354                         return signed_integer;
 355
 356                 case variable_type::unsigned_integer:
 357                         return unsigned_integer;
 358
 359                 case variable_type::floating_point_value:
 360                         return floating_point_value;
 361                 }
 362
 363                 throw ail::exception("Failed to retrieve floating point value");
 364         }
 365
 366         bool variable::get_string_representation(std::string & output) const
 367         {
 368                 switch(type)
 369                 {
 370                 case variable_type::boolean:
 371                         output = ail::bool_to_string(boolean);
 372                         break;
 373
 374                 case variable_type::signed_integer:
 375                         output = ail::number_to_string<types::signed_integer>(signed_integer);
 376                         break;
 377
 378                 case variable_type::unsigned_integer:
 379                         output = ail::number_to_string<types::unsigned_integer>(unsigned_integer);
 380                         break;
 381
 382                 case variable_type::floating_point_value:
 383                         output = ail::number_to_string<types::floating_point_value>(floating_point_value);
 384                         break;
 385
 386                 default:
 387                         return false;
 388                 }
 389
 390                 return true;
 391         }
 392
 393         bool variable::is_zero() const
 394         {
 395                 switch(type)
 396                 {
 397                 case variable_type::signed_integer:
 398                         return signed_integer == 0;
 399
 400                 case variable_type::unsigned_integer:
 401                         return unsigned_integer == 0;
 402
 403                 case variable_type::floating_point_value:
 404                         return floating_point_value == 0.0;
 405                 }
 406
 407                 throw exception("Unable to check if variable is zero");
 408         }
 409
 410         std::string get_type_string(variable_type type)
 411         {
 412                 switch(type)
 413                 {
 414                 case variable_type::undefined:
 415                         return "undefined";
 416
 417                 case variable_type::nil:
 418                         return "nil";
 419
 420                 case variable_type::boolean:
 421                         return "boolean";
 422
 423                 case variable_type::signed_integer:
 424                         return "integer";
 425
 426                 case variable_type::unsigned_integer:
 427                         return "unsigned-integer";
 428
 429                 case variable_type::floating_point_value:
 430                         return "float";
 431
 432                 case variable_type::string:
 433                         return "string";
 434
 435                 case variable_type::array:
 436                         return "array";
 437
 438                 case variable_type::map:
 439                         return "map";
 440                 }
 441
 442                 return "unknown";
 443         }
 444
 445         std::string get_binary_argument_type_error(std::string const & operation, variable_type left, variable_type right)
 446         {
 447                 return operation + ": Invalid argument types \"" + get_type_string(left) + "\", \"" + get_type_string(right);
 448         }
 449 }