8ceabf515b7b13d2b7fb2c363aa125123ee67261
[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, bool isPriorityThread)
138 {
139     if (tree == NULL)
140     {
141         return;
142     }
143
144     ast::Exp* newTree = NULL;
145     if (serialize)
146     {
147         if (timed)
148         {
149             newTree = callTyper(tree, L"tasks");
150         }
151         else
152         {
153             newTree = callTyper(tree);
154         }
155
156         delete tree;
157     }
158     else
159     {
160         newTree = tree;
161     }
162
163     ast::ExecVisitor *exec;
164     if (timed)
165     {
166         _timer.start();
167     }
168
169     if (ASTtimed)
170     {
171         exec = (ast::ExecVisitor*)new ast::TimedVisitor();
172     }
173
174     if (execVerbose)
175     {
176         exec = (ast::ExecVisitor*)new ast::StepVisitor();
177     }
178
179     if (!execVerbose && !ASTtimed)
180     {
181         //call analyzer visitor before exec visitor
182         if (ConfigVariable::getAnalyzerOptions() == 1)
183         {
184             analysis::AnalysisVisitor analysis;
185             newTree->accept(analysis);
186         }
187
188         exec = new ast::ExecVisitor();
189     }
190
191     Runner::execAndWait(newTree, exec, isPriorityThread);
192     //DO NOT DELETE tree or newTree, they was deleted by Runner or previously;
193
194     if (timed)
195     {
196         _timer.check(L"Execute AST");
197     }
198 }
199
200 /*
201 ** Dump Stack Trace
202 **
203 ** Display what is stored in scilab.
204 */
205 void dumpStackTask(bool timed)
206 {
207     if (timed)
208     {
209         _timer.start();
210     }
211
212     symbol::Context::getInstance()->print(std::wcout);
213
214     if (timed)
215     {
216         _timer.check(L"Dumping Stack");
217     }
218 }
219
220 /*
221 ** Execute scilab.start
222 **
223 */
224 void execScilabStartTask(bool _bSerialize)
225 {
226     Parser parse;
227     wstring stSCI = ConfigVariable::getSCIPath();
228
229     stSCI += SCILAB_START;
230     parse.parseFile(stSCI, L"");
231
232     if (parse.getExitStatus() != Parser::Succeded)
233     {
234         scilabWriteW(parse.getErrorMessage());
235         scilabWriteW(L"Failed to parse scilab.start");
236         return;
237     }
238
239     execAstTask(parse.getTree(), _bSerialize, false, false, false, true);
240 }
241
242 /*
243 ** Execute scilab.quit
244 **
245 */
246 void execScilabQuitTask(bool _bSerialize)
247 {
248     Parser parse;
249     wstring stSCI = ConfigVariable::getSCIPath();
250
251     stSCI += SCILAB_QUIT;
252     parse.parseFile(stSCI, L"");
253
254     if (parse.getExitStatus() != Parser::Succeded)
255     {
256         scilabWriteW(parse.getErrorMessage());
257         scilabWriteW(L"Failed to parse scilab.quit");
258         return;
259     }
260
261     execAstTask(parse.getTree(), _bSerialize, false, false, false, true);
262 }
263
264