scilab/modules/ast/src/cpp/ast/runvisitor.cpp

   1 /*
   2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  *  Copyright (C) 2014 - Scilab Enterprises - Antoine ELIAS
   4  *
   5  *  This file must be used under the terms of the CeCILL.
   6  *  This source file is licensed as described in the file COPYING, which
   7  *  you should have received as part of this distribution.  The terms
   8  *  are also available at
   9  *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  10  *
  11  */
  12
  13 //for Visual Leak Detector in debug compilation mode
  14 //#define DEBUG_VLD
  15 #if defined(DEBUG_VLD) && defined(_DEBUG)
  16 #include <vld.h>
  17 #endif
  18
  19 #include <string>
  20
  21 #include "execvisitor.hxx"
  22 #include "stepvisitor.hxx"
  23 #include "timedvisitor.hxx"
  24 #include "shortcutvisitor.hxx"
  25 #include "printvisitor.hxx"
  26 //#include "AnalysisVisitor.hxx"
  27 #include "debuggervisitor.hxx"
  28 #include "debugmanager.hxx"
  29
  30 #include "visitor_common.hxx"
  31
  32 #include "context.hxx"
  33 #include "generic_operations.hxx"
  34 #include "types_or.hxx"
  35 #include "types_and.hxx"
  36 #include "localization.hxx"
  37
  38 #include "macrofile.hxx"
  39 #include "macro.hxx"
  40 #include "cell.hxx"
  41 #include "filemanager_interface.h"
  42
  43 #include "runner.hxx"
  44 #include "threadmanagement.hxx"
  45
  46 extern "C"
  47 {
  48 #include "sciprint.h"
  49 #include "os_string.h"
  50 #include "elem_common.h"
  51 #include "storeCommand.h"
  52 }
  53
  54 namespace ast
  55 {
  56 template <class T>
  57 void RunVisitorT<T>::visitprivate(const CellExp &e)
  58 {
  59     exps_t::const_iterator row;
  60     exps_t::const_iterator col;
  61     int iColMax = 0;
  62
  63     exps_t lines = e.getLines();
  64     //check dimmension
  65     for (row = lines.begin() ; row != lines.end() ; ++row )
  66     {
  67         exps_t cols = (*row)->getAs<MatrixLineExp>()->getColumns();
  68         if (iColMax == 0)
  69         {
  70             iColMax = static_cast<int>(cols.size());
  71         }
  72
  73         if (iColMax != static_cast<int>(cols.size()))
  74         {
  75             std::wostringstream os;
  76             os << _W("inconsistent row/column dimensions\n");
  77             //os << ((Location)(*row)->getLocation()).getLocationString() << std::endl;
  78             throw InternalError(os.str(), 999, (*row)->getLocation());
  79         }
  80     }
  81
  82     //alloc result cell
  83     types::Cell *pC = new types::Cell(static_cast<int>(lines.size()), iColMax);
  84
  85     int i = 0;
  86     int j = 0;
  87
  88     //insert items in cell
  89     for (i = 0, row = lines.begin() ; row != lines.end() ; ++row, ++i)
  90     {
  91         exps_t cols = (*row)->getAs<MatrixLineExp>()->getColumns();
  92         for (j = 0, col = cols.begin() ; col != cols.end() ; ++col, ++j)
  93         {
  94             (*col)->accept(*this);
  95             types::InternalType *pIT = getResult();
  96             if (pIT->isImplicitList())
  97             {
  98                 types::InternalType * _pIT = pIT->getAs<types::ImplicitList>()->extractFullMatrix();
  99                 pC->set(i, j, _pIT);
 100                 _pIT->killMe();
 101             }
 102             else
 103             {
 104                 pC->set(i, j, pIT);
 105             }
 106             clearResult();
 107         }
 108     }
 109
 110     //return new cell
 111     setResult(pC);
 112 }
 113
 114 template <class T>
 115 void RunVisitorT<T>::visitprivate(const FieldExp &e)
 116 {
 117     /*
 118       a.b
 119     */
 120
 121     if (!e.getTail()->isSimpleVar())
 122     {
 123         wchar_t szError[bsiz];
 124         os_swprintf(szError, bsiz, _W("/!\\ Unmanaged FieldExp.\n").c_str());
 125         throw InternalError(szError, 999, e.getLocation());
 126     }
 127
 128     try
 129     {
 130         e.getHead()->accept(*this);
 131     }
 132     catch (const InternalError& error)
 133     {
 134         throw error;
 135     }
 136
 137     if (getResult() == NULL)
 138     {
 139         wchar_t szError[bsiz];
 140         os_swprintf(szError, bsiz, _W("Attempt to reference field of non-structure array.\n").c_str());
 141         throw InternalError(szError, 999, e.getLocation());
 142     }
 143
 144     // TODO: handle case where getSize() > 1
 145     // l=list(struct("toto","coucou"),struct("toto","hello"),1,2);[a,b]=l(1:2).toto
 146     //
 147     if (getResultSize() > 1)
 148     {
 149         clearResult();
 150         wchar_t szError[bsiz];
 151         os_swprintf(szError, bsiz, _W("Not yet implemented in Scilab.\n").c_str());
 152         throw InternalError(szError, 999, e.getLocation());
 153     }
 154
 155     SimpleVar * psvRightMember = static_cast<SimpleVar *>(const_cast<Exp *>(e.getTail()));
 156     std::wstring wstField = psvRightMember->getSymbol().getName();
 157     types::InternalType * pValue = getResult();
 158     types::InternalType * pReturn = NULL;
 159     bool ok = false;
 160
 161     try
 162     {
 163         if (pValue->isGenericType() || pValue->isUserType())
 164         {
 165             ok = pValue->getAs<types::GenericType>()->extract(wstField, pReturn);
 166         }
 167     }
 168     catch (std::wstring & err)
 169     {
 170         pValue->killMe();
 171         throw InternalError(err.c_str(), 999, e.getTail()->getLocation());
 172     }
 173
 174     if (ok)
 175     {
 176         if (pReturn == NULL)
 177         {
 178             std::wostringstream os;
 179             os << _W("Invalid index.\n");
 180             throw InternalError(os.str(), 999, e.getLocation());
 181         }
 182
 183         setResult(pReturn);
 184         if (pValue->isDeletable())
 185         {
 186             if (pValue->isContainer())
 187             {
 188                 // prevent delete of pReturn in case where
 189                 // extract not return a clone
 190                 pReturn->IncreaseRef();
 191                 pValue->killMe();
 192                 pReturn->DecreaseRef();
 193             }
 194             else
 195             {
 196                 pValue->killMe();
 197             }
 198         }
 199     }
 200     else if (pValue->isFieldExtractionOverloadable())
 201     {
 202         types::typed_list in;
 203         types::typed_list out;
 204
 205         types::String* pS = new types::String(wstField.c_str());
 206
 207         //TODO: in the case where overload is a macro there is no need to incref in
 208         // because args will be put in context, removed and killed if required.
 209         // But if the overload is a function... it is another story...
 210
 211         pS->IncreaseRef();
 212         pValue->IncreaseRef();
 213
 214         in.push_back(pS);
 215         in.push_back(pValue);
 216         types::Callable::ReturnValue Ret = types::Callable::Error;
 217         std::wstring stType = pValue->getShortTypeStr();
 218
 219         try
 220         {
 221             Ret = Overload::call(L"%" + stType + L"_e", in, 1, out, this);
 222         }
 223         catch (const InternalError& ie)
 224         {
 225             try
 226             {
 227                 //to compatibility with scilab 5 code.
 228                 //tlist/mlist name are truncated to 8 first character
 229                 if (stType.size() > 8)
 230                 {
 231                     Ret = Overload::call(L"%" + stType.substr(0, 8) + L"_e", in, 1, out, this);
 232                 }
 233                 else
 234                 {
 235                     throw ie;
 236                 }
 237             }
 238             catch (const InternalError& ie)
 239             {
 240                 // TList or Mlist
 241                 if (pValue->isList())
 242                 {
 243                     Ret = Overload::call(L"%l_e", in, 1, out, this);
 244                 }
 245                 else
 246                 {
 247                     throw ie;
 248                 }
 249             }
 250         }
 251
 252         if (Ret != types::Callable::OK)
 253         {
 254             cleanInOut(in, out);
 255             setResult(NULL);
 256             throw InternalError(ConfigVariable::getLastErrorMessage(), ConfigVariable::getLastErrorNumber(), e.getLocation());
 257         }
 258
 259         setResult(out);
 260         cleanIn(in, out);
 261     }
 262     else
 263     {
 264         pValue->killMe();
 265         wchar_t szError[bsiz];
 266         os_swprintf(szError, bsiz, _W("Attempt to reference field of non-structure array.\n").c_str());
 267         throw InternalError(szError, 999, e.getLocation());
 268     }
 269 }
 270
 271 template <class T>
 272 void RunVisitorT<T>::visitprivate(const IfExp  &e)
 273 {
 274     //Create local exec visitor
 275     ShortCutVisitor SCTest;
 276     bool bTestStatus = false;
 277
 278     //condition
 279     e.getTest().accept(SCTest);
 280     e.getTest().accept(*this);
 281
 282     bTestStatus = getResult()->isTrue();
 283     clearResult();
 284     if (bTestStatus == true)
 285     {
 286         e.getThen().accept(*this);
 287     }
 288     else if (e.hasElse())
 289     {
 290         e.getElse().accept(*this);
 291     }
 292
 293     if (e.isBreakable()
 294             && ( (&e.getElse())->isBreak()
 295                  || (&e.getThen())->isBreak() ))
 296     {
 297         const_cast<IfExp*>(&e)->setBreak();
 298         const_cast<Exp*>(&e.getElse())->resetBreak();
 299         const_cast<Exp*>(&e.getThen())->resetBreak();
 300     }
 301
 302     if (e.isContinuable()
 303             && ( (&e.getElse())->isContinue()
 304                  || (&e.getThen())->isContinue() ))
 305     {
 306         const_cast<IfExp*>(&e)->setContinue();
 307         const_cast<Exp*>(&e.getElse())->resetContinue();
 308         const_cast<Exp*>(&e.getThen())->resetContinue();
 309     }
 310
 311     if (e.isReturnable()
 312             && ( (&e.getElse())->isReturn()
 313                  || (&e.getThen())->isReturn() ))
 314     {
 315         const_cast<IfExp*>(&e)->setReturn();
 316         const_cast<Exp*>(&e.getElse())->resetReturn();
 317         const_cast<Exp*>(&e.getThen())->resetReturn();
 318     }
 319 }
 320
 321 template <class T>
 322 void RunVisitorT<T>::visitprivate(const WhileExp  &e)
 323 {
 324
 325     //Create local exec visitor
 326     ShortCutVisitor SCTest;
 327
 328     //manage & and | like && and ||
 329     e.getTest().accept(SCTest);
 330     //condition
 331     e.getTest().accept(*this);
 332
 333     types::InternalType* pIT = getResult();
 334
 335     while (pIT->isTrue())
 336     {
 337         pIT->killMe();
 338         e.getBody().accept(*this);
 339
 340         //clear old result value before evaluate new one
 341         if (getResult() != NULL)
 342         {
 343             getResult()->killMe();
 344         }
 345
 346         if (e.getBody().isBreak())
 347         {
 348             const_cast<Exp*>(&(e.getBody()))->resetBreak();
 349             break;
 350         }
 351
 352         if (e.getBody().isReturn())
 353         {
 354             const_cast<WhileExp*>(&e)->setReturn();
 355             const_cast<Exp*>(&(e.getBody()))->resetReturn();
 356             break;
 357         }
 358
 359         if (e.getBody().isContinue())
 360         {
 361             const_cast<Exp*>(&(e.getBody()))->resetContinue();
 362         }
 363
 364         e.getTest().accept(*this);
 365         pIT = getResult();
 366     }
 367
 368     //pIT->killMe();
 369     //clear result of condition or result of body
 370     clearResult();
 371 }
 372
 373 template <class T>
 374 void RunVisitorT<T>::visitprivate(const ForExp  &e)
 375 {
 376     symbol::Context* ctx = symbol::Context::getInstance();
 377     //vardec visit increase its result reference
 378     e.getVardec().accept(*this);
 379     types::InternalType* pIT = getResult();
 380
 381     if (pIT->isImplicitList())
 382     {
 383         //get IL
 384         types::ImplicitList* pVar = pIT->getAs<types::ImplicitList>();
 385         //get IL initial Type
 386         types::InternalType * pIL = pVar->getInitalType();
 387         //std::cout << "for IL: " << pIL << std::endl;
 388         //std::cout << "  for IV: " << pIT << std::endl;
 389         //get index stack
 390         symbol::Variable* var = e.getVardec().getAs<VarDec>()->getStack();
 391
 392         if (ctx->isprotected(var))
 393         {
 394             std::wostringstream os;
 395             os << _W("Redefining permanent variable.\n");
 396             throw ast::InternalError(os.str(), 999, e.getVardec().getLocation());
 397         }
 398
 399         ctx->put(var, pIL);
 400         //use ref count to lock var against clear and detect any changes
 401         pIL->IncreaseRef();
 402
 403         int size = static_cast<int>(pVar->getSize());
 404         for (int i = 0; i < size; ++i)
 405         {
 406             //check if loop index has changed, deleted, copy ...
 407             if (pIL->getRef() != 2)
 408             {
 409                 switch (pIL->getRef())
 410                 {
 411                     case 1:
 412                         //someone clear me
 413                         ctx->put(var, pIL);
 414                         break;
 415                     default:
 416                         //someone assign me to another var
 417                         //a = i;
 418                         //unlock me
 419                         pIL->DecreaseRef();
 420
 421                         //no need to destroy, it already assign to another var
 422                         //pIL->killMe();
 423
 424                         //create a new me
 425                         pIL = pVar->getInitalType();
 426                         //lock loop index
 427                         pIL->IncreaseRef();
 428                         //update me ( must decrease ref of a )
 429                         if (ctx->isprotected(var))
 430                         {
 431                             std::wostringstream os;
 432                             os << _W("Redefining permanent variable.\n");
 433                             throw ast::InternalError(os.str(), 999, e.getVardec().getLocation());
 434                         }
 435
 436                         ctx->put(var, pIL);
 437                         break;
 438                 }
 439             }
 440
 441             pVar->extractValue(i, pIL);
 442
 443             try
 444             {
 445                 e.getBody().accept(*this);
 446             }
 447             catch (const InternalError& ie)
 448             {
 449                 //unlock loop index and implicit list
 450                 pIL->DecreaseRef();
 451                 pIL->killMe();
 452                 pIT->DecreaseRef();
 453                 pIT->killMe();
 454
 455                 setResult(NULL);
 456                 throw ie;
 457             }
 458
 459             if (e.getBody().isBreak())
 460             {
 461                 const_cast<Exp&>(e.getBody()).resetBreak();
 462                 break;
 463             }
 464
 465             if (e.getBody().isContinue())
 466             {
 467                 const_cast<Exp&>(e.getBody()).resetContinue();
 468                 continue;
 469             }
 470
 471             if (e.getBody().isReturn())
 472             {
 473                 const_cast<ForExp&>(e).setReturn();
 474                 const_cast<Exp&>(e.getBody()).resetReturn();
 475                 break;
 476             }
 477         }
 478
 479         //unlock loop index
 480         pIL->DecreaseRef();
 481         pIL->killMe();
 482     }
 483     else if (pIT->isList())
 484     {
 485         types::List* pL = pIT->getAs<types::List>();
 486         const int size = pL->getSize();
 487         symbol::Variable* var = e.getVardec().getAs<VarDec>()->getStack();
 488         for (int i = 0; i < size; ++i)
 489         {
 490             types::InternalType* pNew = pL->get(i);
 491
 492             if (ctx->isprotected(var))
 493             {
 494                 std::wostringstream os;
 495                 os << _W("Redefining permanent variable.\n");
 496                 throw ast::InternalError(os.str(), 999, e.getVardec().getLocation());
 497             }
 498             ctx->put(var, pNew);
 499
 500             try
 501             {
 502                 e.getBody().accept(*this);
 503             }
 504             catch (const InternalError& ie)
 505             {
 506                 //implicit list
 507                 pIT->DecreaseRef();
 508                 pIT->killMe();
 509                 setResult(NULL);
 510                 throw ie;
 511             }
 512
 513             if (e.getBody().isBreak())
 514             {
 515                 const_cast<Exp*>(&(e.getBody()))->resetBreak();
 516                 break;
 517             }
 518
 519             if (e.getBody().isContinue())
 520             {
 521                 const_cast<Exp*>(&(e.getBody()))->resetContinue();
 522                 continue;
 523             }
 524
 525             if (e.getBody().isReturn())
 526             {
 527                 const_cast<ForExp*>(&e)->setReturn();
 528                 const_cast<Exp&>(e.getBody()).resetReturn();
 529                 break;
 530             }
 531         }
 532     }
 533     else if (pIT->isGenericType())
 534     {
 535         //Matrix i = [1,3,2,6] or other type
 536         types::GenericType* pVar = pIT->getAs<types::GenericType>();
 537         if (pVar->getDims() > 2)
 538         {
 539             pIT->DecreaseRef();
 540             pIT->killMe();
 541             throw InternalError(_W("for expression can only manage 1 or 2 dimensions variables\n"), 999, e.getVardec().getLocation());
 542         }
 543
 544         symbol::Variable* var = e.getVardec().getAs<VarDec>()->getStack();
 545         for (int i = 0; i < pVar->getCols(); i++)
 546         {
 547             types::GenericType* pNew = pVar->getColumnValues(i);
 548             if (pNew == NULL)
 549             {
 550                 pIT->DecreaseRef();
 551                 pIT->killMe();
 552                 throw InternalError(_W("for expression : Wrong type for loop iterator.\n"), 999, e.getVardec().getLocation());
 553             }
 554
 555             if (ctx->isprotected(var))
 556             {
 557                 std::wostringstream os;
 558                 os << _W("Redefining permanent variable.\n");
 559                 throw InternalError(os.str(), 999, e.getVardec().getLocation());
 560             }
 561             ctx->put(var, pNew);
 562
 563             try
 564             {
 565                 e.getBody().accept(*this);
 566             }
 567             catch (const InternalError& ie)
 568             {
 569                 //implicit list
 570                 pIT->DecreaseRef();
 571                 pIT->killMe();
 572                 setResult(NULL);
 573                 throw ie;
 574             }
 575
 576             if (e.getBody().isBreak())
 577             {
 578                 const_cast<Exp*>(&(e.getBody()))->resetBreak();
 579                 break;
 580             }
 581
 582             if (e.getBody().isContinue())
 583             {
 584                 const_cast<Exp*>(&(e.getBody()))->resetContinue();
 585                 continue;
 586             }
 587
 588             if (e.getBody().isReturn())
 589             {
 590                 const_cast<ForExp*>(&e)->setReturn();
 591                 const_cast<Exp&>(e.getBody()).resetReturn();
 592                 break;
 593             }
 594         }
 595     }
 596     else
 597     {
 598         pIT->DecreaseRef();
 599         pIT->killMe();
 600         throw InternalError(_W("for expression : Wrong type for loop iterator.\n"), 999, e.getVardec().getLocation());
 601     }
 602
 603     pIT->DecreaseRef();
 604     pIT->killMe();
 605
 606     setResult(NULL);
 607 }
 608
 609 template <class T>
 610 void RunVisitorT<T>::visitprivate(const ReturnExp &e)
 611 {
 612     if (e.isGlobal())
 613     {
 614         if (ConfigVariable::getEnableDebug() == true)
 615         {
 616             sciprint(_("%s: function is disable in debug mode.\n"), "resume");
 617             return;
 618         }
 619
 620         if (ConfigVariable::getPauseLevel() != 0 && symbol::Context::getInstance()->getScopeLevel() == ConfigVariable::getActivePauseLevel())
 621         {
 622             //return or resume
 623             ConfigVariable::DecreasePauseLevel();
 624             return;
 625         }
 626         else
 627         {
 628             const_cast<ReturnExp*>(&e)->setReturn();
 629         }
 630     }
 631     else
 632     {
 633         //return(x)
 634
 635         //in case of CallExp, we can return only one values
 636         int iSaveExpectedSize = getExpectedSize();
 637         setExpectedSize(1);
 638         e.getExp().accept(*this);
 639         setExpectedSize(iSaveExpectedSize);
 640         const_cast<ReturnExp*>(&e)->setReturn();
 641     }
 642 }
 643
 644 template <class T>
 645 void RunVisitorT<T>::visitprivate(const IntSelectExp &e)
 646 {
 647     bool found = false;
 648     //e.getSelect()->accept(*this);
 649     //InternalType* pIT = getResult();
 650     //setResult(nullptr);
 651     //if (pIT && pIT->isDouble())
 652     //{
 653     //    Double * pDbl = static_cast<Double *>(pIT);
 654     //    if (!pDbl->isComplex() && pDbl->getSize() == 1)
 655     //    {
 656     //        int64_t val;
 657     //        if (analysis::tools::asInteger<int64_t>(pDbl->get(0), val))
 658     //        {
 659     //            Exp * exp = e.getExp(val);
 660     //            found = true;
 661     //            if (exp)
 662     //            {
 663     //                Exp * body = exp->isCaseExp() ? exp->getAs<CaseExp>()->getBody() : exp;
 664     //                if (e.isBreakable())
 665     //                {
 666     //                    const_cast<IntSelectExp*>(&e)->resetBreak();
 667     //                    body->setBreakable();
 668     //                }
 669
 670     //                if (e.isContinuable())
 671     //                {
 672     //                    const_cast<IntSelectExp*>(&e)->resetContinue();
 673     //                    body->setContinuable();
 674     //                }
 675
 676     //                if (e.isReturnable())
 677     //                {
 678     //                    const_cast<IntSelectExp*>(&e)->resetReturn();
 679     //                    body->setReturnable();
 680     //                }
 681
 682     //                try
 683     //                {
 684     //                    //the good one
 685     //                    body->accept(*this);
 686     //                }
 687     //                catch (const InternalError& ie)
 688     //                {
 689     //                    pIT->killMe();
 690     //                    throw ie;
 691     //                }
 692
 693     //                if (e.isBreakable() && body->isBreak())
 694     //                {
 695     //                    const_cast<IntSelectExp*>(&e)->setBreak();
 696     //                    body->resetBreak();
 697     //                }
 698
 699     //                if (e.isContinuable() && body->isContinue())
 700     //                {
 701     //                    const_cast<IntSelectExp*>(&e)->setContinue();
 702     //                    body->resetContinue();
 703     //                }
 704
 705     //                if (e.isReturnable() && body->isReturn())
 706     //                {
 707     //                    const_cast<IntSelectExp*>(&e)->setReturn();
 708     //                    body->resetReturn();
 709     //                }
 710     //            }
 711     //        }
 712     //    }
 713     //}
 714
 715     if (!found)
 716     {
 717         e.getOriginal()->accept(*this);
 718     }
 719 }
 720
 721 template <class T>
 722 void RunVisitorT<T>::visitprivate(const StringSelectExp &e)
 723 {
 724     e.getSelect()->accept(*this);
 725     types::InternalType* pIT = getResult();
 726     setResult(nullptr);
 727     bool found = false;
 728     if (pIT && pIT->isString())
 729     {
 730         types::String * pStr = static_cast<types::String *>(pIT);
 731         if (pStr->getSize() == 1)
 732         {
 733             if (wchar_t * s = pStr->get(0))
 734             {
 735                 const std::wstring ws(s);
 736                 Exp * exp = e.getExp(ws);
 737                 found = true;
 738                 if (exp)
 739                 {
 740                     Exp * body = exp->isCaseExp() ? exp->getAs<CaseExp>()->getBody() : exp;
 741                     if (e.isBreakable())
 742                     {
 743                         const_cast<StringSelectExp*>(&e)->resetBreak();
 744                         body->setBreakable();
 745                     }
 746
 747                     if (e.isContinuable())
 748                     {
 749                         const_cast<StringSelectExp*>(&e)->resetContinue();
 750                         body->setContinuable();
 751                     }
 752
 753                     if (e.isReturnable())
 754                     {
 755                         const_cast<StringSelectExp*>(&e)->resetReturn();
 756                         body->setReturnable();
 757                     }
 758
 759                     try
 760                     {
 761                         //the good one
 762                         body->accept(*this);
 763                     }
 764                     catch (const InternalError& ie)
 765                     {
 766                         pIT->killMe();
 767                         throw ie;
 768                     }
 769
 770                     if (e.isBreakable() && body->isBreak())
 771                     {
 772                         const_cast<StringSelectExp*>(&e)->setBreak();
 773                         body->resetBreak();
 774                     }
 775
 776                     if (e.isContinuable() && body->isContinue())
 777                     {
 778                         const_cast<StringSelectExp*>(&e)->setContinue();
 779                         body->resetContinue();
 780                     }
 781
 782                     if (e.isReturnable() && body->isReturn())
 783                     {
 784                         const_cast<StringSelectExp*>(&e)->setReturn();
 785                         body->resetReturn();
 786                     }
 787                 }
 788             }
 789         }
 790     }
 791
 792     if (!found)
 793     {
 794         e.getOriginal()->accept(*this);
 795     }
 796 }
 797
 798 template <class T>
 799 void RunVisitorT<T>::visitprivate(const SelectExp &e)
 800 {
 801     // FIXME : exec select ... case ... else ... end
 802     e.getSelect()->accept(*this);
 803     bool bCase = false;
 804
 805     types::InternalType* pIT = getResult();
 806     setResult(NULL);
 807     if (pIT)
 808     {
 809         // protect pIT to avoid double free when
 810         // the variable in select is override in the case
 811         pIT->IncreaseRef();
 812
 813         //find good case
 814         exps_t cases = e.getCases();
 815         for (auto exp : cases)
 816         {
 817             CaseExp* pCase = exp->getAs<CaseExp>();
 818             pCase->getTest()->accept(*this);
 819             types::InternalType *pITCase = getResult();
 820             setResult(NULL);
 821             if (pITCase)
 822             {
 823                 if (pITCase->isContainer()) //WARNING ONLY FOR CELL
 824                 {
 825                     //check each item
 826                 }
 827                 else if (*pITCase == *pIT)
 828                 {
 829                     try
 830                     {
 831                         //the good one
 832                         pCase->getBody()->accept(*this);
 833                     }
 834                     catch (const InternalError& ie)
 835                     {
 836                         pIT->DecreaseRef();
 837                         pIT->killMe();
 838                         throw ie;
 839                     }
 840
 841                     if (e.isBreakable() && pCase->getBody()->isBreak())
 842                     {
 843                         const_cast<SelectExp*>(&e)->setBreak();
 844                         pCase->getBody()->resetBreak();
 845                     }
 846
 847                     if (e.isContinuable() && pCase->getBody()->isContinue())
 848                     {
 849                         const_cast<SelectExp*>(&e)->setContinue();
 850                         pCase->getBody()->resetContinue();
 851                     }
 852
 853                     if (e.isReturnable() && pCase->getBody()->isReturn())
 854                     {
 855                         const_cast<SelectExp*>(&e)->setReturn();
 856                         pCase->getBody()->resetReturn();
 857                     }
 858
 859                     pITCase->killMe();
 860                     bCase = true;
 861                     break;
 862                 }
 863
 864                 pITCase->killMe();
 865             }
 866         }
 867     }
 868
 869     if (bCase == false && e.getDefaultCase() != NULL)
 870     {
 871         try
 872         {
 873             //default case
 874             e.getDefaultCase()->accept(*this);
 875         }
 876         catch (const InternalError& ie)
 877         {
 878             if (pIT)
 879             {
 880                 pIT->DecreaseRef();
 881                 pIT->killMe();
 882             }
 883             throw ie;
 884         }
 885
 886         if (e.isBreakable() && e.getDefaultCase()->isBreak())
 887         {
 888             const_cast<SelectExp*>(&e)->setBreak();
 889             e.getDefaultCase()->resetBreak();
 890         }
 891
 892         if (e.isContinuable() && e.getDefaultCase()->isContinue())
 893         {
 894             const_cast<SelectExp*>(&e)->setContinue();
 895             e.getDefaultCase()->resetContinue();
 896         }
 897
 898         if (e.isReturnable() && e.getDefaultCase()->isReturn())
 899         {
 900             const_cast<SelectExp*>(&e)->setReturn();
 901             e.getDefaultCase()->resetReturn();
 902         }
 903     }
 904
 905     clearResult();
 906
 907     if (pIT)
 908     {
 909         pIT->DecreaseRef();
 910         pIT->killMe();
 911     }
 912 }
 913
 914 template <class T>
 915 void RunVisitorT<T>::visitprivate(const SeqExp  &e)
 916 {
 917     for (auto exp : e.getExps())
 918     {
 919         if (exp->isCommentExp())
 920         {
 921             continue;
 922         }
 923
 924         if (ConfigVariable::isExecutionBreak())
 925         {
 926             ConfigVariable::resetExecutionBreak();
 927             StorePrioritaryCommand("pause");
 928         }
 929
 930         // interrupt me to execute a prioritary command
 931         while (StaticRunner_isInterruptibleCommand() == 1 && StaticRunner_isRunnerAvailable() == 1)
 932         {
 933             StaticRunner_launch();
 934             StaticRunner_setInterruptibleCommand(1);
 935         }
 936
 937
 938
 939         try
 940         {
 941             //reset default values
 942             setResult(NULL);
 943             int iExpectedSize = getExpectedSize();
 944             setExpectedSize(-1);
 945             exp->accept(*this);
 946             setExpectedSize(iExpectedSize);
 947             types::InternalType * pIT = getResult();
 948
 949             // In case of exec file, set the file name in the Macro to store where it is defined.
 950             int iFileID = ConfigVariable::getExecutedFileID();
 951             if (iFileID && exp->isFunctionDec())
 952             {
 953                 types::InternalType* pITMacro = symbol::Context::getInstance()->get(exp->getAs<FunctionDec>()->getSymbol());
 954                 if (pITMacro)
 955                 {
 956                     types::Macro* pMacro = pITMacro->getAs<types::Macro>();
 957                     const wchar_t* filename = getfile_filename(iFileID);
 958                     // scilab.quit is not open with mopen
 959                     // in this case filename is NULL because FileManager have not been filled.
 960                     if (filename)
 961                     {
 962                         pMacro->setFileName(filename);
 963                     }
 964                 }
 965             }
 966
 967             if (pIT != NULL)
 968             {
 969                 bool bImplicitCall = false;
 970                 if (pIT->isCallable()) //to manage call without ()
 971                 {
 972                     types::Callable *pCall = pIT->getAs<types::Callable>();
 973                     types::typed_list out;
 974                     types::typed_list in;
 975                     types::optional_list opt;
 976
 977                     try
 978                     {
 979                         //in this case of calling, we can return only one values
 980                         int iSaveExpectedSize = getExpectedSize();
 981                         setExpectedSize(1);
 982
 983                         pCall->invoke(in, opt, getExpectedSize(), out, e);
 984                         setExpectedSize(iSaveExpectedSize);
 985
 986                         if (out.size() == 0)
 987                         {
 988                             setResult(NULL);
 989                         }
 990                         else
 991                         {
 992                             setResult(out[0]);
 993                         }
 994
 995                         bImplicitCall = true;
 996                     }
 997                     catch (const InternalError& ie)
 998                     {
 999                         if (ConfigVariable::getLastErrorFunction() == L"")
1000                         {
1001                             ConfigVariable::setLastErrorFunction(pCall->getName());
1002                             ConfigVariable::setLastErrorLine(e.getLocation().first_line);
1003                         }
1004
1005                         throw ie;
1006                     }
1007                 }
1008
1009                 //don't output Simplevar and empty result
1010                 if (getResult() != NULL && (!exp->isSimpleVar() || bImplicitCall))
1011                 {
1012                     //symbol::Context::getInstance()->put(symbol::Symbol(L"ans"), *execMe.getResult());
1013                     types::InternalType* pITAns = getResult();
1014                     symbol::Context::getInstance()->put(m_pAns, pITAns);
1015                     if (exp->isVerbose() && ConfigVariable::isPromptShow())
1016                     {
1017                         //TODO manage multiple returns
1018                         scilabWriteW(L" ans  =\n\n");
1019                         std::wostringstream ostrName;
1020                         ostrName << L"ans";
1021                         VariableToString(pITAns, ostrName.str().c_str());
1022                     }
1023                 }
1024
1025                 pIT->killMe();
1026             }
1027
1028             if ((&e)->isBreakable() && exp->isBreak())
1029             {
1030                 const_cast<SeqExp *>(&e)->setBreak();
1031                 exp->resetBreak();
1032                 break;
1033             }
1034
1035             if ((&e)->isContinuable() && exp->isContinue())
1036             {
1037                 const_cast<SeqExp *>(&e)->setContinue();
1038                 exp->resetContinue();
1039                 break;
1040             }
1041
1042             if ((&e)->isReturnable() && exp->isReturn())
1043             {
1044                 const_cast<SeqExp *>(&e)->setReturn();
1045                 exp->resetReturn();
1046                 break;
1047             }
1048         }
1049         catch (const InternalError& ie)
1050         {
1051             ConfigVariable::fillWhereError(ie.GetErrorLocation().first_line);
1052             throw ie;
1053         }
1054
1055         // If something other than NULL is given to setResult, then that would imply
1056         // to make a cleanup in visit(ForExp) for example (e.getBody().accept(*this);)
1057         setResult(NULL);
1058     }
1059 }
1060
1061 template <class T>
1062 void RunVisitorT<T>::visitprivate(const NotExp &e)
1063 {
1064     /*
1065       @ or ~ !
1066     */
1067     e.getExp().accept(*this);
1068
1069     types::InternalType * pValue = getResult();
1070     types::InternalType * pReturn = NULL;
1071     if (pValue->neg(pReturn))
1072     {
1073         if (pValue != pReturn)
1074         {
1075             pValue->killMe();
1076         }
1077
1078         setResult(pReturn);
1079     }
1080     else
1081     {
1082         // neg returned false so the negation is not possible so we call the overload (%foo_5)
1083         types::typed_list in;
1084         types::typed_list out;
1085
1086         pValue->IncreaseRef();
1087         in.push_back(pValue);
1088
1089         types::Callable::ReturnValue Ret = Overload::call(L"%" + pValue->getShortTypeStr() + L"_5", in, 1, out, this);
1090
1091         if (Ret != types::Callable::OK)
1092         {
1093             cleanInOut(in, out);
1094             throw InternalError(ConfigVariable::getLastErrorMessage(), ConfigVariable::getLastErrorNumber(), e.getLocation());
1095         }
1096
1097         setResult(out);
1098         cleanIn(in, out);
1099     }
1100 }
1101
1102 template <class T>
1103 void RunVisitorT<T>::visitprivate(const TransposeExp &e)
1104 {
1105     e.getExp().accept(*this);
1106
1107     if (getResultSize() != 1)
1108     {
1109         clearResult();
1110         wchar_t szError[bsiz];
1111         os_swprintf(szError, bsiz, _W("%ls: Can not transpose multiple elements.\n").c_str(), L"Transpose");
1112         throw InternalError(szError, 999, e.getLocation());
1113     }
1114
1115     types::InternalType * pValue = getResult();
1116     types::InternalType * pReturn = NULL;
1117     const bool bConjug = e.getConjugate() == TransposeExp::_Conjugate_;
1118
1119     if ((bConjug && pValue->adjoint(pReturn)) || (!bConjug && pValue->transpose(pReturn)))
1120     {
1121         if (pValue != pReturn)
1122         {
1123             pValue->killMe();
1124         }
1125
1126         setResult(pReturn);
1127
1128         return;
1129     }
1130     else
1131     {
1132         // transpose returned false so the negation is not possible so we call the overload (%foo_t or %foo_0)
1133         types::typed_list in;
1134         types::typed_list out;
1135
1136         pValue->IncreaseRef();
1137         in.push_back(pValue);
1138
1139         types::Callable::ReturnValue Ret;
1140         if (bConjug)
1141         {
1142             Ret = Overload::call(L"%" + getResult()->getShortTypeStr() + L"_t", in, 1, out, this);
1143         }
1144         else
1145         {
1146             Ret = Overload::call(L"%" + getResult()->getShortTypeStr() + L"_0", in, 1, out, this);
1147         }
1148
1149         if (Ret != types::Callable::OK)
1150         {
1151             cleanInOut(in, out);
1152             throw InternalError(ConfigVariable::getLastErrorMessage(), ConfigVariable::getLastErrorNumber(), e.getLocation());
1153         }
1154
1155         setResult(out);
1156         cleanIn(in, out);
1157     }
1158 }
1159
1160 template <class T>
1161 void RunVisitorT<T>::visitprivate(const FunctionDec & e)
1162 {
1163     symbol::Context* ctx = symbol::Context::getInstance();
1164     /*
1165       function foo
1166       endfunction
1167     */
1168
1169     // funcprot(0) : do nothing
1170     // funcprot(1) && warning(on) : warning
1171     //get input parameters list
1172     std::list<symbol::Variable*> *pVarList = new std::list<symbol::Variable*>();
1173     const exps_t & vars = e.getArgs().getVars();
1174     for (const auto var : vars)
1175     {
1176         pVarList->push_back(var->getAs<SimpleVar>()->getStack());
1177     }
1178
1179     //get output parameters list
1180     std::list<symbol::Variable*> *pRetList = new std::list<symbol::Variable*>();
1181     const exps_t & rets = e.getReturns().getVars();
1182     for (const auto ret : rets)
1183     {
1184         pRetList->push_back(ret->getAs<SimpleVar>()->getStack());
1185     }
1186
1187     types::Macro *pMacro = new types::Macro(e.getSymbol().getName(), *pVarList, *pRetList,
1188                                             const_cast<SeqExp&>(static_cast<const SeqExp&>(e.getBody())), L"script");
1189     pMacro->setLines(e.getLocation().first_line, e.getLocation().last_line);
1190
1191     bool bEquals = false;
1192     int iFuncProt = ConfigVariable::getFuncprot();
1193     if (iFuncProt != 0)
1194     {
1195         types::InternalType* pITFunc = ctx->get(((FunctionDec&)e).getStack());
1196         if (pITFunc && pITFunc->isCallable())
1197         {
1198             if (pITFunc->isMacroFile())
1199             {
1200                 types::MacroFile* pMF = pITFunc->getAs<types::MacroFile>();
1201                 bEquals = *pMF->getMacro() == *pMacro;
1202             }
1203             else if (pITFunc->isMacro())
1204             {
1205                 types::Macro* pM = pITFunc->getAs<types::Macro>();
1206                 bEquals = *pM == *pMacro;
1207             }
1208         }
1209         else
1210         {
1211             bEquals = true; //avoid msg but keep assignation
1212         }
1213     }
1214
1215     if (bEquals == false && iFuncProt == 1 && ConfigVariable::getWarningMode())
1216     {
1217         wchar_t pwstFuncName[1024];
1218         os_swprintf(pwstFuncName, 1024, L"%-24ls", e.getSymbol().getName().c_str());
1219         char* pstFuncName = wide_string_to_UTF8(pwstFuncName);
1220
1221
1222         sciprint(_("Warning : redefining function: %s. Use funcprot(0) to avoid this message"), pstFuncName);
1223         sciprint("\n");
1224         FREE(pstFuncName);
1225     }
1226     else if (bEquals == false && iFuncProt == 2)
1227     {
1228         char pstError[1024];
1229         char* pstFuncName = wide_string_to_UTF8(e.getSymbol().getName().c_str());
1230         os_sprintf(pstError, _("It is not possible to redefine the %s primitive this way (see clearfun).\n"), pstFuncName);
1231         wchar_t* pwstError = to_wide_string(pstError);
1232         std::wstring wstError(pwstError);
1233         FREE(pstFuncName);
1234         FREE(pwstError);
1235         delete pMacro;
1236         throw InternalError(wstError, 999, e.getLocation());
1237     }
1238
1239
1240     if (ctx->isprotected(symbol::Symbol(pMacro->getName())))
1241     {
1242         delete pMacro;
1243         std::wostringstream os;
1244         os << _W("Redefining permanent variable.\n");
1245         throw InternalError(os.str(), 999, e.getLocation());
1246     }
1247
1248     ctx->addMacro(pMacro);
1249
1250 }
1251
1252 template <class T>
1253 void RunVisitorT<T>::visitprivate(const ListExp &e)
1254 {
1255     e.getStart().accept(*this);
1256     types::GenericType* pITStart = static_cast<types::GenericType*>(getResult());
1257     if ((pITStart->getSize() != 1 || (pITStart->isDouble() && pITStart->getAs<types::Double>()->isComplex())) &&
1258             pITStart->isList() == false) // list case => call overload
1259     {
1260         pITStart->killMe();
1261         wchar_t szError[bsiz];
1262         os_swprintf(szError, bsiz, _W("%ls: Wrong type for argument %d: Real scalar expected.\n").c_str(), L"':'", 1);
1263         throw InternalError(szError, 999, e.getLocation());
1264     }
1265     types::InternalType * piStart = pITStart;
1266
1267     e.getStep().accept(*this);
1268     types::GenericType* pITStep = static_cast<types::GenericType*>(getResult());
1269     if ((pITStep->getSize() != 1 || (pITStep->isDouble() && pITStep->getAs<types::Double>()->isComplex())) &&
1270             pITStep->isList() == false) // list case => call overload
1271     {
1272         pITStart->killMe();
1273         pITStep->killMe();
1274         wchar_t szError[bsiz];
1275         os_swprintf(szError, bsiz, _W("%ls: Wrong type for argument %d: Real scalar expected.\n").c_str(), L"':'", 2);
1276         throw InternalError(szError, 999, e.getLocation());
1277     }
1278     types::InternalType* piStep = pITStep;
1279
1280     e.getEnd().accept(*this);
1281     types::GenericType* pITEnd = static_cast<types::GenericType*>(getResult());
1282     if ((pITEnd->getSize() != 1 || (pITEnd->isDouble() && pITEnd->getAs<types::Double>()->isComplex())) &&
1283             pITEnd->isList() == false) // list case => call overload
1284     {
1285         pITStart->killMe();
1286         pITStep->killMe();
1287         pITEnd->killMe();
1288         wchar_t szError[bsiz];
1289         os_swprintf(szError, bsiz, _W("%ls: Wrong type for argument %d: Real scalar expected.\n").c_str(), L"':'", 3);
1290         throw InternalError(szError, 999, e.getLocation());
1291     }
1292     types::InternalType* piEnd = pITEnd;
1293
1294     ////check if implicitlist is 1:$ to replace by ':'
1295     //if (piStart->isDouble() && piStep->isDouble() && piEnd->isPoly())
1296     //{
1297     //    if (piStart->getAs<Double>()->get()[0] == 1 && piStep->getAs<Double>()->get()[0] == 1)
1298     //    {
1299     //        SinglePoly* end = piEnd->getAs<Polynom>()->get()[0];
1300     //        if (end->getRank() == 1 && end->get()[0] == 0 && end->get()[1] == 1)
1301     //        {
1302     //            setResult(new Colon());
1303     //            return;
1304     //        }
1305     //    }
1306     //}
1307
1308     //check compatibility
1309     // double : double : double or poly : poly : poly and mix like double : double : poly
1310     if ((piStart->isPoly() || piStart->isDouble()) &&
1311             (piStep->isPoly()  || piStep->isDouble())  &&
1312             (piEnd->isPoly()   || piEnd->isDouble()))
1313     {
1314         // No need to kill piStart, ... because Implicit list ctor will incref them
1315         setResult(new types::ImplicitList(piStart, piStep, piEnd));
1316         return;
1317     }
1318
1319     // int : double or int : int
1320     if ( piStart->isInt()   &&
1321             (piStep->isDouble() || piStep->isInt()) &&
1322             piEnd->isInt())
1323     {
1324         // check for same int type int8, int 16 ...
1325         if (piStart->getType() == piEnd->getType()  &&
1326                 (piStart->getType() == piStep->getType() ||
1327                  piStep->isDouble()))
1328         {
1329             // No need to kill piStart, ... because Implicit list ctor will incref them
1330             setResult(new types::ImplicitList(piStart, piStep, piEnd));
1331             return;
1332         }
1333     }
1334
1335     // Call Overload
1336     types::Callable::ReturnValue Ret;
1337     types::typed_list in;
1338     types::typed_list out;
1339
1340     piStart->IncreaseRef();
1341     in.push_back(piStart);
1342
1343     try
1344     {
1345         if (e.hasExplicitStep())
1346         {
1347             // 1:2:4
1348             //call overload %typeStart_b_typeStep
1349             piStep->IncreaseRef();
1350             in.push_back(piStep);
1351             piEnd->IncreaseRef();
1352             in.push_back(piEnd);
1353             Ret = Overload::call(L"%" + piStart->getShortTypeStr() + L"_b_" + piStep->getShortTypeStr(), in, 1, out, true);
1354         }
1355         else
1356         {
1357             // 1:2
1358             //call overload %typeStart_b_typeEnd
1359             piStep->killMe();
1360             piEnd->IncreaseRef();
1361             in.push_back(piEnd);
1362             Ret = Overload::call(L"%" + piStart->getShortTypeStr() + L"_b_" + piEnd->getShortTypeStr(), in, 1, out, true);
1363         }
1364     }
1365     catch (const InternalError& error)
1366     {
1367         cleanInOut(in, out);
1368         throw error;
1369     }
1370
1371     if (Ret != types::Callable::OK)
1372     {
1373         cleanInOut(in, out);
1374         throw InternalError(ConfigVariable::getLastErrorMessage(), ConfigVariable::getLastErrorNumber(), e.getLocation());
1375     }
1376
1377     setResult(out);
1378     cleanIn(in, out);
1379 }
1380
1381 template <class T>
1382 void RunVisitorT<T>::visitprivate(const OptimizedExp &e)
1383 {
1384 }
1385
1386 template <class T>
1387 void RunVisitorT<T>::visitprivate(const MemfillExp &e)
1388 {
1389     e.getOriginal()->accept(*this);
1390 }
1391
1392 template <class T>
1393 void RunVisitorT<T>::visitprivate(const DAXPYExp &e)
1394 {
1395     types::InternalType* pIT = NULL;
1396     types::Double* ad = NULL;
1397     int ar = 0;
1398     int ac = 0;
1399
1400     types::Double* xd = NULL;
1401     int xr = 0;
1402     int xc = 0;
1403
1404     types::Double* yd = NULL;
1405     int yr = 0;
1406     int yc = 0;
1407
1408     //check types and dimensions
1409
1410     //y must be double
1411     const Exp &ye = e.getY();
1412     ye.accept(*this);
1413     pIT = getResult();
1414     if (pIT->isDouble())
1415     {
1416         yd = pIT->getAs<types::Double>();
1417         if (yd->getDims() == 2 && yd->isComplex() == false)
1418         {
1419             yr = yd->getRows();
1420             yc = yd->getCols();
1421         }
1422         else
1423         {
1424             yd->killMe();
1425             e.getOriginal()->accept(*this);
1426             return;
1427         }
1428     }
1429     else
1430     {
1431         pIT->killMe();
1432         e.getOriginal()->accept(*this);
1433         return;
1434     }
1435
1436     //x
1437     const Exp &xe = e.getX();
1438     xe.accept(*this);
1439     pIT = getResult();
1440
1441     if (pIT->isDouble())
1442     {
1443         xd = pIT->getAs<types::Double>();
1444         if (xd->isScalar() && xd->isComplex() == false)
1445         {
1446             // x become a
1447             ad = xd;
1448             ar = 1;
1449             ac = 1;
1450         }
1451         else if (xd->getDims() == 2 && xd->isComplex() == false)
1452         {
1453             xr = xd->getRows();
1454             xc = xd->getCols();
1455         }
1456         else
1457         {
1458             yd->killMe();
1459             xd->killMe();
1460             e.getOriginal()->accept(*this);
1461             return;
1462         }
1463     }
1464     else
1465     {
1466         pIT->killMe();
1467         yd->killMe();
1468         e.getOriginal()->accept(*this);
1469         return;
1470     }
1471
1472     const Exp &ae = e.getA();
1473     ae.accept(*this);
1474     pIT = getResult();
1475
1476     if (pIT->isDouble())
1477     {
1478         if (ad)
1479         {
1480             xd = pIT->getAs<types::Double>();
1481             //X is scalar it become A
1482             //now use A as X
1483             if (xd->getDims() == 2 && xd->isComplex() == false)
1484             {
1485                 xr = xd->getRows();
1486                 xc = xd->getCols();
1487             }
1488             else
1489             {
1490                 yd->killMe();
1491                 xd->killMe();
1492                 ad->killMe();
1493                 e.getOriginal()->accept(*this);
1494                 return;
1495             }
1496         }
1497         else
1498         {
1499             //a is a and it must be scalar
1500             ad = pIT->getAs<types::Double>();
1501             if (/*ad->isScalar() && */ad->isComplex() == false)
1502             {
1503                 ar = ad->getRows(); //1;
1504                 ac = ad->getCols();//1;
1505             }
1506             else
1507             {
1508                 yd->killMe();
1509                 xd->killMe();
1510                 ad->killMe();
1511                 e.getOriginal()->accept(*this);
1512                 return;
1513             }
1514         }
1515     }
1516     else
1517     {
1518         pIT->killMe();
1519         yd->killMe();
1520         xd->killMe();
1521         e.getOriginal()->accept(*this);
1522         return;
1523     }
1524
1525     if (ad && xd && yd)
1526     {
1527         if ( ac == 1 &&
1528                 ar == 1 &&
1529                 xr == yr &&
1530                 xc == yc)
1531         {
1532             //go !
1533             int one = 1;
1534             int size = xc * xr;
1535             //Double* od = (Double*)yd->clone();
1536             C2F(daxpy)(&size, ad->get(), xd->get(), &one, yd->get(), &one);
1537             //setResult(od);
1538             //yd->killMe();
1539             xd->killMe();
1540             ad->killMe();
1541             return;
1542         }
1543         else if (ac == xr && ar == yr && xc == yc)
1544         {
1545             char n = 'n';
1546             double one = 1;
1547             C2F(dgemm)(&n, &n, &ar, &xc, &ac, &one, ad->get(), &ar, xd->get(), &ac, &one, yd->get(), &ar);
1548             xd->killMe();
1549             ad->killMe();
1550             return;
1551         }
1552     }
1553
1554     if (yd)
1555     {
1556         yd->killMe();
1557     }
1558
1559     if (xd)
1560     {
1561         xd->killMe();
1562     }
1563
1564     if (ad)
1565     {
1566         ad->killMe();
1567     }
1568
1569     e.getOriginal()->accept(*this);
1570     return;
1571 }
1572
1573 } /* namespace ast */
1574
1575 #include "run_CallExp.hpp"
1576 #include "run_MatrixExp.hpp"
1577 #include "run_OpExp.hpp"
1578 #include "run_AssignExp.hpp"
1579
1580 template EXTERN_AST class ast::RunVisitorT<ast::ExecVisitor>;
1581 template EXTERN_AST class ast::RunVisitorT<ast::StepVisitor>;
1582 template EXTERN_AST class ast::RunVisitorT<ast::TimedVisitor>;
1583 template EXTERN_AST class ast::RunVisitorT<ast::DebuggerVisitor>;