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