exec : management of macro and macrofile.
[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_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 */