Add c interface to manage dyn link function via index
[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 dynlib_ptr ConfigVariable::getEntryPointFromPosition(int position)
767 {
768     std::list<EntryPointStr*>::const_iterator it;
769     int pos = 0;
770     for (it = m_EntryPointList.begin(); it != m_EntryPointList.end(); it++, ++pos)
771     {
772         if (pos == position)
773         {
774             return (*it)->functionPtr;
775         }
776     }
777     return NULL;
778 }
779
780 int ConfigVariable::getEntryPointPosition(wchar_t* _pwstEntryPointName, int _iDynamicLibraryIndex)
781 {
782     int pos = 0;
783     std::list<EntryPointStr*>::const_iterator it;
784     for (it = m_EntryPointList.begin(); it != m_EntryPointList.end(); it++, ++pos)
785     {
786         //by pass iLibIndex check if _iDynamicLibraryIndex == -1
787         if (_iDynamicLibraryIndex == -1 || (*it)->iLibIndex == _iDynamicLibraryIndex)
788         {
789             if (wcscmp((*it)->pwstEntryPointName, _pwstEntryPointName) == 0)
790             {
791                 return pos;
792             }
793         }
794     }
795     return -1;
796 }
797
798 std::vector<std::wstring> ConfigVariable::getEntryPointNameList()
799 {
800     std::vector<std::wstring> EntryPointNames;
801     std::list<EntryPointStr*>::const_iterator it;
802     for (it = m_EntryPointList.begin() ; it != m_EntryPointList.end() ; it++)
803     {
804         EntryPointNames.push_back((*it)->pwstEntryPointName);
805     }
806     return EntryPointNames;
807 }
808
809 std::vector<ConfigVariable::DynamicLibraryStr*>* ConfigVariable::getDynamicLibraryList()
810 {
811     return &m_DynLibList;
812 }
813
814 std::list<ConfigVariable::EntryPointStr*>* ConfigVariable::getEntryPointList()
815 {
816     return &m_EntryPointList;
817 }
818
819 //dynamic modules
820 std::map<std::wstring, DynLibHandle> ConfigVariable::m_DynModules;
821
822 void ConfigVariable::addDynModule(std::wstring _name, DynLibHandle _lib)
823 {
824     m_DynModules[_name] = _lib;
825 }
826
827 void ConfigVariable::removeDynModule(std::wstring _name)
828 {
829     m_DynModules.erase(_name);
830 }
831
832 DynLibHandle ConfigVariable::getDynModule(std::wstring _name)
833 {
834     std::map<std::wstring, DynLibHandle>::iterator it;
835     it = m_DynModules.find(_name);
836     if (it != m_DynModules.end())
837     {
838         return it->second;
839     }
840
841     return 0;
842 }
843
844 int ConfigVariable::getDynModuleCount()
845 {
846     return (int)m_DynModules.size();
847 }
848
849 DynLibHandle* ConfigVariable::getAllDynModule()
850 {
851     DynLibHandle* moduleList = new DynLibHandle[m_DynModules.size()];
852     std::map<std::wstring, DynLibHandle>::iterator it = m_DynModules.begin();
853     std::map<std::wstring, DynLibHandle>::iterator itEnd = m_DynModules.end();
854     for (int i = 0; it != itEnd ; ++it, ++i)
855     {
856         moduleList[i] = it->second;
857     }
858
859     return moduleList;
860 }
861
862 void ConfigVariable::cleanDynModule()
863 {
864     m_DynModules.clear();
865 }
866
867 // Command Line Arguments
868 std::vector<std::wstring> ConfigVariable::m_Args;
869 bool ConfigVariable::m_bTimed = false;
870 bool ConfigVariable::m_bSerialize = false;
871
872 void ConfigVariable::setCommandLineArgs(int _iArgs, char** _pstArgs)
873 {
874     m_Args.clear();
875     for (int i = 0 ; i < _iArgs ; i++)
876     {
877         wchar_t * ws = to_wide_string(_pstArgs[i]);
878         m_Args.push_back(ws);
879         FREE(ws);
880     }
881 }
882
883 wchar_t** ConfigVariable::getCommandLineArgs(int* _piCount)
884 {
885     wchar_t** pwstArgs = (wchar_t**)MALLOC(m_Args.size() * sizeof(wchar_t*));
886     for (int i = 0 ; i < (int)m_Args.size() ; i++)
887     {
888         pwstArgs[i] = os_wcsdup(m_Args[i].c_str());
889     }
890
891     *_piCount = (int)m_Args.size();
892     return pwstArgs;
893 }
894
895 bool ConfigVariable::getTimed()
896 {
897     return m_bTimed;
898 }
899
900 void ConfigVariable::setTimed(bool _bTimed)
901 {
902     m_bTimed = _bTimed;
903 }
904
905 bool ConfigVariable::getSerialize()
906 {
907     return m_bSerialize;
908 }
909
910 void ConfigVariable::setSerialize(bool _bSerialize)
911 {
912     m_bSerialize = _bSerialize;
913 }
914
915 /*
916 ** \}
917 */
918
919 ///*
920 //** Input Method
921 //** \{
922 //*/
923 //
924 //SCILAB_INPUT_METHOD ConfigVariable::m_pInputMethod = NULL;
925 //
926 //void ConfigVariable::setInputMethod(SCILAB_INPUT_METHOD _pInputMethod)
927 //{
928 //    m_pInputMethod = _pInputMethod;
929 //}
930 //
931 //SCILAB_INPUT_METHOD ConfigVariable::getInputMethod(void)
932 //{
933 //    return m_pInputMethod;
934 //}
935 //
936 ///*
937 //** \}
938 //*/
939 //
940 ///*
941 //** Output Method
942 //** \{
943 //*/
944 //
945 //SCILAB_OUTPUT_METHOD ConfigVariable::m_pOutputMethod = NULL;
946 //
947 //void ConfigVariable::setOutputMethod(SCILAB_OUTPUT_METHOD _pOutputMethod)
948 //{
949 //    m_pOutputMethod = _pOutputMethod;
950 //}
951 //
952 //SCILAB_OUTPUT_METHOD ConfigVariable::getOutputMethod(void)
953 //{
954 //    return m_pOutputMethod;
955 //}
956 //
957 ///*
958 //** \}
959 //*/
960
961 /*
962 ** schur function
963 ** \{
964 */
965
966 types::Callable* ConfigVariable::m_schurFunction = NULL;
967
968 void ConfigVariable::setSchurFunction(types::Callable* _schurFunction)
969 {
970     m_schurFunction = _schurFunction;
971 }
972
973 types::Callable* ConfigVariable::getSchurFunction()
974 {
975     return m_schurFunction;
976 }
977
978 /*
979 ** \}
980 */
981
982 /*
983 ** grand (module randlib)
984 ** \{
985 */
986
987 int ConfigVariable::m_currentBaseGen = 0;
988 int ConfigVariable::m_currentClcg4   = 0;
989
990 void ConfigVariable::setCurrentBaseGen(int _gen)
991 {
992     m_currentBaseGen = _gen;
993 }
994
995 int ConfigVariable::getCurrentBaseGen()
996 {
997     return m_currentBaseGen;
998 }
999
1000 void ConfigVariable::setCurrentClcg4(int _clcg4)
1001 {
1002     m_currentClcg4 = _clcg4;
1003 }
1004
1005 int ConfigVariable::getCurrentClcg4()
1006 {
1007     return m_currentClcg4;
1008 }
1009 /*
1010 ** \}
1011 */
1012
1013 /*
1014 ** Start finish flag
1015 ** \{
1016 */
1017 bool ConfigVariable::m_bStartProcessing = false;
1018 bool ConfigVariable::m_bEndProcessing = false;
1019
1020 void ConfigVariable::setStartProcessing(bool _bStartProcessing)
1021 {
1022     m_bStartProcessing = _bStartProcessing;
1023 }
1024
1025 bool ConfigVariable::getStartProcessing()
1026 {
1027     return m_bStartProcessing;
1028 }
1029
1030 void ConfigVariable::setEndProcessing(bool _bEndProcessing)
1031 {
1032     m_bEndProcessing = _bEndProcessing;
1033 }
1034
1035 bool ConfigVariable::getEndProcessing()
1036 {
1037     return m_bEndProcessing;
1038 }
1039 /*
1040 ** \}
1041 */
1042
1043 /*
1044 ** ieee
1045 ** \{
1046 */
1047 int ConfigVariable::m_iIeee = 0;
1048
1049 void ConfigVariable::setIeee(int _iIeee)
1050 {
1051     m_iIeee = _iIeee;
1052 }
1053
1054 int ConfigVariable::getIeee()
1055 {
1056     return m_iIeee;
1057 }
1058 /*
1059 ** \}
1060 */
1061
1062 /*
1063 ** simp Mode
1064 ** \{
1065 */
1066 int ConfigVariable::m_iSimpMode = 1;
1067
1068 void ConfigVariable::setSimpMode(int _iSimpMode)
1069 {
1070     m_iSimpMode = _iSimpMode;
1071 }
1072
1073 int ConfigVariable::getSimpMode()
1074 {
1075     return m_iSimpMode;
1076 }
1077 /*
1078 ** \}
1079 */
1080
1081 /*
1082 ** funcprot Mode
1083 ** \{
1084 */
1085 int ConfigVariable::m_iFuncprot = 1;
1086
1087 void ConfigVariable::setFuncprot(int _iFuncprot)
1088 {
1089     m_iFuncprot = _iFuncprot;
1090 }
1091
1092 int ConfigVariable::getFuncprot()
1093 {
1094     return m_iFuncprot;
1095 }
1096 /*
1097 ** \}
1098 */
1099
1100 /*
1101 ** where
1102 ** \{
1103 */
1104
1105 std::list< std::pair<int, std::wstring> > ConfigVariable::m_Where;
1106 std::list<int> ConfigVariable::m_FirstMacroLine;
1107 void ConfigVariable::where_begin(int _iLineNum, std::wstring _wstName)
1108 {
1109     m_Where.push_front(std::pair<int, std::wstring>(_iLineNum, _wstName));
1110 }
1111
1112 void ConfigVariable::where_end()
1113 {
1114     if (m_Where.empty() == false)
1115     {
1116         m_Where.pop_front();
1117     }
1118 }
1119
1120 std::list< std::pair<int, std::wstring> >& ConfigVariable::getWhere()
1121 {
1122     return m_Where;
1123 }
1124
1125 void ConfigVariable::macroFirstLine_begin(int _iLine)
1126 {
1127     m_FirstMacroLine.push_back(_iLine);
1128 }
1129
1130 void ConfigVariable::macroFirstLine_end()
1131 {
1132     m_FirstMacroLine.pop_back();
1133 }
1134
1135 int ConfigVariable::getMacroFirstLines()
1136 {
1137     if (m_FirstMacroLine.empty())
1138     {
1139         return 1;
1140     }
1141
1142     return m_FirstMacroLine.back();
1143 }
1144
1145 /*
1146 ** \}
1147 */
1148
1149 /*
1150 ** module called with variable by reference
1151 ** \{
1152 */
1153
1154 std::list<std::wstring> ConfigVariable::m_ReferenceModules;
1155
1156 bool ConfigVariable::checkReferenceModule(std::wstring _module)
1157 {
1158     std::list<std::wstring>::iterator it = m_ReferenceModules.begin();
1159     for ( ; it != m_ReferenceModules.end() ; ++it)
1160     {
1161         if (*it == _module)
1162         {
1163             return true;
1164         }
1165     }
1166
1167     return false;
1168 }
1169
1170 void ConfigVariable::addReferenceModule(std::wstring _module)
1171 {
1172     if (checkReferenceModule(_module) == false)
1173     {
1174         m_ReferenceModules.push_back(_module);
1175     }
1176 }
1177
1178 void ConfigVariable::removeReferenceModule(std::wstring _module)
1179 {
1180     if (checkReferenceModule(_module))
1181     {
1182         m_ReferenceModules.remove(_module);
1183     }
1184 }
1185
1186 std::list<std::wstring> ConfigVariable::getReferenceModules()
1187 {
1188     std::list<std::wstring> l(m_ReferenceModules);
1189     return l;
1190 }
1191
1192 /*
1193 ** \}
1194 */
1195
1196 /*
1197 ** analyzer options
1198 ** \{
1199 */
1200
1201 int ConfigVariable::m_analyzerOptions = 0;
1202 void ConfigVariable::setAnalyzerOptions(int _val)
1203 {
1204     m_analyzerOptions = _val;
1205 }
1206
1207 int ConfigVariable::getAnalyzerOptions(void)
1208 {
1209     return m_analyzerOptions;
1210 }
1211
1212 /*
1213 ** \}
1214 */
1215
1216 /*
1217 ** divide by zero
1218 ** \{
1219 */
1220
1221 bool ConfigVariable::m_dividebyzero = false;
1222 void ConfigVariable::setDivideByZero(bool _dividebyzero)
1223 {
1224     m_dividebyzero = _dividebyzero;
1225 }
1226
1227 bool ConfigVariable::isDivideByZero(void)
1228 {
1229     return m_dividebyzero;
1230 }
1231 /*
1232 ** \}
1233 */