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