58dbf6b3e6798448fd7dae12c1e48a7ad89f1a28
[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 }
21 /*
22 ** Module List
23 ** \{
24 */
25 std::list<std::wstring> ConfigVariable::m_ModuleList;
26
27 void ConfigVariable::setModuleList(std::list<std::wstring>& _pModule_list)
28 {
29     m_ModuleList.clear();
30
31     std::list<std::wstring>::iterator it;
32     for(it = _pModule_list.begin() ; it != _pModule_list.end() ; it++)
33     {
34         m_ModuleList.push_back(*it);
35     }
36 }
37
38 std::list<std::wstring> ConfigVariable::getModuleList()
39 {
40     std::list<std::wstring> moduleList;
41     std::list<std::wstring>::iterator it;
42     for(it = m_ModuleList.begin() ; it != m_ModuleList.end() ; it++)
43     {
44         moduleList.push_back(*it);
45     }
46     return moduleList;
47 }
48 /*
49 ** \}
50 */
51
52 /*
53 ** SCI
54 ** \{
55 */
56 std::wstring ConfigVariable::m_SCIPath;
57
58 void ConfigVariable::setSCIPath(std::wstring& _SCIPath)
59 {
60     m_SCIPath = _SCIPath;
61 }
62
63 std::wstring ConfigVariable::getSCIPath()
64 {
65     return m_SCIPath;
66 }
67
68 /*
69 ** \}
70 */
71
72 /*
73 ** SCIHOME
74 ** \{
75 */
76
77 std::wstring ConfigVariable::m_SCIHOME;
78
79 void ConfigVariable::setSCIHOME(std::wstring& _SCIHOME)
80 {
81     m_SCIHOME = _SCIHOME;
82 }
83
84 std::wstring ConfigVariable::getSCIHOME()
85 {
86     return m_SCIHOME;
87 }
88 /*
89 ** \}
90 */
91
92 /*
93 ** TMPDIR
94 ** \{
95 */
96
97 std::wstring ConfigVariable::m_TMPDIR;
98
99 void ConfigVariable::setTMPDIR(std::wstring& _TMPDIR)
100 {
101     m_TMPDIR = _TMPDIR;
102 }
103
104 std::wstring ConfigVariable::getTMPDIR()
105 {
106     return m_TMPDIR;
107 }
108 /*
109 ** \}
110 */
111
112 /*
113 ** Force Quit
114 ** \{
115 */
116 bool ConfigVariable::m_bForceQuit = false;
117
118 void ConfigVariable::setForceQuit(bool _bForceQuit)
119 {
120     m_bForceQuit = _bForceQuit;
121 }
122
123 bool ConfigVariable::getForceQuit(void)
124 {
125     return m_bForceQuit;
126 }
127 /*
128 ** \}
129 */
130
131 /*
132 ** Exit Status
133 ** \{
134 */
135 int ConfigVariable::m_iExitStatus = 0;
136
137 void ConfigVariable::setExitStatus(int _iExitStatus)
138 {
139     m_iExitStatus = _iExitStatus;
140 }
141
142 int ConfigVariable::getExitStatus(void)
143 {
144     return m_iExitStatus;
145 }
146 /*
147 ** \}
148 */
149
150 /*
151 ** Digit precision, ex format function
152 ** \{
153 */
154
155 int ConfigVariable::m_iFormat = 0;
156
157 void ConfigVariable::setFormat(int _iFormat)
158 {
159     m_iFormat = _iFormat;
160 }
161
162 int ConfigVariable::getFormat(void)
163 {
164     return m_iFormat;
165 }
166
167 /*
168 ** \}
169 */
170
171 /*
172 ** Screen console width
173 ** \{
174 */
175
176 int ConfigVariable::m_iConsoleWidth = 0;
177
178 void ConfigVariable::setConsoleWidth(int _iConsoleWidth)
179 {
180     m_iConsoleWidth = _iConsoleWidth;
181 }
182
183 int ConfigVariable::getConsoleWidth(void)
184 {
185     return m_iConsoleWidth;
186 }
187 /*
188 ** \}
189 */
190
191 /*
192 ** Screen console lines
193 ** \{
194 */
195
196 int ConfigVariable::m_iConsoleLines = 28; //console lines default value
197
198 void ConfigVariable::setConsoleLines(int _iConsoleLines)
199 {
200     m_iConsoleLines = _iConsoleLines;
201 }
202
203 int ConfigVariable::getConsoleLines(void)
204 {
205     return m_iConsoleLines;
206 }
207 /*
208 ** \}
209 */
210
211 /*
212 ** Scilab mode
213 ** \{
214 */
215
216 int ConfigVariable::m_iScilabMode = 0;
217
218 void ConfigVariable::setScilabMode(int _iScilabMode)
219 {
220     m_iScilabMode = _iScilabMode;
221 }
222
223 int ConfigVariable::getScilabMode(void)
224 {
225     return m_iScilabMode;
226 }
227 /*
228 ** \}
229 */
230
231 /*
232 ** Warning Mode
233 ** \{
234 */
235 bool ConfigVariable::m_bWarningMode = true;
236
237 void ConfigVariable::setWarningMode(bool _bWarningMode)
238 {
239     m_bWarningMode = _bWarningMode;
240 }
241
242 bool ConfigVariable::getWarningMode(void)
243 {
244     return m_bWarningMode;
245 }
246 /*
247 ** \}
248 */
249
250 /*
251 ** HOME
252 ** \{
253 */
254
255 std::wstring ConfigVariable::m_HOME;
256
257 void ConfigVariable::setHOME(std::wstring& _HOME)
258 {
259     m_HOME = _HOME;
260 }
261
262 std::wstring ConfigVariable::getHOME()
263 {
264     return m_HOME;
265 }
266 /*
267 ** \}
268 */
269
270 /*
271 ** Clear last error information
272 ** \{
273 */
274 bool ConfigVariable::m_bLastErrorCall = false;
275
276 void ConfigVariable::setLastErrorCall(void)
277 {
278     m_bLastErrorCall = true;
279 }
280
281 void ConfigVariable::clearLastError(void)
282 {
283     if(m_bLastErrorCall == false)
284     {
285         m_wstError          = L"";
286         m_iError            = 0;
287         m_iErrorLine        = 0;
288         m_wstErrorFunction  = L"";
289     }
290     m_bLastErrorCall = false;
291 }
292 /*
293 ** \}
294 */
295
296 /*
297 ** Last Error Message
298 ** \{
299 */
300
301 std::wstring ConfigVariable::m_wstError;
302
303 void ConfigVariable::setLastErrorMessage(std::wstring _wstError)
304 {
305     wchar_t* pwstTemp1 = os_wcsdup(_wstError.c_str());
306     wchar_t* pwstTemp2 = wcssub(pwstTemp1, L"\n", L"");
307     wchar_t* pwstTemp3 = wcssub(pwstTemp2, L"\n", L"");
308     m_wstError = pwstTemp3;
309 }
310
311 std::wstring ConfigVariable::getLastErrorMessage()
312 {
313     return m_wstError;
314 }
315 /*
316 ** \}
317 */
318
319 /*
320 ** Last Error ID
321 ** \{
322 */
323 int ConfigVariable::m_iError = 0;
324
325 void ConfigVariable::setLastErrorNumber(int _iError)
326 {
327     m_iError = _iError;
328 }
329
330 int ConfigVariable::getLastErrorNumber(void)
331 {
332     return m_iError;
333 }
334 /*
335 ** \}
336 */
337
338 /*
339 ** Last Error Line
340 ** \{
341 */
342 int ConfigVariable::m_iErrorLine = 0;
343
344 void ConfigVariable::setLastErrorLine(int _iErrorLine)
345 {
346     m_iErrorLine = _iErrorLine;
347 }
348
349 int ConfigVariable::getLastErrorLine(void)
350 {
351     return m_iErrorLine;
352 }
353 /*
354 ** \}
355 */
356
357 /*
358 ** Last Error Function
359 ** \{
360 */
361
362 std::wstring ConfigVariable::m_wstErrorFunction;
363
364 void ConfigVariable::setLastErrorFunction(std::wstring _wstErrorFunction)
365 {
366     m_wstErrorFunction = _wstErrorFunction;
367 }
368
369 std::wstring ConfigVariable::getLastErrorFunction()
370 {
371     return m_wstErrorFunction;
372 }
373
374 /*
375 ** \}
376 */
377
378 /*
379 ** Prompt Mode
380 ** \{
381 */
382
383 int ConfigVariable::m_iPromptMode = 0;
384 int ConfigVariable::m_iSilentError = 0;
385
386 void ConfigVariable::setPromptMode(int _iPromptMode)
387 {
388     m_iPromptMode = _iPromptMode;
389     if(m_iPromptMode == 0)
390     {
391         //m_iPromptMode = -1;
392     }
393 }
394
395 int ConfigVariable::getPromptMode(void)
396 {
397     return m_iPromptMode;
398 }
399
400 bool ConfigVariable::isPromptShow(void)
401 {
402     if( m_iPromptMode == 0 || 
403         m_iPromptMode == 1 || 
404         m_iPromptMode == 2 || 
405         m_iPromptMode == 3)
406     {
407         return true;
408     }
409     else
410     {
411         return false;
412     }
413 }
414
415 void ConfigVariable::setSilentError(int _iSilentError)
416 {
417     m_iSilentError = _iSilentError;
418 }
419
420 int ConfigVariable::getSilentError(void)
421 {
422     return m_iSilentError;
423 }
424
425 /*
426 ** ThreadList
427 ** \{
428 */
429
430 std::list<types::ThreadId *> ConfigVariable::m_threadList;
431
432 types::ThreadId* ConfigVariable::getLastPausedThread()
433 {
434     std::list<types::ThreadId *>::reverse_iterator it;
435     for(it = m_threadList.rbegin() ; it != m_threadList.rend() ; it++)
436     {
437         if((*it)->getStatus() == types::ThreadId::Paused)
438         {
439             return *it;
440         }
441     }
442     return NULL;
443 }
444
445 types::ThreadId* ConfigVariable::getLastRunningThread()
446 {
447     std::list<types::ThreadId *>::reverse_iterator it;
448     for(it = m_threadList.rbegin() ; it != m_threadList.rend() ; it++)
449     {
450         if((*it)->getStatus() == types::ThreadId::Running)
451         {
452             return *it;
453         }
454     }
455     return NULL;
456 }
457
458 types::ThreadId* ConfigVariable::getLastThread()
459 {
460     return m_threadList.back();
461 }
462
463 types::Cell* ConfigVariable::getAllThreads(void)
464 {
465     int iSize = (int) ConfigVariable::m_threadList.size();
466
467     if (iSize == 0)
468     {
469         return new types::Cell();
470     }
471
472     int i = 0;
473     types::Cell *pcResult = new types::Cell(iSize, 1);
474     std::list<types::ThreadId *>::iterator it;
475
476     for (it = ConfigVariable::m_threadList.begin() ; it != ConfigVariable::m_threadList.end() ; ++it, ++i)
477     {
478         pcResult->set(i, *it);
479     }
480
481     return pcResult;
482 }
483
484
485 void ConfigVariable::addThread(types::ThreadId* _thread)
486 {
487     _thread->IncreaseRef();
488     m_threadList.push_back(_thread);
489 }
490
491
492 types::ThreadId* ConfigVariable::getThread(__threadKey _key)
493 {
494     std::list<types::ThreadId *>::const_iterator it;
495
496     for (it = ConfigVariable::m_threadList.begin() ; it != ConfigVariable::m_threadList.end() ; ++it)
497     {
498         if((*it)->getKey() == _key)
499         {
500             return *it;
501         }
502     }
503     return NULL;
504 }
505
506
507 void ConfigVariable::deleteThread(__threadKey _key)
508 {
509     //for(int i = 0 ; i < m_threadList.size() ; i++)
510     //{
511     //    types::ThreadId* pThread = m_threadList[i];
512     //    if(pThread->getKey() == _key)
513     //    {
514     //        pThread->DecreaseRef();
515     //        if(pThread->isDeletable())
516     //        {
517     //            delete pThread;
518     //            m_threadList.erase(.begin() + i - 1);
519     //        }
520     //    }
521     //}
522     std::list<types::ThreadId *>::iterator it;
523     for (it = ConfigVariable::m_threadList.begin() ; it != ConfigVariable::m_threadList.end() ; ++it)
524     {
525         if((*it)->getKey() == _key)
526         {
527             (*it)->DecreaseRef();
528             if((*it)->isDeletable())
529             {
530                 delete (*it);
531                 (*it) = NULL;
532                 m_threadList.erase(it);
533                 return;
534             }
535         }
536     }
537 }
538
539 /*
540 ** \}
541 */
542
543 /*
544 ** Prompt Mode
545 ** \{
546 */
547
548 int ConfigVariable::m_iPauseLevel = 0;
549
550 void ConfigVariable::IncreasePauseLevel()
551 {
552     m_iPauseLevel++;
553 }
554
555 void ConfigVariable::DecreasePauseLevel()
556 {
557     m_iPauseLevel--;
558 }
559
560 int ConfigVariable::getPauseLevel()
561 {
562     return m_iPauseLevel;
563 }
564
565 /*
566 ** \}
567 */
568
569 /*
570 ** Dynamic Link
571 ** \{
572 */
573
574 std::vector<ConfigVariable::DynamicLibraryStr*> ConfigVariable::m_DynLibList;
575 std::list<ConfigVariable::EntryPointStr*> ConfigVariable::m_EntryPointList;
576
577
578 ConfigVariable::DynamicLibraryStr* ConfigVariable::getNewDynamicLibraryStr()
579 {
580     DynamicLibraryStr* pDL = (DynamicLibraryStr*)MALLOC(sizeof(DynamicLibraryStr));
581     pDL->pwstLibraryName = NULL;
582     pDL->hLib = 0;
583     return pDL;
584 }
585
586 ConfigVariable::EntryPointStr* ConfigVariable::getNewEntryPointStr()
587 {
588     EntryPointStr* pEP = (EntryPointStr*)MALLOC(sizeof(EntryPointStr));
589     pEP->bOK = false;
590     pEP->functionPtr = NULL;
591     pEP->iLibIndex = -1;
592     pEP->pwstEntryPointName = NULL;
593     return pEP;
594 }
595
596 void ConfigVariable::setLibraryName(ConfigVariable::DynamicLibraryStr* _pDynamicLibrary, wchar_t* _pwstLibraryName)
597 {
598     if(_pDynamicLibrary)
599     {
600         if(_pDynamicLibrary->pwstLibraryName)
601         {
602             FREE(_pDynamicLibrary->pwstLibraryName);
603         }
604         _pDynamicLibrary->pwstLibraryName = os_wcsdup(_pwstLibraryName);
605     }
606 }
607
608 void ConfigVariable::setEntryPointName(ConfigVariable::EntryPointStr* _pEntryPoint, wchar_t* _pwstEntryPointName)
609 {
610     if(_pEntryPoint)
611     {
612         if(_pEntryPoint->pwstEntryPointName)
613         {
614             FREE(_pEntryPoint->pwstEntryPointName);
615         }
616         _pEntryPoint->pwstEntryPointName = os_wcsdup(_pwstEntryPointName);;
617     }
618 }
619
620 /* Dynamic libraries functions */
621 int ConfigVariable::addDynamicLibrary(ConfigVariable::DynamicLibraryStr* _pDynamicLibrary)
622 {
623     for(int i = 0 ; i < m_DynLibList.size() ; i++)
624     {
625         if(m_DynLibList[i] == NULL)
626         {
627             m_DynLibList[i] = _pDynamicLibrary;
628             return i;
629         }
630     }
631
632     m_DynLibList.push_back(_pDynamicLibrary);
633     return (int)m_DynLibList.size() - 1;
634 }
635
636 void ConfigVariable::removeDynamicLibrary(int _iDynamicLibraryIndex)
637 {
638     if(_iDynamicLibraryIndex < m_DynLibList.size())
639     {
640         std::list<EntryPointStr*>::const_iterator it;
641         for(it = m_EntryPointList.begin() ; it != m_EntryPointList.end() ; it++)
642         {//clear all entry points linked to removed dynamic library
643             if((*it)->iLibIndex == _iDynamicLibraryIndex)
644             {
645                 m_EntryPointList.remove(*it);
646                 if(m_EntryPointList.size() == 0)
647                 {
648                     break;
649                 }
650                 it = m_EntryPointList.begin();
651             }
652         }
653         //remove dynamic library
654         m_DynLibList[_iDynamicLibraryIndex] = NULL;
655     }
656
657     //clean dynamic library vector
658     while(m_DynLibList.size() != 0 && m_DynLibList.back() == NULL)
659     {
660         m_DynLibList.pop_back();
661     }
662 }
663
664 ConfigVariable::DynamicLibraryStr* ConfigVariable::getDynamicLibrary(int _iDynamicLibraryIndex)
665 {
666     if(_iDynamicLibraryIndex < m_DynLibList.size())
667     {
668         return m_DynLibList[_iDynamicLibraryIndex];
669     }
670     return NULL;
671 }
672
673 bool ConfigVariable::isDynamicLibrary(int _iDynamicLibraryIndex)
674 {
675     if(_iDynamicLibraryIndex < m_DynLibList.size())
676     {
677         if(m_DynLibList[_iDynamicLibraryIndex] != NULL)
678         {
679             return true;
680         }
681     }
682     return false;
683 }
684
685 void ConfigVariable::addEntryPoint(ConfigVariable::EntryPointStr* _pEP)
686 {
687     if(_pEP != NULL)
688     {
689         m_EntryPointList.push_back(_pEP);
690     }
691 }
692
693 ConfigVariable::EntryPointStr* ConfigVariable::getEntryPoint(wchar_t* _pwstEntryPointName, int _iDynamicLibraryIndex)
694 {
695     std::list<EntryPointStr*>::const_iterator it;
696     for(it = m_EntryPointList.begin() ; it != m_EntryPointList.end() ; it++)
697     {
698         //by pass iLibIndex check if _iDynamicLibraryIndex == -1
699         if(_iDynamicLibraryIndex == -1 || (*it)->iLibIndex == _iDynamicLibraryIndex)
700         {
701             if(wcscmp((*it)->pwstEntryPointName, _pwstEntryPointName) == 0)
702             {
703                 return *it;
704             }
705         }
706     }
707     return NULL;
708 }
709
710 std::vector<std::wstring> ConfigVariable::getEntryPointNameList()
711 {
712     std::vector<std::wstring> EntryPointNames;
713     std::list<EntryPointStr*>::const_iterator it;
714     for(it = m_EntryPointList.begin() ; it != m_EntryPointList.end() ; it++)
715     {
716         EntryPointNames.push_back((*it)->pwstEntryPointName);
717     }
718     return EntryPointNames;
719 }
720
721 std::vector<ConfigVariable::DynamicLibraryStr*>* ConfigVariable::getDynamicLibraryList()
722 {
723     return &m_DynLibList;
724 }
725
726 std::list<ConfigVariable::EntryPointStr*>* ConfigVariable::getEntryPointList()
727 {
728     return &m_EntryPointList;
729 }
730
731
732     // Command Line Arguments
733 std::vector<std::wstring> ConfigVariable::m_Args;
734
735 void ConfigVariable::setCommandLineArgs(int _iArgs, char** _pstArgs)
736 {
737     m_Args.clear();
738     for(int i = 0 ; i < _iArgs ; i++)
739     {
740         m_Args.push_back(to_wide_string(_pstArgs[i]));
741     }
742 }
743
744 wchar_t** ConfigVariable::getCommandLineArgs(int* _piCount)
745 {
746     wchar_t** pwstArgs = (wchar_t**)MALLOC(m_Args.size() * sizeof(wchar_t*));
747     for(int i = 0 ; i < m_Args.size() ; i++)
748     {
749         pwstArgs[i] = os_wcsdup(m_Args[i].c_str());
750     }
751
752     *_piCount = (int)m_Args.size();
753     return pwstArgs;
754 }
755
756 /*
757 ** \}
758 */
759
760
761 ///*
762 //** Input Method
763 //** \{
764 //*/
765 //
766 //SCILAB_INPUT_METHOD ConfigVariable::m_pInputMethod = NULL;
767 //
768 //void ConfigVariable::setInputMethod(SCILAB_INPUT_METHOD _pInputMethod)
769 //{
770 //    m_pInputMethod = _pInputMethod;
771 //}
772 //
773 //SCILAB_INPUT_METHOD ConfigVariable::getInputMethod(void)
774 //{
775 //    return m_pInputMethod;
776 //}
777 //
778 ///*
779 //** \}
780 //*/
781 //
782 ///*
783 //** Output Method
784 //** \{
785 //*/
786 //
787 //SCILAB_OUTPUT_METHOD ConfigVariable::m_pOutputMethod = NULL;
788 //
789 //void ConfigVariable::setOutputMethod(SCILAB_OUTPUT_METHOD _pOutputMethod)
790 //{
791 //    m_pOutputMethod = _pOutputMethod;
792 //}
793 //
794 //SCILAB_OUTPUT_METHOD ConfigVariable::getOutputMethod(void)
795 //{
796 //    return m_pOutputMethod;
797 //}
798 //
799 ///*
800 //** \}
801 //*/