add save(filename) to save all variables in context.
[scilab.git] / scilab / modules / ast / includes / symbol / context.hxx
1 /*
2 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 *  Copyright (C) 2007-2008 - INRIA - Bruno JOFRET
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
13 /**
14 ** \file symbol/context.hh
15 ** \brief Define class Context.
16 */
17
18 #ifndef __CONTEXT_HXX__
19 #define __CONTEXT_HXX__
20
21 #include "function.hxx"
22 #include "variables.hxx"
23 #include "libraries.hxx"
24
25 extern "C"
26 {
27 #include "dynlib_ast.h"
28 }
29
30 namespace symbol
31 {
32
33 /** \brief Define class Context.
34 */
35 class EXTERN_AST Context
36 {
37 public:
38     typedef std::map<Symbol, Variable*> VarList;
39     typedef std::stack<VarList*> VarStack;
40
41     static Context* getInstance(void);
42
43     static void destroyInstance(void);
44
45     /** Open a context scope i.e
46     ** open the heap table one
47     ** and the env table too. */
48     void scope_begin();
49
50     /** Close a context scope i.e
51     ** close the heap table one
52     ** and the env table too. */
53     void scope_end();
54
55     /** If key was associated to some Entry_T in the open scopes, return the
56     ** most recent insertion. Otherwise return the empty pointer. */
57     types::InternalType* get(const Symbol& key);
58     types::InternalType* get(const Variable* _var);
59     Variable* getOrCreate(const Symbol& _key);
60     int getLevel(const Symbol & _key) const;
61
62     /** If key was associated to some Entry_T in the last opened scope, return it.
63     ** Otherwise return the empty pointer. */
64     types::InternalType* getCurrentLevel(const Symbol& key);
65     types::InternalType* getCurrentLevel(Variable* _var);
66
67     /** If key was associated to some Entry_T in the open scopes, return the
68     ** most recent insertion DESPITE the current/last one. Otherwise return the empty pointer. */
69     types::InternalType* getAllButCurrentLevel(const Symbol& key);
70     types::InternalType* getAtLevel(const Symbol& key, int level = SCOPE_ALL);
71
72     /** If key was associated to some Entry_T in the open scopes, return the
73     ** most recent insertion. Otherwise return the empty pointer. */
74     types::InternalType* getFunction(const Symbol& key);
75
76     /*return function list in the module _stModuleName*/
77     int getFunctionList(std::list<Symbol>& lst, std::wstring _stModuleName);
78
79     int getConsoleVarsName(std::list<std::wstring>& lst);
80     int getVarsName(std::list<std::wstring>& lst);
81     int getMacrosName(std::list<std::wstring>& lst);
82     int getFunctionsName(std::list<std::wstring>& lst);
83     int getVarsNameForWho(std::list<std::wstring>& lst, bool sorted);
84     int getGlobalNameForWho(std::list<std::wstring>& lst, bool sorted);
85     int getWhereIs(std::list<std::wstring>& lst, const std::wstring& _str);
86     int getLibrariesList(std::list<std::wstring>& lst);
87     int getVarsToVariableBrowser(std::list<Variable*>& lst);
88     int getLibsToVariableBrowser(std::list<Library*>& lst);
89     /* global functions */
90
91     /*return global variable visibility status*/
92     bool isGlobalVisible(const Symbol& key);
93
94     /*return global variable existance status*/
95     bool isGlobal(const Symbol& key);
96
97     /*remove global variable and all visibility references */
98     //clearglobal("a")
99     void removeGlobal(const Symbol& key);
100
101     /*remove all global variables and references */
102     //clearglobal
103     void removeGlobalAll();
104     void clearAll();
105
106     //predef
107     void protect();
108     void unprotect();
109     bool isprotected(const Symbol& key);
110     bool isprotected(Variable* _var);
111     int protectedVars(std::list<std::wstring>& lst);
112
113     /*set variable visible/hidden in current global scope*/
114     void setGlobalVisible(const Symbol& key, bool bVisible);
115     void setGlobal(const Symbol& key);
116
117     types::InternalType* getGlobalValue(const Symbol& _key);
118
119     /*add symbol and value in the stack*/
120     void put(const Symbol& _key, types::InternalType* _pIT);
121     void put(Variable* _var, types::InternalType* _pIT);
122     /*add symbol and value in the previous scope*/
123     bool putInPreviousScope(Variable* _var, types::InternalType* _pIT);
124
125     /* remove symbol/value association */
126     //clear("a")
127     bool remove(const Symbol& key);
128     //clear();
129     bool removeAll();
130
131     bool addFunction(types::Function *_info);
132     bool addMacro(types::Macro *_info);
133     bool addMacroFile(types::MacroFile *_info);
134     void print(std::wostream& ostr, bool bSorted = false) const;
135     int getScopeLevel();
136     bool isValidVariableName(const wchar_t*);
137     bool isValidVariableName(const char*);
138
139     inline bool isOriginalSymbol(const symbol::Symbol & sym) const
140     {
141         return getLevel(sym) == 0;
142     }
143
144 private:
145
146     types::InternalType* get(const Symbol& key, int _iLevel);
147     bool clearCurrentScope(bool _bClose);
148     void updateProtection(bool protect);
149
150     std::list<Symbol>* globals;
151     VarStack varStack;
152     Variables variables;
153     Libraries libraries;
154     VarList* console;
155     int m_iLevel;
156
157     Context();
158     ~Context();
159
160     static Context* me;
161 };
162
163 inline std::wostream& operator<< (std::wostream& ostr, const Context &ctx)
164 {
165     ctx.print(ostr);
166     return ostr;
167 }
168
169 }
170 #endif /* !__CONTEXT_HXX__ */