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