delete of opt arguments corrected.
[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
15 extern "C"
16 {
17 #include "strsubst.h"
18 #include "os_wcsdup.h"
19 #include "sci_malloc.h"
20 #include "elem_common.h"
21 }
22 /*
23 ** Module List
24 ** \{
25 */
26 std::list<std::wstring> ConfigVariable::m_ModuleList;
27
28 void ConfigVariable::setModuleList(std::list<std::wstring>& _pModule_list)
29 {
30     m_ModuleList = _pModule_list;
31
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
578 void ConfigVariable::IncreasePauseLevel()
579 {
580     m_iPauseLevel++;
581 }
582
583 void ConfigVariable::DecreasePauseLevel()
584 {
585     m_iPauseLevel--;
586 }
587
588 int ConfigVariable::getPauseLevel()
589 {
590     return m_iPauseLevel;
591 }
592
593 /*
594 ** \}
595 */
596
597 /*
598 ** Dynamic Link
599 ** \{
600 */
601
602 std::vector<ConfigVariable::DynamicLibraryStr*> ConfigVariable::m_DynLibList;
603 std::list<ConfigVariable::EntryPointStr*> ConfigVariable::m_EntryPointList;
604
605
606 ConfigVariable::DynamicLibraryStr* ConfigVariable::getNewDynamicLibraryStr()
607 {
608     DynamicLibraryStr* pDL = (DynamicLibraryStr*)MALLOC(sizeof(DynamicLibraryStr));
609     pDL->pwstLibraryName = NULL;
610     pDL->hLib = 0;
611     return pDL;
612 }
613
614 ConfigVariable::EntryPointStr* ConfigVariable::getNewEntryPointStr()
615 {
616     EntryPointStr* pEP = (EntryPointStr*)MALLOC(sizeof(EntryPointStr));
617     pEP->bOK = false;
618     pEP->functionPtr = NULL;
619     pEP->iLibIndex = -1;
620     pEP->pwstEntryPointName = NULL;
621     return pEP;
622 }
623
624 void ConfigVariable::setLibraryName(ConfigVariable::DynamicLibraryStr* _pDynamicLibrary, wchar_t* _pwstLibraryName)
625 {
626     if (_pDynamicLibrary)
627     {
628         if (_pDynamicLibrary->pwstLibraryName)
629         {
630             FREE(_pDynamicLibrary->pwstLibraryName);
631         }
632         _pDynamicLibrary->pwstLibraryName = os_wcsdup(_pwstLibraryName);
633     }
634 }
635
636 void ConfigVariable::setEntryPointName(ConfigVariable::EntryPointStr* _pEntryPoint, wchar_t* _pwstEntryPointName)
637 {
638     if (_pEntryPoint)
639     {
640         if (_pEntryPoint->pwstEntryPointName)
641         {
642             FREE(_pEntryPoint->pwstEntryPointName);
643         }
644         _pEntryPoint->pwstEntryPointName = os_wcsdup(_pwstEntryPointName);;
645     }
646 }
647
648 /* Dynamic libraries functions */
649 int ConfigVariable::addDynamicLibrary(ConfigVariable::DynamicLibraryStr* _pDynamicLibrary)
650 {
651     for (int i = 0 ; i < m_DynLibList.size() ; i++)
652     {
653         if (m_DynLibList[i] == NULL)
654         {
655             m_DynLibList[i] = _pDynamicLibrary;
656             return i;
657         }
658     }
659
660     m_DynLibList.push_back(_pDynamicLibrary);
661     return (int)m_DynLibList.size() - 1;
662 }
663
664 void ConfigVariable::removeDynamicLibrary(int _iDynamicLibraryIndex)
665 {
666     if (_iDynamicLibraryIndex < m_DynLibList.size())
667     {
668         std::list<EntryPointStr*>::const_iterator it;
669         for (it = m_EntryPointList.begin() ; it != m_EntryPointList.end() ; it++)
670         {
671             //clear all entry points linked to removed dynamic library
672             if ((*it)->iLibIndex == _iDynamicLibraryIndex)
673             {
674                 m_EntryPointList.remove(*it);
675                 if (m_EntryPointList.size() == 0)
676                 {
677                     break;
678                 }
679                 it = m_EntryPointList.begin();
680             }
681         }
682         //remove dynamic library
683         m_DynLibList[_iDynamicLibraryIndex] = NULL;
684     }
685
686     //clean dynamic library vector
687     while (m_DynLibList.size() != 0 && m_DynLibList.back() == NULL)
688     {
689         m_DynLibList.pop_back();
690     }
691 }
692
693 ConfigVariable::DynamicLibraryStr* ConfigVariable::getDynamicLibrary(int _iDynamicLibraryIndex)
694 {
695     if (_iDynamicLibraryIndex < m_DynLibList.size())
696     {
697         return m_DynLibList[_iDynamicLibraryIndex];
698     }
699     return NULL;
700 }
701
702 bool ConfigVariable::isDynamicLibrary(int _iDynamicLibraryIndex)
703 {
704     if (_iDynamicLibraryIndex < m_DynLibList.size())
705     {
706         if (m_DynLibList[_iDynamicLibraryIndex] != NULL)
707         {
708             return true;
709         }
710     }
711     return false;
712 }
713
714 void ConfigVariable::addEntryPoint(ConfigVariable::EntryPointStr* _pEP)
715 {
716     if (_pEP != NULL)
717     {
718         m_EntryPointList.push_back(_pEP);
719     }
720 }
721
722 ConfigVariable::EntryPointStr* ConfigVariable::getEntryPoint(wchar_t* _pwstEntryPointName, int _iDynamicLibraryIndex)
723 {
724     std::list<EntryPointStr*>::const_iterator it;
725     for (it = m_EntryPointList.begin() ; it != m_EntryPointList.end() ; it++)
726     {
727         //by pass iLibIndex check if _iDynamicLibraryIndex == -1
728         if (_iDynamicLibraryIndex == -1 || (*it)->iLibIndex == _iDynamicLibraryIndex)
729         {
730             if (wcscmp((*it)->pwstEntryPointName, _pwstEntryPointName) == 0)
731             {
732                 return *it;
733             }
734         }
735     }
736     return NULL;
737 }
738
739 std::vector<std::wstring> ConfigVariable::getEntryPointNameList()
740 {
741     std::vector<std::wstring> EntryPointNames;
742     std::list<EntryPointStr*>::const_iterator it;
743     for (it = m_EntryPointList.begin() ; it != m_EntryPointList.end() ; it++)
744     {
745         EntryPointNames.push_back((*it)->pwstEntryPointName);
746     }
747     return EntryPointNames;
748 }
749
750 std::vector<ConfigVariable::DynamicLibraryStr*>* ConfigVariable::getDynamicLibraryList()
751 {
752     return &m_DynLibList;
753 }
754
755 std::list<ConfigVariable::EntryPointStr*>* ConfigVariable::getEntryPointList()
756 {
757     return &m_EntryPointList;
758 }
759
760 //dynamic modules
761 std::map<std::wstring, DynLibHandle> ConfigVariable::m_DynModules;
762
763 void ConfigVariable::addDynModule(std::wstring _name, DynLibHandle _lib)
764 {
765     m_DynModules[_name] = _lib;
766 }
767
768 void ConfigVariable::removeDynModule(std::wstring _name)
769 {
770     m_DynModules.erase(_name);
771 }
772
773 DynLibHandle ConfigVariable::getDynModule(std::wstring _name)
774 {
775     std::map<std::wstring, DynLibHandle>::iterator it;
776     it = m_DynModules.find(_name);
777     if (it != m_DynModules.end())
778     {
779         return it->second;
780     }
781
782     return 0;
783 }
784
785 int ConfigVariable::getDynModuleCount()
786 {
787     return (int)m_DynModules.size();
788 }
789
790 DynLibHandle* ConfigVariable::getAllDynModule()
791 {
792     DynLibHandle* moduleList = new DynLibHandle[m_DynModules.size()];
793     std::map<std::wstring, DynLibHandle>::iterator it = m_DynModules.begin();
794     std::map<std::wstring, DynLibHandle>::iterator itEnd = m_DynModules.end();
795     for (int i = 0; it != itEnd ; ++it, ++i)
796     {
797         moduleList[i] = it->second;
798     }
799
800     return moduleList;
801 }
802
803 void ConfigVariable::cleanDynModule()
804 {
805     m_DynModules.clear();
806 }
807
808 // Command Line Arguments
809 std::vector<std::wstring> ConfigVariable::m_Args;
810 bool ConfigVariable::m_bTimed = false;
811 bool ConfigVariable::m_bSerialize = false;
812
813 void ConfigVariable::setCommandLineArgs(int _iArgs, char** _pstArgs)
814 {
815     m_Args.clear();
816     for (int i = 0 ; i < _iArgs ; i++)
817     {
818         wchar_t * ws = to_wide_string(_pstArgs[i]);
819         m_Args.push_back(ws);
820         FREE(ws);
821     }
822 }
823
824 wchar_t** ConfigVariable::getCommandLineArgs(int* _piCount)
825 {
826     wchar_t** pwstArgs = (wchar_t**)MALLOC(m_Args.size() * sizeof(wchar_t*));
827     for (int i = 0 ; i < m_Args.size() ; i++)
828     {
829         pwstArgs[i] = os_wcsdup(m_Args[i].c_str());
830     }
831
832     *_piCount = (int)m_Args.size();
833     return pwstArgs;
834 }
835
836 bool ConfigVariable::getTimed()
837 {
838     return m_bTimed;
839 }
840
841 void ConfigVariable::setTimed(bool _bTimed)
842 {
843     m_bTimed = _bTimed;
844 }
845
846 bool ConfigVariable::getSerialize()
847 {
848     return m_bSerialize;
849 }
850
851 void ConfigVariable::setSerialize(bool _bSerialize)
852 {
853     m_bSerialize = _bSerialize;
854 }
855
856 /*
857 ** \}
858 */
859
860 ///*
861 //** Input Method
862 //** \{
863 //*/
864 //
865 //SCILAB_INPUT_METHOD ConfigVariable::m_pInputMethod = NULL;
866 //
867 //void ConfigVariable::setInputMethod(SCILAB_INPUT_METHOD _pInputMethod)
868 //{
869 //    m_pInputMethod = _pInputMethod;
870 //}
871 //
872 //SCILAB_INPUT_METHOD ConfigVariable::getInputMethod(void)
873 //{
874 //    return m_pInputMethod;
875 //}
876 //
877 ///*
878 //** \}
879 //*/
880 //
881 ///*
882 //** Output Method
883 //** \{
884 //*/
885 //
886 //SCILAB_OUTPUT_METHOD ConfigVariable::m_pOutputMethod = NULL;
887 //
888 //void ConfigVariable::setOutputMethod(SCILAB_OUTPUT_METHOD _pOutputMethod)
889 //{
890 //    m_pOutputMethod = _pOutputMethod;
891 //}
892 //
893 //SCILAB_OUTPUT_METHOD ConfigVariable::getOutputMethod(void)
894 //{
895 //    return m_pOutputMethod;
896 //}
897 //
898 ///*
899 //** \}
900 //*/
901
902 /*
903 ** schur function
904 ** \{
905 */
906
907 types::Callable* ConfigVariable::m_schurFunction = NULL;
908
909 void ConfigVariable::setSchurFunction(types::Callable* _schurFunction)
910 {
911     m_schurFunction = _schurFunction;
912 }
913
914 types::Callable* ConfigVariable::getSchurFunction()
915 {
916     return m_schurFunction;
917 }
918
919 /*
920 ** \}
921 */
922
923 /*
924 ** grand (module randlib)
925 ** \{
926 */
927
928 int ConfigVariable::m_currentBaseGen = 0;
929 int ConfigVariable::m_currentClcg4   = 0;
930
931 void ConfigVariable::setCurrentBaseGen(int _gen)
932 {
933     m_currentBaseGen = _gen;
934 }
935
936 int ConfigVariable::getCurrentBaseGen()
937 {
938     return m_currentBaseGen;
939 }
940
941 void ConfigVariable::setCurrentClcg4(int _clcg4)
942 {
943     m_currentClcg4 = _clcg4;
944 }
945
946 int ConfigVariable::getCurrentClcg4()
947 {
948     return m_currentClcg4;
949 }
950 /*
951 ** \}
952 */
953
954 /*
955 ** Start finish flag
956 ** \{
957 */
958 bool ConfigVariable::m_bStartFinished = false;
959
960 void ConfigVariable::setStartFinished(bool _bStartFinished)
961 {
962     m_bStartFinished = _bStartFinished;
963 }
964
965 bool ConfigVariable::getStartFinished()
966 {
967     return m_bStartFinished;
968 }
969 /*
970 ** \}
971 */
972
973 /*
974 ** ieee
975 ** \{
976 */
977 int ConfigVariable::m_iIeee = 0;
978
979 void ConfigVariable::setIeee(int _iIeee)
980 {
981     m_iIeee = _iIeee;
982 }
983
984 int ConfigVariable::getIeee()
985 {
986     return m_iIeee;
987 }
988 /*
989 ** \}
990 */
991
992 /*
993 ** simp Mode
994 ** \{
995 */
996 int ConfigVariable::m_iSimpMode = 1;
997
998 void ConfigVariable::setSimpMode(int _iSimpMode)
999 {
1000     m_iSimpMode = _iSimpMode;
1001 }
1002
1003 int ConfigVariable::getSimpMode()
1004 {
1005     return m_iSimpMode;
1006 }
1007 /*
1008 ** \}
1009 */
1010
1011 /*
1012 ** funcprot Mode
1013 ** \{
1014 */
1015 int ConfigVariable::m_iFuncprot = 1;
1016
1017 void ConfigVariable::setFuncprot(int _iFuncprot)
1018 {
1019     m_iFuncprot = _iFuncprot;
1020 }
1021
1022 int ConfigVariable::getFuncprot()
1023 {
1024     return m_iFuncprot;
1025 }
1026 /*
1027 ** \}
1028 */
1029
1030 /*
1031 ** where
1032 ** \{
1033 */
1034
1035 std::list< std::pair<int, std::wstring> > ConfigVariable::m_Where;
1036 std::list<int> ConfigVariable::m_FirstMacroLine;
1037 void ConfigVariable::where_begin(int _iLineNum, std::wstring _wstName)
1038 {
1039     m_Where.push_front(std::pair<int, std::wstring>(_iLineNum, _wstName));
1040 }
1041
1042 void ConfigVariable::where_end()
1043 {
1044     if (m_Where.empty() == false)
1045     {
1046         m_Where.pop_front();
1047     }
1048 }
1049
1050 std::list< std::pair<int, std::wstring> >& ConfigVariable::getWhere()
1051 {
1052     return m_Where;
1053 }
1054
1055 void ConfigVariable::macroFirstLine_begin(int _iLine)
1056 {
1057     m_FirstMacroLine.push_back(_iLine);
1058 }
1059
1060 void ConfigVariable::macroFirstLine_end()
1061 {
1062     m_FirstMacroLine.pop_back();
1063 }
1064
1065 int ConfigVariable::getMacroFirstLines()
1066 {
1067     if (m_FirstMacroLine.empty())
1068     {
1069         return 1;
1070     }
1071
1072     return m_FirstMacroLine.back();
1073 }
1074
1075 /*
1076 ** \}
1077 */
1078
1079 /*
1080 ** module called with variable by reference
1081 ** \{
1082 */
1083
1084 std::list<std::wstring> ConfigVariable::m_ReferenceModules;
1085
1086 bool ConfigVariable::checkReferenceModule(std::wstring _module)
1087 {
1088     std::list<std::wstring>::iterator it = m_ReferenceModules.begin();
1089     for ( ; it != m_ReferenceModules.end() ; ++it)
1090     {
1091         if (*it == _module)
1092         {
1093             return true;
1094         }
1095     }
1096
1097     return false;
1098 }
1099
1100 void ConfigVariable::addReferenceModule(std::wstring _module)
1101 {
1102     if (checkReferenceModule(_module) == false)
1103     {
1104         m_ReferenceModules.push_back(_module);
1105     }
1106 }
1107
1108 void ConfigVariable::removeReferenceModule(std::wstring _module)
1109 {
1110     if (checkReferenceModule(_module))
1111     {
1112         m_ReferenceModules.remove(_module);
1113     }
1114 }
1115
1116 std::list<std::wstring> ConfigVariable::getReferenceModules()
1117 {
1118     std::list<std::wstring> l(m_ReferenceModules);
1119     return l;
1120 }