* bug 16280 fixed: allow users to use mode() inside a macro.
[scilab.git] / scilab / modules / ast / includes / system_env / configvariable.hxx
1 /*
2 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 *  Copyright (C) 2008-2008 - DIGITEO - Antoine ELIAS
4 *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13 *
14 */
15
16 #ifndef __CONFIGVARIABLE_HXX__
17 #define __CONFIGVARIABLE_HXX__
18
19 //disable warnings about exports STL items
20 #ifdef _MSC_VER
21 #pragma warning (disable : 4251)
22 #endif
23
24 #include <vector>
25 #include <list>
26 #include <map>
27 #include <string>
28 #include <memory>
29 #include <atomic>
30
31 #include "visitor.hxx"
32
33 extern "C"
34 {
35 #include "dynamiclibrary.h"
36 #include "dynlib_ast.h"
37 }
38
39 // Minimal values for iConsoleLines & iConsoleWidth
40 #define ICONSOLELINES_MIN 0
41 #define ICONSOLEWIDTH_MIN 10
42
43 namespace types
44 {
45 class Cell;
46 class ThreadId;
47 class Callable;
48 }
49
50 class EXTERN_AST ConfigVariable
51 {
52     //module list
53 private :
54     static std::list<std::wstring> m_ModuleList;
55
56 public :
57     static void setModuleList(std::list<std::wstring>& _module_list);
58     static std::list<std::wstring> getModuleList();
59
60
61     //SCI
62 private :
63     static std::wstring m_SCIPath;
64
65 public :
66     static void setSCIPath(const std::wstring& _SCIPath);
67     static std::wstring& getSCIPath();
68
69     //SCIHOME
70 private :
71     static std::wstring m_SCIHOME;
72
73 public :
74     static void setSCIHOME(const std::wstring& _m_SCIHOME);
75     static std::wstring& getSCIHOME();
76
77     //TMPDIR
78 private :
79     static std::wstring m_TMPDIR;
80
81 public :
82     static void setTMPDIR(const std::wstring& _TMPDIR);
83     static std::wstring& getTMPDIR();
84
85     // Force Quit
86 private :
87     static bool m_bForceQuit;
88
89 public :
90     static void setForceQuit(bool _bForceQuit);
91     static bool getForceQuit(void);
92
93     // Exit Status
94 private :
95     static int m_iExitStatus;
96
97 public :
98     static void setExitStatus(int _iExitStatus);
99     static int getExitStatus(void);
100
101     // Digit precision, ex format function
102 private :
103     static int m_iFormatSize;
104
105 public :
106     static void setFormatSize(int _iFormatSize);
107     static int getFormatSize(void);
108
109     // printf format ( 0 -> "e", 1 -> "v")
110 private :
111     static int m_iFormatMode;
112
113 public :
114     static void setFormatMode(int _iFormatMode);
115     static int getFormatMode(void);
116
117
118     // Screen console width
119 private :
120     static int m_iConsoleWidth;
121
122 public :
123     static void setConsoleWidth(int _iConsoleWidth);
124     static int getConsoleWidth(void);
125
126     // Screen console lines
127 private :
128     static int m_iConsoleLines;
129
130 public :
131     static void setConsoleLines(int _iConsoleLines);
132     static int getConsoleLines(void);
133
134     // Scilab mode
135 private :
136     static int m_iScilabMode;
137
138 public :
139     static void setScilabMode(int _iScilabMode);
140     static int getScilabMode(void);
141
142     //Warning mode
143 private :
144     static bool m_bWarningMode;
145
146 public :
147     static void setWarningMode(bool _bWarningMode);
148     static bool getWarningMode(void);
149
150     // WarningStop
151 private :
152     static bool m_bWarningStop;
153
154 public :
155     static void setWarningStop(bool _bWarningStop);
156     static bool getWarningStop(void);
157
158     // WarningStop
159 private :
160     static bool m_bOldEmptyBehaviour;
161
162 public :
163     static void setOldEmptyBehaviour(bool _bOldEmptyBehaviour);
164     static bool getOldEmptyBehaviour(void);
165
166     //HOME
167 private :
168     static std::wstring m_HOME;
169
170 public :
171     static void setHOME(const std::wstring& _m_HOME);
172     static std::wstring& getHOME();
173
174     //Clear last error information
175 public :
176     static void setLastErrorClear(void);
177
178     //Clear last error information
179 private :
180     static bool m_bLastErrorCall;
181 public :
182     static void setLastErrorCall(void);
183     static void clearLastError(void);
184
185     //Last Error Message
186 private :
187     static std::wstring m_wstError;
188
189 public :
190     static void setLastErrorMessage(const std::wstring& _wstError);
191     static std::wstring& getLastErrorMessage();
192
193     //Last Error ID
194 private :
195     static int m_iError;
196     static bool m_bError;
197
198 public :
199     static void setLastErrorNumber(int _iError);
200     static int getLastErrorNumber();
201     static void setError();
202     static bool isError();
203     static void resetError();
204
205     //Last Error Line
206 private :
207     static int m_iErrorLine;
208
209 public :
210     static void setLastErrorLine(int _iLine);
211     static int getLastErrorLine();
212
213     //Last Error Function
214 private :
215     static std::wstring m_wstErrorFunction;
216 public:
217     static void setLastErrorFunction(const std::wstring& _wstFunction);
218     static std::wstring& getLastErrorFunction();
219
220     //verbose ";" after instruction
221     //set before function call to know status of e.isVerbose in functions
222 private:
223     static bool m_bVerbose;
224
225 public :
226     static void setVerbose(bool _bVerbose);
227     static bool getVerbose(void);
228
229
230     //silent error ( try catch, errcatch, ... )
231 private :
232     static bool m_iSilentError;
233 public:
234     static void setSilentError(bool _iSilentError);
235     static bool isSilentError(void);
236
237     //Prompt Mode
238 public :
239     /*
240     Prompt mode
241     normal = 0,
242     silent = -1,
243     prompt = 2,
244     exec = 1,
245     exec3 = 3,
246     step = 4,
247     step7 = 7
248     */
249
250 private :
251     static int m_iUserMode;
252     static int m_iPromptMode;
253     static bool m_printInput;
254     static bool m_printOutput;
255     static bool m_printCompact;
256     static bool m_printInteractive;
257
258 public :
259     static void setUserMode(int _iPromptMode);
260     static int getUserMode(void);
261
262     static void setPromptMode(int _iPromptMode);
263     static int getPromptMode(void);
264
265     static void setPrintInput(bool val);
266     static bool isPrintInput(void);
267     static bool togglePrintInput(void);
268
269     static void setPrintOutput(bool val);
270     static bool isPrintOutput(void);
271     static bool togglePrintOutput(void);
272
273     static void setPrintInteractive(bool val);
274     static bool isPrintInteractive(void);
275     static bool togglePrintInteractive(void);
276
277     static void setPrintCompact(bool val);
278     static bool isPrintCompact(void);
279     static bool togglePrintCompact(void);
280
281
282     // Pause level
283 private :
284     static int m_iPauseLevel;
285     static std::list<int> m_listScope;
286
287 public :
288     static void IncreasePauseLevel();
289     static void DecreasePauseLevel();
290     static int getPauseLevel();
291     static int getActivePauseLevel();
292     // Dynamic Libraries
293
294     typedef struct
295     {
296         wchar_t* pwstLibraryName;      /** name of dynamic library **/
297         DynLibHandle hLib;              /** handle of the library **/
298     } DynamicLibraryStr;
299
300     typedef void(*dynlib_ptr)();
301
302     typedef struct
303     {
304         wchar_t* pwstEntryPointName;    /** name of interface **/
305         int iLibIndex;                  /** name of interface **/
306         dynlib_ptr functionPtr;         /** entrypoint for the interface **/
307         bool bOK;                       /** flag set to TRUE if entrypoint can be used **/
308     } EntryPointStr;
309
310 private :
311     static std::list<EntryPointStr*> m_EntryPointList;
312     static std::vector<DynamicLibraryStr*> m_DynLibList;
313 public :
314
315     /* tools fucntions */
316     static void setLibraryName(DynamicLibraryStr* _pDynamicLibrary, wchar_t* _pwstLibraryName);
317     static void setEntryPointName(EntryPointStr* _pEntryPoint, wchar_t* _pwstEntryPointName);
318
319     /* "Constructors" */
320     static DynamicLibraryStr* getNewDynamicLibraryStr();
321     static EntryPointStr* getNewEntryPointStr();
322
323     /* Dynamic libraries functions */
324     static std::vector<DynamicLibraryStr*>* getDynamicLibraryList();
325     static int addDynamicLibrary(DynamicLibraryStr* _pDynamicLibrary);
326     static void removeDynamicLibrary(int _iDynamicLibraryIndex);
327     static DynamicLibraryStr* getDynamicLibrary(int _iDynamicLibraryIndex);
328     static bool isDynamicLibrary(int _iDynamicLibraryIndex);
329
330     /* Entry point functions */
331     static std::list<EntryPointStr*>* getEntryPointList();
332     static void addEntryPoint(EntryPointStr* _pEP);
333     static void removeEntryPoint(int _iEntryPointIndex);
334     static EntryPointStr* getEntryPoint(wchar_t* _pwstEntryPointName, int _iDynamicLibraryIndex = -1);
335     static int getEntryPointPosition(wchar_t* _pwstEntryPointName, int _iDynamicLibraryIndex = -1);
336     static dynlib_ptr getEntryPointFromPosition(int position);
337     static std::vector<std::wstring> getEntryPointNameList();
338
339     //dynamic modules
340 private :
341     static std::map<std::wstring, DynLibHandle> m_DynModules;
342 public :
343     static void addDynModule(const std::wstring& _name, DynLibHandle _lib);
344     static void removeDynModule(const std::wstring& _name);
345     static DynLibHandle getDynModule(const std::wstring& _name);
346     static int getDynModuleCount();
347     static DynLibHandle* getAllDynModule();
348     static void cleanDynModule();
349
350     // Command Line Arguments
351 private :
352     static std::vector<std::wstring> m_Args;
353     static bool m_bTimed;
354     static bool m_bSerialize;
355 public :
356     static void setCommandLineArgs(int _iArgs, char** _pstArgs);
357     static wchar_t** getCommandLineArgs(int* _piCount);
358     static bool getTimed();
359     static void setTimed(bool _bTimed);
360     static bool getSerialize();
361     static void setSerialize(bool _bSerialize);
362
363     //schur function
364 private :
365     static types::Callable* m_schurFunction;
366
367 public :
368     static void setSchurFunction(types::Callable* _schurFunction);
369     static types::Callable* getSchurFunction();
370
371     //grand (module randlib)
372 private :
373     static int m_currentBaseGen;
374     static int m_currentClcg4;
375
376 public :
377     static void setCurrentBaseGen(int _currentBaseGen);
378     static int getCurrentBaseGen();
379
380     static void setCurrentClcg4(int _currentClcg4);
381     static int getCurrentClcg4();
382
383     //Start and end finish flag
384 private :
385     static bool m_bStartProcessing;
386     static bool m_bEndProcessing;
387
388 public :
389     static void setStartProcessing(bool _bStartProcessing);
390     static bool getStartProcessing();
391     static void setEndProcessing(bool _bEndFinished);
392     static bool getEndProcessing();
393
394     // ieee
395 private :
396     static int m_iIeee;
397
398 public :
399     static void setIeee(int _iIeee);
400     static int getIeee();
401
402     // simp mode
403 private :
404     static int m_iSimpMode;
405
406 public :
407     static void setSimpMode(int _iSimpMode);
408     static int getSimpMode();
409
410     // funcprot mode
411 private :
412     static int m_iFuncprot;
413
414 public :
415     static void setFuncprot(int _iFuncprot);
416     static int getFuncprot();
417
418     // where
419 public :
420     // On macro call, some information are pushed to the call stack
421     struct WhereEntry
422     {
423         int m_line;
424         int m_absolute_line;
425         int m_scope_lvl;
426         types::Callable* call;
427         const std::wstring* m_file_name;
428     };
429
430     // On error, every information is copied back as values from the Callable to avoid being freed on call stack return
431     struct WhereErrorEntry
432     {
433         int m_line;
434         int m_absolute_line;
435         int m_first_line;
436         std::wstring m_function_name;
437         std::wstring m_file_name;
438     };
439
440     static void where_begin(int _iLineNum, int _iLineLocation, types::Callable* _pCall);
441     static void where_end();
442     static const std::vector<WhereEntry>& getWhere();
443     static void fillWhereError(int _iErrorLine);
444     static void resetWhereError();
445
446     static void macroFirstLine_begin(int _iLine);
447     static void macroFirstLine_end();
448     static int getMacroFirstLines();
449     static void setFileNameToLastWhere(const std::wstring* _fileName);
450     static void whereErrorToString(std::wostringstream &ostr);
451 private :
452     static std::vector<WhereEntry> m_Where;
453     static std::vector<WhereErrorEntry> m_WhereError;
454     static std::vector<int> m_FirstMacroLine;
455     //module called with variable by reference
456 private :
457     static std::list<std::wstring> m_ReferenceModules;
458 public :
459     static bool checkReferenceModule(const std::wstring& _module);
460     static void addReferenceModule(const std::wstring& _module);
461     static void removeReferenceModule(const std::wstring& _module);
462     static std::list<std::wstring> getReferenceModules();
463
464     //analyzer options
465
466 private :
467     static int m_analyzerOptions;
468 public :
469     static void setAnalyzerOptions(int _val);
470     static int getAnalyzerOptions(void);
471
472     //divide by zero
473 private:
474     static bool m_dividebyzero;
475 public:
476     static void setDivideByZero(bool _dividebyzero);
477     static bool isDivideByZero(void);
478
479     //mex info
480 private:
481     static std::string mexFunctionName;
482 public:
483     static void setMexFunctionName(const std::string& name);
484     static std::string& getMexFunctionName();
485
486     // executed file with exec
487 private:
488     static int m_iFileID;
489 public:
490     static void setExecutedFileID(int _iFileID);
491     static int getExecutedFileID();
492
493     // string read from console by scilabRead
494 private:
495     static std::atomic<char*> m_pcConsoleReadStr;
496 public:
497     static void setConsoleReadStr(char* _pcConsoleReadStr);
498     static char* getConsoleReadStr();
499
500     // tell if the command return by scilabRead is a scilab command or not
501 private:
502     static std::atomic<int> m_isScilabCommand;
503 public:
504     static void setScilabCommand(int _isciCmd);
505     static int isScilabCommand();
506
507     //debugger information
508     static bool m_bEnabledebug;
509     static std::unique_ptr<ast::ConstVisitor> m_defaultvisitor;
510
511     static bool getEnableDebug();
512     static void setEnableDebug(bool _enable);
513
514     static void setDefaultVisitor(ast::ConstVisitor* _default);
515     static ast::ConstVisitor* getDefaultVisitor();
516
517     //manage CTRL C in console
518 private :
519     static bool executionbreak;
520 public :
521     static bool isExecutionBreak();
522     static void setExecutionBreak();
523     static void resetExecutionBreak();
524 private:
525     static int recursionLimit;
526     static int recursionLevel;
527
528     // manage recursion stack
529 public :
530     static int getRecursionLimit();
531     static int setRecursionLimit(int val);
532
533     static int getRecursionLevel();
534     static void resetRecursionLevel();
535     static bool increaseRecursion();
536     static void decreaseRecursion();
537 private:
538     static bool webMode;
539 public:
540     static bool getWebMode();
541     static void setWebMode(bool);
542
543 };
544
545 #endif /* !__CONFIGVARIABLE_HXX__ */