a682bc7fa3f93d9c3cade2c3485c2e8ebb3e341d
[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 #include <list>
13 #include "configvariable.hxx"
14 #include "context.hxx"
15
16 extern "C"
17 {
18 #include "strsubst.h"
19 #include "os_string.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 == 5)
408     {
409         m_iPromptMode = 1;
410     }
411
412     if (m_iPromptMode == 6)
413     {
414         m_iPromptMode = 7;
415     }
416 }
417
418 int ConfigVariable::getPromptMode(void)
419 {
420     return m_iPromptMode;
421 }
422
423 bool ConfigVariable::isEmptyLineShow(void)
424 {
425     if ( m_iPromptMode == 0     ||
426             m_iPromptMode == 2  ||
427             m_iPromptMode == 3)
428     {
429         return true;
430     }
431     else
432     {
433         return false;
434     }
435 }
436
437 bool ConfigVariable::isPromptShow(void)
438 {
439     if ( m_iPromptMode == 0     ||
440             m_iPromptMode == 1  ||
441             m_iPromptMode == 2  ||
442             m_iPromptMode == 3)
443     {
444         return true;
445     }
446     else
447     {
448         return false;
449     }
450 }
451
452 void ConfigVariable::setSilentError(int _iSilentError)
453 {
454     m_iSilentError = _iSilentError;
455 }
456
457 int ConfigVariable::getSilentError(void)
458 {
459     return m_iSilentError;
460 }
461
462 void ConfigVariable::setVerbose(bool _bVerbose)
463 {
464     m_bVerbose = _bVerbose;
465 }
466
467 bool ConfigVariable::getVerbose(void)
468 {
469     return m_bVerbose;
470 }
471
472 /*
473 ** ThreadList
474 ** \{
475 */
476
477 std::list<types::ThreadId *> ConfigVariable::m_threadList;
478
479 types::ThreadId* ConfigVariable::getLastPausedThread()
480 {
481     std::list<types::ThreadId *>::reverse_iterator it;
482     for (it = m_threadList.rbegin() ; it != m_threadList.rend() ; it++)
483     {
484         if ((*it)->getStatus() == types::ThreadId::Paused)
485         {
486             return *it;
487         }
488     }
489     return NULL;
490 }
491
492 types::ThreadId* ConfigVariable::getLastRunningThread()
493 {
494     std::list<types::ThreadId *>::reverse_iterator it;
495     for (it = m_threadList.rbegin() ; it != m_threadList.rend() ; it++)
496     {
497         if ((*it)->getStatus() == types::ThreadId::Running)
498         {
499             return *it;
500         }
501     }
502     return NULL;
503 }
504
505 types::ThreadId* ConfigVariable::getLastThread()
506 {
507     return m_threadList.back();
508 }
509
510 types::Cell* ConfigVariable::getAllThreads(void)
511 {
512     int iSize = (int) ConfigVariable::m_threadList.size();
513
514     if (iSize == 0)
515     {
516         return new types::Cell();
517     }
518
519     int i = 0;
520     types::Cell *pcResult = new types::Cell(iSize, 1);
521     std::list<types::ThreadId *>::iterator it;
522
523     for (it = ConfigVariable::m_threadList.begin() ; it != ConfigVariable::m_threadList.end() ; ++it, ++i)
524     {
525         pcResult->set(i, *it);
526     }
527
528     return pcResult;
529 }
530
531
532 void ConfigVariable::addThread(types::ThreadId* _thread)
533 {
534     _thread->IncreaseRef();
535     m_threadList.push_back(_thread);
536 }
537
538
539 types::ThreadId* ConfigVariable::getThread(__threadKey _key)
540 {
541     std::list<types::ThreadId *>::const_iterator it;
542
543     for (it = ConfigVariable::m_threadList.begin() ; it != ConfigVariable::m_threadList.end() ; ++it)
544     {
545         if ((*it)->getKey() == _key)
546         {
547             return *it;
548         }
549     }
550     return NULL;
551 }
552
553
554 void ConfigVariable::deleteThread(__threadKey _key)
555 {
556     //for(int i = 0 ; i < m_threadList.size() ; i++)
557     //{
558     //    types::ThreadId* pThread = m_threadList[i];
559     //    if(pThread->getKey() == _key)
560     //    {
561     //        pThread->DecreaseRef();
562     //        if(pThread->isDeletable())
563     //        {
564     //            delete pThread;
565     //            m_threadList.erase(.begin() + i - 1);
566     //        }
567     //    }
568     //}
569     std::list<types::ThreadId *>::iterator it;
570     for (it = ConfigVariable::m_threadList.begin() ; it != ConfigVariable::m_threadList.end() ; ++it)
571     {
572         if ((*it)->getKey() == _key)
573         {
574             (*it)->DecreaseRef();
575             if ((*it)->isDeletable())
576             {
577                 (*it)->killMe();
578                 (*it) = NULL;
579                 m_threadList.erase(it);
580                 return;
581             }
582         }
583     }
584 }
585
586 /*
587 ** \}
588 */
589
590 /*
591 ** Prompt Mode
592 ** \{
593 */
594
595 int ConfigVariable::m_iPauseLevel = 0;
596 std::list<int> ConfigVariable::m_listScope;
597
598 void ConfigVariable::IncreasePauseLevel()
599 {
600     m_iPauseLevel++;
601     m_listScope.push_back(symbol::Context::getInstance()->getScopeLevel());
602 }
603
604 void ConfigVariable::DecreasePauseLevel()
605 {
606     m_iPauseLevel--;
607     m_listScope.pop_back();
608 }
609
610 int ConfigVariable::getActivePauseLevel()
611 {
612     return m_listScope.back();
613 }
614
615 int ConfigVariable::getPauseLevel()
616 {
617     return m_iPauseLevel;
618 }
619
620 /*
621 ** \}
622 */
623
624 /*
625 ** Dynamic Link
626 ** \{
627 */
628
629 std::vector<ConfigVariable::DynamicLibraryStr*> ConfigVariable::m_DynLibList;
630 std::list<ConfigVariable::EntryPointStr*> ConfigVariable::m_EntryPointList;
631
632
633 ConfigVariable::DynamicLibraryStr* ConfigVariable::getNewDynamicLibraryStr()
634 {
635     DynamicLibraryStr* pDL = (DynamicLibraryStr*)MALLOC(sizeof(DynamicLibraryStr));
636     pDL->pwstLibraryName = NULL;
637     pDL->hLib = 0;
638     return pDL;
639 }
640
641 ConfigVariable::EntryPointStr* ConfigVariable::getNewEntryPointStr()
642 {
643     EntryPointStr* pEP = (EntryPointStr*)MALLOC(sizeof(EntryPointStr));
644     pEP->bOK = false;
645     pEP->functionPtr = NULL;
646     pEP->iLibIndex = -1;
647     pEP->pwstEntryPointName = NULL;
648     return pEP;
649 }
650
651 void ConfigVariable::setLibraryName(ConfigVariable::DynamicLibraryStr* _pDynamicLibrary, wchar_t* _pwstLibraryName)
652 {
653     if (_pDynamicLibrary)
654     {
655         if (_pDynamicLibrary->pwstLibraryName)
656         {
657             FREE(_pDynamicLibrary->pwstLibraryName);
658         }
659         _pDynamicLibrary->pwstLibraryName = os_wcsdup(_pwstLibraryName);
660     }
661 }
662
663 void ConfigVariable::setEntryPointName(ConfigVariable::EntryPointStr* _pEntryPoint, wchar_t* _pwstEntryPointName)
664 {
665     if (_pEntryPoint)
666     {
667         if (_pEntryPoint->pwstEntryPointName)
668         {
669             FREE(_pEntryPoint->pwstEntryPointName);
670         }
671         _pEntryPoint->pwstEntryPointName = os_wcsdup(_pwstEntryPointName);;
672     }
673 }
674
675 /* Dynamic libraries functions */
676 int ConfigVariable::addDynamicLibrary(ConfigVariable::DynamicLibraryStr* _pDynamicLibrary)
677 {
678     for (int i = 0 ; i < (int)m_DynLibList.size() ; i++)
679     {
680         if (m_DynLibList[i] == NULL)
681         {
682             m_DynLibList[i] = _pDynamicLibrary;
683             return i;
684         }
685     }
686
687     m_DynLibList.push_back(_pDynamicLibrary);
688     return (int)m_DynLibList.size() - 1;
689 }
690
691 void ConfigVariable::removeDynamicLibrary(int _iDynamicLibraryIndex)
692 {
693     if (_iDynamicLibraryIndex < (int)m_DynLibList.size())
694     {
695         std::list<EntryPointStr*>::const_iterator it;
696         for (it = m_EntryPointList.begin() ; it != m_EntryPointList.end() ; it++)
697         {
698             //clear all entry points linked to removed dynamic library
699             if ((*it)->iLibIndex == _iDynamicLibraryIndex)
700             {
701                 m_EntryPointList.remove(*it);
702                 if (m_EntryPointList.size() == 0)
703                 {
704                     break;
705                 }
706                 it = m_EntryPointList.begin();
707             }
708         }
709         //remove dynamic library
710         m_DynLibList[_iDynamicLibraryIndex] = NULL;
711     }
712
713     //clean dynamic library vector
714     while (m_DynLibList.size() != 0 && m_DynLibList.back() == NULL)
715     {
716         m_DynLibList.pop_back();
717     }
718 }
719
720 ConfigVariable::DynamicLibraryStr* ConfigVariable::getDynamicLibrary(int _iDynamicLibraryIndex)
721 {
722     if (_iDynamicLibraryIndex < (int)m_DynLibList.size())
723     {
724         return m_DynLibList[_iDynamicLibraryIndex];
725     }
726     return NULL;
727 }
728
729 bool ConfigVariable::isDynamicLibrary(int _iDynamicLibraryIndex)
730 {
731     if (_iDynamicLibraryIndex < (int)m_DynLibList.size())
732     {
733         if (m_DynLibList[_iDynamicLibraryIndex] != NULL)
734         {
735             return true;
736         }
737     }
738     return false;
739 }
740
741 void ConfigVariable::addEntryPoint(ConfigVariable::EntryPointStr* _pEP)
742 {
743     if (_pEP != NULL)
744     {
745         m_EntryPointList.push_back(_pEP);
746     }
747 }
748
749 ConfigVariable::EntryPointStr* ConfigVariable::getEntryPoint(wchar_t* _pwstEntryPointName, int _iDynamicLibraryIndex)
750 {
751     std::list<EntryPointStr*>::const_iterator it;
752     for (it = m_EntryPointList.begin() ; it != m_EntryPointList.end() ; it++)
753     {
754         //by pass iLibIndex check if _iDynamicLibraryIndex == -1
755         if (_iDynamicLibraryIndex == -1 || (*it)->iLibIndex == _iDynamicLibraryIndex)
756         {
757             if (wcscmp((*it)->pwstEntryPointName, _pwstEntryPointName) == 0)
758             {
759                 return *it;
760             }
761         }
762     }
763     return NULL;
764 }
765
766 std::vector<std::wstring> ConfigVariable::getEntryPointNameList()
767 {
768     std::vector<std::wstring> EntryPointNames;
769     std::list<EntryPointStr*>::const_iterator it;
770     for (it = m_EntryPointList.begin() ; it != m_EntryPointList.end() ; it++)
771     {
772         EntryPointNames.push_back((*it)->pwstEntryPointName);
773     }
774     return EntryPointNames;
775 }
776
777 std::vector<ConfigVariable::DynamicLibraryStr*>* ConfigVariable::getDynamicLibraryList()
778 {
779     return &m_DynLibList;
780 }
781
782 std::list<ConfigVariable::EntryPointStr*>* ConfigVariable::getEntryPointList()
783 {
784     return &m_EntryPointList;
785 }
786
787 //dynamic modules
788 std::map<std::wstring, DynLibHandle> ConfigVariable::m_DynModules;
789
790 void ConfigVariable::addDynModule(std::wstring _name, DynLibHandle _lib)
791 {
792     m_DynModules[_name] = _lib;
793 }
794
795 void ConfigVariable::removeDynModule(std::wstring _name)
796 {
797     m_DynModules.erase(_name);
798 }
799
800 DynLibHandle ConfigVariable::getDynModule(std::wstring _name)
801 {
802     std::map<std::wstring, DynLibHandle>::iterator it;
803     it = m_DynModules.find(_name);
804     if (it != m_DynModules.end())
805     {
806         return it->second;
807     }
808
809     return 0;
810 }
811
812 int ConfigVariable::getDynModuleCount()
813 {
814     return (int)m_DynModules.size();
815 }
816
817 DynLibHandle* ConfigVariable::getAllDynModule()
818 {
819     DynLibHandle* moduleList = new DynLibHandle[m_DynModules.size()];
820     std::map<std::wstring, DynLibHandle>::iterator it = m_DynModules.begin();
821     std::map<std::wstring, DynLibHandle>::iterator itEnd = m_DynModules.end();
822     for (int i = 0; it != itEnd ; ++it, ++i)
823     {
824         moduleList[i] = it->second;
825     }
826
827     return moduleList;
828 }
829
830 void ConfigVariable::cleanDynModule()
831 {
832     m_DynModules.clear();
833 }
834
835 // Command Line Arguments
836 std::vector<std::wstring> ConfigVariable::m_Args;
837 bool ConfigVariable::m_bTimed = false;
838 bool ConfigVariable::m_bSerialize = false;
839
840 void ConfigVariable::setCommandLineArgs(int _iArgs, char** _pstArgs)
841 {
842     m_Args.clear();
843     for (int i = 0 ; i < _iArgs ; i++)
844     {
845         wchar_t * ws = to_wide_string(_pstArgs[i]);
846         m_Args.push_back(ws);
847         FREE(ws);
848     }
849 }
850
851 wchar_t** ConfigVariable::getCommandLineArgs(int* _piCount)
852 {
853     wchar_t** pwstArgs = (wchar_t**)MALLOC(m_Args.size() * sizeof(wchar_t*));
854     for (int i = 0 ; i < (int)m_Args.size() ; i++)
855     {
856         pwstArgs[i] = os_wcsdup(m_Args[i].c_str());
857     }
858
859     *_piCount = (int)m_Args.size();
860     return pwstArgs;
861 }
862
863 bool ConfigVariable::getTimed()
864 {
865     return m_bTimed;
866 }
867
868 void ConfigVariable::setTimed(bool _bTimed)
869 {
870     m_bTimed = _bTimed;
871 }
872
873 bool ConfigVariable::getSerialize()
874 {
875     return m_bSerialize;
876 }
877
878 void ConfigVariable::setSerialize(bool _bSerialize)
879 {
880     m_bSerialize = _bSerialize;
881 }
882
883 /*
884 ** \}
885 */
886
887 ///*
888 //** Input Method
889 //** \{
890 //*/
891 //
892 //SCILAB_INPUT_METHOD ConfigVariable::m_pInputMethod = NULL;
893 //
894 //void ConfigVariable::setInputMethod(SCILAB_INPUT_METHOD _pInputMethod)
895 //{
896 //    m_pInputMethod = _pInputMethod;
897 //}
898 //
899 //SCILAB_INPUT_METHOD ConfigVariable::getInputMethod(void)
900 //{
901 //    return m_pInputMethod;
902 //}
903 //
904 ///*
905 //** \}
906 //*/
907 //
908 ///*
909 //** Output Method
910 //** \{
911 //*/
912 //
913 //SCILAB_OUTPUT_METHOD ConfigVariable::m_pOutputMethod = NULL;
914 //
915 //void ConfigVariable::setOutputMethod(SCILAB_OUTPUT_METHOD _pOutputMethod)
916 //{
917 //    m_pOutputMethod = _pOutputMethod;
918 //}
919 //
920 //SCILAB_OUTPUT_METHOD ConfigVariable::getOutputMethod(void)
921 //{
922 //    return m_pOutputMethod;
923 //}
924 //
925 ///*
926 //** \}
927 //*/
928
929 /*
930 ** schur function
931 ** \{
932 */
933
934 types::Callable* ConfigVariable::m_schurFunction = NULL;
935
936 void ConfigVariable::setSchurFunction(types::Callable* _schurFunction)
937 {
938     m_schurFunction = _schurFunction;
939 }
940
941 types::Callable* ConfigVariable::getSchurFunction()
942 {
943     return m_schurFunction;
944 }
945
946 /*
947 ** \}
948 */
949
950 /*
951 ** grand (module randlib)
952 ** \{
953 */
954
955 int ConfigVariable::m_currentBaseGen = 0;
956 int ConfigVariable::m_currentClcg4   = 0;
957
958 void ConfigVariable::setCurrentBaseGen(int _gen)
959 {
960     m_currentBaseGen = _gen;
961 }
962
963 int ConfigVariable::getCurrentBaseGen()
964 {
965     return m_currentBaseGen;
966 }
967
968 void ConfigVariable::setCurrentClcg4(int _clcg4)
969 {
970     m_currentClcg4 = _clcg4;
971 }
972
973 int ConfigVariable::getCurrentClcg4()
974 {
975     return m_currentClcg4;
976 }
977 /*
978 ** \}
979 */
980
981 /*
982 ** Start finish flag
983 ** \{
984 */
985 bool ConfigVariable::m_bStartProcessing = false;
986 bool ConfigVariable::m_bEndProcessing = false;
987
988 void ConfigVariable::setStartProcessing(bool _bStartProcessing)
989 {
990     m_bStartProcessing = _bStartProcessing;
991 }
992
993 bool ConfigVariable::getStartProcessing()
994 {
995     return m_bStartProcessing;
996 }
997
998 void ConfigVariable::setEndProcessing(bool _bEndProcessing)
999 {
1000     m_bEndProcessing = _bEndProcessing;
1001 }
1002
1003 bool ConfigVariable::getEndProcessing()
1004 {
1005     return m_bEndProcessing;
1006 }
1007 /*
1008 ** \}
1009 */
1010
1011 /*
1012 ** ieee
1013 ** \{
1014 */
1015 int ConfigVariable::m_iIeee = 0;
1016
1017 void ConfigVariable::setIeee(int _iIeee)
1018 {
1019     m_iIeee = _iIeee;
1020 }
1021
1022 int ConfigVariable::getIeee()
1023 {
1024     return m_iIeee;
1025 }
1026 /*
1027 ** \}
1028 */
1029
1030 /*
1031 ** simp Mode
1032 ** \{
1033 */
1034 int ConfigVariable::m_iSimpMode = 1;
1035
1036 void ConfigVariable::setSimpMode(int _iSimpMode)
1037 {
1038     m_iSimpMode = _iSimpMode;
1039 }
1040
1041 int ConfigVariable::getSimpMode()
1042 {
1043     return m_iSimpMode;
1044 }
1045 /*
1046 ** \}
1047 */
1048
1049 /*
1050 ** funcprot Mode
1051 ** \{
1052 */
1053 int ConfigVariable::m_iFuncprot = 1;
1054
1055 void ConfigVariable::setFuncprot(int _iFuncprot)
1056 {
1057     m_iFuncprot = _iFuncprot;
1058 }
1059
1060 int ConfigVariable::getFuncprot()
1061 {
1062     return m_iFuncprot;
1063 }
1064 /*
1065 ** \}
1066 */
1067
1068 /*
1069 ** where
1070 ** \{
1071 */
1072
1073 std::list< std::pair<int, std::wstring> > ConfigVariable::m_Where;
1074 std::list<int> ConfigVariable::m_FirstMacroLine;
1075 void ConfigVariable::where_begin(int _iLineNum, std::wstring _wstName)
1076 {
1077     m_Where.push_front(std::pair<int, std::wstring>(_iLineNum, _wstName));
1078 }
1079
1080 void ConfigVariable::where_end()
1081 {
1082     if (m_Where.empty() == false)
1083     {
1084         m_Where.pop_front();
1085     }
1086 }
1087
1088 std::list< std::pair<int, std::wstring> >& ConfigVariable::getWhere()
1089 {
1090     return m_Where;
1091 }
1092
1093 void ConfigVariable::macroFirstLine_begin(int _iLine)
1094 {
1095     m_FirstMacroLine.push_back(_iLine);
1096 }
1097
1098 void ConfigVariable::macroFirstLine_end()
1099 {
1100     m_FirstMacroLine.pop_back();
1101 }
1102
1103 int ConfigVariable::getMacroFirstLines()
1104 {
1105     if (m_FirstMacroLine.empty())
1106     {
1107         return 1;
1108     }
1109
1110     return m_FirstMacroLine.back();
1111 }
1112
1113 /*
1114 ** \}
1115 */
1116
1117 /*
1118 ** module called with variable by reference
1119 ** \{
1120 */
1121
1122 std::list<std::wstring> ConfigVariable::m_ReferenceModules;
1123
1124 bool ConfigVariable::checkReferenceModule(std::wstring _module)
1125 {
1126     std::list<std::wstring>::iterator it = m_ReferenceModules.begin();
1127     for ( ; it != m_ReferenceModules.end() ; ++it)
1128     {
1129         if (*it == _module)
1130         {
1131             return true;
1132         }
1133     }
1134
1135     return false;
1136 }
1137
1138 void ConfigVariable::addReferenceModule(std::wstring _module)
1139 {
1140     if (checkReferenceModule(_module) == false)
1141     {
1142         m_ReferenceModules.push_back(_module);
1143     }
1144 }
1145
1146 void ConfigVariable::removeReferenceModule(std::wstring _module)
1147 {
1148     if (checkReferenceModule(_module))
1149     {
1150         m_ReferenceModules.remove(_module);
1151     }
1152 }
1153
1154 std::list<std::wstring> ConfigVariable::getReferenceModules()
1155 {
1156     std::list<std::wstring> l(m_ReferenceModules);
1157     return l;
1158 }
1159
1160 /*
1161 ** \}
1162 */
1163
1164 /*
1165 ** analyzer options
1166 ** \{
1167 */
1168
1169 int ConfigVariable::m_analyzerOptions = 0;
1170 void ConfigVariable::setAnalyzerOptions(int _val)
1171 {
1172     m_analyzerOptions = _val;
1173 }
1174
1175 int ConfigVariable::getAnalyzerOptions(void)
1176 {
1177     return m_analyzerOptions;
1178 }
1179
1180 /*
1181 ** \}
1182 */
1183
1184 /*
1185 ** divide by zero
1186 ** \{
1187 */
1188
1189 bool ConfigVariable::m_dividebyzero = false;
1190 void ConfigVariable::setDivideByZero(bool _dividebyzero)
1191 {
1192     m_dividebyzero = _dividebyzero;
1193 }
1194
1195 bool ConfigVariable::isDivideByZero(void)
1196 {
1197     return m_dividebyzero;
1198 }
1199 /*
1200 ** \}
1201 */