thread management fixed.
[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 *  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 #include "tasks.hxx"
14 #include "timer.hxx"
15 #include "context.hxx"
16 #include "visitor.hxx"
17 #include "printvisitor.hxx"
18 #include "execvisitor.hxx"
19 #include "timedvisitor.hxx"
20 #include "debugvisitor.hxx"
21 #include "stepvisitor.hxx"
22 #include "AnalysisVisitor.hxx"
23 #include "visitor_common.hxx"
24
25 #include "scilabWrite.hxx"
26 #include "runner.hxx"
27
28 #define SCILAB_START    L"/etc/scilab.start"
29 #define SCILAB_QUIT     L"/etc/scilab.quit"
30
31 Timer _timer;
32
33 //#define DEBUG
34
35 /*
36 ** Parse
37 **
38 ** Parse the given file and create the AST.
39 */
40 void parseFileTask(Parser *parser, bool timed, const wchar_t* file_name, const wchar_t* prog_name)
41 {
42 #ifdef DEBUG
43     std::cerr << "*** Processing " << file_name << " file..." << std::endl;
44 #endif
45
46     if (timed)
47     {
48         _timer.start();
49     }
50
51     parser->parseFile(file_name, prog_name);
52
53     if (timed)
54     {
55         _timer.check(L"Parsing");
56     }
57 }
58
59 /*
60 ** Parse
61 **
62 ** Parse the given command and create the AST.
63 */
64 void parseCommandTask(Parser *parser, bool timed, char *command)
65 {
66 #ifdef DEBUG
67     std::cerr << "*** Processing [" <<  command << "]..." << std::endl;
68 #endif
69
70     if (timed)
71     {
72         _timer.start();
73     }
74
75     parser->parse(command);
76
77     if (timed && parser->getControlStatus() == Parser::AllControlClosed)
78     {
79         _timer.check(L"Parsing");
80     }
81 }
82
83 /*
84 ** Dump AST
85 **
86 ** Display the AST in human readable format.
87 */
88 void dumpAstTask(ast::Exp *tree, bool timed)
89 {
90     if (timed)
91     {
92         _timer.start();
93     }
94
95     ast::DebugVisitor debugMe;
96     if (tree)
97     {
98         tree->accept(debugMe);
99     }
100
101     if (timed)
102     {
103         _timer.check(L"AST Dump");
104     }
105 }
106
107 /*
108 ** Pretty Print
109 **
110 ** Pretty print the Stored AST.
111 */
112 void printAstTask(ast::Exp *tree, bool timed)
113 {
114     if (timed)
115     {
116         _timer.start();
117     }
118
119     if (tree)
120     {
121         ast::PrintVisitor printMe = *new ast::PrintVisitor(std::wcout);
122         tree->accept(printMe);
123     }
124
125     if (timed)
126     {
127         _timer.check(L"Pretty Print");
128     }
129 }
130
131
132 /*
133 ** Exec Tree
134 **
135 ** Execute the stored AST.
136 */
137 void execAstTask(ast::Exp* tree, bool serialize, bool timed, bool ASTtimed, bool execVerbose,
138                  bool isInterruptibleThread, bool isPrioritaryThread, bool isConsoleCommand)
139 {
140     if (tree == NULL)
141     {
142         return;
143     }
144
145     ast::Exp* newTree = NULL;
146     if (serialize)
147     {
148         if (timed)
149         {
150             newTree = callTyper(tree, L"tasks");
151         }
152         else
153         {
154             newTree = callTyper(tree);
155         }
156
157         delete tree;
158     }
159     else
160     {
161         newTree = tree;
162     }
163
164     ast::ExecVisitor *exec;
165     if (timed)
166     {
167         _timer.start();
168     }
169
170     if (ASTtimed)
171     {
172         exec = (ast::ExecVisitor*)new ast::TimedVisitor();
173     }
174
175     if (execVerbose)
176     {
177         exec = (ast::ExecVisitor*)new ast::StepVisitor();
178     }
179
180     if (!execVerbose && !ASTtimed)
181     {
182         //call analyzer visitor before exec visitor
183         if (ConfigVariable::getAnalyzerOptions() == 1)
184         {
185             analysis::AnalysisVisitor analysis;
186             newTree->accept(analysis);
187         }
188
189         exec = new ast::ExecVisitor();
190     }
191
192     Runner::execAndWait(newTree, exec, isInterruptibleThread, isPrioritaryThread, isConsoleCommand);
193     //DO NOT DELETE tree or newTree, they was deleted by Runner or previously;
194
195     if (timed)
196     {
197         _timer.check(L"Execute AST");
198     }
199 }
200
201 /*
202 ** Dump Stack Trace
203 **
204 ** Display what is stored in scilab.
205 */
206 void dumpStackTask(bool timed)
207 {
208     if (timed)
209     {
210         _timer.start();
211     }
212
213     symbol::Context::getInstance()->print(std::wcout);
214
215     if (timed)
216     {
217         _timer.check(L"Dumping Stack");
218     }
219 }
220
221 /*
222 ** Execute scilab.start
223 **
224 */
225 void execScilabStartTask(bool _bSerialize)
226 {
227     Parser parse;
228     wstring stSCI = ConfigVariable::getSCIPath();
229
230     stSCI += SCILAB_START;
231     parse.parseFile(stSCI, L"");
232
233     if (parse.getExitStatus() != Parser::Succeded)
234     {
235         scilabWriteW(parse.getErrorMessage());
236         scilabWriteW(L"Failed to parse scilab.start");
237         return;
238     }
239
240     execAstTask(parse.getTree(), _bSerialize, false, false, false, true, true, false);
241 }
242
243 /*
244 ** Execute scilab.quit
245 **
246 */
247 void execScilabQuitTask(bool _bSerialize)
248 {
249     Parser parse;
250     wstring stSCI = ConfigVariable::getSCIPath();
251
252     stSCI += SCILAB_QUIT;
253     parse.parseFile(stSCI, L"");
254
255     if (parse.getExitStatus() != Parser::Succeded)
256     {
257         scilabWriteW(parse.getErrorMessage());
258         scilabWriteW(L"Failed to parse scilab.quit");
259         return;
260     }
261
262     execAstTask(parse.getTree(), _bSerialize, false, false, false, true, true, false);
263 }
264
265