kturtle/src/executer.cpp

   1 /*
   2     Copyright (C) 2003 by Walter Schreppers
   3     Copyright (C) 2004 by Cies Breijs
   4
   5     This program is free software; you can redistribute it and/or
   6     modify it under the terms of version 2 of the GNU General Public
   7     License as published by the Free Software Foundation.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17  */
  18
  19 // This file is originally written by Walter Scheppers, but allmost
  20 // every aspect of it is slightly changed by Cies Breijs.
  21
  22
  23 #include <unistd.h> // for usleep();
  24
  25 #include <qtimer.h>
  26
  27 #include <kapplication.h>
  28 #include <kdebug.h>
  29 #include <klocale.h>
  30
  31 #include "executer.h"
  32
  33 // this function is used in executer and canvas:
  34 #define ROUND2INT(x) ( (x) >= 0 ? (int)( (x) + .5 ) : (int)( (x) - .5 ) )
  35
  36
  37 Executer::Executer(TreeNode* tree)
  38 {
  39         this->tree = tree;
  40         functionTable.clear();
  41         bBreak = false;
  42         bReturn = false;
  43 }
  44
  45 Executer::~Executer()
  46 {
  47         emit Finished();
  48 }
  49
  50 bool Executer::run()
  51 {
  52         bBreak = false;
  53         bReturn = false;
  54         bPause = false;
  55         bAbort = false;
  56         symtable main;
  57         symbolTables.push(main); // new symbol table for main block
  58
  59         TreeNode::const_iterator i;
  60         for (i = tree->begin(); i != tree->end(); ++i)
  61         {
  62                 if (bAbort) return false;
  63                 kapp->processEvents();
  64                 execute(*i);
  65
  66                 symbolTables.pop(); //free up stack
  67         }
  68         return true;
  69 }
  70
  71 void Executer::slowDown(TreeNode* node)
  72 {
  73         switch (runSpeed)
  74         {
  75                 case 1: // slow
  76                         startWaiting(0);
  77                         break;
  78
  79                 case 2: // slower
  80                         startWaiting(250);
  81                         break;
  82
  83                 case 3: // slowest
  84                         startWaiting(900);
  85                         break;
  86
  87                 default:
  88                         kdDebug(0)<<"Executer: Wrong execution speed given"<<endl;
  89                         break;
  90         }
  91         Token tok = node->getToken();
  92         emit setSelection(tok.start.row, tok.start.col, tok.end.row, tok.end.col);
  93 }
  94
  95 void Executer::slotChangeSpeed(int speed)
  96 {
  97         runSpeed = speed;
  98 }
  99
 100 void Executer::pause()
 101 {
 102         // The next line is within all loops of the Executer
 103         //     if (bAbort) return;
 104         // mostly before
 105         //     kapp->processEvents();
 106         // this to keep the GUI of KTurtle accessible while executing the logo code
 107         // so the Abort button can be clicked, and will function
 108         bPause = true;
 109 }
 110
 111 void Executer::abort()
 112 {
 113         // The next line is within all loops of the Executer
 114         //     if(bAbort) return;
 115         // mostly before
 116         //     kapp->processEvents();
 117         // this to keep the GUI of KTurtle accessible while executing the logo code
 118         // so the Abort button can be clicked, and will function
 119         bAbort = true;
 120 }
 121
 122
 123 void Executer::execute(TreeNode* node)
 124 {
 125         switch ( node->getType() )
 126         {
 127                 case blockNode          : execBlock(node);          break;
 128                 case forNode            : execFor(node);            break;
 129                 case forEachNode        : execForEach(node);        break;
 130                 case whileNode          : execWhile(node);          break;
 131                 case ifNode             : execIf(node);             break;
 132                 case assignNode         : execAssign(node);         break;
 133                 case expressionNode     : execExpression(/*node*/); break;
 134                 case idNode             : execId(node);             break;
 135                 case constantNode       : execConstant(/*node*/);   break; // does nothing value allready set
 136
 137                 case addNode            : execAdd(node);            break;
 138                 case mulNode            : execMul(node);            break;
 139                 case divNode            : execDiv(node);            break;
 140                 case subNode            : execSub(node);            break;
 141                 case minusNode          : execMinus(node);          break;
 142
 143                 case nodeGE             : execGE(node);             break;
 144                 case nodeGT             : execGT(node);             break;
 145                 case nodeLE             : execLE(node);             break;
 146                 case nodeLT             : execLT(node);             break;
 147                 case nodeNE             : execNE(node);             break;
 148                 case nodeEQ             : execEQ(node);             break;
 149
 150                 case andNode            : execAnd(node);            break;
 151                 case orNode             : execOr(node);             break;
 152                 case notNode            : execNot(node);            break;
 153
 154                 case functionNode       : createFunction(node);     break;
 155                 case functionCallNode   : execFunction(node);       break;
 156                 case funcReturnNode     : execRetFunction(node);    break;
 157                 case returnNode         : execReturn(node);         break;
 158                 case breakNode          : execBreak(/*node*/);      break;
 159
 160                 case runNode            : execRun(node);            break;
 161
 162                 case ClearNode          : execClear(node);          break;
 163                 case GoNode             : execGo(node);             break;
 164                 case GoXNode            : execGoX(node);            break;
 165                 case GoYNode            : execGoY(node);            break;
 166                 case ForwardNode        : execForward(node);        break;
 167                 case BackwardNode       : execBackward(node);       break;
 168                 case DirectionNode      : execDirection(node);      break;
 169                 case TurnLeftNode       : execTurnLeft(node);       break;
 170                 case TurnRightNode      : execTurnRight(node);      break;
 171                 case CenterNode         : execCenter(node);         break;
 172                 case SetPenWidthNode    : execSetPenWidth(node);    break;
 173                 case PenUpNode          : execPenUp(node);          break;
 174                 case PenDownNode        : execPenDown(node);        break;
 175                 case SetFgColorNode     : execSetFgColor(node);     break;
 176                 case SetBgColorNode     : execSetBgColor(node);     break;
 177                 case ResizeCanvasNode   : execResizeCanvas(node);   break;
 178                 case SpriteShowNode     : execSpriteShow(node);     break;
 179                 case SpriteHideNode     : execSpriteHide(node);     break;
 180                 case SpritePressNode    : execSpritePress(node);    break;
 181                 case SpriteChangeNode   : execSpriteChange(node);   break;
 182
 183                 case MessageNode        : execMessage(node);        break;
 184                 case InputWindowNode    : execInputWindow(node);    break;
 185                 case printNode          : execPrint(node);          break;
 186                 case FontTypeNode       : execFontType(node);       break;
 187                 case FontSizeNode       : execFontSize(node);       break;
 188                 case RepeatNode         : execRepeat(node);         break;
 189                 case RandomNode         : execRandom(node);         break;
 190                 case WaitNode           : execWait(node);           break;
 191                 case WrapOnNode         : execWrapOn(node);         break;
 192                 case WrapOffNode        : execWrapOff(node);        break;
 193                 case ResetNode          : execReset(node);          break;
 194
 195                 case EndOfFileNode      : break; // just do nothing is enough
 196
 197                 case Unknown            : // dont break but fallthrough to default
 198
 199                 default:
 200                         kdDebug(0)<<"Found unsupported node named '"<<node->getLook()<<"' in the tree @ ("<<node->getRow()<<", "<<node->getCol()<<")"<<endl;
 201                         break;
 202         }
 203 }
 204
 205
 206 void Executer::createFunction(TreeNode* node)
 207 {
 208         QString funcname = node->getLook();
 209         functionTable[funcname] = node; //store for later use
 210 }
 211
 212
 213 //execute a function
 214 void Executer::execFunction(TreeNode* node)
 215 {
 216         QString funcname = node->getLook();
 217
 218         // locate function node
 219         functable::iterator p = functionTable.find(funcname);
 220         if ( p == functionTable.end() )
 221         {
 222                 emit ErrorMsg(node->getToken(), i18n("Call to undefined function: %1.").arg(funcname), 5010);
 223                 return;
 224         }
 225
 226         TreeNode* funcnode   = p->second;
 227         TreeNode* funcIds    = funcnode->firstChild();
 228         TreeNode* callparams = node->firstChild();
 229
 230         // check if number of parameters match
 231         if ( callparams->size() != funcIds->size() )
 232         {
 233                 emit ErrorMsg(node->getToken(), i18n("Call to function '%1' with wrong number of parameters.").arg(funcname), 5020);
 234                 return;
 235         }
 236
 237         // pass parameters to function
 238         // by adding them to it's symboltable and setting the values
 239         TreeNode::iterator pfrom, pto = funcIds->begin();
 240         symtable funcSymTable;
 241
 242         for (pfrom = callparams->begin(); pfrom != callparams->end(); ++pfrom )
 243         {
 244                 if (bAbort) return;
 245                 if (bPause) startPausing();
 246                 kapp->processEvents();
 247
 248                 // execute the parameters which can be expressions
 249                 execute(*pfrom);
 250
 251                 QString idname = (*pto)->getLook();
 252                 funcSymTable[idname] = (*pfrom)->getValue();
 253                 ++pto;
 254         }
 255
 256         symbolTables.push(funcSymTable); // use new symboltable for current function
 257
 258         // execute function statement block
 259         bReturn = false; // set to true when return is called
 260         execute( funcnode->secondChild() );
 261         bReturn = false; // function execution done
 262
 263         symbolTables.pop(); // release function symboltable
 264 }
 265
 266
 267 // execute a function and expect and get return
 268 // value from stack
 269 // first child   = function name
 270 // second child  = parameters
 271 void Executer::execRetFunction(TreeNode* node)
 272 {
 273         execFunction(node);
 274         if (runStack.size() == 0)
 275         {
 276                 emit ErrorMsg(node->getToken(), i18n("Function %1 did not return a value.").arg( node->getLook() ), 5030);
 277                 return;
 278         }
 279         node->setValue( runStack.top() ); // set return val
 280         runStack.pop(); // remove from stack
 281 }
 282
 283
 284 void Executer::execReturn(TreeNode* node)
 285 {
 286         execute( node->firstChild() ); // execute return expression
 287         runStack.push( node->firstChild()->getValue() );
 288         bReturn = true; // notify blocks of return
 289 }
 290
 291
 292 void Executer::execBreak(/*TreeNode* node*/)
 293 {
 294         bBreak = true; // stops loop block execution
 295 }
 296
 297
 298 void Executer::execBlock(TreeNode* node)
 299 {
 300         // execute all statements in block
 301         TreeNode::iterator i;
 302         for (i = node->begin(); i != node->end(); ++i)
 303         {
 304                 if (runSpeed != 0) slowDown(*i);
 305                 if (bAbort) return;
 306                 if (bPause) startPausing();
 307                 kapp->processEvents();
 308
 309                 execute(*i);
 310
 311                 if (bReturn || bBreak) break; //jump out of block
 312         }
 313 }
 314
 315
 316 void Executer::execForEach(TreeNode* node)
 317 {
 318         // sorry, not fully implemented/tested yet
 319         TreeNode* expr1      = node->firstChild();
 320         TreeNode* expr2      = node->secondChild();
 321         TreeNode* statements = node->thirdChild();
 322
 323         execute(expr1);
 324         execute(expr2);
 325
 326         QString expStr1 = expr1->getValue().String();
 327         QString expStr2 = expr2->getValue().String();
 328
 329         bBreak = false;
 330
 331         int i = expStr2.contains(expStr1, false);
 332         for ( ; i > 0; i-- )
 333         {
 334                 if (bAbort) return;
 335                 if (bPause) startPausing();
 336                 kapp->processEvents();
 337
 338                 execute(statements);
 339                 if (bBreak || bReturn) break; //jump out loop
 340         }
 341         bBreak = false;
 342 }
 343
 344
 345
 346 void Executer::execFor(TreeNode* node)
 347 {
 348         TreeNode* id = node->firstChild();
 349         TreeNode* startNode = node->secondChild();
 350         TreeNode* stopNode = node->thirdChild();
 351         TreeNode* statements = node->fourthChild();
 352
 353         QString name = id->getLook();
 354
 355         execute(startNode);
 356         //assign startval to id
 357         Value startVal = startNode->getValue();
 358         ( symbolTables.top() )[ name ] = startVal;
 359
 360
 361         execute(stopNode);
 362         Value stopVal = stopNode->getValue();
 363
 364         if(node->size() == 4 ) //for loop without step part
 365         {
 366                 bBreak = false;
 367                 for (double d = startVal.Number(); d <= stopVal.Number(); d = d + 1)
 368                 {
 369                         if (bAbort) return;
 370                         if (bPause) startPausing();
 371                         kapp->processEvents();
 372                         ( symbolTables.top() )[name] = d;
 373                         execute( statements );
 374                         if (bBreak || bReturn) break; //jump out loop
 375                 }
 376                 bBreak = false;
 377         }
 378         else //for loop with step part
 379         {
 380                 TreeNode* step = node->fourthChild();
 381                 statements = node->fifthChild();
 382
 383                 execute(step);
 384                 Value stepVal = step->getValue();
 385                 bBreak = false;
 386                 if ( (stepVal.Number() >= 0.0) && (startVal.Number() <= stopVal.Number() ) )
 387                 {
 388                         for ( double d = startVal.Number(); d <= stopVal.Number(); d = d + stepVal.Number() )
 389                         {
 390                                 if (bAbort) return;
 391                                 if (bPause) startPausing();
 392                                 kapp->processEvents();
 393
 394                                 (symbolTables.top() )[name] = d;
 395                                 execute( statements );
 396                                 if (bBreak || bReturn) break; //jump out loop
 397                         }
 398                 }
 399                 else if ( (stepVal.Number() < 0.0) && (startVal.Number() >= stopVal.Number() ) )
 400                 {
 401                         for (double d = startVal.Number(); d >= stopVal.Number(); d = d + stepVal.Number() )
 402                         {
 403                                 if (bAbort) return;
 404                                 if (bPause) startPausing();
 405                                 kapp->processEvents();
 406
 407                                 ( symbolTables.top() )[name] = d;
 408                                 execute(statements);
 409                                 if (bBreak || bReturn) break; //jump out loop
 410                         }
 411                 }
 412                 bBreak = false;
 413         }
 414 }
 415
 416
 417
 418 void Executer::execRepeat(TreeNode* node)
 419 {
 420         TreeNode* value = node->firstChild();
 421         TreeNode* statements = node->secondChild();
 422
 423         bBreak = false;
 424         execute(value);
 425         for ( int i = ROUND2INT( value->getValue().Number() ); i > 0; i-- )
 426         {
 427                 if (bAbort) return;
 428                 if (bPause) startPausing();
 429                 kapp->processEvents();
 430
 431                 execute(statements);
 432                 if (bBreak || bReturn) break; //jump out loop
 433         }
 434         bBreak = false;
 435 }
 436
 437
 438 void Executer::execWhile(TreeNode* node)
 439 {
 440         TreeNode* condition = node->firstChild();
 441         TreeNode* statements = node->secondChild();
 442
 443         bBreak = false;
 444         execute(condition);
 445         while (condition->getValue().Number() != 0)
 446         {
 447                 if (bAbort) return;
 448                 if (bPause) startPausing();
 449                 kapp->processEvents();
 450
 451                 execute(statements);
 452                 if (bBreak || bReturn) break; //jump out loop
 453                 execute(condition);
 454         }
 455         bBreak = false;
 456 }
 457
 458
 459 void Executer::execIf(TreeNode* node)
 460 {
 461         TreeNode* condition = node->firstChild();
 462         TreeNode* ifblok = node->secondChild();
 463
 464         //determine if there is an else part
 465         if (node->size() == 2) // no else
 466         {
 467                 execute( condition );
 468                 if( condition->getValue().Number() != 0 ) execute(ifblok);
 469         }
 470         else // else part given
 471         {
 472                 TreeNode* elseblok = node->thirdChild();
 473                 execute( condition );
 474                 if( condition->getValue().Number() != 0 ) execute(ifblok);
 475                 else execute( elseblok );
 476         }
 477 }
 478
 479
 480
 481 void Executer::execAssign(TreeNode* node)
 482 {
 483         TreeNode* expr = node->firstChild();
 484
 485         execute(expr);
 486         ( symbolTables.top() )[ node->getLook() ] = expr->getValue();
 487 }
 488
 489 void Executer::execExpression(/*TreeNode* node*/)
 490 {
 491         // execExpression is not implemented, because it should not be needed!
 492 }
 493
 494 void Executer::execId(TreeNode* node)
 495 {
 496         node->setValue( ( symbolTables.top() )[ node->getLook() ] );
 497 }
 498
 499 void Executer::execConstant(/*TreeNode* node*/)
 500 {
 501         // do nothing, value is already set
 502 }
 503
 504 Value Executer::exec2getValue(TreeNode* node)
 505 {
 506         execute(node);
 507         return node->getValue();
 508 }
 509
 510
 511 void Executer::execAdd(TreeNode* node)
 512 {
 513         Value left( exec2getValue( node->firstChild() ) );
 514         Value right( exec2getValue( node->secondChild() ) );
 515
 516         if (left.Type() == numberValue && right.Type() == numberValue) node->setValue( left + right );
 517         else node->setValue( left.String().append( right.String() ) );
 518 }
 519
 520
 521 void Executer::execMul(TreeNode* node)
 522 {
 523         Value left( exec2getValue( node->firstChild() ) );
 524         Value right( exec2getValue( node->secondChild() ) );
 525
 526         if (left.Type() == numberValue && right.Type() == numberValue) node->setValue( left * right );
 527         else emit ErrorMsg(node->getToken(), i18n("Can only multiply numbers."), 9000);
 528 }
 529
 530
 531 void Executer::execDiv(TreeNode* node)
 532 {
 533         Value left( exec2getValue( node->firstChild() ) );
 534         Value right( exec2getValue( node->secondChild() ) );
 535
 536         if (left.Type() == numberValue && right.Type() == numberValue)
 537         {
 538                 if (right.Number() == 0) emit ErrorMsg(node->getToken(), i18n("Cannot divide by zero."), 9000);
 539                 else node->setValue( left / right );
 540         }
 541         else emit ErrorMsg(node->getToken(), i18n("Can only divide numbers."), 9000);
 542 }
 543
 544
 545 void Executer::execSub(TreeNode* node)
 546 {
 547         Value left( exec2getValue( node->firstChild() ) );
 548         Value right( exec2getValue( node->secondChild() ) );
 549
 550         if (left.Type() == numberValue && right.Type() == numberValue)
 551                 node->setValue( left - right );
 552
 553         else emit ErrorMsg(node->getToken(), i18n("Can only subtract numbers."), 9000);
 554 }
 555
 556
 557
 558 void Executer::execLT(TreeNode* node)
 559 {
 560         Value left( exec2getValue( node->firstChild() ) );
 561         Value right( exec2getValue( node->secondChild() ) );
 562
 563         node->setValue( left < right );
 564 }
 565
 566 void Executer::execLE(TreeNode* node)
 567 {
 568         Value left( exec2getValue( node->firstChild() ) );
 569         Value right( exec2getValue( node->secondChild() ) );
 570
 571         node->setValue( left <= right );
 572 }
 573
 574 void Executer::execGT(TreeNode* node)
 575 {
 576         Value left( exec2getValue( node->firstChild() ) );
 577         Value right( exec2getValue( node->secondChild() ) );
 578
 579         node->setValue( left > right );
 580 }
 581
 582 void Executer::execGE(TreeNode* node)
 583 {
 584         Value left( exec2getValue( node->firstChild() ) );
 585         Value right( exec2getValue( node->secondChild() ) );
 586
 587         node->setValue( left >= right );
 588 }
 589
 590
 591 void Executer::execEQ(TreeNode* node)
 592 {
 593         Value left( exec2getValue( node->firstChild() ) );
 594         Value right( exec2getValue( node->secondChild() ) );
 595
 596         node->setValue( left == right );
 597 }
 598
 599
 600 void Executer::execNE(TreeNode* node)
 601 {
 602         Value left( exec2getValue( node->firstChild() ) );
 603         Value right( exec2getValue( node->secondChild() ) );
 604
 605         node->setValue( left != right );
 606 }
 607
 608
 609
 610 void Executer::execAnd(TreeNode* node)
 611 {
 612         bool nl = exec2getValue( node->firstChild() ).Number() != 0;
 613         bool nr = exec2getValue( node->secondChild() ).Number() != 0;
 614         node->setValue( (double) (nl && nr) );
 615 }
 616
 617
 618 void Executer::execOr(TreeNode* node)
 619 {
 620         bool nl = exec2getValue( node->firstChild() ).Number() != 0;
 621         bool nr = exec2getValue( node->secondChild() ).Number() != 0;
 622         node->setValue(nl || nr);
 623 }
 624
 625
 626 void Executer::execNot(TreeNode* node)
 627 {
 628         node->setValue( exec2getValue( node->firstChild() ).Number() == 0 );
 629 }
 630
 631
 632 void Executer::execMinus(TreeNode* node)
 633 {
 634         node->setValue( -exec2getValue( node->firstChild() ).Number() );
 635 }
 636
 637
 638 QString Executer::runCommand(const QString& command)
 639 {
 640         FILE *pstream;
 641
 642         if ( ( pstream = popen( command.ascii(), "r" ) ) == NULL ) return ("");
 643
 644         QString Line;
 645         char buf[100];
 646
 647         while( fgets(buf, sizeof(buf), pstream) !=NULL) {
 648                 if (bAbort) return ("");
 649                 kapp->processEvents();
 650
 651                 Line += buf;
 652         }
 653         pclose(pstream);
 654         return Line;
 655 }
 656
 657
 658 void Executer::execRun(TreeNode* node)
 659 {
 660         QString cmd = exec2getValue( node->firstChild() ).String();
 661         node->setValue( runCommand(cmd) );
 662 }
 663
 664
 665
 666
 667 void Executer::execClear(TreeNode* node)
 668 {
 669         if ( checkParameterQuantity(node, 0, 5060) ) emit Clear();
 670 }
 671
 672 void Executer::execCenter(TreeNode* node)
 673 {
 674         if ( checkParameterQuantity(node, 0, 5060) ) emit Center();
 675 }
 676
 677 void Executer::execPenUp(TreeNode* node)
 678 {
 679         if ( checkParameterQuantity(node, 0, 5060) ) emit PenUp();
 680 }
 681
 682 void Executer::execPenDown(TreeNode* node)
 683 {
 684         if ( checkParameterQuantity(node, 0, 5060) ) emit PenDown();
 685 }
 686
 687 void Executer::execSpriteShow(TreeNode* node)
 688 {
 689         if ( checkParameterQuantity(node, 0, 5060) ) emit SpriteShow();
 690 }
 691
 692 void Executer::execSpriteHide(TreeNode* node)
 693 {
 694         if ( checkParameterQuantity(node, 0, 5060) ) emit SpriteHide();
 695 }
 696
 697 void Executer::execSpritePress(TreeNode* node)
 698 {
 699         if ( checkParameterQuantity(node, 0, 5060) ) emit SpritePress();
 700 }
 701
 702 void Executer::execWrapOn(TreeNode* node)
 703 {
 704         if ( checkParameterQuantity(node, 0, 5060) ) emit WrapOn();
 705 }
 706
 707 void Executer::execWrapOff(TreeNode* node)
 708 {
 709         if ( checkParameterQuantity(node, 0, 5060) ) emit WrapOff();
 710 }
 711
 712 void Executer::execReset(TreeNode* node)
 713 {
 714         if ( checkParameterQuantity(node, 0, 5060) ) emit Reset();
 715 }
 716
 717 void Executer::execMessage(TreeNode* node)
 718 {
 719         if ( checkParameterQuantity(node, 1, 5060) && checkParameterType(node, stringValue, 5060) )
 720                 emit MessageDialog( node->firstChild()->getValue().String() );
 721 }
 722
 723
 724
 725
 726
 727
 728 void Executer::execGoX(TreeNode* node)
 729 {
 730         if ( !checkParameterQuantity(node, 1, 5060) ) return;
 731         TreeNode* param1 = node->firstChild();
 732         execute(param1);
 733         if ( checkParameterType(node, numberValue, 5060) )
 734         {
 735                 emit GoX( param1->getValue().Number() );
 736         }
 737 }
 738
 739 void Executer::execGoY(TreeNode* node)
 740 {
 741         if ( !checkParameterQuantity(node, 1, 5060) ) return;
 742         TreeNode* param1 = node->firstChild();
 743         execute(param1);
 744         if ( checkParameterType(node, numberValue, 5060) )
 745         {
 746                 emit GoY( param1->getValue().Number() );
 747         }
 748 }
 749
 750 void Executer::execForward(TreeNode* node)
 751 {
 752         if ( !checkParameterQuantity(node, 1, 5060) ) return;
 753         TreeNode* param1 = node->firstChild();
 754         execute(param1);
 755         if ( checkParameterType(node, numberValue, 5060) )
 756         {
 757                 emit Forward( param1->getValue().Number() );
 758         }
 759 }
 760
 761 void Executer::execBackward(TreeNode* node)
 762 {
 763         if ( !checkParameterQuantity(node, 1, 5060) ) return;
 764         TreeNode* param1 = node->firstChild();
 765         execute(param1);
 766         if ( checkParameterType(node, numberValue, 5060) )
 767         {
 768                 emit Backward( param1->getValue().Number() );
 769         }
 770 }
 771
 772 void Executer::execDirection(TreeNode* node)
 773 {
 774         if ( !checkParameterQuantity(node, 1, 5060) ) return;
 775         TreeNode* param1 = node->firstChild();
 776         execute(param1);
 777         if ( checkParameterType(node, numberValue, 5060) )
 778         {
 779                 emit Direction( param1->getValue().Number() );
 780         }
 781 }
 782
 783 void Executer::execTurnLeft(TreeNode* node)
 784 {
 785         if ( !checkParameterQuantity(node, 1, 5060) ) return;
 786         TreeNode* param1 = node->firstChild();
 787         execute(param1);
 788         if ( checkParameterType(node, numberValue, 5060) )
 789         {
 790                 emit TurnLeft( param1->getValue().Number() );
 791         }
 792 }
 793
 794 void Executer::execTurnRight(TreeNode* node)
 795 {
 796         if ( !checkParameterQuantity(node, 1, 5060) ) return;
 797         TreeNode* param1 = node->firstChild();
 798         execute(param1);
 799         if ( checkParameterType(node, numberValue, 5060) )
 800         {
 801                 emit TurnRight( param1->getValue().Number() );
 802         }
 803 }
 804
 805 void Executer::execSetPenWidth(TreeNode* node)
 806 {
 807         if ( !checkParameterQuantity(node, 1, 5060) ) return;
 808         TreeNode* param1 = node->firstChild();
 809         execute(param1);
 810         if ( checkParameterType(node, numberValue, 5060) )
 811         {
 812                 int x = ROUND2INT( param1->getValue().Number() ); // pull the number value & round it to int
 813                 if (x < 1 || x > 10000)
 814                         emit ErrorMsg(node->getToken(), i18n("The penwidth cannot be set to something smaller than 1, or bigger than 10000."), 6050);
 815                 else
 816                         emit SetPenWidth(x);
 817         }
 818 }
 819
 820 void Executer::execSpriteChange(TreeNode* node)
 821 {
 822         if ( !checkParameterQuantity(node, 1, 5060) ) return;
 823         TreeNode* param1 = node->firstChild();
 824         execute(param1);
 825         if ( checkParameterType(node, numberValue, 5060) )
 826         {
 827                 int x = ROUND2INT( param1->getValue().Number() ); // pull the number value & round it to int
 828                 emit SpriteChange(x);
 829         }
 830 }
 831
 832 void Executer::execFontSize(TreeNode* node)
 833 {
 834         if ( !checkParameterQuantity(node, 1, 5060) ) return;
 835         TreeNode* param1 = node->firstChild();
 836         execute(param1);
 837         if ( checkParameterType(node, numberValue, 5060) )
 838         {
 839                 int x = ROUND2INT( param1->getValue().Number() ); // pull the number value & round it to int
 840                 if ( x < 0 || x > 350 )
 841                         emit ErrorMsg(node->getToken(), i18n("The parameters of function %1 must be within range: 0 to 350.").arg( node->getLook() ), 5065);
 842                 else
 843                         emit FontSize(x);
 844         }
 845 }
 846
 847
 848
 849
 850
 851
 852 void Executer::execGo(TreeNode* node)
 853 {
 854         if ( !checkParameterQuantity(node, 2, 5060) ) return;
 855         TreeNode* nodeX = node->firstChild(); // getting
 856         TreeNode* nodeY = node->secondChild();
 857         execute(nodeX); // executing
 858         execute(nodeY);
 859
 860         if ( checkParameterType(node, numberValue, 5060) )
 861         {
 862                 emit Go( nodeX->getValue().Number(), nodeY->getValue().Number() );
 863         }
 864 }
 865
 866 void Executer::execResizeCanvas(TreeNode* node)
 867 {
 868         if ( !checkParameterQuantity(node, 2, 5060) ) return;
 869         TreeNode* nodeX = node->firstChild(); // getting
 870         TreeNode* nodeY = node->secondChild();
 871         execute(nodeX); // executing
 872         execute(nodeY);
 873
 874         if ( checkParameterType(node, numberValue, 5060) )
 875         {
 876                 int x = ROUND2INT( nodeX->getValue().Number() ); // converting & rounding to int
 877                 int y = ROUND2INT( nodeY->getValue().Number() );
 878                 if ( ( x < 1 || y < 1 ) || ( x > 10000 || y > 10000 ) )
 879                         emit ErrorMsg(node->getToken(), i18n("The parameters of the %1 command must be numbers in the range: 1 to 10000.").arg( node->getLook() ), 7030);
 880                 else
 881                         emit ResizeCanvas(x, y);
 882         }
 883 }
 884
 885 void Executer::execRandom(TreeNode* node)
 886 {
 887         if ( !checkParameterQuantity(node, 2, 5060) ) return;
 888         TreeNode* nodeX = node->firstChild(); // getting
 889         TreeNode* nodeY = node->secondChild();
 890         execute(nodeX); // executing
 891         execute(nodeY);
 892
 893         if ( !checkParameterType(node, numberValue, 5060) ) return;
 894         double x = nodeX->getValue().Number();
 895         double y = nodeY->getValue().Number();
 896         double r = (double)( KApplication::random() ) / RAND_MAX;
 897         node->setValue( r * ( y - x ) + x );
 898 }
 899
 900
 901
 902
 903
 904 void Executer::execSetFgColor(TreeNode* node)
 905 {
 906         if ( !checkParameterQuantity(node, 3, 5060) ) return;
 907         TreeNode* nodeR = node->firstChild(); // getting
 908         TreeNode* nodeG = node->secondChild();
 909         TreeNode* nodeB = node->thirdChild();
 910         execute(nodeR); // executing
 911         execute(nodeG);
 912         execute(nodeB);
 913         if ( checkParameterType(node, numberValue, 5060) )
 914         {
 915                 int r = ROUND2INT( nodeR->getValue().Number() ); // converting & rounding to int
 916                 int g = ROUND2INT( nodeG->getValue().Number() );
 917                 int b = ROUND2INT( nodeB->getValue().Number() );
 918                 if ( ( r < 0 || g < 0 || b < 0 ) || ( r > 255 || g > 255 || b > 255 ) )
 919                         emit ErrorMsg(node->getToken(), i18n("The parameters of the %1 command must be numbers in the range: 0 to 255.").arg( node->getLook() ), 6090);
 920                 else
 921                         emit SetFgColor(r, g, b);
 922         }
 923 }
 924
 925 void Executer::execSetBgColor(TreeNode* node)
 926 {
 927         if ( !checkParameterQuantity(node, 3, 5060) ) return;
 928         TreeNode* nodeR = node->firstChild(); // getting
 929         TreeNode* nodeG = node->secondChild();
 930         TreeNode* nodeB = node->thirdChild();
 931         execute(nodeR); // executing
 932         execute(nodeG);
 933         execute(nodeB);
 934         if ( checkParameterType(node, numberValue, 5060) )
 935         {
 936                 int r = ROUND2INT( nodeR->getValue().Number() ); // converting & rounding to int
 937                 int g = ROUND2INT( nodeG->getValue().Number() );
 938                 int b = ROUND2INT( nodeB->getValue().Number() );
 939                 if ( ( r < 0 || g < 0 || b < 0 ) || ( r > 255 || g > 255 || b > 255 ) )
 940                         emit ErrorMsg(node->getToken(), i18n("The parameters of the %1 command must be numbers in the range: 0 to 255.").arg( node->getLook() ), 6090);
 941                 else
 942                         emit SetBgColor(r, g, b);
 943         }
 944 }
 945
 946
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956 void Executer::execInputWindow(TreeNode* node)
 957 {
 958         if ( !checkParameterQuantity(node, 1, 5060) ) return;
 959
 960         QString value = node->firstChild()->getValue().String();
 961         emit InputDialog(value);
 962
 963         node->setType(constantNode);
 964         if ( value.isEmpty() ) node->getValue().resetValue(); // set value back to empty
 965         else
 966         {
 967                 bool ok = true;
 968                 double num = value.toDouble(&ok); // to see if the value from the InpDialog is a float
 969                 if (ok) node->setValue(num);
 970                 else    node->setValue(value);
 971         }
 972 }
 973
 974 void Executer::execPrint(TreeNode* node)
 975 {
 976         if (node->size() == 0)
 977         {
 978                 emit ErrorMsg(node->getToken(), i18n("The print command needs input"), 5050);
 979                 return;
 980         }
 981         TreeNode::iterator i;
 982         QString str = "";
 983         for (i = node->begin(); i != node->end(); ++i)
 984         {
 985                 execute(*i); // execute expression
 986                 str = str + (*i)->getValue().String();
 987         }
 988         emit Print(str);
 989 }
 990
 991 void Executer::execFontType(TreeNode* node)
 992 {
 993         // if not 2 params go staight to the checkParam, diplay the error, and return to prevent a crash
 994         if ( !checkParameterQuantity(node, 2, 5060) && !checkParameterType(node, stringValue, 5060) ) return;
 995
 996         QString extra;
 997         if (node->size() == 2) QString extra = node->secondChild()->getValue().String();
 998         QString family = node->firstChild()->getValue().String();
 999         emit FontType(family, extra);
1000 }
1001
1002
1003 void Executer::execWait(TreeNode* node)
1004 {
1005         if ( !checkParameterQuantity(node, 1, 5060) ) return;
1006         TreeNode* param1 = node->firstChild();
1007         execute(param1);
1008         if ( !checkParameterType(node, numberValue, 5060) ) return;
1009         int msec = (int)( 1000 * param1->getValue().Number() );
1010         startWaiting(msec);
1011 }
1012
1013 void Executer::startWaiting(int msec)
1014 {
1015         bStopWaiting = false;
1016         // call a timer that sets stopWaiting to true when it runs
1017         QTimer::singleShot( msec, this, SLOT( slotStopWaiting() ) );
1018         while (bStopWaiting == false)
1019         {
1020                 if (bAbort) return; // waits need to be interrupted by the stop action
1021                 if (bPause) startPausing();
1022                 kapp->processEvents();
1023
1024                 // only 10 times per second is enough... else the CPU gets 100% loaded ( not nice :)
1025                 usleep(100000);
1026         }
1027 }
1028
1029 void Executer::slotStopWaiting()
1030 {
1031         bStopWaiting = true;
1032 }
1033
1034 void Executer::startPausing()
1035 {
1036         while (bPause == true)
1037         {
1038                 if (bAbort) return; // waits need to be interrupted by the stop action
1039                 kapp->processEvents();
1040                 // only 10 times per second is enough... else the CPU gets 100% loaded ( not nice :)
1041                 usleep(100000);
1042         }
1043 }
1044
1045 void Executer::slotStopPausing()
1046 {
1047         bPause = false;
1048 }
1049
1050
1051
1052
1053 bool Executer::checkParameterQuantity(TreeNode* node, uint quantity, int errorCode)
1054 {
1055         if (quantity == 0)
1056         {
1057                 if (node->size() == 0) return true; // thats easy!
1058                 emit ErrorMsg(node->getToken(), i18n("The %1 command accepts no parameters.").arg( node->getLook() ), errorCode);
1059                 return false;
1060         }
1061
1062         uint nodeSize = node->size();
1063         if (nodeSize != 0) // when all parameters are forgotten the parser puts a Unknown/tokEOL param, catch this:
1064                 if (node->firstChild()->getToken().type == tokEOL) nodeSize = 0;
1065
1066         if (nodeSize != quantity)
1067         {
1068                 if (nodeSize < quantity)
1069                 {
1070                         emit ErrorMsg(node->getToken(), i18n("The %1 command was called with %2 but needs 1 parameter.", "The %1 command was called with %2 but needs %n parameters.", quantity).arg( node->getLook() ).arg(nodeSize), errorCode);
1071                 }
1072                 else
1073                 {
1074                         emit ErrorMsg(node->getToken(), i18n("The %1 command was called with %2 but only accepts 1 parameter.", "The %1 command was called with %2 but only accepts %n parameters.", quantity).arg( node->getLook() ).arg(nodeSize), errorCode);
1075                 }
1076                 return false;
1077         }
1078         return true; // if all tests passed
1079 }
1080
1081
1082 bool Executer::checkParameterType(TreeNode* node, int valueType, int errorCode)
1083 {
1084         uint quantity = node->size();
1085         uint ii = 1;
1086         TreeNode::iterator i = node->begin();
1087         while ( i != node->end() && ii <= quantity )
1088         {
1089                 if ( (*i)->getValue().Type() != valueType )
1090                 {
1091                         switch (valueType)
1092                         {
1093                                 case stringValue:
1094                                         if (quantity == 1)
1095                                                 emit ErrorMsg(node->getToken(), i18n("The %1 command only accepts a string as its parameter.").arg( node->getLook() ), errorCode);
1096                                         else
1097                                                 emit ErrorMsg(node->getToken(), i18n("The %1 command only accepts strings as its parameters.").arg( node->getLook() ), errorCode);
1098                                         break;
1099
1100                                 case numberValue:
1101                                         if (quantity == 1)
1102                                                 emit ErrorMsg(node->getToken(), i18n("The %1 command only accepts a number as its parameter.").arg( node->getLook() ), errorCode);
1103                                         else
1104                                                 emit ErrorMsg(node->getToken(), i18n("The %1 command only accepts numbers as its parameters.").arg( node->getLook() ), errorCode);
1105                                         break;
1106                         }
1107                         return false;
1108                 }
1109                 ++i;
1110                 ii++;
1111         }
1112         return true; // if all tests passed
1113 }
1114
1115 #include "executer.moc"