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 }