src/ops.cpp

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