frith/variable.cpp

   1 #include <ail/string.hpp>
   2 #include <frith/variable.hpp>
   3 #include <fnv.hpp>
   4
   5 namespace frith
   6 {
   7         namespace
   8         {
   9                 std::string const zero_division_error_message = "Zero division error";
  10         }
  11
  12         unary_argument::unary_argument(variable & output, std::string & error_message):
  13                 output(output),
  14                 error_message(error_message)
  15         {
  16         }
  17
  18         binary_argument::binary_argument(variable const & other, variable & output, std::string & error_message):
  19                 other(other),
  20                 output(output),
  21                 error_message(error_message)
  22         {
  23         }
  24
  25         variable::variable():
  26                 type(variable_type_identifier::undefined)
  27         {
  28         }
  29
  30         variable::variable(variable const & other):
  31                 type(other.type)
  32         {
  33                 switch(type)
  34                 {
  35                 case variable_type_identifier::boolean:
  36                         boolean = other.boolean;
  37                         break;
  38
  39                 case variable_type_identifier::signed_integer:
  40                         signed_integer = other.signed_integer;
  41                         break;
  42
  43                 case variable_type_identifier::unsigned_integer:
  44                         unsigned_integer = other.unsigned_integer;
  45                         break;
  46
  47                 case variable_type_identifier::floating_point_value:
  48                         floating_point_value = other.floating_point_value;
  49                         break;
  50
  51                 case variable_type_identifier::string:
  52                         string = new std::string(*other.string);
  53                         break;
  54
  55                 case variable_type_identifier::array:
  56                         array = new types::vector(*other.array);
  57                         break;
  58
  59                 case variable_type_identifier::map:
  60                         map = new types::map(*other.map);
  61                         break;
  62                 }
  63         }
  64
  65         variable::~variable()
  66         {
  67                 switch(type)
  68                 {
  69                 case variable_type_identifier::string:
  70                         delete string;
  71                         break;
  72
  73                 case variable_type_identifier::array:
  74                         delete array;
  75                         break;
  76
  77                 case variable_type_identifier::map:
  78                         delete map;
  79                         break;
  80                 }
  81         }
  82
  83         variable_type variable::get_type() const
  84         {
  85                 return type;
  86         }
  87
  88         void variable::nil()
  89         {
  90                 type = variable_type_identifier::nil;
  91         }
  92
  93         void variable::new_boolean(types::boolean new_boolean)
  94         {
  95                 type = variable_type_identifier::boolean;
  96                 boolean = new_boolean;
  97         }
  98
  99         void variable::new_signed_integer(types::signed_integer new_signed_integer)
 100         {
 101                 type = variable_type_identifier::signed_integer;
 102                 signed_integer = new_signed_integer;
 103         }
 104
 105         void variable::new_unsigned_integer(types::unsigned_integer new_unsigned_integer)
 106         {
 107                 type = variable_type_identifier::unsigned_integer;
 108                 unsigned_integer = new_unsigned_integer;
 109         }
 110
 111         void variable::new_floating_point_value(types::floating_point_value new_floating_point_value)
 112         {
 113                 type = variable_type_identifier::floating_point_value;
 114                 floating_point_value = new_floating_point_value;
 115         }
 116
 117         void variable::new_string(types::string const & new_string)
 118         {
 119                 type = variable_type_identifier::string;
 120                 string = new std::string(new_string);
 121         }
 122
 123         void variable::new_array()
 124         {
 125                 type = variable_type_identifier::array;
 126                 array = new types::vector();
 127         }
 128
 129         void variable::new_map()
 130         {
 131                 type = variable_type_identifier::map;
 132                 map = new types::map();
 133         }
 134
 135         bool variable::array_addition(binary_argument & argument) const
 136         {
 137                 bool left_is_array = type == variable_type_identifier::array;
 138                 bool right_is_array = argument.other.type == variable_type_identifier::array;
 139
 140                 if(left_is_array || right_is_array)
 141                 {
 142                         argument.output.type = variable_type_identifier::array;
 143                         argument.output.array = new types::vector;
 144                         types::vector & vector = *argument.output.array;
 145
 146                         if(left_is_array && right_is_array)
 147                         {
 148                                 vector = *array;
 149                                 types::vector & right_vector = *argument.other.array;
 150                                 vector.insert(vector.end(), right_vector.begin(), right_vector.end());
 151                         }
 152                         else if(left_is_array && !right_is_array)
 153                         {
 154                                 vector = *array;
 155                                 vector.push_back(argument.other);
 156                         }
 157                         else if(!left_is_array && right_is_array)
 158                         {
 159                                 vector = *argument.other.array;
 160                                 vector.push_back(*this);
 161                         }
 162                 }
 163                 else
 164                         return false;
 165
 166                 return true;
 167         }
 168
 169         bool variable::perform_string_conversion(std::string & output, bool & error) const
 170         {
 171                 if(!get_string_representation(output))
 172                 {
 173                         error = true;
 174                         return false;
 175                 }
 176                 else
 177                         return true;
 178         }
 179
 180         bool variable::string_addition(binary_argument & argument, bool & error) const
 181         {
 182                 bool left_is_string = type == variable_type_identifier::string;
 183                 bool right_is_string = argument.other.type == variable_type_identifier::string;
 184
 185                 error = false;
 186
 187                 if(left_is_string || right_is_string)
 188                 {
 189                         argument.output.type = variable_type_identifier::string;
 190                         argument.output.string = new std::string;
 191                         std::string & output_string = *argument.output.string;
 192                         if(left_is_string && right_is_string)
 193                                 output_string = *string + *argument.other.string;
 194                         else if(left_is_string && !right_is_string)
 195                                 return argument.other.perform_string_conversion(output_string, error);
 196                         else if(!left_is_string && right_is_string)
 197                                 return perform_string_conversion(output_string, error);
 198                 }
 199                 else
 200                         return false;
 201
 202                 return true;
 203         }
 204
 205 #define ARITHMETIC_OPERATION(operator) \
 206                 if(is_numeric_type() && argument.other.is_numeric_type()) \
 207                 { \
 208                         if(is_floating_point_operation(argument)) \
 209                                 argument.output.new_floating_point_value(get_floating_point_value() operator argument.other.get_floating_point_value()); \
 210                         else if(type == variable_type_identifier::unsigned_integer && argument.other.type == variable_type_identifier::unsigned_integer) \
 211                                 argument.output.new_unsigned_integer(unsigned_integer operator argument.other.unsigned_integer); \
 212                         else \
 213                                 argument.output.new_signed_integer(signed_integer operator argument.other.signed_integer); \
 214                 } \
 215                 else \
 216                 { \
 217                         argument.error_message = get_binary_argument_type_error(name_of_operation, type, argument.other.type); \
 218                         return false; \
 219                 } \
 220                 return true;
 221
 222         bool variable::addition(binary_argument & argument) const
 223         {
 224                 std::string const name_of_operation = "Addition";
 225
 226                 if(array_addition(argument))
 227                         return true;
 228
 229                 bool string_error;
 230                 if(string_addition(argument, string_error))
 231                         return true;
 232
 233                 if(string_error)
 234                 {
 235                         argument.error_message = get_binary_argument_type_error(name_of_operation, type, argument.other.type);
 236                         return false;
 237                 }
 238
 239                 ARITHMETIC_OPERATION(+)
 240         }
 241
 242         bool variable::subtraction(binary_argument & argument) const
 243         {
 244                 std::string const name_of_operation = "Subtraction";
 245                 ARITHMETIC_OPERATION(-)
 246         }
 247
 248         bool variable::multiplication(binary_argument & argument) const
 249         {
 250                 std::string const name_of_operation = "Multiplication";
 251                 ARITHMETIC_OPERATION(*)
 252         }
 253
 254         bool variable::division(binary_argument & argument) const
 255         {
 256                 std::string const name_of_operation = "Division";
 257                 if(argument.other.is_zero())
 258                 {
 259                         argument.error_message = zero_division_error_message;
 260                         return false;
 261                 }
 262                 ARITHMETIC_OPERATION(/)
 263         }
 264
 265         bool variable::modulo(binary_argument & argument) const
 266         {
 267                 std::string const name_of_operation = "Modulo";
 268                 if(argument.other.is_zero())
 269                 {
 270                         argument.error_message = zero_division_error_message;
 271                         return false;
 272                 }
 273                 else if(is_integer_type() && argument.other.is_integer_type())
 274                 {
 275                         if(type == variable_type_identifier::unsigned_integer && argument.other.type == variable_type_identifier::unsigned_integer)
 276                                 argument.output.new_unsigned_integer(unsigned_integer % argument.other.unsigned_integer);
 277                         else
 278                                 argument.output.new_signed_integer(signed_integer % argument.other.signed_integer);
 279                 }
 280                 else
 281                 {
 282                         argument.error_message = get_binary_argument_type_error(name_of_operation, type, argument.other.type);
 283                         return false;
 284                 }
 285         }
 286
 287         bool variable::negative(unary_argument & argument) const
 288         {
 289                 argument.output.type = type;
 290                 switch(type)
 291                 {
 292                 case variable_type_identifier::signed_integer:
 293                         argument.output.signed_integer = - signed_integer;
 294                         break;
 295
 296                 case variable_type_identifier::unsigned_integer:
 297                         argument.output.type = variable_type_identifier::signed_integer;
 298                         argument.output.signed_integer = - static_cast<types::signed_integer>(unsigned_integer);
 299                         break;
 300
 301                 case variable_type_identifier::floating_point_value:
 302                         argument.output.floating_point_value = - floating_point_value;
 303                         break;
 304
 305                 default:
 306                         argument.error_message = "Cannot use unary minus on type " + get_type_string(type);
 307                         return false;
 308                 }
 309
 310                 return true;
 311         }
 312
 313 #define NUMERIC_COMPARISON(operator) \
 314                 if(is_numeric_type() && argument.other.is_numeric_type()) \
 315                 { \
 316                         if(is_floating_point_operation(argument)) \
 317                                 argument.output.new_boolean(get_floating_point_value() operator argument.other.get_floating_point_value()); \
 318                         else if(type == variable_type_identifier::unsigned_integer && argument.other.type == variable_type_identifier::signed_integer) \
 319                                 argument.output.new_boolean(unsigned_integer operator argument.other.unsigned_integer); \
 320                         else \
 321                                 argument.output.new_boolean(signed_integer operator argument.other.signed_integer); \
 322                 } \
 323                 else \
 324                 { \
 325                         argument.error_message = get_binary_argument_type_error(name_of_operation, type, argument.other.type); \
 326                         return false; \
 327                 } \
 328                 return true;
 329
 330         bool variable::less_than(binary_argument & argument) const
 331         {
 332                 std::string const name_of_operation = "Less than";
 333                 NUMERIC_COMPARISON(<=)
 334         }
 335
 336         bool variable::less_than_or_equal(binary_argument & argument) const
 337         {
 338                 std::string const name_of_operation = "Less than or equal";
 339                 NUMERIC_COMPARISON(<=)
 340         }
 341
 342         bool variable::greater_than(binary_argument & argument) const
 343         {
 344                 std::string const name_of_operation = "Greater than";
 345                 NUMERIC_COMPARISON(<=)
 346         }
 347
 348         bool variable::greater_than_or_equal(binary_argument & argument) const
 349         {
 350                 std::string const name_of_operation = "Greater than or equal";
 351                 NUMERIC_COMPARISON(<=)
 352         }
 353
 354         bool variable::unequal(binary_argument & argument) const
 355         {
 356                 argument.output.new_boolean(operator!=(argument.other));
 357                 return true;
 358         }
 359
 360         bool variable::equal(binary_argument & argument) const
 361         {
 362                 argument.output.new_boolean(operator==(argument.other));
 363                 return true;
 364         }
 365
 366         bool variable::logical_not(unary_argument & argument) const
 367         {
 368                 bool value;
 369                 if(get_boolean_value(value))
 370                 {
 371                         argument.output.new_boolean(!value);
 372                         return true;
 373                 }
 374                 else
 375                 {
 376                         argument.error_message = get_unary_argument_type_error("Logical not", type);
 377                         return false;
 378                 }
 379         }
 380
 381 #define LOGICAL_OPERATOR(name, operator) \
 382                 bool \
 383                         left_value, \
 384                         right_value; \
 385                 if(get_boolean_value(left_value) && argument.other.get_boolean_value(right_value)) \
 386                 { \
 387                         argument.output.new_boolean(left_value operator right_value); \
 388                         return true; \
 389                 } \
 390                 else \
 391                 { \
 392                         argument.error_message = get_unary_argument_type_error(name, type); \
 393                         return false; \
 394                 }
 395
 396         bool variable::logical_and(binary_argument & argument) const
 397         {
 398                 LOGICAL_OPERATOR("Logical and", &&)
 399         }
 400
 401         bool variable::logical_or(binary_argument & argument) const
 402         {
 403                 LOGICAL_OPERATOR("Logical or", ||)
 404         }
 405
 406 #define BINARY_OPERATOR(name, operator) \
 407                 if(is_integer_type() && argument.other.is_integer_type()) \
 408                 { \
 409                         argument.output.new_unsigned_integer(unsigned_integer operator argument.other.unsigned_integer); \
 410                         return true; \
 411                 } \
 412                 else \
 413                 { \
 414                         argument.error_message = get_binary_argument_type_error(name, type, argument.other.type); \
 415                         return false; \
 416                 }
 417
 418         bool variable::shift_left(binary_argument & argument) const
 419         {
 420                 BINARY_OPERATOR("Shift left", <<)
 421         }
 422
 423         bool variable::shift_right(binary_argument & argument) const
 424         {
 425                 BINARY_OPERATOR("Shift right", >>)
 426         }
 427
 428         bool variable::binary_and(binary_argument & argument) const
 429         {
 430                 BINARY_OPERATOR("Binary and", &)
 431         }
 432
 433         bool variable::binary_or(binary_argument & argument) const
 434         {
 435                 BINARY_OPERATOR("Binary or", |)
 436         }
 437
 438         bool variable::binary_xor(binary_argument & argument) const
 439         {
 440                 BINARY_OPERATOR("Binary exclusive or", ^)
 441         }
 442
 443         bool variable::binary_not(unary_argument & argument) const
 444         {
 445                 if(is_integer_type())
 446                 {
 447                         argument.output.new_unsigned_integer(~unsigned_integer);
 448                         return true;
 449                 }
 450                 else
 451                 {
 452                         argument.error_message = get_unary_argument_type_error("Binary not", type);
 453                         return false;
 454                 }
 455         }
 456
 457         bool variable::is_floating_point_operation(binary_argument & argument) const
 458         {
 459                 return type == variable_type_identifier::floating_point_value || argument.other.type == variable_type_identifier::floating_point_value;
 460         }
 461
 462         bool variable::is_integer_type() const
 463         {
 464                 return
 465                         type == variable_type_identifier::signed_integer ||
 466                         type == variable_type_identifier::unsigned_integer;
 467         }
 468
 469         bool variable::is_numeric_type() const
 470         {
 471                 return
 472                         type == variable_type_identifier::signed_integer ||
 473                         type == variable_type_identifier::unsigned_integer ||
 474                         type == variable_type_identifier::floating_point_value;
 475         }
 476
 477         types::floating_point_value variable::get_floating_point_value() const
 478         {
 479                 switch(type)
 480                 {
 481                 case variable_type_identifier::signed_integer:
 482                         return signed_integer;
 483
 484                 case variable_type_identifier::unsigned_integer:
 485                         return unsigned_integer;
 486
 487                 case variable_type_identifier::floating_point_value:
 488                         return floating_point_value;
 489                 }
 490
 491                 throw ail::exception("Failed to retrieve floating point value");
 492         }
 493
 494         bool variable::get_string_representation(std::string & output) const
 495         {
 496                 switch(type)
 497                 {
 498                 case variable_type_identifier::boolean:
 499                         output = ail::bool_to_string(boolean);
 500                         break;
 501
 502                 case variable_type_identifier::signed_integer:
 503                         output = ail::number_to_string<types::signed_integer>(signed_integer);
 504                         break;
 505
 506                 case variable_type_identifier::unsigned_integer:
 507                         output = ail::number_to_string<types::unsigned_integer>(unsigned_integer);
 508                         break;
 509
 510                 case variable_type_identifier::floating_point_value:
 511                         output = ail::number_to_string<types::floating_point_value>(floating_point_value);
 512                         break;
 513
 514                 default:
 515                         return false;
 516                 }
 517
 518                 return true;
 519         }
 520
 521         bool variable::get_boolean_value(bool & output) const
 522         {
 523                 switch(type)
 524                 {
 525                 case variable_type_identifier::boolean:
 526                         output = boolean;
 527                         break;
 528
 529                 case variable_type_identifier::signed_integer:
 530                         output = signed_integer != 0;
 531                         break;
 532
 533                 case variable_type_identifier::unsigned_integer:
 534                         output = unsigned_integer != 0;
 535                         break;
 536
 537                 default:
 538                         return false;
 539                 }
 540
 541                 return true;
 542         }
 543
 544         bool variable::is_zero() const
 545         {
 546                 switch(type)
 547                 {
 548                 case variable_type_identifier::signed_integer:
 549                         return signed_integer == 0;
 550
 551                 case variable_type_identifier::unsigned_integer:
 552                         return unsigned_integer == 0;
 553
 554                 case variable_type_identifier::floating_point_value:
 555                         return floating_point_value == 0.0;
 556                 }
 557
 558                 throw ail::exception("Unable to check if variable is zero");
 559         }
 560
 561         bool variable::array_equality(variable const & other) const
 562         {
 563                 types::vector
 564                         & vector = *array,
 565                         & other_vector = *other.array;
 566
 567                 std::size_t size = vector.size();
 568                 if(size != vector.size())
 569                         return false;
 570
 571                 for(std::size_t i = 0; i < size; i++)
 572                 {
 573                         if(vector[i] != other_vector[i])
 574                                 return false;
 575                 }
 576
 577                 return true;
 578         }
 579
 580         bool variable::map_equality(variable const & other) const
 581         {
 582                 types::map
 583                         & this_map = *map,
 584                         & other_map = *other.map;
 585
 586                 if(this_map.size() != other_map.size())
 587                         return false;
 588
 589                 for(types::map::const_iterator i = this_map.begin(), end = this_map.end(); i != end; i++)
 590                 {
 591                         types::map::const_iterator iterator = other_map.find(i->first);
 592                         if(iterator == other_map.end())
 593                                 return false;
 594
 595                         if(i->second != iterator->second)
 596                                 return false;
 597                 }
 598
 599                 return true;
 600         }
 601
 602         bool variable::operator==(variable const & other) const
 603         {
 604                 if(is_numeric_type() && other.is_numeric_type())
 605                 {
 606                         if(type == variable_type_identifier::floating_point_value || other.type == variable_type_identifier::floating_point_value)
 607                                 return get_floating_point_value() == other.get_floating_point_value();
 608                         else
 609                                 return unsigned_integer == other.unsigned_integer;
 610                 }
 611                 else
 612                 {
 613                         switch(type)
 614                         {
 615                         case variable_type_identifier::nil:
 616                                 return type == other.type;
 617
 618                         case variable_type_identifier::boolean:
 619                                 return type == other.type && boolean == other.boolean;
 620
 621                         case variable_type_identifier::string:
 622                                 return type == other.type && *string == *other.string;
 623
 624                         case variable_type_identifier::array:
 625                                 return array_equality(other);
 626
 627                         case variable_type_identifier::map:
 628                                 return map_equality(other);
 629
 630                         case variable_type_identifier::function:
 631                                 throw ail::exception("Comparison of functions has not been implemented yet");
 632
 633                         case variable_type_identifier::signed_integer:
 634                         case variable_type_identifier::unsigned_integer:
 635                         case variable_type_identifier::floating_point_value:
 636                         default:
 637                                 return false;
 638                         }
 639                 }
 640         }
 641
 642         bool variable::operator!=(variable const & other) const
 643         {
 644                 return !operator==(other);
 645         }
 646
 647         bool variable::operator<(variable const & other) const
 648         {
 649                 if(is_numeric_type() && other.is_numeric_type())
 650                 {
 651                         if
 652                         (
 653                                 type == variable_type_identifier::floating_point_value ||
 654                                 other.type == variable_type_identifier::floating_point_value
 655                         )
 656                                 return get_floating_point_value() < other.get_floating_point_value();
 657                         else if
 658                         (
 659                                 type == variable_type_identifier::unsigned_integer &&
 660                                 other.type == variable_type_identifier::unsigned_integer
 661                         )
 662                                 return unsigned_integer < other.unsigned_integer;
 663                         else
 664                                 return signed_integer < other.signed_integer;
 665                 }
 666                 else if(type != other.type)
 667                         return static_cast<word>(type) < static_cast<word>(other.type);
 668                 else
 669                 {
 670                         if(type == variable_type_identifier::string)
 671                                 return *string < *other.string;
 672                         else
 673                         {
 674
 675                         }
 676                 }
 677         }
 678
 679         uword variable::array_hash(uword previous_hash) const
 680         {
 681                 uword hash = previous_hash;
 682                 for(types::vector::iterator i = array->begin(), end = array->end(); i != end; i++)
 683                         hash = i->hash(hash);
 684                 return hash;
 685         }
 686
 687         uword variable::map_hash(uword previous_hash) const
 688         {
 689                 uword hash = previous_hash;
 690                 for(types::map::iterator i = map->begin(), end = map->end(); i != end; i++)
 691                 {
 692                         hash = i->first.hash(hash);
 693                         hash = i->second.hash(hash);
 694                 }
 695                 return hash;
 696         }
 697
 698         uword variable::hash(uword previous_hash) const
 699         {
 700                 switch(type)
 701                 {
 702                 case variable_type_identifier::undefined:
 703                         throw ail::exception("Attempted to calculate the hash of an undefined variable");
 704
 705                 case variable_type_identifier::nil:
 706                 {
 707                         std::string const value = "nil";
 708                         return fnv1a_hash(value.c_str(), value.size(), previous_hash);
 709                 }
 710
 711                 case variable_type_identifier::boolean:
 712                         return fnv1a_hash(hash_pointer, sizeof(types::signed_integer), previous_hash);
 713
 714                 case variable_type_identifier::signed_integer:
 715                         return fnv1a_hash(hash_pointer, sizeof(types::signed_integer), previous_hash);
 716
 717                 case variable_type_identifier::unsigned_integer:
 718                         return fnv1a_hash(hash_pointer, sizeof(types::unsigned_integer), previous_hash);
 719
 720                 case variable_type_identifier::floating_point_value:
 721                         return fnv1a_hash(hash_pointer, sizeof(types::floating_point_value), previous_hash);
 722
 723                 case variable_type_identifier::string:
 724                         return fnv1a_hash(string->c_str(), string->size(), previous_hash);
 725
 726                 case variable_type_identifier::array:
 727                         return array_hash(previous_hash);
 728
 729                 case variable_type_identifier::map:
 730                         return map_hash(previous_hash);
 731
 732                 case variable_type_identifier::function:
 733                         throw ail::exception("Hashing for functions has not been implemented yet");
 734                 }
 735         }
 736
 737         std::string get_type_string(variable_type type)
 738         {
 739                 switch(type)
 740                 {
 741                 case variable_type_identifier::undefined:
 742                         return "undefined";
 743
 744                 case variable_type_identifier::nil:
 745                         return "nil";
 746
 747                 case variable_type_identifier::boolean:
 748                         return "boolean";
 749
 750                 case variable_type_identifier::signed_integer:
 751                         return "integer";
 752
 753                 case variable_type_identifier::unsigned_integer:
 754                         return "unsigned-integer";
 755
 756                 case variable_type_identifier::floating_point_value:
 757                         return "float";
 758
 759                 case variable_type_identifier::string:
 760                         return "string";
 761
 762                 case variable_type_identifier::array:
 763                         return "array";
 764
 765                 case variable_type_identifier::map:
 766                         return "map";
 767
 768                 case variable_type_identifier::function:
 769                         return "function";
 770                 }
 771
 772                 return "unknown";
 773         }
 774
 775         std::string get_unary_argument_type_error(std::string const & operation, variable_type type)
 776         {
 777                 return operation + ": Invalid argument type \"" + get_type_string(type) + "\"";
 778         }
 779
 780         std::string get_binary_argument_type_error(std::string const & operation, variable_type left, variable_type right)
 781         {
 782                 return operation + ": Invalid argument types \"" + get_type_string(left) + "\", \"" + get_type_string(right);
 783         }
 784 }