src/ops.cpp

   1
   2 #include "private.h"
   3
   4 namespace Aqua
   5 {
   6     using namespace Internal;
   7
   8     Interpreter::Value Interpreter::operator()(Variable<Iter,Interpreter::Value,FuncType> &node)
   9     {
  10         return get(node.name);
  11     }
  12
  13     Interpreter::Value Interpreter::operator()(FieldName<Iter,Interpreter::Value,FuncType> &node)
  14     {
  15         return node.name;
  16     }
  17
  18     Interpreter::Value Interpreter::operator()(Constant<Iter,Interpreter::Value,FuncType> &node)
  19     {
  20         return node.value;
  21     }
  22
  23     Interpreter::Value Interpreter::operator()(Nop<Iter,Interpreter::Value,FuncType>&)
  24     {
  25         return Interpreter::Value(1.0);
  26     }
  27
  28     Interpreter::Value Interpreter::operator()(Nil<Iter,Interpreter::Value,FuncType>&)
  29     {
  30         return Interpreter::Value();
  31     }
  32
  33     Interpreter::Value Interpreter::operator()(String<Iter,Interpreter::Value,FuncType> &node)
  34     {
  35         return node.value;
  36     }
  37
  38     Interpreter::Value Interpreter::operator()(Parens<Iter,Interpreter::Value,FuncType> &node)
  39     {
  40         return node.children[0]->accept(*this);
  41     }
  42
  43
  44     Interpreter::Value Interpreter::operator()(Type<Iter,Interpreter::Value,FuncType> &node)
  45     {
  46         Interpreter::Value expr;
  47         expr = node.children[0]->accept(*this);
  48         switch(expr.type())
  49         {
  50             case Interpreter::Value::Type::String:
  51                 return Interpreter::Value(std::string("string"));
  52             case Interpreter::Value::Type::Number:
  53                 return Interpreter::Value(std::string("number"));
  54             case Interpreter::Value::Type::Tree:
  55                 return Interpreter::Value(std::string("tree"));
  56             case Interpreter::Value::Type::Function:
  57                 return Interpreter::Value(std::string("function"));
  58             case Interpreter::Value::Type::Table:
  59                 return Interpreter::Value(std::string("table"));
  60             case Interpreter::Value::Type::Array:
  61                 return Interpreter::Value(std::string("array"));
  62             case Interpreter::Value::Type::Nil:
  63                 return Interpreter::Value(std::string("nil"));
  64             default:
  65                 error("unknown type", node);
  66                 return Interpreter::Value();
  67         }
  68     }
  69
  70     Interpreter::Value Interpreter::operator()(Size<Iter,Interpreter::Value,FuncType> &node)
  71     {
  72         Interpreter::Value expr;
  73         expr = node.children[0]->accept(*this);
  74         switch(expr.type())
  75         {
  76             case Interpreter::Value::Type::String:
  77                 return Interpreter::Value(expr.string().size());
  78             case Interpreter::Value::Type::Number:
  79                 return Interpreter::Value(1);
  80             case Interpreter::Value::Type::Tree:
  81                 return Interpreter::Value(expr.pointer()->size());
  82             case Interpreter::Value::Type::Function:
  83                 return Interpreter::Value(expr.pointer()->size());
  84             case Interpreter::Value::Type::Table:
  85                 return Interpreter::Value(expr.table()->size());
  86             case Interpreter::Value::Type::Array:
  87                 return Interpreter::Value(expr.array()->size());
  88             case Interpreter::Value::Type::Nil:
  89                 return Interpreter::Value(0.0);
  90             default:
  91                 error("unknown type", node);
  92                 return Interpreter::Value();
  93         }
  94     }
  95
  96     Interpreter::Value Interpreter::operator()(FieldAccess<Iter,Interpreter::Value,FuncType> &node)
  97     {
  98         int idx;
  99         Interpreter::Value left;
 100         Interpreter::Value right;
 101         left = node.children[0]->accept(*this);
 102         if(left.type() == Interpreter::Value::Type::Table)
 103         {
 104             right = node.children[1]->accept(*this);
 105             return left.table()->get(right);
 106         }
 107         else if(left.type() == Interpreter::Value::Type::Array)
 108         {
 109             right = node.children[1]->accept(*this);
 110             if(right.type() != Interpreter::Value::Type::Number || !isint(right.number()))
 111             {
 112                 error("array index not a integer", node);
 113             }
 114             idx = right.number();
 115             if(idx<0 || idx>=int(left.array()->size()))
 116             {
 117                 error("array index out of range", node);
 118             }
 119             return left.array()->get(right);
 120         }
 121         else if(left.type() == Interpreter::Value::Type::String)
 122         {
 123             auto selfstr = left.string();
 124             right = node.children[1]->accept(*this);
 125             if(right.type() != Interpreter::Value::Type::Number || !isint(right.number()))
 126             {
 127                 error("string index not an integer", node);
 128             }
 129             idx = right.number();
 130             if((idx < 0) || (idx >= int(selfstr.size())))
 131             {
 132                 error("string index out of range", node);
 133             }
 134             return Value(Value::NumberType(selfstr.at(idx)));
 135         }
 136         else
 137         {
 138             error("can only index tables or arrays", node);
 139             return Interpreter::Value();
 140         }
 141     }
 142
 143     Interpreter::Value Interpreter::operator()(FieldAssignment<Iter,Interpreter::Value,FuncType> &node)
 144     {
 145         Interpreter::Value table;
 146         table = node.children[0]->accept(*this);
 147         if(table.type() == Interpreter::Value::Type::Table)
 148         {
 149             Interpreter::Value index = node.children[1]->accept(*this);
 150             Interpreter::Value value = node.children[2]->accept(*this);
 151             table.table()->set(index, value);
 152             return value;
 153         }
 154         else if(table.type() == Interpreter::Value::Type::Array)
 155         {
 156             Interpreter::Value index = node.children[1]->accept(*this);
 157             if(index.type() != Interpreter::Value::Type::Number || !isint(index.number()))
 158             {
 159                 error("array index not a integer.", node);
 160             }
 161             int idx = index.number();
 162             if(idx<0 || idx>=int(table.array()->size()))
 163             {
 164                 error("array index out of range.", node);
 165             }
 166             Interpreter::Value value = node.children[2]->accept(*this);
 167             table.array()->set(index, value);
 168             return value;
 169         }
 170         else
 171         {
 172             error("can only index tables or arrays.", node);
 173             return Interpreter::Value();
 174         }
 175     }
 176
 177     Interpreter::Value Interpreter::operator()(AddFieldAssignment<Iter,Interpreter::Value,FuncType> &node)
 178     {
 179         Interpreter::Value table;
 180         Interpreter::Value index, left, right;
 181         Interpreter::Value::Type t;
 182         table = node.children[0]->accept(*this);
 183         t = table.type();
 184         if(t == Interpreter::Value::Type::Table)
 185         {
 186             index = node.children[1]->accept(*this);
 187             left = table.table()->get(index);
 188             right = node.children[2]->accept(*this);
 189         }
 190         else if(t == Interpreter::Value::Type::Array)
 191         {
 192             index = node.children[1]->accept(*this);
 193             if(index.type() != Interpreter::Value::Type::Number || !isint(index.number()))
 194             {
 195                 error("array index not a integer.", node);
 196             }
 197             int idx = index.number();
 198             if(idx<0 || idx>=int(table.array()->size()))
 199             {
 200                 error("array index out of range.", node);
 201             }
 202             left = table.array()->get(index);
 203             right = node.children[2]->accept(*this);
 204         }
 205         else
 206         {
 207             error("can only index tables and arrays.", node);
 208             return Interpreter::Value();
 209         }
 210         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 211         {
 212             left = Interpreter::Value(left.number() + right.number());
 213         }
 214         else if(left.type() == Interpreter::Value::Type::String && right.type() == Interpreter::Value::Type::String)
 215         {
 216             left.string() += right.string();
 217         }
 218         else if(left.type() == Interpreter::Value::Type::Table && right.type() == Interpreter::Value::Type::Table)
 219         {
 220             left.table()->append(*right.table());
 221         }
 222         else if(left.type() == Interpreter::Value::Type::Array && right.type() == Interpreter::Value::Type::Array)
 223         {
 224             left.array()->append(*right.array());
 225         }
 226         else
 227         {
 228             error("invalid operands '+='.", node);
 229             return Interpreter::Value();
 230         }
 231         if(t == Interpreter::Value::Type::Table)
 232         {
 233             table.table()->set(index, left);
 234         }
 235         else if(t == Interpreter::Value::Type::Array)
 236         {
 237             table.array()->set(index, left);
 238         }
 239         return left;
 240     }
 241
 242     Interpreter::Value Interpreter::operator()(SubFieldAssignment<Iter,Interpreter::Value,FuncType> &node)
 243     {
 244         Interpreter::Value table = node.children[0]->accept(*this);
 245         Interpreter::Value index, left, right;
 246         Interpreter::Value::Type t = table.type();
 247         if(t == Interpreter::Value::Type::Table)
 248         {
 249             index = node.children[1]->accept(*this);
 250             left = table.table()->get(index);
 251             right = node.children[2]->accept(*this);
 252         }
 253         else if(t == Interpreter::Value::Type::Array)
 254         {
 255             index = node.children[1]->accept(*this);
 256             if(index.type() != Interpreter::Value::Type::Number || !isint(index.number()))
 257             {
 258                 error("array index not a integer.", node);
 259             }
 260             int idx = index.number();
 261             if(idx<0 || idx>=int(table.array()->size()))
 262             {
 263                 error("array index out of range.", node);
 264             }
 265             left = table.array()->get(index);
 266             right = node.children[2]->accept(*this);
 267         }
 268         else
 269         {
 270             error("can only index tables and arrays.", node);
 271             return Interpreter::Value();
 272         }
 273         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 274         {
 275             left = Interpreter::Value(left.number() - right.number());
 276         }
 277         else
 278         {
 279             error("invalid operands to '-='.", node);
 280             return Interpreter::Value();
 281         }
 282         if(t == Interpreter::Value::Type::Table)
 283         {
 284             table.table()->set(index, left);
 285         }
 286         else if(t == Interpreter::Value::Type::Array)
 287         {
 288             table.array()->set(index, left);
 289         }
 290         return left;
 291     }
 292
 293     Interpreter::Value Interpreter::operator()(MulFieldAssignment<Iter,Interpreter::Value,FuncType> &node)
 294     {
 295         Interpreter::Value table = node.children[0]->accept(*this);
 296         Interpreter::Value index, left, right;
 297         Interpreter::Value::Type t = table.type();
 298         if(t == Interpreter::Value::Type::Table)
 299         {
 300             index = node.children[1]->accept(*this);
 301             left = table.table()->get(index);
 302             right = node.children[2]->accept(*this);
 303         }
 304         else if(t == Interpreter::Value::Type::Array)
 305         {
 306             index = node.children[1]->accept(*this);
 307             if(index.type() != Interpreter::Value::Type::Number || !isint(index.number()))
 308             {
 309                 error("array index not a integer.", node);
 310             }
 311             int idx = index.number();
 312             if(idx<0 || idx>=int(table.array()->size()))
 313             {
 314                 error("array index out of range.", node);
 315             }
 316             left = table.array()->get(index);
 317             right = node.children[2]->accept(*this);
 318         }
 319         else
 320         {
 321             error("can only index tables and arrays.", node);
 322             return Interpreter::Value();
 323         }
 324         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 325         {
 326             left = Interpreter::Value(left.number() * right.number());
 327         }
 328         else
 329         {
 330             error("invalid operands to '*='.", node);
 331             return Interpreter::Value();
 332         }
 333         if(t == Interpreter::Value::Type::Table)
 334         {
 335             table.table()->set(index, left);
 336         }
 337         else if(t == Interpreter::Value::Type::Array)
 338         {
 339             table.array()->set(index, left);
 340         }
 341         return left;
 342     }
 343
 344     Interpreter::Value Interpreter::operator()(DivFieldAssignment<Iter,Interpreter::Value,FuncType> &node)
 345     {
 346         Interpreter::Value table = node.children[0]->accept(*this);
 347         Interpreter::Value index, left, right;
 348         Interpreter::Value::Type t = table.type();
 349         if(t == Interpreter::Value::Type::Table)
 350         {
 351             index = node.children[1]->accept(*this);
 352             left = table.table()->get(index);
 353             right = node.children[2]->accept(*this);
 354         }
 355         else if(t == Interpreter::Value::Type::Array)
 356         {
 357             index = node.children[1]->accept(*this);
 358             if(index.type() != Interpreter::Value::Type::Number || !isint(index.number()))
 359             {
 360                 error("array index not a integer.", node);
 361             }
 362             int idx = index.number();
 363             if(idx<0 || idx>=int(table.array()->size()))
 364             {
 365                 error("array index out of range.", node);
 366             }
 367             left = table.array()->get(index);
 368             right = node.children[2]->accept(*this);
 369         }
 370         else
 371         {
 372             error("can only index tables and arrays.", node);
 373             return Interpreter::Value();
 374         }
 375         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 376         {
 377             left = Interpreter::Value(left.number() / right.number());
 378         }
 379         else
 380         {
 381             error("invalid operands to '/='.", node);
 382             return Interpreter::Value();
 383         }
 384         if(t == Interpreter::Value::Type::Table)
 385         {
 386             table.table()->set(index, left);
 387         }
 388         else if(t == Interpreter::Value::Type::Array)
 389         {
 390             table.array()->set(index, left);
 391         }
 392         return left;
 393     }
 394
 395     Interpreter::Value Interpreter::operator()(ModFieldAssignment<Iter,Interpreter::Value,FuncType> &node)
 396     {
 397         Interpreter::Value table = node.children[0]->accept(*this);
 398         Interpreter::Value index, left, right;
 399         Interpreter::Value::Type t = table.type();
 400         if(t == Interpreter::Value::Type::Table)
 401         {
 402             index = node.children[1]->accept(*this);
 403             left = table.table()->get(index);
 404             right = node.children[2]->accept(*this);
 405         }
 406         else if(t == Interpreter::Value::Type::Array)
 407         {
 408             index = node.children[1]->accept(*this);
 409             if(index.type() != Interpreter::Value::Type::Number || !isint(index.number()))
 410             {
 411                 error("array index not a integer.", node);
 412             }
 413             int idx = index.number();
 414             if(idx<0 || idx>=int(table.array()->size()))
 415             {
 416                 error("array index out of range.", node);
 417             }
 418             left = table.array()->get(index);
 419             right = node.children[2]->accept(*this);
 420         }
 421         else
 422         {
 423             error("can only index tables and arrays.", node);
 424             return Interpreter::Value();
 425         }
 426         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 427         {
 428             left = Interpreter::Value(std::fmod(left.number(), right.number()));
 429         }
 430         else
 431         {
 432             error("invalid operands to '%='.", node);
 433             return Interpreter::Value();
 434         }
 435         if(t == Interpreter::Value::Type::Table)
 436         {
 437             table.table()->set(index, left);
 438         }
 439         else if(t == Interpreter::Value::Type::Array)
 440         {
 441             table.array()->set(index, left);
 442         }
 443         return left;
 444     }
 445
 446     Interpreter::Value Interpreter::operator()(UnaryPlusExpression<Iter,Interpreter::Value,FuncType> &node)
 447     {
 448         Interpreter::Value operand = node.children[0]->accept(*this);
 449         if(operand.type() != Interpreter::Value::Type::Number)
 450         {
 451             error("invalid operand to '+'.", node);
 452         }
 453         return operand;
 454     }
 455
 456     Interpreter::Value Interpreter::operator()(UnaryMinusExpression<Iter,Interpreter::Value,FuncType> &node)
 457     {
 458         Interpreter::Value operand = node.children[0]->accept(*this);
 459         if(operand.type() != Interpreter::Value::Type::Number)
 460         {
 461             error("invalid operand to '-'.", node);
 462         }
 463         return Interpreter::Value(-operand.number());
 464     }
 465
 466     Interpreter::Value Interpreter::operator()(UnaryNotExpression<Iter,Interpreter::Value,FuncType> &node)
 467     {
 468         Interpreter::Value operand = node.children[0]->accept(*this);
 469         if(operand.type() != Interpreter::Value::Type::Number)
 470         {
 471             error("invalid operand to '!'.", node);
 472         }
 473         return Interpreter::Value(operand.number()==0.0?1.0:0.0);
 474     }
 475
 476     Interpreter::Value Interpreter::operator()(MultiplyExpression<Iter,Interpreter::Value,FuncType> &node)
 477     {
 478         Interpreter::Value left = node.children[0]->accept(*this);
 479         Interpreter::Value right = node.children[1]->accept(*this);
 480         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 481         {
 482             return Interpreter::Value(left.number() * right.number());
 483         }
 484         else
 485         {
 486             error("invalid operands to '*'.", node);
 487             return Interpreter::Value();
 488         }
 489     }
 490
 491     Interpreter::Value Interpreter::operator()(DivideExpression<Iter,Interpreter::Value,FuncType> &node)
 492     {
 493         Interpreter::Value left = node.children[0]->accept(*this);
 494         Interpreter::Value right = node.children[1]->accept(*this);
 495         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 496         {
 497             return Interpreter::Value(left.number() / right.number());
 498         }
 499         else
 500         {
 501             error("invalid operands to '/'.", node);
 502             return Interpreter::Value();
 503         }
 504     }
 505
 506     Interpreter::Value Interpreter::operator()(ModuloExpression<Iter,Interpreter::Value,FuncType> &node)
 507     {
 508         Interpreter::Value left = node.children[0]->accept(*this);
 509         Interpreter::Value right = node.children[1]->accept(*this);
 510         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 511         {
 512             return Interpreter::Value(std::fmod(left.number(), right.number()));
 513         }
 514         else
 515         {
 516             error("invalid operands to '%'.", node);
 517             return Interpreter::Value();
 518         }
 519     }
 520
 521     Interpreter::Value Interpreter::operator()(AddExpression<Iter,Interpreter::Value,FuncType> &node)
 522     {
 523         Interpreter::Value left = node.children[0]->accept(*this);
 524         Interpreter::Value right = node.children[1]->accept(*this);
 525         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 526         {
 527             return Interpreter::Value(left.number() + right.number());
 528         }
 529         else if(left.type() == Interpreter::Value::Type::String && right.type() == Interpreter::Value::Type::String)
 530         {
 531             return Interpreter::Value(left.string() + right.string());
 532         }
 533         else if(left.type() == Interpreter::Value::Type::Table && right.type() == Interpreter::Value::Type::Table)
 534         {
 535             typename Interpreter::Value::TableContainer table(new Table<Interpreter::Value>);
 536             table->append(*left.table());
 537             table->append(*right.table());
 538             return Interpreter::Value(table);
 539         }
 540         else if(left.type() == Interpreter::Value::Type::Array && right.type() == Interpreter::Value::Type::Array)
 541         {
 542             typename Interpreter::Value::ArrayContainer array(new Array<Interpreter::Value>);
 543             array->append(*left.array());
 544             array->append(*right.array());
 545             return Interpreter::Value(array);
 546         }
 547         else
 548         {
 549             error("invalid operands to '+'.", node);
 550             return Interpreter::Value();
 551         }
 552     }
 553
 554     Interpreter::Value Interpreter::operator()(SubtractExpression<Iter,Interpreter::Value,FuncType> &node)
 555     {
 556         Interpreter::Value left = node.children[0]->accept(*this);
 557         Interpreter::Value right = node.children[1]->accept(*this);
 558         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 559         {
 560             return Interpreter::Value(left.number() - right.number());
 561         }
 562         else
 563         {
 564             error("invalid operands to '-'.", node);
 565             return Interpreter::Value();
 566         }
 567     }
 568
 569     Interpreter::Value Interpreter::operator()(LessExpression<Iter,Interpreter::Value,FuncType> &node)
 570     {
 571         Interpreter::Value left = node.children[0]->accept(*this);
 572         Interpreter::Value right = node.children[1]->accept(*this);
 573         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 574         {
 575             return Interpreter::Value(left.number() < right.number());
 576         }
 577         else if(left.type() == Interpreter::Value::Type::String && right.type() == Interpreter::Value::Type::String)
 578         {
 579             return Interpreter::Value(left.string() < right.string());
 580         }
 581         else
 582         {
 583             error("invalid operands to '<'.", node);
 584             return Interpreter::Value();
 585         }
 586     }
 587
 588     Interpreter::Value Interpreter::operator()(LessEqualExpression<Iter,Interpreter::Value,FuncType> &node)
 589     {
 590         Interpreter::Value left = node.children[0]->accept(*this);
 591         Interpreter::Value right = node.children[1]->accept(*this);
 592         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 593         {
 594             return Interpreter::Value(left.number() <= right.number());
 595         }
 596         else if(left.type() == Interpreter::Value::Type::String && right.type() == Interpreter::Value::Type::String)
 597         {
 598             return Interpreter::Value(left.string() <= right.string());
 599         }
 600         else
 601         {
 602             error("invalid operands to '<='.", node);
 603             return Interpreter::Value();
 604         }
 605     }
 606
 607     Interpreter::Value Interpreter::operator()(GreaterExpression<Iter,Interpreter::Value,FuncType> &node)
 608     {
 609         Interpreter::Value left = node.children[0]->accept(*this);
 610         Interpreter::Value right = node.children[1]->accept(*this);
 611         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 612         {
 613             return Interpreter::Value(left.number() > right.number());
 614         }
 615         else if(left.type() == Interpreter::Value::Type::String && right.type() == Interpreter::Value::Type::String)
 616         {
 617             return Interpreter::Value(left.string() > right.string());
 618         }
 619         else
 620         {
 621             error("invalid operands to '>'.", node);
 622             return Interpreter::Value();
 623         }
 624     }
 625
 626     Interpreter::Value Interpreter::operator()(GreaterEqualExpression<Iter,Interpreter::Value,FuncType> &node)
 627     {
 628         Interpreter::Value left = node.children[0]->accept(*this);
 629         Interpreter::Value right = node.children[1]->accept(*this);
 630         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 631         {
 632             return Interpreter::Value(left.number() >= right.number());
 633         }
 634         else if(left.type() == Interpreter::Value::Type::String && right.type() == Interpreter::Value::Type::String)
 635         {
 636             return Interpreter::Value(left.string() >= right.string());
 637         }
 638         else
 639         {
 640             error("invalid operands to '>='.", node);
 641             return Interpreter::Value();
 642         }
 643     }
 644
 645     Interpreter::Value Interpreter::operator()(EqualExpression<Iter,Interpreter::Value,FuncType> &node)
 646     {
 647         Interpreter::Value left = node.children[0]->accept(*this);
 648         Interpreter::Value right = node.children[1]->accept(*this);
 649         return Interpreter::Value(left == right);
 650     }
 651
 652     Interpreter::Value Interpreter::operator()(NotEqualExpression<Iter,Interpreter::Value,FuncType> &node)
 653     {
 654         Interpreter::Value left = node.children[0]->accept(*this);
 655         Interpreter::Value right = node.children[1]->accept(*this);
 656         return Interpreter::Value(!(left == right));
 657     }
 658
 659     Interpreter::Value Interpreter::operator()(LogicalAndExpression<Iter,Interpreter::Value,FuncType> &node)
 660     {
 661         Interpreter::Value left = node.children[0]->accept(*this);
 662         if(left.type() == Interpreter::Value::Type::Number)
 663         {
 664             if(left.number() != 0.0)
 665             {
 666                 Interpreter::Value right = node.children[1]->accept(*this);
 667                 if(right.type() == Interpreter::Value::Type::Number)
 668                 {
 669                     return Interpreter::Value(right.number() != 0.0);
 670                 }
 671                 else
 672                 {
 673                     error("invalid operands to '&&'.", node);
 674                     return Interpreter::Value();
 675                 }
 676             }
 677             else
 678             {
 679                 return Interpreter::Value(0.0);
 680             }
 681         }
 682         else
 683         {
 684             error("invalid operands to '&&'.", node);
 685             return Interpreter::Value();
 686         }
 687     }
 688
 689     Interpreter::Value Interpreter::operator()(LogicalOrExpression<Iter,Interpreter::Value,FuncType> &node)
 690     {
 691         Interpreter::Value left = node.children[0]->accept(*this);
 692         if(left.type() == Interpreter::Value::Type::Number)
 693         {
 694             if(left.number() == 0.0)
 695             {
 696                 Interpreter::Value right = node.children[1]->accept(*this);
 697                 if(right.type() == Interpreter::Value::Type::Number)
 698                 {
 699                     return Interpreter::Value(right.number() != 0.0);
 700                 }
 701                 else
 702                 {
 703                     error("invalid operands to '||'.", node);
 704                     return Interpreter::Value();
 705                 }
 706             }
 707             else
 708             {
 709                 return Interpreter::Value(1.0);
 710             }
 711         }
 712         else
 713         {
 714             error("invalid operands to '||'.", node);
 715             return Interpreter::Value();
 716         }
 717     }
 718
 719     Interpreter::Value Interpreter::operator()(AssignmentExpression<Iter,Interpreter::Value,FuncType> &node)
 720     {
 721         Interpreter::Value left = node.children[0]->accept(*this);
 722         Interpreter::Value right = node.children[1]->accept(*this);
 723         set(left, right);
 724         return right;
 725     }
 726
 727     Interpreter::Value Interpreter::operator()(GlobalAssignmentExpression<Iter,Interpreter::Value,FuncType> &node)
 728     {
 729         Interpreter::Value left = node.children[0]->accept(*this);
 730         Interpreter::Value right = node.children[1]->accept(*this);
 731         setGlobal(left, right);
 732         return right;
 733     }
 734
 735     Interpreter::Value Interpreter::operator()(LocalAssignmentExpression<Iter,Interpreter::Value,FuncType> &node)
 736     {
 737         Interpreter::Value left = node.children[0]->accept(*this);
 738         Interpreter::Value right = node.children[1]->accept(*this);
 739         setLocal(left, right);
 740         return right;
 741     }
 742
 743     Interpreter::Value Interpreter::operator()(AddAssignmentExpression<Iter,Interpreter::Value,FuncType> &node)
 744     {
 745         Interpreter::Value name = node.children[0]->accept(*this);
 746         Interpreter::Value left = get(name);
 747         Interpreter::Value right = node.children[1]->accept(*this);
 748         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 749         {
 750             left = Interpreter::Value(left.number() + right.number());
 751         }
 752         else if(left.type() == Interpreter::Value::Type::String && right.type() == Interpreter::Value::Type::String)
 753         {
 754             left.string() += right.string();
 755         }
 756         else if(left.type() == Interpreter::Value::Type::Table && right.type() == Interpreter::Value::Type::Table)
 757         {
 758             left.table()->append(*right.table());
 759         }
 760         else if(left.type() == Interpreter::Value::Type::Array && right.type() == Interpreter::Value::Type::Array)
 761         {
 762             left.array()->append(*right.array());
 763         }
 764         else
 765         {
 766             error("invalid operands to '+='.", node);
 767             return Interpreter::Value();
 768         }
 769         set(name, left);
 770         return left;
 771     }
 772
 773     Interpreter::Value Interpreter::operator()(SubAssignmentExpression<Iter,Interpreter::Value,FuncType> &node)
 774     {
 775         Interpreter::Value name = node.children[0]->accept(*this);
 776         Interpreter::Value left = get(name);
 777         Interpreter::Value right = node.children[1]->accept(*this);
 778         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 779         {
 780             left = Interpreter::Value(left.number() - right.number());
 781         }
 782         else
 783         {
 784             error("invalid operands to '-='.", node);
 785             return Interpreter::Value();
 786         }
 787         set(name, left);
 788         return left;
 789     }
 790
 791     Interpreter::Value Interpreter::operator()(MulAssignmentExpression<Iter,Interpreter::Value,FuncType> &node)
 792     {
 793         Interpreter::Value name = node.children[0]->accept(*this);
 794         Interpreter::Value left = get(name);
 795         Interpreter::Value right = node.children[1]->accept(*this);
 796         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 797         {
 798             left = Interpreter::Value(left.number() * right.number());
 799         }
 800         else
 801         {
 802             error("invalid operands to '*='.", node);
 803             return Interpreter::Value();
 804         }
 805         set(name, left);
 806         return left;
 807     }
 808
 809     Interpreter::Value Interpreter::operator()(DivAssignmentExpression<Iter,Interpreter::Value,FuncType> &node)
 810     {
 811         Interpreter::Value name = node.children[0]->accept(*this);
 812         Interpreter::Value left = get(name);
 813         Interpreter::Value right = node.children[1]->accept(*this);
 814         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 815         {
 816             left = Interpreter::Value(left.number() / right.number());
 817         }
 818         else
 819         {
 820             error("invalid operands to '/='.", node);
 821             return Interpreter::Value();
 822         }
 823         set(name, left);
 824         return left;
 825     }
 826
 827     Interpreter::Value Interpreter::operator()(ModAssignmentExpression<Iter,Interpreter::Value,FuncType> &node)
 828     {
 829         Interpreter::Value name = node.children[0]->accept(*this);
 830         Interpreter::Value left = get(name);
 831         Interpreter::Value right = node.children[1]->accept(*this);
 832         if(left.type() == Interpreter::Value::Type::Number && right.type() == Interpreter::Value::Type::Number)
 833         {
 834             left = Interpreter::Value(std::fmod(left.number(), right.number()));
 835         }
 836         else
 837         {
 838             error("invalid operands to '%='.", node);
 839             return Interpreter::Value();
 840         }
 841         set(name, left);
 842         return left;
 843     }
 844
 845     Interpreter::Value Interpreter::operator()(Block<Iter,Interpreter::Value,FuncType> &node)
 846     {
 847         LocalScope localscope(*this);
 848         return node.children[0]->accept(*this);
 849     }
 850
 851     Interpreter::Value Interpreter::operator()(TableInitializer<Iter,Interpreter::Value,FuncType> &node)
 852     {
 853         Interpreter::Value::NumberType current = 0;
 854         typename Interpreter::Value::TableContainer table(new Table<Interpreter::Value>);
 855         for(auto tmpchild : node.children)
 856         {
 857             auto child = static_cast<InitializerAssignmentExpression<Iter,Interpreter::Value,FuncType>*>(tmpchild.get());
 858             if(child->children.size() == 1)
 859             {
 860                 table->set(Interpreter::Value(current++), child->children[0]->accept(*this));
 861             }
 862             else
 863             {
 864                 Interpreter::Value index = child->children[0]->accept(*this);
 865                 if(index.type() == Interpreter::Value::Type::Number && isint(index.number()))
 866                 {
 867                     current = index.number()+1;
 868                 }
 869                 table->set(index, child->children[1]->accept(*this));
 870             }
 871         }
 872         return Interpreter::Value(table);
 873     }
 874
 875     Interpreter::Value Interpreter::operator()(ArrayInitializer<Iter,Interpreter::Value,FuncType> &node)
 876     {
 877         typename Interpreter::Value::ArrayContainer array(new Array<Interpreter::Value>);
 878         for(auto& tmpchild : node.children)
 879         {
 880             array->add(tmpchild->accept(*this));
 881         }
 882         return Interpreter::Value(array);
 883     }
 884
 885     Interpreter::Value Interpreter::operator()(Function<Iter,Interpreter::Value,FuncType> &node)
 886     {
 887         return Interpreter::Value(Interpreter::Value::Type::Function, node.shared_from_this());
 888     }
 889
 890     Interpreter::Value Interpreter::operator()(IdentifierList<Iter,Interpreter::Value,FuncType> &node)
 891     {
 892         auto i = m_function_stack.begin();
 893         auto end = m_function_stack.end();
 894         set(Interpreter::Value("this"), *i++);
 895         for(auto child : node.children)
 896         {
 897             if(i==end)
 898             {
 899                 break;
 900             }
 901             set(child->accept(*this), *i++);
 902         }
 903         m_function_stack.clear();
 904         return Interpreter::Value();
 905     }
 906
 907     Interpreter::Value Interpreter::operator()(BuiltinFunction<Iter,Interpreter::Value,FuncType> &node)
 908     {
 909         node.function(*this, m_function_stack);
 910         return Interpreter::Value();
 911     }
 912
 913     Interpreter::Value Interpreter::operator()(Call<Iter,Interpreter::Value,FuncType> &node)
 914     {
 915         std::vector<Interpreter::Value> args;
 916         Interpreter::Value fun = node.children[0]->accept(*this);
 917         if(fun.type() != Interpreter::Value::Type::Function)
 918         {
 919             error("can not call non-function", node);
 920             return Interpreter::Value();
 921         }
 922         auto function = fun.function();
 923         auto innerargs = makeArray();
 924         for(size_t i = 1; i<node.children.size(); ++i)
 925         {
 926             auto val = node.children[i]->accept(*this);
 927             args.push_back(val);
 928             innerargs->add(val);
 929         }
 930         m_function_stack.push_back(Interpreter::Value());
 931         for(size_t i = 1; i<node.children.size(); ++i)
 932         {
 933             m_function_stack.push_back(args[i-1]);
 934         }
 935         FunctionScope functionscope(this);
 936         setLocal(Value("$args"), innerargs);
 937         function->children[0]->accept(*this);
 938         function->children[1]->accept(*this);
 939         if(!m_function_stack.empty())
 940         {
 941             Interpreter::Value result = m_function_stack.back();
 942             m_function_stack.clear();
 943             return result;
 944         }
 945         else
 946         {
 947             return Interpreter::Value();
 948         }
 949     }
 950
 951
 952     Interpreter::Value Interpreter::operator()(Tree<Iter,Interpreter::Value,FuncType> &node)
 953     {
 954         return Interpreter::Value(Interpreter::Value::Type::Tree, node.children[0]);
 955     }
 956
 957     Interpreter::Value Interpreter::operator()(Root<Iter,Interpreter::Value,FuncType> &node)
 958     {
 959         if(node.children.empty())
 960         {
 961             return Interpreter::Value(Interpreter::Value::Type::Tree, node.root.lock());
 962         }
 963         else
 964         {
 965             Interpreter::Value tree = node.children[0]->accept(*this);
 966             if(tree.type() == Interpreter::Value::Type::Tree || tree.type() == Interpreter::Value::Type::Function)
 967             {
 968                 return Interpreter::Value(Interpreter::Value::Type::Tree, tree.pointer()->root.lock());
 969             }
 970             else
 971             {
 972                 error("cannot find root of non-tree.", node);
 973                 return Interpreter::Value();
 974             }
 975         }
 976     }
 977 }