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, wchar_t *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 {
 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);
 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);
 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);
 262 }
 263
 264