where : value returned was inverted.
[scilab.git] / scilab / modules / system_env / src / cpp / 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 "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                 delete (*it);
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
761 // Command Line Arguments
762 std::vector<std::wstring> ConfigVariable::m_Args;
763
764 void ConfigVariable::setCommandLineArgs(int _iArgs, char** _pstArgs)
765 {
766     m_Args.clear();
767     for (int i = 0 ; i < _iArgs ; i++)
768     {
769         wchar_t * ws = to_wide_string(_pstArgs[i]);
770         m_Args.push_back(ws);
771         FREE(ws);
772     }
773 }
774
775 wchar_t** ConfigVariable::getCommandLineArgs(int* _piCount)
776 {
777     wchar_t** pwstArgs = (wchar_t**)MALLOC(m_Args.size() * sizeof(wchar_t*));
778     for (int i = 0 ; i < m_Args.size() ; i++)
779     {
780         pwstArgs[i] = os_wcsdup(m_Args[i].c_str());
781     }
782
783     *_piCount = (int)m_Args.size();
784     return pwstArgs;
785 }
786
787 /*
788 ** \}
789 */
790
791 ///*
792 //** Input Method
793 //** \{
794 //*/
795 //
796 //SCILAB_INPUT_METHOD ConfigVariable::m_pInputMethod = NULL;
797 //
798 //void ConfigVariable::setInputMethod(SCILAB_INPUT_METHOD _pInputMethod)
799 //{
800 //    m_pInputMethod = _pInputMethod;
801 //}
802 //
803 //SCILAB_INPUT_METHOD ConfigVariable::getInputMethod(void)
804 //{
805 //    return m_pInputMethod;
806 //}
807 //
808 ///*
809 //** \}
810 //*/
811 //
812 ///*
813 //** Output Method
814 //** \{
815 //*/
816 //
817 //SCILAB_OUTPUT_METHOD ConfigVariable::m_pOutputMethod = NULL;
818 //
819 //void ConfigVariable::setOutputMethod(SCILAB_OUTPUT_METHOD _pOutputMethod)
820 //{
821 //    m_pOutputMethod = _pOutputMethod;
822 //}
823 //
824 //SCILAB_OUTPUT_METHOD ConfigVariable::getOutputMethod(void)
825 //{
826 //    return m_pOutputMethod;
827 //}
828 //
829 ///*
830 //** \}
831 //*/
832
833 /*
834 ** schur function
835 ** \{
836 */
837
838 types::Callable* ConfigVariable::m_schurFunction = NULL;
839
840 void ConfigVariable::setSchurFunction(types::Callable* _schurFunction)
841 {
842     m_schurFunction = _schurFunction;
843 }
844
845 types::Callable* ConfigVariable::getSchurFunction()
846 {
847     return m_schurFunction;
848 }
849
850 /*
851 ** \}
852 */
853
854 /*
855 ** grand (module randlib)
856 ** \{
857 */
858
859 int ConfigVariable::m_currentBaseGen = 0;
860 int ConfigVariable::m_currentClcg4   = 0;
861
862 void ConfigVariable::setCurrentBaseGen(int _gen)
863 {
864     m_currentBaseGen = _gen;
865 }
866
867 int ConfigVariable::getCurrentBaseGen()
868 {
869     return m_currentBaseGen;
870 }
871
872 void ConfigVariable::setCurrentClcg4(int _clcg4)
873 {
874     m_currentClcg4 = _clcg4;
875 }
876
877 int ConfigVariable::getCurrentClcg4()
878 {
879     return m_currentClcg4;
880 }
881 /*
882 ** \}
883 */
884
885 /*
886 ** Start finish flag
887 ** \{
888 */
889 bool ConfigVariable::m_bStartFinished = false;
890
891 void ConfigVariable::setStartFinished(bool _bStartFinished)
892 {
893     m_bStartFinished = _bStartFinished;
894 }
895
896 bool ConfigVariable::getStartFinished()
897 {
898     return m_bStartFinished;
899 }
900 /*
901 ** \}
902 */
903
904 /*
905 ** ieee
906 ** \{
907 */
908 int ConfigVariable::m_iIeee = 0;
909
910 void ConfigVariable::setIeee(int _iIeee)
911 {
912     m_iIeee = _iIeee;
913 }
914
915 int ConfigVariable::getIeee()
916 {
917     return m_iIeee;
918 }
919 /*
920 ** \}
921 */
922
923 /*
924 ** simp Mode
925 ** \{
926 */
927 int ConfigVariable::m_iSimpMode = 1;
928
929 void ConfigVariable::setSimpMode(int _iSimpMode)
930 {
931     m_iSimpMode = _iSimpMode;
932 }
933
934 int ConfigVariable::getSimpMode()
935 {
936     return m_iSimpMode;
937 }
938 /*
939 ** \}
940 */
941
942 /*
943 ** funcprot Mode
944 ** \{
945 */
946 int ConfigVariable::m_iFuncprot = 1;
947
948 void ConfigVariable::setFuncprot(int _iFuncprot)
949 {
950     m_iFuncprot = _iFuncprot;
951 }
952
953 int ConfigVariable::getFuncprot()
954 {
955     return m_iFuncprot;
956 }
957 /*
958 ** \}
959 */
960
961 /*
962 ** where
963 ** \{
964 */
965
966 std::list< std::pair<int, std::wstring> > ConfigVariable::m_Where;
967 std::list<int> ConfigVariable::m_FirstMacroLine;
968 void ConfigVariable::where_begin(int _iLineNum, std::wstring _wstName)
969 {
970     m_Where.push_front(std::pair<int, std::wstring>(_iLineNum, _wstName));
971 }
972
973 void ConfigVariable::where_end()
974 {
975     if (m_Where.empty() == false)
976     {
977         m_Where.pop_front();
978     }
979 }
980
981 std::list< std::pair<int, std::wstring> >& ConfigVariable::getWhere()
982 {
983     return m_Where;
984 }
985
986 void ConfigVariable::macroFirstLine_begin(int _iLine)
987 {
988     m_FirstMacroLine.push_back(_iLine);
989 }
990
991 void ConfigVariable::macroFirstLine_end()
992 {
993     m_FirstMacroLine.pop_back();
994 }
995
996 int ConfigVariable::getMacroFirstLines()
997 {
998     if (m_FirstMacroLine.empty())
999     {
1000         return 1;
1001     }
1002
1003     return m_FirstMacroLine.back();
1004 }
1005
1006 /*
1007 ** \}
1008 */
1009
1010 /*
1011 ** module called with variable by reference
1012 ** \{
1013 */
1014
1015 std::list<std::wstring> ConfigVariable::m_ReferenceModules;
1016
1017 bool ConfigVariable::checkReferenceModule(std::wstring _module)
1018 {
1019     std::list<std::wstring>::iterator it = m_ReferenceModules.begin();
1020     for ( ; it != m_ReferenceModules.end() ; ++it)
1021     {
1022         if (*it == _module)
1023         {
1024             return true;
1025         }
1026     }
1027
1028     return false;
1029 }
1030
1031 void ConfigVariable::addReferenceModule(std::wstring _module)
1032 {
1033     if (checkReferenceModule(_module) == false)
1034     {
1035         m_ReferenceModules.push_back(_module);
1036     }
1037 }
1038
1039 void ConfigVariable::removeReferenceModule(std::wstring _module)
1040 {
1041     if (checkReferenceModule(_module))
1042     {
1043         m_ReferenceModules.remove(_module);
1044     }
1045 }
1046
1047 std::list<std::wstring> ConfigVariable::getReferenceModules()
1048 {
1049     std::list<std::wstring> l(m_ReferenceModules);
1050     return l;
1051 }