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