8387c6266591585518515e3daff921ecff7a5fae
[scilab.git] / 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
13 #include <vector>
14 #include <list>
15 #include "context.hxx"
16 #include "configvariable.hxx"
17 #include "macrofile.hxx"
18 #include "threadmanagement.hxx"
19 #include "execvisitor.hxx"
20 #include "threadId.hxx"
21 #include "cell.hxx"
22 #include "callable.hxx"
23
24 extern "C"
25 {
26 #include "strsubst.h"
27 #include "os_string.h"
28 #include "sci_malloc.h"
29 #include "elem_common.h"
30 #include "FileExist.h"
31 }
32
33 /*
34 ** Module List
35 ** \{
36 */
37 std::list<std::wstring> ConfigVariable::m_ModuleList;
38
39 void ConfigVariable::setModuleList(std::list<std::wstring>& _pModule_list)
40 {
41     m_ModuleList = _pModule_list;
42 }
43
44 std::list<std::wstring> ConfigVariable::getModuleList()
45 {
46     std::list<std::wstring> moduleList(m_ModuleList);
47     return moduleList;
48 }
49 /*
50 ** \}
51 */
52
53 /*
54 ** SCI
55 ** \{
56 */
57 std::wstring ConfigVariable::m_SCIPath;
58
59 void ConfigVariable::setSCIPath(const std::wstring& _SCIPath)
60 {
61     m_SCIPath = _SCIPath;
62 }
63
64 std::wstring& ConfigVariable::getSCIPath()
65 {
66     return m_SCIPath;
67 }
68
69 /*
70 ** \}
71 */
72
73 /*
74 ** SCIHOME
75 ** \{
76 */
77
78 std::wstring ConfigVariable::m_SCIHOME;
79
80 void ConfigVariable::setSCIHOME(const std::wstring& _SCIHOME)
81 {
82     m_SCIHOME = _SCIHOME;
83 }
84
85 std::wstring& ConfigVariable::getSCIHOME()
86 {
87     return m_SCIHOME;
88 }
89 /*
90 ** \}
91 */
92
93 /*
94 ** TMPDIR
95 ** \{
96 */
97
98 std::wstring ConfigVariable::m_TMPDIR;
99
100 void ConfigVariable::setTMPDIR(const std::wstring& _TMPDIR)
101 {
102     m_TMPDIR = _TMPDIR;
103 }
104
105 std::wstring& ConfigVariable::getTMPDIR()
106 {
107     return m_TMPDIR;
108 }
109 /*
110 ** \}
111 */
112
113 /*
114 ** Force Quit
115 ** \{
116 */
117 bool ConfigVariable::m_bForceQuit = false;
118
119 void ConfigVariable::setForceQuit(bool _bForceQuit)
120 {
121     m_bForceQuit = _bForceQuit;
122 }
123
124 bool ConfigVariable::getForceQuit(void)
125 {
126     return m_bForceQuit;
127 }
128 /*
129 ** \}
130 */
131
132 /*
133 ** Exit Status
134 ** \{
135 */
136 int ConfigVariable::m_iExitStatus = 0;
137
138 void ConfigVariable::setExitStatus(int _iExitStatus)
139 {
140     m_iExitStatus = _iExitStatus;
141 }
142
143 int ConfigVariable::getExitStatus(void)
144 {
145     return m_iExitStatus;
146 }
147 /*
148 ** \}
149 */
150
151 /*
152 ** Digit precision, ex format function
153 ** \{
154 */
155
156 int ConfigVariable::m_iFormatSize = 0;
157
158 void ConfigVariable::setFormatSize(int _iFormatSize)
159 {
160     m_iFormatSize = _iFormatSize;
161 }
162
163 int ConfigVariable::getFormatSize(void)
164 {
165     return m_iFormatSize;
166 }
167
168 int ConfigVariable::m_iFormatMode = 0;
169
170 void ConfigVariable::setFormatMode(int _iFormatMode)
171 {
172     m_iFormatMode = _iFormatMode;
173 }
174
175 int ConfigVariable::getFormatMode(void)
176 {
177     return m_iFormatMode;
178 }
179
180 /*
181 ** \}
182 */
183
184 /*
185 ** Screen console width
186 ** \{
187 */
188
189 int ConfigVariable::m_iConsoleWidth = 0;
190
191 void ConfigVariable::setConsoleWidth(int _iConsoleWidth)
192 {
193     m_iConsoleWidth = Max(ICONSOLEWIDTH_MIN, _iConsoleWidth);
194 }
195
196 int ConfigVariable::getConsoleWidth(void)
197 {
198     return m_iConsoleWidth;
199 }
200 /*
201 ** \}
202 */
203
204 /*
205 ** Screen console lines
206 ** \{
207 */
208
209 int ConfigVariable::m_iConsoleLines = 0; //console lines default value
210
211 void ConfigVariable::setConsoleLines(int _iConsoleLines)
212 {
213     m_iConsoleLines = Max(ICONSOLELINES_MIN, _iConsoleLines);
214 }
215
216 int ConfigVariable::getConsoleLines(void)
217 {
218     return m_iConsoleLines;
219 }
220 /*
221 ** \}
222 */
223
224 /*
225 ** Scilab mode
226 ** \{
227 */
228
229 int ConfigVariable::m_iScilabMode = 1; //SCILAB_API = 1  Scilab is launch as an API
230
231 void ConfigVariable::setScilabMode(int _iScilabMode)
232 {
233     m_iScilabMode = _iScilabMode;
234 }
235
236 int ConfigVariable::getScilabMode(void)
237 {
238     return m_iScilabMode;
239 }
240 /*
241 ** \}
242 */
243
244 /*
245 ** Warning Mode
246 ** \{
247 */
248 bool ConfigVariable::m_bWarningMode = true;
249
250 void ConfigVariable::setWarningMode(bool _bWarningMode)
251 {
252     m_bWarningMode = _bWarningMode;
253 }
254
255 bool ConfigVariable::getWarningMode(void)
256 {
257     return m_bWarningMode;
258 }
259 /*
260 ** \}
261 */
262
263 /*
264 ** HOME
265 ** \{
266 */
267
268 std::wstring ConfigVariable::m_HOME;
269
270 void ConfigVariable::setHOME(const std::wstring& _HOME)
271 {
272     m_HOME = _HOME;
273 }
274
275 std::wstring& ConfigVariable::getHOME()
276 {
277     return m_HOME;
278 }
279 /*
280 ** \}
281 */
282
283 /*
284 ** Clear last error information
285 ** \{
286 */
287 bool ConfigVariable::m_bLastErrorCall = false;
288
289 void ConfigVariable::setLastErrorCall(void)
290 {
291     m_bLastErrorCall = true;
292 }
293
294 void ConfigVariable::clearLastError(void)
295 {
296     //if (m_bLastErrorCall == false)
297     {
298         m_wstError          = L"";
299         m_iError            = 0;
300         m_iErrorLine        = 0;
301         m_wstErrorFunction  = L"";
302     }
303     m_bLastErrorCall = false;
304 }
305 /*
306 ** \}
307 */
308
309 /*
310 ** Last Error Message
311 ** \{
312 */
313
314 std::wstring ConfigVariable::m_wstError;
315
316 void ConfigVariable::setLastErrorMessage(const std::wstring& _wstError)
317 {
318     m_wstError = _wstError;
319 }
320
321 std::wstring& ConfigVariable::getLastErrorMessage()
322 {
323     return m_wstError;
324 }
325 /*
326 ** \}
327 */
328
329 /*
330 ** Last Error ID
331 ** \{
332 */
333 int ConfigVariable::m_iError = 0;
334 bool ConfigVariable::m_bError = false;
335
336 void ConfigVariable::setError()
337 {
338     m_bError = true;
339 }
340
341 bool ConfigVariable::isError()
342 {
343     return m_bError;
344 }
345
346 void ConfigVariable::resetError()
347 {
348     m_bError = false;
349 }
350
351 void ConfigVariable::setLastErrorNumber(int _iError)
352 {
353     m_iError = _iError;
354 }
355
356 int ConfigVariable::getLastErrorNumber(void)
357 {
358     return m_iError;
359 }
360 /*
361 ** \}
362 */
363
364 /*
365 ** Last Error Line
366 ** \{
367 */
368 int ConfigVariable::m_iErrorLine = 0;
369
370 void ConfigVariable::setLastErrorLine(int _iErrorLine)
371 {
372     m_iErrorLine = _iErrorLine;
373 }
374
375 int ConfigVariable::getLastErrorLine(void)
376 {
377     return m_iErrorLine;
378 }
379 /*
380 ** \}
381 */
382
383 /*
384 ** Last Error Function
385 ** \{
386 */
387
388 std::wstring ConfigVariable::m_wstErrorFunction = L"";
389
390 void ConfigVariable::setLastErrorFunction(const std::wstring& _wstErrorFunction)
391 {
392     m_wstErrorFunction = _wstErrorFunction;
393 }
394
395 std::wstring& ConfigVariable::getLastErrorFunction()
396 {
397     return m_wstErrorFunction;
398 }
399
400 /*
401 ** \}
402 */
403
404 /*
405 ** Prompt Mode
406 ** \{
407 */
408
409 int ConfigVariable::m_iPromptMode = 0;
410 int ConfigVariable::m_iSilentError = 0;
411 bool ConfigVariable::m_bVerbose = true;
412
413 void ConfigVariable::setPromptMode(int _iPromptMode)
414 {
415     m_iPromptMode = _iPromptMode;
416     if (m_iPromptMode == 5)
417     {
418         m_iPromptMode = 1;
419     }
420
421     if (m_iPromptMode == 6)
422     {
423         m_iPromptMode = 7;
424     }
425 }
426
427 int ConfigVariable::getPromptMode(void)
428 {
429     return m_iPromptMode;
430 }
431
432 bool ConfigVariable::isEmptyLineShow(void)
433 {
434     if ( m_iPromptMode == 0     ||
435             m_iPromptMode == 2  ||
436             m_iPromptMode == 3)
437     {
438         return true;
439     }
440     else
441     {
442         return false;
443     }
444 }
445
446 bool ConfigVariable::isPromptShow(void)
447 {
448     if ( m_iPromptMode == 0     ||
449             m_iPromptMode == 1  ||
450             m_iPromptMode == 2  ||
451             m_iPromptMode == 3)
452     {
453         return true;
454     }
455     else
456     {
457         return false;
458     }
459 }
460
461 void ConfigVariable::setSilentError(int _iSilentError)
462 {
463     m_iSilentError = _iSilentError;
464 }
465
466 int ConfigVariable::getSilentError(void)
467 {
468     return m_iSilentError;
469 }
470
471 void ConfigVariable::setVerbose(bool _bVerbose)
472 {
473     m_bVerbose = _bVerbose;
474 }
475
476 bool ConfigVariable::getVerbose(void)
477 {
478     return m_bVerbose;
479 }
480
481 /*
482 ** ThreadList
483 ** \{
484 */
485
486 std::list<types::ThreadId *> ConfigVariable::m_threadList;
487
488 types::ThreadId* ConfigVariable::getLastPausedThread()
489 {
490     std::list<types::ThreadId *>::reverse_iterator it;
491     for (it = m_threadList.rbegin() ; it != m_threadList.rend() ; it++)
492     {
493         if ((*it)->getStatus() == types::ThreadId::Paused)
494         {
495             return *it;
496         }
497     }
498     return NULL;
499 }
500
501 types::ThreadId* ConfigVariable::getLastRunningThread()
502 {
503     std::list<types::ThreadId *>::reverse_iterator it;
504     for (it = m_threadList.rbegin() ; it != m_threadList.rend() ; it++)
505     {
506         if ((*it)->getStatus() == types::ThreadId::Running)
507         {
508             return *it;
509         }
510     }
511     return NULL;
512 }
513
514 types::ThreadId* ConfigVariable::getLastThread()
515 {
516     return m_threadList.back();
517 }
518
519 types::Cell* ConfigVariable::getAllThreads(void)
520 {
521     int iSize = (int) ConfigVariable::m_threadList.size();
522
523     if (iSize == 0)
524     {
525         return new types::Cell();
526     }
527
528     int i = 0;
529     types::Cell *pcResult = new types::Cell(iSize, 1);
530     std::list<types::ThreadId *>::iterator it;
531
532     for (auto thread : ConfigVariable::m_threadList)
533     {
534         pcResult->set(i++, *it);
535     }
536
537     return pcResult;
538 }
539
540
541 void ConfigVariable::addThread(types::ThreadId* _thread)
542 {
543     _thread->IncreaseRef();
544     m_threadList.push_back(_thread);
545 }
546
547
548 types::ThreadId* ConfigVariable::getThread(__threadKey _key)
549 {
550     std::list<types::ThreadId *>::const_iterator it;
551
552     for (it = ConfigVariable::m_threadList.begin() ; it != ConfigVariable::m_threadList.end() ; ++it)
553     {
554         if ((*it)->getKey() == _key)
555         {
556             return *it;
557         }
558     }
559     return NULL;
560 }
561
562
563 void ConfigVariable::deleteThread(__threadKey _key)
564 {
565     std::list<types::ThreadId *>::iterator it;
566     for (it = ConfigVariable::m_threadList.begin() ; it != ConfigVariable::m_threadList.end() ; ++it)
567     {
568         if ((*it)->getKey() == _key)
569         {
570             (*it)->DecreaseRef();
571             if ((*it)->isDeletable())
572             {
573                 (*it)->killMe();
574                 (*it) = NULL;
575                 m_threadList.erase(it);
576                 return;
577             }
578         }
579     }
580 }
581
582 /*
583 ** \}
584 */
585
586 /*
587 ** Prompt Mode
588 ** \{
589 */
590
591 int ConfigVariable::m_iPauseLevel = 0;
592 std::list<int> ConfigVariable::m_listScope;
593
594 void ConfigVariable::IncreasePauseLevel()
595 {
596     m_iPauseLevel++;
597     m_listScope.push_back(symbol::Context::getInstance()->getScopeLevel());
598 }
599
600 void ConfigVariable::DecreasePauseLevel()
601 {
602     m_iPauseLevel--;
603     m_listScope.pop_back();
604 }
605
606 int ConfigVariable::getActivePauseLevel()
607 {
608     return m_listScope.back();
609 }
610
611 int ConfigVariable::getPauseLevel()
612 {
613     return m_iPauseLevel;
614 }
615
616 /*
617 ** \}
618 */
619
620 /*
621 ** Dynamic Link
622 ** \{
623 */
624
625 std::vector<ConfigVariable::DynamicLibraryStr*> ConfigVariable::m_DynLibList;
626 std::list<ConfigVariable::EntryPointStr*> ConfigVariable::m_EntryPointList;
627
628
629 ConfigVariable::DynamicLibraryStr* ConfigVariable::getNewDynamicLibraryStr()
630 {
631     DynamicLibraryStr* pDL = (DynamicLibraryStr*)MALLOC(sizeof(DynamicLibraryStr));
632     pDL->pwstLibraryName = NULL;
633     pDL->hLib = 0;
634     return pDL;
635 }
636
637 ConfigVariable::EntryPointStr* ConfigVariable::getNewEntryPointStr()
638 {
639     EntryPointStr* pEP = (EntryPointStr*)MALLOC(sizeof(EntryPointStr));
640     pEP->bOK = false;
641     pEP->functionPtr = NULL;
642     pEP->iLibIndex = -1;
643     pEP->pwstEntryPointName = NULL;
644     return pEP;
645 }
646
647 void ConfigVariable::setLibraryName(ConfigVariable::DynamicLibraryStr* _pDynamicLibrary, wchar_t* _pwstLibraryName)
648 {
649     if (_pDynamicLibrary)
650     {
651         if (_pDynamicLibrary->pwstLibraryName)
652         {
653             FREE(_pDynamicLibrary->pwstLibraryName);
654         }
655         _pDynamicLibrary->pwstLibraryName = os_wcsdup(_pwstLibraryName);
656     }
657 }
658
659 void ConfigVariable::setEntryPointName(ConfigVariable::EntryPointStr* _pEntryPoint, wchar_t* _pwstEntryPointName)
660 {
661     if (_pEntryPoint)
662     {
663         if (_pEntryPoint->pwstEntryPointName)
664         {
665             FREE(_pEntryPoint->pwstEntryPointName);
666         }
667         _pEntryPoint->pwstEntryPointName = os_wcsdup(_pwstEntryPointName);;
668     }
669 }
670
671 /* Dynamic libraries functions */
672 int ConfigVariable::addDynamicLibrary(ConfigVariable::DynamicLibraryStr* _pDynamicLibrary)
673 {
674     for (int i = 0 ; i < (int)m_DynLibList.size() ; i++)
675     {
676         if (m_DynLibList[i] == NULL)
677         {
678             m_DynLibList[i] = _pDynamicLibrary;
679             return i;
680         }
681     }
682
683     m_DynLibList.push_back(_pDynamicLibrary);
684     return (int)m_DynLibList.size() - 1;
685 }
686
687 void ConfigVariable::removeDynamicLibrary(int _iDynamicLibraryIndex)
688 {
689     if (_iDynamicLibraryIndex < (int)m_DynLibList.size())
690     {
691         std::list<EntryPointStr*>::const_iterator it;
692         for (it = m_EntryPointList.begin() ; it != m_EntryPointList.end() ; it++)
693         {
694             //clear all entry points linked to removed dynamic library
695             if ((*it)->iLibIndex == _iDynamicLibraryIndex)
696             {
697                 EntryPointStr* pEP = *it;
698                 m_EntryPointList.remove(*it);
699                 FREE(pEP->pwstEntryPointName);
700                 FREE(pEP);
701                 if (m_EntryPointList.size() == 0)
702                 {
703                     break;
704                 }
705                 it = m_EntryPointList.begin();
706             }
707         }
708         //remove dynamic library
709         FREE(m_DynLibList[_iDynamicLibraryIndex]->pwstLibraryName);
710         FREE(m_DynLibList[_iDynamicLibraryIndex]);
711         m_DynLibList[_iDynamicLibraryIndex] = NULL;
712     }
713
714     //clean dynamic library vector
715     while (m_DynLibList.size() != 0 && m_DynLibList.back() == NULL)
716     {
717         m_DynLibList.pop_back();
718     }
719 }
720
721 ConfigVariable::DynamicLibraryStr* ConfigVariable::getDynamicLibrary(int _iDynamicLibraryIndex)
722 {
723     if (_iDynamicLibraryIndex < (int)m_DynLibList.size())
724     {
725         return m_DynLibList[_iDynamicLibraryIndex];
726     }
727     return NULL;
728 }
729
730 bool ConfigVariable::isDynamicLibrary(int _iDynamicLibraryIndex)
731 {
732     if (_iDynamicLibraryIndex < (int)m_DynLibList.size())
733     {
734         if (m_DynLibList[_iDynamicLibraryIndex] != NULL)
735         {
736             return true;
737         }
738     }
739     return false;
740 }
741
742 void ConfigVariable::addEntryPoint(ConfigVariable::EntryPointStr* _pEP)
743 {
744     if (_pEP != NULL)
745     {
746         m_EntryPointList.push_back(_pEP);
747     }
748 }
749
750 ConfigVariable::EntryPointStr* ConfigVariable::getEntryPoint(wchar_t* _pwstEntryPointName, int _iDynamicLibraryIndex)
751 {
752     std::list<EntryPointStr*>::const_iterator it;
753     for (it = m_EntryPointList.begin() ; it != m_EntryPointList.end() ; it++)
754     {
755         //by pass iLibIndex check if _iDynamicLibraryIndex == -1
756         if (_iDynamicLibraryIndex == -1 || (*it)->iLibIndex == _iDynamicLibraryIndex)
757         {
758             if (wcscmp((*it)->pwstEntryPointName, _pwstEntryPointName) == 0)
759             {
760                 return *it;
761             }
762         }
763     }
764     return NULL;
765 }
766
767 dynlib_ptr ConfigVariable::getEntryPointFromPosition(int position)
768 {
769     std::list<EntryPointStr*>::const_iterator it;
770     int pos = 0;
771     for (it = m_EntryPointList.begin(); it != m_EntryPointList.end(); it++, ++pos)
772     {
773         if (pos == position)
774         {
775             return (*it)->functionPtr;
776         }
777     }
778     return NULL;
779 }
780
781 int ConfigVariable::getEntryPointPosition(wchar_t* _pwstEntryPointName, int _iDynamicLibraryIndex)
782 {
783     int pos = 0;
784     std::list<EntryPointStr*>::const_iterator it;
785     for (it = m_EntryPointList.begin(); it != m_EntryPointList.end(); it++, ++pos)
786     {
787         //by pass iLibIndex check if _iDynamicLibraryIndex == -1
788         if (_iDynamicLibraryIndex == -1 || (*it)->iLibIndex == _iDynamicLibraryIndex)
789         {
790             if (wcscmp((*it)->pwstEntryPointName, _pwstEntryPointName) == 0)
791             {
792                 return pos;
793             }
794         }
795     }
796     return -1;
797 }
798
799 std::vector<std::wstring> ConfigVariable::getEntryPointNameList()
800 {
801     std::vector<std::wstring> EntryPointNames;
802     std::list<EntryPointStr*>::const_iterator it;
803     for (it = m_EntryPointList.begin() ; it != m_EntryPointList.end() ; it++)
804     {
805         EntryPointNames.push_back((*it)->pwstEntryPointName);
806     }
807     return EntryPointNames;
808 }
809
810 std::vector<ConfigVariable::DynamicLibraryStr*>* ConfigVariable::getDynamicLibraryList()
811 {
812     return &m_DynLibList;
813 }
814
815 std::list<ConfigVariable::EntryPointStr*>* ConfigVariable::getEntryPointList()
816 {
817     return &m_EntryPointList;
818 }
819
820 //dynamic modules
821 std::map<std::wstring, DynLibHandle> ConfigVariable::m_DynModules;
822
823 void ConfigVariable::addDynModule(const std::wstring& _name, DynLibHandle _lib)
824 {
825     m_DynModules[_name] = _lib;
826 }
827
828 void ConfigVariable::removeDynModule(const std::wstring& _name)
829 {
830     m_DynModules.erase(_name);
831 }
832
833 DynLibHandle ConfigVariable::getDynModule(const std::wstring& _name)
834 {
835     std::map<std::wstring, DynLibHandle>::iterator it;
836     it = m_DynModules.find(_name);
837     if (it != m_DynModules.end())
838     {
839         return it->second;
840     }
841
842     return 0;
843 }
844
845 int ConfigVariable::getDynModuleCount()
846 {
847     return (int)m_DynModules.size();
848 }
849
850 DynLibHandle* ConfigVariable::getAllDynModule()
851 {
852     DynLibHandle* moduleList = new DynLibHandle[m_DynModules.size()];
853     std::map<std::wstring, DynLibHandle>::iterator it = m_DynModules.begin();
854     std::map<std::wstring, DynLibHandle>::iterator itEnd = m_DynModules.end();
855     for (int i = 0; it != itEnd ; ++it, ++i)
856     {
857         moduleList[i] = it->second;
858     }
859
860     return moduleList;
861 }
862
863 void ConfigVariable::cleanDynModule()
864 {
865     m_DynModules.clear();
866 }
867
868 // Command Line Arguments
869 std::vector<std::wstring> ConfigVariable::m_Args;
870 bool ConfigVariable::m_bTimed = false;
871 bool ConfigVariable::m_bSerialize = false;
872
873 void ConfigVariable::setCommandLineArgs(int _iArgs, char** _pstArgs)
874 {
875     m_Args.clear();
876     for (int i = 0 ; i < _iArgs ; i++)
877     {
878         wchar_t * ws = to_wide_string(_pstArgs[i]);
879         m_Args.push_back(ws);
880         FREE(ws);
881     }
882 }
883
884 wchar_t** ConfigVariable::getCommandLineArgs(int* _piCount)
885 {
886     wchar_t** pwstArgs = NULL;
887     *_piCount = (int)m_Args.size();
888     if (*_piCount != 0)
889     {
890         pwstArgs = (wchar_t**)MALLOC(*_piCount * sizeof(wchar_t*));
891         for (int i = 0; i < *_piCount; i++)
892         {
893             pwstArgs[i] = os_wcsdup(m_Args[i].c_str());
894         }
895     }
896     return pwstArgs;
897 }
898
899 bool ConfigVariable::getTimed()
900 {
901     return m_bTimed;
902 }
903
904 void ConfigVariable::setTimed(bool _bTimed)
905 {
906     m_bTimed = _bTimed;
907 }
908
909 bool ConfigVariable::getSerialize()
910 {
911     return m_bSerialize;
912 }
913
914 void ConfigVariable::setSerialize(bool _bSerialize)
915 {
916     m_bSerialize = _bSerialize;
917 }
918
919 /*
920 ** \}
921 */
922
923 ///*
924 //** Input Method
925 //** \{
926 //*/
927 //
928 //SCILAB_INPUT_METHOD ConfigVariable::m_pInputMethod = NULL;
929 //
930 //void ConfigVariable::setInputMethod(SCILAB_INPUT_METHOD _pInputMethod)
931 //{
932 //    m_pInputMethod = _pInputMethod;
933 //}
934 //
935 //SCILAB_INPUT_METHOD ConfigVariable::getInputMethod(void)
936 //{
937 //    return m_pInputMethod;
938 //}
939 //
940 ///*
941 //** \}
942 //*/
943 //
944 ///*
945 //** Output Method
946 //** \{
947 //*/
948 //
949 //SCILAB_OUTPUT_METHOD ConfigVariable::m_pOutputMethod = NULL;
950 //
951 //void ConfigVariable::setOutputMethod(SCILAB_OUTPUT_METHOD _pOutputMethod)
952 //{
953 //    m_pOutputMethod = _pOutputMethod;
954 //}
955 //
956 //SCILAB_OUTPUT_METHOD ConfigVariable::getOutputMethod(void)
957 //{
958 //    return m_pOutputMethod;
959 //}
960 //
961 ///*
962 //** \}
963 //*/
964
965 /*
966 ** schur function
967 ** \{
968 */
969
970 types::Callable* ConfigVariable::m_schurFunction = NULL;
971
972 void ConfigVariable::setSchurFunction(types::Callable* _schurFunction)
973 {
974     m_schurFunction = _schurFunction;
975 }
976
977 types::Callable* ConfigVariable::getSchurFunction()
978 {
979     return m_schurFunction;
980 }
981
982 /*
983 ** \}
984 */
985
986 /*
987 ** grand (module randlib)
988 ** \{
989 */
990
991 int ConfigVariable::m_currentBaseGen = 0;
992 int ConfigVariable::m_currentClcg4   = 0;
993
994 void ConfigVariable::setCurrentBaseGen(int _gen)
995 {
996     m_currentBaseGen = _gen;
997 }
998
999 int ConfigVariable::getCurrentBaseGen()
1000 {
1001     return m_currentBaseGen;
1002 }
1003
1004 void ConfigVariable::setCurrentClcg4(int _clcg4)
1005 {
1006     m_currentClcg4 = _clcg4;
1007 }
1008
1009 int ConfigVariable::getCurrentClcg4()
1010 {
1011     return m_currentClcg4;
1012 }
1013 /*
1014 ** \}
1015 */
1016
1017 /*
1018 ** Start finish flag
1019 ** \{
1020 */
1021 bool ConfigVariable::m_bStartProcessing = false;
1022 bool ConfigVariable::m_bEndProcessing = false;
1023
1024 void ConfigVariable::setStartProcessing(bool _bStartProcessing)
1025 {
1026     m_bStartProcessing = _bStartProcessing;
1027 }
1028
1029 bool ConfigVariable::getStartProcessing()
1030 {
1031     return m_bStartProcessing;
1032 }
1033
1034 void ConfigVariable::setEndProcessing(bool _bEndProcessing)
1035 {
1036     m_bEndProcessing = _bEndProcessing;
1037 }
1038
1039 bool ConfigVariable::getEndProcessing()
1040 {
1041     return m_bEndProcessing;
1042 }
1043 /*
1044 ** \}
1045 */
1046
1047 /*
1048 ** ieee
1049 ** \{
1050 */
1051 int ConfigVariable::m_iIeee = 0;
1052
1053 void ConfigVariable::setIeee(int _iIeee)
1054 {
1055     m_iIeee = _iIeee;
1056 }
1057
1058 int ConfigVariable::getIeee()
1059 {
1060     return m_iIeee;
1061 }
1062 /*
1063 ** \}
1064 */
1065
1066 /*
1067 ** simp Mode
1068 ** \{
1069 */
1070 int ConfigVariable::m_iSimpMode = 1;
1071
1072 void ConfigVariable::setSimpMode(int _iSimpMode)
1073 {
1074     m_iSimpMode = _iSimpMode;
1075 }
1076
1077 int ConfigVariable::getSimpMode()
1078 {
1079     return m_iSimpMode;
1080 }
1081 /*
1082 ** \}
1083 */
1084
1085 /*
1086 ** funcprot Mode
1087 ** \{
1088 */
1089 int ConfigVariable::m_iFuncprot = 1;
1090
1091 void ConfigVariable::setFuncprot(int _iFuncprot)
1092 {
1093     m_iFuncprot = _iFuncprot;
1094 }
1095
1096 int ConfigVariable::getFuncprot()
1097 {
1098     return m_iFuncprot;
1099 }
1100 /*
1101 ** \}
1102 */
1103
1104 /*
1105 ** where
1106 ** \{
1107 */
1108
1109 ConfigVariable::WhereVector ConfigVariable::m_Where;
1110 ConfigVariable::WhereVector ConfigVariable::m_WhereError;
1111 std::vector<int> ConfigVariable::m_FirstMacroLine;
1112 void ConfigVariable::where_begin(int _iLineNum, int _iLineLocation, types::Callable* _pCall)
1113 {
1114     std::wstring wstrFileName = L"";
1115     types::Callable* pCall = _pCall;
1116     if (pCall->isMacroFile())
1117     {
1118         types::Macro* pM = pCall->getAs<types::MacroFile>()->getMacro();
1119         wstrFileName = pM->getFileName();
1120         pCall = pM;
1121     }
1122     else if (pCall->isMacro())
1123     {
1124         types::Macro* pM = pCall->getAs<types::Macro>();
1125         wstrFileName = pM->getFileName();
1126     }
1127
1128     m_Where.emplace_back(_iLineNum, _iLineLocation, pCall->getName(), pCall->getFirstLine(), wstrFileName);
1129 }
1130
1131 void ConfigVariable::where_end()
1132 {
1133     m_Where.pop_back();
1134 }
1135
1136 const ConfigVariable::WhereVector& ConfigVariable::getWhere()
1137 {
1138     return m_Where;
1139 }
1140
1141 void ConfigVariable::macroFirstLine_begin(int _iLine)
1142 {
1143     m_FirstMacroLine.push_back(_iLine);
1144 }
1145
1146 void ConfigVariable::macroFirstLine_end()
1147 {
1148     m_FirstMacroLine.pop_back();
1149 }
1150
1151 int ConfigVariable::getMacroFirstLines()
1152 {
1153     if (m_FirstMacroLine.empty())
1154     {
1155         return 1;
1156     }
1157
1158     return m_FirstMacroLine.back();
1159 }
1160 void ConfigVariable::setFileNameToLastWhere(const std::wstring& _fileName)
1161 {
1162     m_Where.back().m_file_name = _fileName;
1163 }
1164
1165 void ConfigVariable::whereErrorToString(std::wostringstream &ostr)
1166 {
1167     int iLenName = 1;
1168     bool isExecstr = false;
1169     bool isExecfile = false;
1170
1171     // get max length of functions name and check if exec or execstr have been called.
1172     for (auto & where : m_WhereError)
1173     {
1174         if (isExecstr == false && where.m_name == L"execstr")
1175         {
1176             isExecstr = true;
1177             continue;
1178         }
1179         else if (isExecfile == false && where.m_name == L"exec")
1180         {
1181             isExecfile = true;
1182             continue;
1183         }
1184
1185         iLenName = std::max((int)where.m_name.length(), iLenName);
1186
1187         // in case of bin file, the file path and line is displayed only if the associated .sci file exists
1188         if (where.m_file_name != L"" && where.m_file_name.find(L".bin") != std::wstring::npos)
1189         {
1190             std::size_t pos = where.m_file_name.find_last_of(L".");
1191             where.m_file_name.replace(pos, pos + 4, L".sci");
1192             if (FileExistW(const_cast<wchar_t*>(where.m_file_name.c_str())) == false)
1193             {
1194                 where.m_file_name = L"";
1195             }
1196         }
1197     }
1198
1199     // add margin
1200     iLenName++;
1201
1202     // initialize localized strings
1203     std::wstring wstrBuiltin(_W("in builtin "));
1204     std::wstring wstrAtLine(_W("at line % 5d of function "));
1205     std::wstring wstrExecStr(_W("at line % 5d of executed string "));
1206     std::wstring wstrExecFile(_W("at line % 5d of executed file "));
1207
1208     // compute max size between "at line xxx of function" and "in builtin "
1209     // +1 : line number is pad to 5. length of "% 5d" + 1 == 5
1210     int iMaxLen = std::max(wstrAtLine.length() + 1, wstrBuiltin.length());
1211     if (isExecstr)
1212     {
1213         iMaxLen = std::max(((int)wstrExecStr.length()) + 1, iMaxLen);
1214     }
1215
1216     if (isExecstr)
1217     {
1218         iMaxLen = std::max(((int)wstrExecFile.length()) + 1, iMaxLen);
1219     }
1220
1221     // print call stack
1222     ostr << std::left;
1223     ostr.fill(L' ');
1224     for (auto & where : m_WhereError)
1225     {
1226         ostr.width(iMaxLen);
1227         if (where.m_line == 0)
1228         {
1229             ostr << wstrBuiltin;
1230         }
1231         else
1232         {
1233             if (where.m_name == L"execstr")
1234             {
1235                 isExecstr = true;
1236                 wchar_t wcsTmp[bsiz];
1237                 os_swprintf(wcsTmp, bsiz, wstrExecStr.c_str(), where.m_line);
1238                 ostr << wcsTmp << std::endl;
1239                 continue;
1240             }
1241             else if (where.m_name == L"exec")
1242             {
1243                 wchar_t wcsTmp[bsiz];
1244                 os_swprintf(wcsTmp, bsiz, wstrExecFile.c_str(), where.m_line);
1245                 ostr << wcsTmp << where.m_file_name << std::endl;
1246                 continue;
1247             }
1248             else
1249             {
1250                 wchar_t wcsTmp[bsiz];
1251                 os_swprintf(wcsTmp, bsiz, wstrAtLine.c_str(), where.m_line);
1252                 ostr << wcsTmp;
1253             }
1254         }
1255
1256         ostr.width(iLenName);
1257         ostr << where.m_name;
1258
1259         if (where.m_file_name != L"")
1260         {
1261             // -1 because the first line of a function dec is : "function myfunc()"
1262             ostr << L"( " << where.m_file_name << L" " << _W("line") << L" " << where.m_macro_first_line + where.m_line - 1 << L" )";
1263         }
1264
1265         ostr << std::endl;
1266     }
1267 }
1268
1269 void ConfigVariable::fillWhereError(int _iErrorLine)
1270 {
1271     if (m_WhereError.empty())
1272     {
1273         int iTmp = 0;
1274         if (_iErrorLine != 0)
1275         {
1276             // +1 because the first line of the funtionDec "function func()" is the line 1.
1277             iTmp = _iErrorLine - getMacroFirstLines() + 1;
1278         }
1279
1280         m_WhereError.reserve(m_Where.size());
1281         for (auto where = m_Where.rbegin(); where != m_Where.rend(); ++where)
1282         {
1283             m_WhereError.emplace_back(iTmp, (*where).m_absolute_line, (*where).m_name, (*where).m_macro_first_line, (*where).m_file_name);
1284             iTmp = (*where).m_line;
1285         }
1286     }
1287 }
1288
1289 void ConfigVariable::resetWhereError()
1290 {
1291     m_WhereError.clear();
1292 }
1293
1294 /*
1295 ** \}
1296 */
1297
1298 /*
1299 ** module called with variable by reference
1300 ** \{
1301 */
1302
1303 std::list<std::wstring> ConfigVariable::m_ReferenceModules;
1304
1305 bool ConfigVariable::checkReferenceModule(const std::wstring& _module)
1306 {
1307     for (auto ref : m_ReferenceModules)
1308     {
1309         if (ref == _module)
1310         {
1311             return true;
1312         }
1313     }
1314
1315     return false;
1316 }
1317
1318 void ConfigVariable::addReferenceModule(const std::wstring& _module)
1319 {
1320     if (checkReferenceModule(_module) == false)
1321     {
1322         m_ReferenceModules.push_back(_module);
1323     }
1324 }
1325
1326 void ConfigVariable::removeReferenceModule(const std::wstring& _module)
1327 {
1328     if (checkReferenceModule(_module))
1329     {
1330         m_ReferenceModules.remove(_module);
1331     }
1332 }
1333
1334 std::list<std::wstring> ConfigVariable::getReferenceModules()
1335 {
1336     std::list<std::wstring> l(m_ReferenceModules);
1337     return l;
1338 }
1339
1340 /*
1341 ** \}
1342 */
1343
1344 /*
1345 ** analyzer options
1346 ** \{
1347 */
1348
1349 int ConfigVariable::m_analyzerOptions = 0;
1350 void ConfigVariable::setAnalyzerOptions(int _val)
1351 {
1352     m_analyzerOptions = _val;
1353 }
1354
1355 int ConfigVariable::getAnalyzerOptions(void)
1356 {
1357     return m_analyzerOptions;
1358 }
1359
1360 /*
1361 ** \}
1362 */
1363
1364 /*
1365 ** divide by zero
1366 ** \{
1367 */
1368
1369 bool ConfigVariable::m_dividebyzero = false;
1370 void ConfigVariable::setDivideByZero(bool _dividebyzero)
1371 {
1372     m_dividebyzero = _dividebyzero;
1373 }
1374
1375 bool ConfigVariable::isDivideByZero(void)
1376 {
1377     return m_dividebyzero;
1378 }
1379 /*
1380 ** \}
1381 */
1382
1383 //mex info
1384 std::string ConfigVariable::mexFunctionName;
1385 void ConfigVariable::setMexFunctionName(const std::string& name)
1386 {
1387     mexFunctionName = name;
1388 }
1389
1390 std::string& ConfigVariable::getMexFunctionName()
1391 {
1392     return mexFunctionName;
1393 }
1394
1395 /*
1396 ** \}
1397 */
1398 // executed file with exec
1399 int ConfigVariable::m_iFileID = 0;
1400 void ConfigVariable::setExecutedFileID(int _iFileID)
1401 {
1402     m_iFileID = _iFileID;
1403 }
1404
1405 int ConfigVariable::getExecutedFileID()
1406 {
1407     return m_iFileID;
1408 }
1409
1410 /*
1411 ** string read from console by scilabRead
1412 ** \{
1413 */
1414 char* ConfigVariable::m_pcConsoleReadStr = NULL;
1415 void ConfigVariable::setConsoleReadStr(char* _pcConsoleReadStr)
1416 {
1417     m_pcConsoleReadStr = _pcConsoleReadStr;
1418 }
1419
1420 char* ConfigVariable::getConsoleReadStr()
1421 {
1422     ThreadManagement::LockScilabRead();
1423     char* tmp = m_pcConsoleReadStr;
1424     m_pcConsoleReadStr = NULL;
1425     ThreadManagement::UnlockScilabRead();
1426     return tmp;
1427 }
1428 /*
1429 ** \}
1430 */
1431
1432 /*
1433 ** Tell to the console thread if the scilabRead return
1434 ** is a scilab command or not.
1435 ** \{
1436 */
1437 int ConfigVariable::m_isScilabCommand = 1;
1438 void ConfigVariable::setScilabCommand(int _isciCmd)
1439 {
1440     m_isScilabCommand = _isciCmd;
1441 }
1442
1443 int ConfigVariable::isScilabCommand()
1444 {
1445     return m_isScilabCommand;
1446 }
1447 /*
1448 ** \}
1449 */
1450
1451 //debugger information
1452 bool ConfigVariable::m_bEnabledebug = false;
1453 ast::ConstVisitor* ConfigVariable::m_defaultvisitor = NULL;
1454
1455 bool ConfigVariable::getEnableDebug()
1456 {
1457     return m_bEnabledebug;
1458 }
1459
1460 void ConfigVariable::setEnableDebug(bool _enable)
1461 {
1462     m_bEnabledebug = _enable;
1463 }
1464
1465 void ConfigVariable::setDefaultVisitor(ast::ConstVisitor* _default)
1466 {
1467     if (m_defaultvisitor)
1468     {
1469         delete m_defaultvisitor;
1470     }
1471
1472     m_defaultvisitor = _default;
1473 }
1474
1475 ast::ConstVisitor* ConfigVariable::getDefaultVisitor()
1476 {
1477     if (m_defaultvisitor == NULL)
1478     {
1479         m_defaultvisitor = new ast::ExecVisitor();
1480     }
1481     return m_defaultvisitor->clone();
1482 }
1483
1484 bool ConfigVariable::executionbreak = false;
1485
1486 bool ConfigVariable::isExecutionBreak()
1487 {
1488     return executionbreak;
1489 }
1490
1491 void ConfigVariable::setExecutionBreak()
1492 {
1493     executionbreak = true;
1494 }
1495
1496 void ConfigVariable::resetExecutionBreak()
1497 {
1498     executionbreak = false;
1499 }
1500
1501
1502 #ifdef _DEBUG
1503 int ConfigVariable::recursionLimit = 25;
1504 #else
1505 int ConfigVariable::recursionLimit = 1000;
1506 #endif
1507 int ConfigVariable::recursionLevel = 0;
1508
1509 int ConfigVariable::getRecursionLimit()
1510 {
1511     return recursionLimit;
1512 }
1513
1514 int ConfigVariable::setRecursionLimit(int val)
1515 {
1516     int old = recursionLimit;
1517     recursionLimit = std::max(10, val);
1518     return old;
1519 }
1520
1521 int ConfigVariable::getRecursionLevel()
1522 {
1523     return recursionLevel;
1524 }
1525
1526 bool ConfigVariable::increaseRecursion()
1527 {
1528     if (recursionLevel < recursionLimit)
1529     {
1530         ++recursionLevel;
1531         return true;
1532     }
1533
1534     return false;
1535 }
1536
1537 void ConfigVariable::decreaseRecursion()
1538 {
1539     //recursionLevel = std::max(--recursionLevel, 0);
1540     --recursionLevel;
1541 }
1542
1543 void ConfigVariable::resetRecursionLevel()
1544 {
1545     recursionLevel = 0;
1546 }