src/PyInterp/PyInterp_Interp.cxx

   1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 //  File   : PyInterp_Interp.cxx
  24 //  Author : Christian CAREMOLI, Paul RASCLE, EDF
  25 //  Module : SALOME
  26 //
  27 #include "PyInterp_Interp.h"  // !!! WARNING !!! THIS INCLUDE MUST BE THE VERY FIRST !!!
  28 #include <pythread.h>
  29
  30 #include <cStringIO.h>
  31 #include <structmember.h>
  32
  33 #include <string>
  34 #include <vector>
  35 #include <map>
  36 #include <iostream>
  37 #include <algorithm>
  38
  39 #define TOP_HISTORY_PY   "--- top of history ---"
  40 #define BEGIN_HISTORY_PY "--- begin of history ---"
  41
  42 /*!
  43   \class PyLockWrapper
  44   \brief Python GIL wrapper.
  45 */
  46
  47 /*!
  48   \brief Constructor. Automatically acquires GIL.
  49 */
  50 PyLockWrapper::PyLockWrapper()
  51 {
  52   _gil_state = PyGILState_Ensure();
  53 }
  54
  55 /*!
  56   \brief Destructor. Automatically releases GIL.
  57 */
  58 PyLockWrapper::~PyLockWrapper()
  59 {
  60 //  if (myThreadState->interp == PyInterp_Interp::_interp)
  61 //    PyGILState_Release(_savestate);
  62 //  else
  63 //    PyEval_ReleaseThread(myThreadState);
  64
  65   /* The destructor can never be called concurrently by two threads since it is called
  66    * when the GIL is held - the below test should never run concurrently in two threads.
  67    */
  68   PyGILState_Release(_gil_state);
  69 }
  70
  71 /*
  72   The following functions are used to hook the Python
  73   interpreter output.
  74 */
  75
  76 static void
  77 PyStdOut_dealloc(PyStdOut *self)
  78 {
  79   PyObject_Del(self);
  80 }
  81
  82 static PyObject*
  83 PyStdOut_write(PyStdOut *self, PyObject *args)
  84 {
  85   char *c;
  86   int l;
  87   if (!PyArg_ParseTuple(args, "t#:write",&c, &l))
  88     return NULL;
  89   if(self->_cb==NULL) {
  90     if ( self->_iscerr )
  91       std::cerr << c ;
  92     else
  93       std::cout << c ;
  94   }
  95   else {
  96     self->_cb(self->_data,c);
  97   }
  98   Py_INCREF(Py_None);
  99   return Py_None;
 100 }
 101
 102 static PyObject*
 103 PyStdOut_flush(PyStdOut *self)
 104 {
 105   Py_INCREF(Py_None);
 106   return Py_None;
 107 }
 108
 109 static PyMethodDef PyStdOut_methods[] = {
 110   {"write",  (PyCFunction)PyStdOut_write,  METH_VARARGS, PyDoc_STR("write(string) -> None")},
 111   {"flush",  (PyCFunction)PyStdOut_flush,  METH_NOARGS,  PyDoc_STR("flush() -> None")},
 112   {NULL,    NULL}   /* sentinel */
 113 };
 114
 115 static PyMemberDef PyStdOut_memberlist[] = {
 116   {(char*)"softspace", T_INT,  offsetof(PyStdOut, softspace), 0,
 117    (char*)"flag indicating that a space needs to be printed; used by print"},
 118   {NULL} /* Sentinel */
 119 };
 120
 121 static PyTypeObject PyStdOut_Type = {
 122   /* The ob_type field must be initialized in the module init function
 123    * to be portable to Windows without using C++. */
 124   PyObject_HEAD_INIT(NULL)
 125   0,                            /*ob_size*/
 126   "PyOut",                      /*tp_name*/
 127   sizeof(PyStdOut),             /*tp_basicsize*/
 128   0,                            /*tp_itemsize*/
 129   /* methods */
 130   (destructor)PyStdOut_dealloc, /*tp_dealloc*/
 131   0,                            /*tp_print*/
 132   0,                            /*tp_getattr*/
 133   0,                            /*tp_setattr*/
 134   0,                            /*tp_compare*/
 135   0,                            /*tp_repr*/
 136   0,                            /*tp_as_number*/
 137   0,                            /*tp_as_sequence*/
 138   0,                            /*tp_as_mapping*/
 139   0,                            /*tp_hash*/
 140   0,                            /*tp_call*/
 141   0,                            /*tp_str*/
 142   PyObject_GenericGetAttr,      /*tp_getattro*/
 143   /* softspace is writable:  we must supply tp_setattro */
 144   PyObject_GenericSetAttr,      /* tp_setattro */
 145   0,                            /*tp_as_buffer*/
 146   Py_TPFLAGS_DEFAULT,           /*tp_flags*/
 147   0,                            /*tp_doc*/
 148   0,                            /*tp_traverse*/
 149   0,                            /*tp_clear*/
 150   0,                            /*tp_richcompare*/
 151   0,                            /*tp_weaklistoffset*/
 152   0,                            /*tp_iter*/
 153   0,                            /*tp_iternext*/
 154   PyStdOut_methods,             /*tp_methods*/
 155   PyStdOut_memberlist,          /*tp_members*/
 156   0,                            /*tp_getset*/
 157   0,                            /*tp_base*/
 158   0,                            /*tp_dict*/
 159   0,                            /*tp_descr_get*/
 160   0,                            /*tp_descr_set*/
 161   0,                            /*tp_dictoffset*/
 162   0,                            /*tp_init*/
 163   0,                            /*tp_alloc*/
 164   0,                            /*tp_new*/
 165   0,                            /*tp_free*/
 166   0,                            /*tp_is_gc*/
 167 };
 168
 169 #define PyStdOut_Check(v)  ((v)->ob_type == &PyStdOut_Type)
 170
 171 static PyStdOut* newPyStdOut( bool iscerr )
 172 {
 173   PyStdOut *self;
 174   self = PyObject_New(PyStdOut, &PyStdOut_Type);
 175   if (self == NULL)
 176     return NULL;
 177   self->softspace = 0;
 178   self->_cb = NULL;
 179   self->_iscerr = iscerr;
 180   return self;
 181 }
 182
 183 /*!
 184   \class PyInterp_Interp
 185   \brief Generic embedded Python interpreter.
 186 */
 187
 188 int   PyInterp_Interp::_argc   = 1;
 189 char* PyInterp_Interp::_argv[] = {(char*)""};
 190 //PyObject*           PyInterp_Interp::builtinmodule = NULL;
 191 //PyThreadState*      PyInterp_Interp::_gtstate      = NULL;
 192 //PyInterpreterState* PyInterp_Interp::_interp       = NULL;
 193
 194 /*!
 195   \brief Basic constructor.
 196
 197   After construction the interpreter instance successor classes
 198   must call virtual method initalize().
 199 */
 200 PyInterp_Interp::PyInterp_Interp():
 201   _vout(0), _verr(0), _context(0)
 202 {
 203 }
 204
 205
 206
 207 /*!
 208   \brief Destructor.
 209 */
 210 PyInterp_Interp::~PyInterp_Interp()
 211 {
 212 }
 213
 214 /*!
 215   \brief Initialize embedded interpreter.
 216
 217   This method shoud be called after construction of the interpreter.
 218   The method initialize() calls virtuals methods
 219   - initPython()  to initialize global Python interpreter
 220   - initState()   to initialize embedded interpreter state
 221   - initContext() to initialize interpreter internal context
 222   - initRun()     to prepare interpreter for running commands
 223   which should be implemented in the successor classes, according to the
 224   embedded Python interpreter policy (mono or multi interpreter, etc).
 225 */
 226 void PyInterp_Interp::initialize()
 227 {
 228   _history.clear();       // start a new list of user's commands
 229   _ith = _history.begin();
 230
 231   initPython();  // This also inits the multi-threading for Python (but w/o acquiring GIL)
 232
 233   //initState(); // [ABN] OBSOLETE
 234
 235   // ---- The rest of the initialisation process is done hodling the GIL
 236   PyLockWrapper lck;
 237
 238   initContext();
 239
 240   // used to interpret & compile commands - this is really imported here
 241   // and only added again (with PyImport_AddModule) later on
 242   PyObjWrapper m(PyImport_ImportModule("codeop"));
 243   if(!m) {
 244     PyErr_Print();
 245     return;
 246   }
 247
 248   // Create python objects to capture stdout and stderr
 249   _vout=(PyObject*)newPyStdOut( false ); // stdout
 250   _verr=(PyObject*)newPyStdOut( true );  // stderr
 251
 252   // All the initRun outputs are redirected to the standard output (console)
 253   initRun();
 254 }
 255
 256 void PyInterp_Interp::destroy()
 257 {
 258   PyLockWrapper lck;
 259   closeContext();
 260 }
 261
 262 /*!
 263   \brief Initialize Python interpreter.
 264
 265   In case if Python is not initialized, it sets program name, initializes the single true Python
 266   interpreter, sets program arguments, and initializes threads.
 267   Otherwise, does nothing. This is important for light SALOME configuration,
 268   as in full SALOME this is done at SalomeApp level.
 269   \sa SalomeApp_PyInterp class and main() in SALOME_Session_Server
 270  */
 271 void PyInterp_Interp::initPython()
 272 {
 273   if (!Py_IsInitialized()){
 274     // Python is not initialized
 275     Py_SetProgramName(_argv[0]);
 276     Py_Initialize(); // Initialize the interpreter
 277     PySys_SetArgv(_argc, _argv);
 278
 279     PyEval_InitThreads(); // Create (and acquire) the Python global interpreter lock (GIL)
 280     PyEval_ReleaseLock();
 281   }
 282 }
 283
 284 /*!
 285   \brief Get embedded Python interpreter banner.
 286   \return banner string
 287  */
 288 std::string PyInterp_Interp::getbanner() const
 289 {
 290   PyLockWrapper lck;
 291   std::string aBanner("Python ");
 292   aBanner = aBanner + Py_GetVersion() + " on " + Py_GetPlatform() ;
 293   aBanner = aBanner + "\ntype help to get general information on environment\n";
 294   return aBanner;
 295 }
 296
 297 /*!
 298   \brief Initialize run command.
 299
 300   This method is used to prepare interpreter for running
 301   Python commands.
 302
 303   \return \c true on success and \c false on error
 304 */
 305 bool PyInterp_Interp::initRun()
 306 {
 307   return true;
 308 }
 309
 310 void PyInterp_Interp::closeContext()
 311 {
 312 }
 313
 314 /*!
 315   \brief Compile Python command and evaluate it in the
 316          python dictionary context if possible. This is not thread-safe.
 317          This is the caller's responsability to make this thread-safe.
 318   \internal
 319   \param command Python command string
 320   \param context Python context (dictionary)
 321   \return -1 on fatal error, 1 if command is incomplete and 0
 322          if command is executed successfully
 323  */
 324 static int run_command(const char *command, PyObject *context)
 325 {
 326   PyObject *m = PyImport_AddModule("codeop");
 327   if(!m) { // Fatal error. No way to go on.
 328     PyErr_Print();
 329     return -1;
 330   }
 331   PyObjWrapper v(PyObject_CallMethod(m,(char*)"compile_command",(char*)"s",command));
 332   if(!v) {
 333     // Error encountered. It should be SyntaxError,
 334     //so we don't write out traceback
 335     PyObjWrapper exception, value, tb;
 336     PyErr_Fetch(&exception, &value, &tb);
 337     PyErr_NormalizeException(&exception, &value, &tb);
 338     PyErr_Display(exception, value, NULL);
 339     return -1;
 340   }
 341   else if (v == Py_None) {
 342     // Incomplete text we return 1 : we need a complete text to execute
 343     return 1;
 344   }
 345   else {
 346     PyObjWrapper r(PyEval_EvalCode((PyCodeObject *)(void *)v,context,context));
 347     if(!r) {
 348       // Execution error. We return -1
 349       PyErr_Print();
 350       return -1;
 351     }
 352     // The command has been successfully executed. Return 0
 353     return 0;
 354   }
 355 }
 356
 357 void replaceAll(std::string& str, const std::string& from, const std::string& to) {
 358     if(from.empty())
 359         return;
 360     size_t start_pos = 0;
 361     while((start_pos = str.find(from, start_pos)) != std::string::npos) {
 362         str.replace(start_pos, from.length(), to);
 363         start_pos += to.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'
 364     }
 365 }
 366 /*!
 367   \brief Compile Python command and evaluate it in the
 368          python dictionary context if possible. Command might correspond to
 369          the execution of a script with optional arguments.
 370          In this case, command is:
 371          execfile(r"/absolute/path/to/script.py [args:arg1,...,argn]")
 372   \internal
 373   \param command Python command string
 374   \param context Python context (dictionary)
 375   \return -1 on fatal error, 1 if command is incomplete and 0
 376          if command is executed successfully
 377  */
 378 static int compile_command(const char *command, PyObject *context)
 379 {
 380   // First guess if command is execution of a script with args, or a simple Python command
 381   std::string singleCommand = command;
 382   std::string commandArgs = "";
 383
 384   std::size_t pos = std::string(command).find("args:");
 385   if (pos != std::string::npos) {
 386     commandArgs = singleCommand.substr(pos+5);
 387     commandArgs = commandArgs.substr(0, commandArgs.length()-3);
 388     singleCommand = singleCommand.substr(0, pos-1)+"\")";
 389   }
 390
 391   if (commandArgs.empty()) {
 392     // process command: expression
 393     // process command: execfile(r"/absolute/path/to/script.py") (no args)
 394     return run_command(singleCommand.c_str(), context);
 395   }
 396   else {
 397     // process command: execfile(r"/absolute/path/to/script.py [args:arg1,...,argn]")
 398     std::string script = singleCommand.substr(11); // remove leading execfile(r"
 399     script = script.substr(0, script.length()-2); // remove trailing ")
 400
 401     std::string preCommandBegin = "import sys; save_argv = sys.argv; sys.argv=[";
 402     std::string preCommandEnd = "];";
 403     replaceAll(commandArgs, ",", "\",\"");
 404     commandArgs = "\""+commandArgs+"\"";
 405     std::string completeCommand = preCommandBegin+"\""+script+"\","+commandArgs+preCommandEnd+singleCommand+";sys.argv=save_argv";
 406     return run_command(completeCommand.c_str(), context);
 407   }
 408 }
 409
 410 /*!
 411   \brief Run Python command - the command has to fit on a single line (no \n!).
 412   Use ';' if you need multiple statements evaluated at once.
 413   \param command Python command
 414   \return command status
 415 */
 416 int PyInterp_Interp::run(const char *command)
 417 {
 418   beforeRun();
 419   return simpleRun(command);
 420 }
 421
 422 /**
 423  * Called before a command is run (when calling run() method). Not thread-safe. Caller's responsability
 424  * to acquire GIL if needed.
 425  */
 426 int PyInterp_Interp::beforeRun()
 427 {
 428   return 0;
 429 }
 430
 431 /*!
 432   \brief Run Python command (used internally). Not thread-safe. GIL acquisition is caller's responsability.
 433   \param command Python command
 434   \param addToHistory if \c true (default), the command is added to the commands history
 435   \return command status
 436 */
 437 int PyInterp_Interp::simpleRun(const char *command, const bool addToHistory)
 438 {
 439   if( addToHistory && strcmp(command,"") != 0 ) {
 440     _history.push_back(command);
 441     _ith = _history.end();
 442   }
 443
 444   // Current stdout and stderr are saved
 445   PyObject * oldOut = PySys_GetObject((char*)"stdout");
 446   PyObject * oldErr = PySys_GetObject((char*)"stderr");
 447   // Keep them alive (PySys_GetObject returned a *borrowed* ref!)
 448   Py_INCREF(oldOut);
 449   Py_INCREF(oldErr);
 450
 451   // Redirect outputs to SALOME Python console before treatment
 452   PySys_SetObject((char*)"stderr",_verr);
 453   PySys_SetObject((char*)"stdout",_vout);
 454
 455   int ier = compile_command(command,_context);
 456
 457   // Outputs are redirected to what they were before
 458   PySys_SetObject((char*)"stdout",oldOut);
 459   PySys_SetObject((char*)"stderr",oldErr);
 460
 461   return ier;
 462 }
 463
 464 /*!
 465   \brief Get previous command in the commands history.
 466   \return previous command
 467 */
 468 const char * PyInterp_Interp::getPrevious()
 469 {
 470   if(_ith != _history.begin()){
 471     _ith--;
 472     return (*_ith).c_str();
 473   }
 474   else
 475     return BEGIN_HISTORY_PY;
 476 }
 477
 478 /*!
 479   \brief Get next command in the commands history.
 480   \return next command
 481 */
 482 const char * PyInterp_Interp::getNext()
 483 {
 484   if(_ith != _history.end()){
 485     _ith++;
 486   }
 487   if (_ith == _history.end())
 488     return TOP_HISTORY_PY;
 489   else
 490     return (*_ith).c_str();
 491 }
 492
 493 /*!
 494   \brief Set Python standard output device hook.
 495   \param cb callback function
 496   \param data callback function parameters
 497 */
 498 void PyInterp_Interp::setvoutcb(PyOutChanged* cb, void* data)
 499 {
 500   ((PyStdOut*)_vout)->_cb=cb;
 501   ((PyStdOut*)_vout)->_data=data;
 502 }
 503
 504 /*!
 505   \brief Set Python standard error device hook.
 506   \param cb callback function
 507   \param data callback function parameters
 508 */
 509 void PyInterp_Interp::setverrcb(PyOutChanged* cb, void* data)
 510 {
 511   ((PyStdOut*)_verr)->_cb=cb;
 512   ((PyStdOut*)_verr)->_data=data;
 513 }