scilab/modules/ast/src/cpp/system_env/configvariable.cpp

   1 /*
   2 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3 *  Copyright (C) 2008-2008 - DIGITEO - 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 #include <list>
  13 #include "configvariable.hxx"
  14 #include "context.hxx"
  15
  16 extern "C"
  17 {
  18 #include "strsubst.h"
  19 #include "os_wcsdup.h"
  20 #include "sci_malloc.h"
  21 #include "elem_common.h"
  22 }
  23 /*
  24 ** Module List
  25 ** \{
  26 */
  27 std::list<std::wstring> ConfigVariable::m_ModuleList;
  28
  29 void ConfigVariable::setModuleList(std::list<std::wstring>& _pModule_list)
  30 {
  31     m_ModuleList = _pModule_list;
  32 }
  33
  34 std::list<std::wstring> ConfigVariable::getModuleList()
  35 {
  36     std::list<std::wstring> moduleList(m_ModuleList);
  37     return moduleList;
  38 }
  39 /*
  40 ** \}
  41 */
  42
  43 /*
  44 ** SCI
  45 ** \{
  46 */
  47 std::wstring ConfigVariable::m_SCIPath;
  48
  49 void ConfigVariable::setSCIPath(std::wstring& _SCIPath)
  50 {
  51     m_SCIPath = _SCIPath;
  52 }
  53
  54 std::wstring ConfigVariable::getSCIPath()
  55 {
  56     return m_SCIPath;
  57 }
  58
  59 /*
  60 ** \}
  61 */
  62
  63 /*
  64 ** SCIHOME
  65 ** \{
  66 */
  67
  68 std::wstring ConfigVariable::m_SCIHOME;
  69
  70 void ConfigVariable::setSCIHOME(std::wstring& _SCIHOME)
  71 {
  72     m_SCIHOME = _SCIHOME;
  73 }
  74
  75 std::wstring ConfigVariable::getSCIHOME()
  76 {
  77     return m_SCIHOME;
  78 }
  79 /*
  80 ** \}
  81 */
  82
  83 /*
  84 ** TMPDIR
  85 ** \{
  86 */
  87
  88 std::wstring ConfigVariable::m_TMPDIR;
  89
  90 void ConfigVariable::setTMPDIR(std::wstring& _TMPDIR)
  91 {
  92     m_TMPDIR = _TMPDIR;
  93 }
  94
  95 std::wstring ConfigVariable::getTMPDIR()
  96 {
  97     return m_TMPDIR;
  98 }
  99 /*
 100 ** \}
 101 */
 102
 103 /*
 104 ** Force Quit
 105 ** \{
 106 */
 107 bool ConfigVariable::m_bForceQuit = false;
 108
 109 void ConfigVariable::setForceQuit(bool _bForceQuit)
 110 {
 111     m_bForceQuit = _bForceQuit;
 112 }
 113
 114 bool ConfigVariable::getForceQuit(void)
 115 {
 116     return m_bForceQuit;
 117 }
 118 /*
 119 ** \}
 120 */
 121
 122 /*
 123 ** Exit Status
 124 ** \{
 125 */
 126 int ConfigVariable::m_iExitStatus = 0;
 127
 128 void ConfigVariable::setExitStatus(int _iExitStatus)
 129 {
 130     m_iExitStatus = _iExitStatus;
 131 }
 132
 133 int ConfigVariable::getExitStatus(void)
 134 {
 135     return m_iExitStatus;
 136 }
 137 /*
 138 ** \}
 139 */
 140
 141 /*
 142 ** Digit precision, ex format function
 143 ** \{
 144 */
 145
 146 int ConfigVariable::m_iFormatSize = 0;
 147
 148 void ConfigVariable::setFormatSize(int _iFormatSize)
 149 {
 150     m_iFormatSize = _iFormatSize;
 151 }
 152
 153 int ConfigVariable::getFormatSize(void)
 154 {
 155     return m_iFormatSize;
 156 }
 157
 158 int ConfigVariable::m_iFormatMode = 0;
 159
 160 void ConfigVariable::setFormatMode(int _iFormatMode)
 161 {
 162     m_iFormatMode = _iFormatMode;
 163 }
 164
 165 int ConfigVariable::getFormatMode(void)
 166 {
 167     return m_iFormatMode;
 168 }
 169
 170 /*
 171 ** \}
 172 */
 173
 174 /*
 175 ** Screen console width
 176 ** \{
 177 */
 178
 179 int ConfigVariable::m_iConsoleWidth = 0;
 180
 181 void ConfigVariable::setConsoleWidth(int _iConsoleWidth)
 182 {
 183     m_iConsoleWidth = _iConsoleWidth;
 184 }
 185
 186 int ConfigVariable::getConsoleWidth(void)
 187 {
 188     return m_iConsoleWidth;
 189 }
 190 /*
 191 ** \}
 192 */
 193
 194 /*
 195 ** Screen console lines
 196 ** \{
 197 */
 198
 199 int ConfigVariable::m_iConsoleLines = 0; //console lines default value
 200
 201 void ConfigVariable::setConsoleLines(int _iConsoleLines)
 202 {
 203     m_iConsoleLines = _iConsoleLines;
 204 }
 205
 206 int ConfigVariable::getConsoleLines(void)
 207 {
 208     return m_iConsoleLines;
 209 }
 210 /*
 211 ** \}
 212 */
 213
 214 /*
 215 ** Scilab mode
 216 ** \{
 217 */
 218
 219 int ConfigVariable::m_iScilabMode = 0;
 220
 221 void ConfigVariable::setScilabMode(int _iScilabMode)
 222 {
 223     m_iScilabMode = _iScilabMode;
 224 }
 225
 226 int ConfigVariable::getScilabMode(void)
 227 {
 228     return m_iScilabMode;
 229 }
 230 /*
 231 ** \}
 232 */
 233
 234 /*
 235 ** Warning Mode
 236 ** \{
 237 */
 238 bool ConfigVariable::m_bWarningMode = true;
 239
 240 void ConfigVariable::setWarningMode(bool _bWarningMode)
 241 {
 242     m_bWarningMode = _bWarningMode;
 243 }
 244
 245 bool ConfigVariable::getWarningMode(void)
 246 {
 247     return m_bWarningMode;
 248 }
 249 /*
 250 ** \}
 251 */
 252
 253 /*
 254 ** HOME
 255 ** \{
 256 */
 257
 258 std::wstring ConfigVariable::m_HOME;
 259
 260 void ConfigVariable::setHOME(std::wstring& _HOME)
 261 {
 262     m_HOME = _HOME;
 263 }
 264
 265 std::wstring ConfigVariable::getHOME()
 266 {
 267     return m_HOME;
 268 }
 269 /*
 270 ** \}
 271 */
 272
 273 /*
 274 ** Clear last error information
 275 ** \{
 276 */
 277 bool ConfigVariable::m_bLastErrorCall = false;
 278
 279 void ConfigVariable::setLastErrorCall(void)
 280 {
 281     m_bLastErrorCall = true;
 282 }
 283
 284 void ConfigVariable::clearLastError(void)
 285 {
 286     //if (m_bLastErrorCall == false)
 287     {
 288         m_wstError          = L"";
 289         m_iError            = 0;
 290         m_iErrorLine        = 0;
 291         m_wstErrorFunction  = L"";
 292     }
 293     m_bLastErrorCall = false;
 294 }
 295 /*
 296 ** \}
 297 */
 298
 299 /*
 300 ** Last Error Message
 301 ** \{
 302 */
 303
 304 std::wstring ConfigVariable::m_wstError;
 305
 306 void ConfigVariable::setLastErrorMessage(std::wstring _wstError)
 307 {
 308     wchar_t* pwstTemp1 = os_wcsdup(_wstError.c_str());
 309     m_wstError = pwstTemp1;
 310 }
 311
 312 std::wstring ConfigVariable::getLastErrorMessage()
 313 {
 314     return m_wstError;
 315 }
 316 /*
 317 ** \}
 318 */
 319
 320 /*
 321 ** Last Error ID
 322 ** \{
 323 */
 324 int ConfigVariable::m_iError = 0;
 325 bool ConfigVariable::m_bError = false;
 326
 327 void ConfigVariable::setError()
 328 {
 329     m_bError = true;
 330 }
 331
 332 bool ConfigVariable::isError()
 333 {
 334     return m_bError;
 335 }
 336
 337 void ConfigVariable::resetError()
 338 {
 339     m_bError = false;
 340 }
 341
 342 void ConfigVariable::setLastErrorNumber(int _iError)
 343 {
 344     m_iError = _iError;
 345 }
 346
 347 int ConfigVariable::getLastErrorNumber(void)
 348 {
 349     return m_iError;
 350 }
 351 /*
 352 ** \}
 353 */
 354
 355 /*
 356 ** Last Error Line
 357 ** \{
 358 */
 359 int ConfigVariable::m_iErrorLine = 0;
 360
 361 void ConfigVariable::setLastErrorLine(int _iErrorLine)
 362 {
 363     m_iErrorLine = _iErrorLine;
 364 }
 365
 366 int ConfigVariable::getLastErrorLine(void)
 367 {
 368     return m_iErrorLine;
 369 }
 370 /*
 371 ** \}
 372 */
 373
 374 /*
 375 ** Last Error Function
 376 ** \{
 377 */
 378
 379 std::wstring ConfigVariable::m_wstErrorFunction;
 380
 381 void ConfigVariable::setLastErrorFunction(std::wstring _wstErrorFunction)
 382 {
 383     m_wstErrorFunction = _wstErrorFunction;
 384 }
 385
 386 std::wstring ConfigVariable::getLastErrorFunction()
 387 {
 388     return m_wstErrorFunction;
 389 }
 390
 391 /*
 392 ** \}
 393 */
 394
 395 /*
 396 ** Prompt Mode
 397 ** \{
 398 */
 399
 400 int ConfigVariable::m_iPromptMode = 0;
 401 int ConfigVariable::m_iSilentError = 0;
 402 bool ConfigVariable::m_bVerbose = true;
 403
 404 void ConfigVariable::setPromptMode(int _iPromptMode)
 405 {
 406     m_iPromptMode = _iPromptMode;
 407     if (m_iPromptMode == 0)
 408     {
 409         //m_iPromptMode = -1;
 410     }
 411 }
 412
 413 int ConfigVariable::getPromptMode(void)
 414 {
 415     return m_iPromptMode;
 416 }
 417
 418 bool ConfigVariable::isPromptShow(void)
 419 {
 420     if ( m_iPromptMode == 0 ||
 421             m_iPromptMode == 1 ||
 422             m_iPromptMode == 2 ||
 423             m_iPromptMode == 3)
 424     {
 425         return true;
 426     }
 427     else
 428     {
 429         return false;
 430     }
 431 }
 432
 433 void ConfigVariable::setSilentError(int _iSilentError)
 434 {
 435     m_iSilentError = _iSilentError;
 436 }
 437
 438 int ConfigVariable::getSilentError(void)
 439 {
 440     return m_iSilentError;
 441 }
 442
 443 void ConfigVariable::setVerbose(bool _bVerbose)
 444 {
 445     m_bVerbose = _bVerbose;
 446 }
 447
 448 bool ConfigVariable::getVerbose(void)
 449 {
 450     return m_bVerbose;
 451 }
 452
 453 /*
 454 ** ThreadList
 455 ** \{
 456 */
 457
 458 std::list<types::ThreadId *> ConfigVariable::m_threadList;
 459
 460 types::ThreadId* ConfigVariable::getLastPausedThread()
 461 {
 462     std::list<types::ThreadId *>::reverse_iterator it;
 463     for (it = m_threadList.rbegin() ; it != m_threadList.rend() ; it++)
 464     {
 465         if ((*it)->getStatus() == types::ThreadId::Paused)
 466         {
 467             return *it;
 468         }
 469     }
 470     return NULL;
 471 }
 472
 473 types::ThreadId* ConfigVariable::getLastRunningThread()
 474 {
 475     std::list<types::ThreadId *>::reverse_iterator it;
 476     for (it = m_threadList.rbegin() ; it != m_threadList.rend() ; it++)
 477     {
 478         if ((*it)->getStatus() == types::ThreadId::Running)
 479         {
 480             return *it;
 481         }
 482     }
 483     return NULL;
 484 }
 485
 486 types::ThreadId* ConfigVariable::getLastThread()
 487 {
 488     return m_threadList.back();
 489 }
 490
 491 types::Cell* ConfigVariable::getAllThreads(void)
 492 {
 493     int iSize = (int) ConfigVariable::m_threadList.size();
 494
 495     if (iSize == 0)
 496     {
 497         return new types::Cell();
 498     }
 499
 500     int i = 0;
 501     types::Cell *pcResult = new types::Cell(iSize, 1);
 502     std::list<types::ThreadId *>::iterator it;
 503
 504     for (it = ConfigVariable::m_threadList.begin() ; it != ConfigVariable::m_threadList.end() ; ++it, ++i)
 505     {
 506         pcResult->set(i, *it);
 507     }
 508
 509     return pcResult;
 510 }
 511
 512
 513 void ConfigVariable::addThread(types::ThreadId* _thread)
 514 {
 515     _thread->IncreaseRef();
 516     m_threadList.push_back(_thread);
 517 }
 518
 519
 520 types::ThreadId* ConfigVariable::getThread(__threadKey _key)
 521 {
 522     std::list<types::ThreadId *>::const_iterator it;
 523
 524     for (it = ConfigVariable::m_threadList.begin() ; it != ConfigVariable::m_threadList.end() ; ++it)
 525     {
 526         if ((*it)->getKey() == _key)
 527         {
 528             return *it;
 529         }
 530     }
 531     return NULL;
 532 }
 533
 534
 535 void ConfigVariable::deleteThread(__threadKey _key)
 536 {
 537     //for(int i = 0 ; i < m_threadList.size() ; i++)
 538     //{
 539     //    types::ThreadId* pThread = m_threadList[i];
 540     //    if(pThread->getKey() == _key)
 541     //    {
 542     //        pThread->DecreaseRef();
 543     //        if(pThread->isDeletable())
 544     //        {
 545     //            delete pThread;
 546     //            m_threadList.erase(.begin() + i - 1);
 547     //        }
 548     //    }
 549     //}
 550     std::list<types::ThreadId *>::iterator it;
 551     for (it = ConfigVariable::m_threadList.begin() ; it != ConfigVariable::m_threadList.end() ; ++it)
 552     {
 553         if ((*it)->getKey() == _key)
 554         {
 555             (*it)->DecreaseRef();
 556             if ((*it)->isDeletable())
 557             {
 558                 (*it)->killMe();
 559                 (*it) = NULL;
 560                 m_threadList.erase(it);
 561                 return;
 562             }
 563         }
 564     }
 565 }
 566
 567 /*
 568 ** \}
 569 */
 570
 571 /*
 572 ** Prompt Mode
 573 ** \{
 574 */
 575
 576 int ConfigVariable::m_iPauseLevel = 0;
 577 std::list<int> ConfigVariable::m_listScope;
 578
 579 void ConfigVariable::IncreasePauseLevel()
 580 {
 581     m_iPauseLevel++;
 582     m_listScope.push_back(symbol::Context::getInstance()->getScopeLevel());
 583 }
 584
 585 void ConfigVariable::DecreasePauseLevel()
 586 {
 587     m_iPauseLevel--;
 588     m_listScope.pop_back();
 589 }
 590
 591 int ConfigVariable::getActivePauseLevel()
 592 {
 593     return m_listScope.back();
 594 }
 595
 596 int ConfigVariable::getPauseLevel()
 597 {
 598     return m_iPauseLevel;
 599 }
 600
 601 /*
 602 ** \}
 603 */
 604
 605 /*
 606 ** Dynamic Link
 607 ** \{
 608 */
 609
 610 std::vector<ConfigVariable::DynamicLibraryStr*> ConfigVariable::m_DynLibList;
 611 std::list<ConfigVariable::EntryPointStr*> ConfigVariable::m_EntryPointList;
 612
 613
 614 ConfigVariable::DynamicLibraryStr* ConfigVariable::getNewDynamicLibraryStr()
 615 {
 616     DynamicLibraryStr* pDL = (DynamicLibraryStr*)MALLOC(sizeof(DynamicLibraryStr));
 617     pDL->pwstLibraryName = NULL;
 618     pDL->hLib = 0;
 619     return pDL;
 620 }
 621
 622 ConfigVariable::EntryPointStr* ConfigVariable::getNewEntryPointStr()
 623 {
 624     EntryPointStr* pEP = (EntryPointStr*)MALLOC(sizeof(EntryPointStr));
 625     pEP->bOK = false;
 626     pEP->functionPtr = NULL;
 627     pEP->iLibIndex = -1;
 628     pEP->pwstEntryPointName = NULL;
 629     return pEP;
 630 }
 631
 632 void ConfigVariable::setLibraryName(ConfigVariable::DynamicLibraryStr* _pDynamicLibrary, wchar_t* _pwstLibraryName)
 633 {
 634     if (_pDynamicLibrary)
 635     {
 636         if (_pDynamicLibrary->pwstLibraryName)
 637         {
 638             FREE(_pDynamicLibrary->pwstLibraryName);
 639         }
 640         _pDynamicLibrary->pwstLibraryName = os_wcsdup(_pwstLibraryName);
 641     }
 642 }
 643
 644 void ConfigVariable::setEntryPointName(ConfigVariable::EntryPointStr* _pEntryPoint, wchar_t* _pwstEntryPointName)
 645 {
 646     if (_pEntryPoint)
 647     {
 648         if (_pEntryPoint->pwstEntryPointName)
 649         {
 650             FREE(_pEntryPoint->pwstEntryPointName);
 651         }
 652         _pEntryPoint->pwstEntryPointName = os_wcsdup(_pwstEntryPointName);;
 653     }
 654 }
 655
 656 /* Dynamic libraries functions */
 657 int ConfigVariable::addDynamicLibrary(ConfigVariable::DynamicLibraryStr* _pDynamicLibrary)
 658 {
 659     for (int i = 0 ; i < (int)m_DynLibList.size() ; i++)
 660     {
 661         if (m_DynLibList[i] == NULL)
 662         {
 663             m_DynLibList[i] = _pDynamicLibrary;
 664             return i;
 665         }
 666     }
 667
 668     m_DynLibList.push_back(_pDynamicLibrary);
 669     return (int)m_DynLibList.size() - 1;
 670 }
 671
 672 void ConfigVariable::removeDynamicLibrary(int _iDynamicLibraryIndex)
 673 {
 674     if (_iDynamicLibraryIndex < (int)m_DynLibList.size())
 675     {
 676         std::list<EntryPointStr*>::const_iterator it;
 677         for (it = m_EntryPointList.begin() ; it != m_EntryPointList.end() ; it++)
 678         {
 679             //clear all entry points linked to removed dynamic library
 680             if ((*it)->iLibIndex == _iDynamicLibraryIndex)
 681             {
 682                 m_EntryPointList.remove(*it);
 683                 if (m_EntryPointList.size() == 0)
 684                 {
 685                     break;
 686                 }
 687                 it = m_EntryPointList.begin();
 688             }
 689         }
 690         //remove dynamic library
 691         m_DynLibList[_iDynamicLibraryIndex] = NULL;
 692     }
 693
 694     //clean dynamic library vector
 695     while (m_DynLibList.size() != 0 && m_DynLibList.back() == NULL)
 696     {
 697         m_DynLibList.pop_back();
 698     }
 699 }
 700
 701 ConfigVariable::DynamicLibraryStr* ConfigVariable::getDynamicLibrary(int _iDynamicLibraryIndex)
 702 {
 703     if (_iDynamicLibraryIndex < (int)m_DynLibList.size())
 704     {
 705         return m_DynLibList[_iDynamicLibraryIndex];
 706     }
 707     return NULL;
 708 }
 709
 710 bool ConfigVariable::isDynamicLibrary(int _iDynamicLibraryIndex)
 711 {
 712     if (_iDynamicLibraryIndex < (int)m_DynLibList.size())
 713     {
 714         if (m_DynLibList[_iDynamicLibraryIndex] != NULL)
 715         {
 716             return true;
 717         }
 718     }
 719     return false;
 720 }
 721
 722 void ConfigVariable::addEntryPoint(ConfigVariable::EntryPointStr* _pEP)
 723 {
 724     if (_pEP != NULL)
 725     {
 726         m_EntryPointList.push_back(_pEP);
 727     }
 728 }
 729
 730 ConfigVariable::EntryPointStr* ConfigVariable::getEntryPoint(wchar_t* _pwstEntryPointName, int _iDynamicLibraryIndex)
 731 {
 732     std::list<EntryPointStr*>::const_iterator it;
 733     for (it = m_EntryPointList.begin() ; it != m_EntryPointList.end() ; it++)
 734     {
 735         //by pass iLibIndex check if _iDynamicLibraryIndex == -1
 736         if (_iDynamicLibraryIndex == -1 || (*it)->iLibIndex == _iDynamicLibraryIndex)
 737         {
 738             if (wcscmp((*it)->pwstEntryPointName, _pwstEntryPointName) == 0)
 739             {
 740                 return *it;
 741             }
 742         }
 743     }
 744     return NULL;
 745 }
 746
 747 std::vector<std::wstring> ConfigVariable::getEntryPointNameList()
 748 {
 749     std::vector<std::wstring> EntryPointNames;
 750     std::list<EntryPointStr*>::const_iterator it;
 751     for (it = m_EntryPointList.begin() ; it != m_EntryPointList.end() ; it++)
 752     {
 753         EntryPointNames.push_back((*it)->pwstEntryPointName);
 754     }
 755     return EntryPointNames;
 756 }
 757
 758 std::vector<ConfigVariable::DynamicLibraryStr*>* ConfigVariable::getDynamicLibraryList()
 759 {
 760     return &m_DynLibList;
 761 }
 762
 763 std::list<ConfigVariable::EntryPointStr*>* ConfigVariable::getEntryPointList()
 764 {
 765     return &m_EntryPointList;
 766 }
 767
 768 //dynamic modules
 769 std::map<std::wstring, DynLibHandle> ConfigVariable::m_DynModules;
 770
 771 void ConfigVariable::addDynModule(std::wstring _name, DynLibHandle _lib)
 772 {
 773     m_DynModules[_name] = _lib;
 774 }
 775
 776 void ConfigVariable::removeDynModule(std::wstring _name)
 777 {
 778     m_DynModules.erase(_name);
 779 }
 780
 781 DynLibHandle ConfigVariable::getDynModule(std::wstring _name)
 782 {
 783     std::map<std::wstring, DynLibHandle>::iterator it;
 784     it = m_DynModules.find(_name);
 785     if (it != m_DynModules.end())
 786     {
 787         return it->second;
 788     }
 789
 790     return 0;
 791 }
 792
 793 int ConfigVariable::getDynModuleCount()
 794 {
 795     return (int)m_DynModules.size();
 796 }
 797
 798 DynLibHandle* ConfigVariable::getAllDynModule()
 799 {
 800     DynLibHandle* moduleList = new DynLibHandle[m_DynModules.size()];
 801     std::map<std::wstring, DynLibHandle>::iterator it = m_DynModules.begin();
 802     std::map<std::wstring, DynLibHandle>::iterator itEnd = m_DynModules.end();
 803     for (int i = 0; it != itEnd ; ++it, ++i)
 804     {
 805         moduleList[i] = it->second;
 806     }
 807
 808     return moduleList;
 809 }
 810
 811 void ConfigVariable::cleanDynModule()
 812 {
 813     m_DynModules.clear();
 814 }
 815
 816 // Command Line Arguments
 817 std::vector<std::wstring> ConfigVariable::m_Args;
 818 bool ConfigVariable::m_bTimed = false;
 819 bool ConfigVariable::m_bSerialize = false;
 820
 821 void ConfigVariable::setCommandLineArgs(int _iArgs, char** _pstArgs)
 822 {
 823     m_Args.clear();
 824     for (int i = 0 ; i < _iArgs ; i++)
 825     {
 826         wchar_t * ws = to_wide_string(_pstArgs[i]);
 827         m_Args.push_back(ws);
 828         FREE(ws);
 829     }
 830 }
 831
 832 wchar_t** ConfigVariable::getCommandLineArgs(int* _piCount)
 833 {
 834     wchar_t** pwstArgs = (wchar_t**)MALLOC(m_Args.size() * sizeof(wchar_t*));
 835     for (int i = 0 ; i < (int)m_Args.size() ; i++)
 836     {
 837         pwstArgs[i] = os_wcsdup(m_Args[i].c_str());
 838     }
 839
 840     *_piCount = (int)m_Args.size();
 841     return pwstArgs;
 842 }
 843
 844 bool ConfigVariable::getTimed()
 845 {
 846     return m_bTimed;
 847 }
 848
 849 void ConfigVariable::setTimed(bool _bTimed)
 850 {
 851     m_bTimed = _bTimed;
 852 }
 853
 854 bool ConfigVariable::getSerialize()
 855 {
 856     return m_bSerialize;
 857 }
 858
 859 void ConfigVariable::setSerialize(bool _bSerialize)
 860 {
 861     m_bSerialize = _bSerialize;
 862 }
 863
 864 /*
 865 ** \}
 866 */
 867
 868 ///*
 869 //** Input Method
 870 //** \{
 871 //*/
 872 //
 873 //SCILAB_INPUT_METHOD ConfigVariable::m_pInputMethod = NULL;
 874 //
 875 //void ConfigVariable::setInputMethod(SCILAB_INPUT_METHOD _pInputMethod)
 876 //{
 877 //    m_pInputMethod = _pInputMethod;
 878 //}
 879 //
 880 //SCILAB_INPUT_METHOD ConfigVariable::getInputMethod(void)
 881 //{
 882 //    return m_pInputMethod;
 883 //}
 884 //
 885 ///*
 886 //** \}
 887 //*/
 888 //
 889 ///*
 890 //** Output Method
 891 //** \{
 892 //*/
 893 //
 894 //SCILAB_OUTPUT_METHOD ConfigVariable::m_pOutputMethod = NULL;
 895 //
 896 //void ConfigVariable::setOutputMethod(SCILAB_OUTPUT_METHOD _pOutputMethod)
 897 //{
 898 //    m_pOutputMethod = _pOutputMethod;
 899 //}
 900 //
 901 //SCILAB_OUTPUT_METHOD ConfigVariable::getOutputMethod(void)
 902 //{
 903 //    return m_pOutputMethod;
 904 //}
 905 //
 906 ///*
 907 //** \}
 908 //*/
 909
 910 /*
 911 ** schur function
 912 ** \{
 913 */
 914
 915 types::Callable* ConfigVariable::m_schurFunction = NULL;
 916
 917 void ConfigVariable::setSchurFunction(types::Callable* _schurFunction)
 918 {
 919     m_schurFunction = _schurFunction;
 920 }
 921
 922 types::Callable* ConfigVariable::getSchurFunction()
 923 {
 924     return m_schurFunction;
 925 }
 926
 927 /*
 928 ** \}
 929 */
 930
 931 /*
 932 ** grand (module randlib)
 933 ** \{
 934 */
 935
 936 int ConfigVariable::m_currentBaseGen = 0;
 937 int ConfigVariable::m_currentClcg4   = 0;
 938
 939 void ConfigVariable::setCurrentBaseGen(int _gen)
 940 {
 941     m_currentBaseGen = _gen;
 942 }
 943
 944 int ConfigVariable::getCurrentBaseGen()
 945 {
 946     return m_currentBaseGen;
 947 }
 948
 949 void ConfigVariable::setCurrentClcg4(int _clcg4)
 950 {
 951     m_currentClcg4 = _clcg4;
 952 }
 953
 954 int ConfigVariable::getCurrentClcg4()
 955 {
 956     return m_currentClcg4;
 957 }
 958 /*
 959 ** \}
 960 */
 961
 962 /*
 963 ** Start finish flag
 964 ** \{
 965 */
 966 bool ConfigVariable::m_bStartProcessing = false;
 967 bool ConfigVariable::m_bEndProcessing = false;
 968
 969 void ConfigVariable::setStartProcessing(bool _bStartProcessing)
 970 {
 971     m_bStartProcessing = _bStartProcessing;
 972 }
 973
 974 bool ConfigVariable::getStartProcessing()
 975 {
 976     return m_bStartProcessing;
 977 }
 978
 979 void ConfigVariable::setEndProcessing(bool _bEndProcessing)
 980 {
 981     m_bEndProcessing = _bEndProcessing;
 982 }
 983
 984 bool ConfigVariable::getEndProcessing()
 985 {
 986     return m_bEndProcessing;
 987 }
 988 /*
 989 ** \}
 990 */
 991
 992 /*
 993 ** ieee
 994 ** \{
 995 */
 996 int ConfigVariable::m_iIeee = 0;
 997
 998 void ConfigVariable::setIeee(int _iIeee)
 999 {
1000     m_iIeee = _iIeee;
1001 }
1002
1003 int ConfigVariable::getIeee()
1004 {
1005     return m_iIeee;
1006 }
1007 /*
1008 ** \}
1009 */
1010
1011 /*
1012 ** simp Mode
1013 ** \{
1014 */
1015 int ConfigVariable::m_iSimpMode = 1;
1016
1017 void ConfigVariable::setSimpMode(int _iSimpMode)
1018 {
1019     m_iSimpMode = _iSimpMode;
1020 }
1021
1022 int ConfigVariable::getSimpMode()
1023 {
1024     return m_iSimpMode;
1025 }
1026 /*
1027 ** \}
1028 */
1029
1030 /*
1031 ** funcprot Mode
1032 ** \{
1033 */
1034 int ConfigVariable::m_iFuncprot = 1;
1035
1036 void ConfigVariable::setFuncprot(int _iFuncprot)
1037 {
1038     m_iFuncprot = _iFuncprot;
1039 }
1040
1041 int ConfigVariable::getFuncprot()
1042 {
1043     return m_iFuncprot;
1044 }
1045 /*
1046 ** \}
1047 */
1048
1049 /*
1050 ** where
1051 ** \{
1052 */
1053
1054 std::list< std::pair<int, std::wstring> > ConfigVariable::m_Where;
1055 std::list<int> ConfigVariable::m_FirstMacroLine;
1056 void ConfigVariable::where_begin(int _iLineNum, std::wstring _wstName)
1057 {
1058     m_Where.push_front(std::pair<int, std::wstring>(_iLineNum, _wstName));
1059 }
1060
1061 void ConfigVariable::where_end()
1062 {
1063     if (m_Where.empty() == false)
1064     {
1065         m_Where.pop_front();
1066     }
1067 }
1068
1069 std::list< std::pair<int, std::wstring> >& ConfigVariable::getWhere()
1070 {
1071     return m_Where;
1072 }
1073
1074 void ConfigVariable::macroFirstLine_begin(int _iLine)
1075 {
1076     m_FirstMacroLine.push_back(_iLine);
1077 }
1078
1079 void ConfigVariable::macroFirstLine_end()
1080 {
1081     m_FirstMacroLine.pop_back();
1082 }
1083
1084 int ConfigVariable::getMacroFirstLines()
1085 {
1086     if (m_FirstMacroLine.empty())
1087     {
1088         return 1;
1089     }
1090
1091     return m_FirstMacroLine.back();
1092 }
1093
1094 /*
1095 ** \}
1096 */
1097
1098 /*
1099 ** module called with variable by reference
1100 ** \{
1101 */
1102
1103 std::list<std::wstring> ConfigVariable::m_ReferenceModules;
1104
1105 bool ConfigVariable::checkReferenceModule(std::wstring _module)
1106 {
1107     std::list<std::wstring>::iterator it = m_ReferenceModules.begin();
1108     for ( ; it != m_ReferenceModules.end() ; ++it)
1109     {
1110         if (*it == _module)
1111         {
1112             return true;
1113         }
1114     }
1115
1116     return false;
1117 }
1118
1119 void ConfigVariable::addReferenceModule(std::wstring _module)
1120 {
1121     if (checkReferenceModule(_module) == false)
1122     {
1123         m_ReferenceModules.push_back(_module);
1124     }
1125 }
1126
1127 void ConfigVariable::removeReferenceModule(std::wstring _module)
1128 {
1129     if (checkReferenceModule(_module))
1130     {
1131         m_ReferenceModules.remove(_module);
1132     }
1133 }
1134
1135 std::list<std::wstring> ConfigVariable::getReferenceModules()
1136 {
1137     std::list<std::wstring> l(m_ReferenceModules);
1138     return l;
1139 }
1140
1141 /*
1142 ** \}
1143 */
1144
1145 /*
1146 ** analyzer options
1147 ** \{
1148 */
1149
1150 int ConfigVariable::m_analyzerOptions = 0;
1151 void ConfigVariable::setAnalyzerOptions(int _val)
1152 {
1153     m_analyzerOptions = _val;
1154 }
1155
1156 int ConfigVariable::getAnalyzerOptions(void)
1157 {
1158     return m_analyzerOptions;
1159 }
1160
1161 /*
1162 ** \}
1163 */
1164
1165 /*
1166 ** divide by zero
1167 ** \{
1168 */
1169
1170 bool ConfigVariable::m_dividebyzero = false;
1171 void ConfigVariable::setDivideByZero(bool _dividebyzero)
1172 {
1173     m_dividebyzero = _dividebyzero;
1174 }
1175
1176 bool ConfigVariable::isDivideByZero(void)
1177 {
1178     return m_dividebyzero;
1179 }
1180 /*
1181 ** \}
1182 */