GVN fixed about non managed Exp
[scilab.git] / scilab / modules / core / src / cpp / tasks.cpp
1 /*
2 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 *  Copyright (C) 2009-2009 - DIGITEO - Bruno JOFRET
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 #include "AnalysisVisitor.hxx"
17 #include "tasks.hxx"
18 #include "timer.hxx"
19 #include "context.hxx"
20 #include "visitor.hxx"
21 #include "printvisitor.hxx"
22 #include "execvisitor.hxx"
23 #include "timedvisitor.hxx"
24 #include "prettyprintvisitor.hxx"
25 #include "debuggervisitor.hxx"
26 #include "stepvisitor.hxx"
27 #include "visitor_common.hxx"
28 #include "threadmanagement.hxx"
29
30 #include "scilabWrite.hxx"
31 #include "runner.hxx"
32
33 #define SCILAB_START    L"/etc/scilab.start"
34 #define SCILAB_QUIT     L"/etc/scilab.quit"
35
36 Timer _timer;
37
38 //#define DEBUG
39
40 /*
41 ** Parse
42 **
43 ** Parse the given file and create the AST.
44 */
45 void parseFileTask(Parser *parser, bool timed, const wchar_t* file_name, const wchar_t* prog_name)
46 {
47 #ifdef DEBUG
48     std::cerr << "*** Processing " << file_name << " file..." << std::endl;
49 #endif
50
51     if (timed)
52     {
53         _timer.start();
54     }
55
56     parser->parseFile(file_name, prog_name);
57
58     if (timed)
59     {
60         _timer.check(L"Parsing");
61     }
62 }
63
64 /*
65 ** Parse
66 **
67 ** Parse the given command and create the AST.
68 */
69 void parseCommandTask(Parser *parser, bool timed, char *command)
70 {
71 #ifdef DEBUG
72     std::cerr << "*** Processing [" <<  command << "]..." << std::endl;
73 #endif
74
75     if (timed)
76     {
77         _timer.start();
78     }
79
80     parser->parse(command);
81
82     if (timed && parser->getControlStatus() == Parser::AllControlClosed)
83     {
84         _timer.check(L"Parsing");
85     }
86 }
87
88 /*
89 ** Dump AST
90 **
91 ** Display the AST in human readable format.
92 */
93 void dumpAstTask(ast::Exp *tree, bool timed)
94 {
95     if (timed)
96     {
97         _timer.start();
98     }
99
100     ast::PrettyPrintVisitor debugMe;
101     if (tree)
102     {
103         tree->accept(debugMe);
104     }
105
106     if (timed)
107     {
108         _timer.check(L"AST Dump");
109     }
110 }
111
112 /*
113 ** Pretty Print
114 **
115 ** Pretty print the Stored AST.
116 */
117 void printAstTask(ast::Exp *tree, bool timed)
118 {
119     if (timed)
120     {
121         _timer.start();
122     }
123
124     if (tree)
125     {
126         ast::PrintVisitor printMe (std::wcout);
127         tree->accept(printMe);
128     }
129
130     if (timed)
131     {
132         _timer.check(L"Pretty Print");
133     }
134 }
135
136
137 /*
138 ** Exec Tree
139 **
140 ** Execute the stored AST.
141 */
142 void execAstTask(ast::Exp* tree, bool serialize, bool timed, bool ASTtimed, bool execVerbose,
143                  bool isInterruptibleThread, bool isPrioritaryThread, command_origin_t iCommandOrigin)
144 {
145     if (tree == NULL)
146     {
147         return;
148     }
149
150     ast::Exp* newTree = NULL;
151     if (serialize)
152     {
153         if (timed)
154         {
155             newTree = callTyper(tree, L"tasks");
156         }
157         else
158         {
159             newTree = callTyper(tree);
160         }
161
162         delete tree;
163     }
164     else
165     {
166         newTree = tree;
167     }
168
169     ast::RunVisitor *exec;
170     if (timed)
171     {
172         _timer.start();
173     }
174
175     if (ASTtimed)
176     {
177         exec = new ast::TimedVisitor();
178     }
179     else if (execVerbose)
180     {
181         exec = new ast::StepVisitor();
182     }
183     else
184     {
185         //call analyzer visitor before exec visitor
186         if (ConfigVariable::getAnalyzerOptions() == 1)
187         {
188             analysis::AnalysisVisitor analysis;
189             newTree->accept(analysis);
190         }
191
192         exec = (ast::RunVisitor*)ConfigVariable::getDefaultVisitor();
193     }
194
195     StaticRunner::execAndWait(newTree, exec, isInterruptibleThread, isPrioritaryThread, iCommandOrigin);
196     //DO NOT DELETE tree or newTree, they was deleted by Runner or previously;
197
198     if (timed)
199     {
200         _timer.check(L"Execute AST");
201     }
202 }
203
204 /*
205 ** Dump Stack Trace
206 **
207 ** Display what is stored in scilab.
208 */
209 void dumpStackTask(bool timed)
210 {
211     if (timed)
212     {
213         _timer.start();
214     }
215
216     symbol::Context::getInstance()->print(std::wcout);
217
218     if (timed)
219     {
220         _timer.check(L"Dumping Stack");
221     }
222 }
223
224 /*
225 ** Execute scilab.start
226 **
227 */
228 int execScilabStartTask(bool _bSerialize)
229 {
230     Parser parse;
231     std::wstring stSCI = ConfigVariable::getSCIPath();
232     stSCI += SCILAB_START;
233
234     ThreadManagement::LockParser();
235     try
236     {
237         parse.parseFile(stSCI, L"");
238     }
239     catch (const ast::InternalError& ie)
240     {
241         scilabWrite(ie.what());
242         ThreadManagement::UnlockParser();
243         return 1;
244     }
245
246     if (parse.getExitStatus() != Parser::Succeded)
247     {
248         scilabWriteW(parse.getErrorMessage());
249         scilabWriteW(L"Failed to parse scilab.start");
250         ThreadManagement::UnlockParser();
251         return 1;
252     }
253     ThreadManagement::UnlockParser();
254
255     ast::Exp* newTree = parse.getTree();
256     if (_bSerialize)
257     {
258         newTree = callTyper(parse.getTree());
259     }
260
261     return StaticRunner::exec(newTree, new ast::ExecVisitor()) ? 0 : 1;
262 }
263
264 /*
265 ** Execute scilab.quit
266 **
267 */
268 int execScilabQuitTask(bool _bSerialize)
269 {
270     Parser parse;
271     std::wstring stSCI = ConfigVariable::getSCIPath();
272     stSCI += SCILAB_QUIT;
273
274     ThreadManagement::LockParser();
275     try
276     {
277         parse.parseFile(stSCI, L"");
278     }
279     catch (const ast::InternalError& ie)
280     {
281         scilabWrite(ie.what());
282         ThreadManagement::UnlockParser();
283         return 1;
284     }
285
286     if (parse.getExitStatus() != Parser::Succeded)
287     {
288         scilabWriteW(parse.getErrorMessage());
289         scilabWriteW(L"Failed to parse scilab.quit");
290         ThreadManagement::UnlockParser();
291         return 1;
292     }
293     ThreadManagement::UnlockParser();
294
295     ast::Exp* newTree = parse.getTree();
296     if (_bSerialize)
297     {
298         newTree = callTyper(parse.getTree());
299     }
300
301     return StaticRunner::exec(newTree, new ast::ExecVisitor()) ? 0 : 1;
302 }
303
304
305 ast::Exp* parseCommand(std::wstring _command)
306 {
307     if (_command.empty())
308     {
309         return NULL;
310     }
311
312     Parser parse;
313     parse.parse((wchar_t*)_command.c_str());
314     if (parse.getExitStatus() != Parser::Succeded)
315     {
316         return NULL;
317     }
318
319     return parse.getTree();
320 }