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  */
 282 bool PyInterp_Interp::initContext()
 283 {
 284   PyObject *m = PyImport_AddModule("__main__");  // interpreter main module (module context)
 285   if(!m){
 286     PyErr_Print();
 287     return false;
 288   }
 289   _global_context = PyModule_GetDict(m);          // get interpreter global variable context
 290   Py_INCREF(_global_context);
 291   _local_context = PyDict_New();
 292   return true;
 293 }
 294
 295 /*!
 296  * Destroy context dictionaries. GIL is held already.
 297  */
 298 void PyInterp_Interp::closeContext()
 299 {
 300   Py_XDECREF(_global_context);
 301   Py_XDECREF(_local_context);
 302 }
 303
 304 /*!
 305   \brief Compile Python command and evaluate it in the
 306          python dictionary contexts if possible. This is not thread-safe.
 307          This is the caller's responsability to make this thread-safe.
 308   \internal
 309   \param command Python command string
 310   \return -1 on fatal error, 1 if command is incomplete and 0
 311          if command is executed successfully
 312  */
 313 static int run_command(const char *command, PyObject * global_ctxt, PyObject * local_ctxt)
 314 {
 315   PyObject *m = PyImport_AddModule("codeop");
 316   if(!m) { // Fatal error. No way to go on.
 317     PyErr_Print();
 318     return -1;
 319   }
 320
 321 //  PyObjWrapper v(Py_CompileString(command, "<salome_input>", Py_file_input));
 322   PyObjWrapper v(PyObject_CallMethod(m,(char*)"compile_command",(char*)"s",command));
 323   if(!v) {
 324     // Error encountered. It should be SyntaxError,
 325     //so we don't write out traceback
 326     PyObjWrapper exception, value, tb;
 327     PyErr_Fetch(&exception, &value, &tb);
 328     PyErr_NormalizeException(&exception, &value, &tb);
 329     PyErr_Display(exception, value, NULL);
 330     return -1;
 331   }
 332   else if (v == Py_None) {
 333     // Incomplete text we return 1 : we need a complete text to execute
 334     return 1;
 335   }
 336   else {
 337     PyObjWrapper r(PyEval_EvalCode((PyCodeObject *)(void *)v,global_ctxt, local_ctxt));
 338     if(!r) {
 339       // Execution error. We return -1
 340       PyErr_Print();
 341       return -1;
 342     }
 343     // The command has been successfully executed. Return 0
 344     return 0;
 345   }
 346 }
 347
 348 void replaceAll(std::string& str, const std::string& from, const std::string& to) {
 349     if(from.empty())
 350         return;
 351     size_t start_pos = 0;
 352     while((start_pos = str.find(from, start_pos)) != std::string::npos) {
 353         str.replace(start_pos, from.length(), to);
 354         start_pos += to.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'
 355     }
 356 }
 357 /*!
 358   \brief Compile Python command and evaluate it in the
 359          python dictionary context if possible. Command might correspond to
 360          the execution of a script with optional arguments.
 361          In this case, command is:
 362          execfile(r"/absolute/path/to/script.py [args:arg1,...,argn]")
 363   \internal
 364   \param command Python command string
 365   \param context Python context (dictionary)
 366   \return -1 on fatal error, 1 if command is incomplete and 0
 367          if command is executed successfully
 368  */
 369 static int compile_command(const char *command, PyObject * global_ctxt, PyObject * local_ctxt)
 370 {
 371   // First guess if command is execution of a script with args, or a simple Python command
 372   std::string singleCommand = command;
 373   std::string commandArgs = "";
 374
 375   std::size_t pos = std::string(command).find("args:");
 376   if (pos != std::string::npos) {
 377     commandArgs = singleCommand.substr(pos+5);
 378     commandArgs = commandArgs.substr(0, commandArgs.length()-3);
 379     singleCommand = singleCommand.substr(0, pos-1)+"\")";
 380   }
 381
 382   if (commandArgs.empty()) {
 383     // process command: expression
 384     // process command: execfile(r"/absolute/path/to/script.py") (no args)
 385     return run_command(singleCommand.c_str(), global_ctxt, local_ctxt);
 386   }
 387   else {
 388     // process command: execfile(r"/absolute/path/to/script.py [args:arg1,...,argn]")
 389     std::string script = singleCommand.substr(11); // remove leading execfile(r"
 390     script = script.substr(0, script.length()-2); // remove trailing ")
 391
 392     std::string preCommandBegin = "import sys; save_argv = sys.argv; sys.argv=[";
 393     std::string preCommandEnd = "];";
 394     replaceAll(commandArgs, ",", "\",\"");
 395     commandArgs = "\""+commandArgs+"\"";
 396     std::string completeCommand = preCommandBegin+"\""+script+"\","+commandArgs+preCommandEnd+singleCommand+";sys.argv=save_argv";
 397     return run_command(completeCommand.c_str(), global_ctxt, local_ctxt);
 398   }
 399 }
 400
 401 /*!
 402   \brief Run Python command - the command has to fit on a single line (no \n!).
 403   Use ';' if you need multiple statements evaluated at once.
 404   \param command Python command
 405   \return command status
 406 */
 407 int PyInterp_Interp::run(const char *command)
 408 {
 409   beforeRun();
 410   return simpleRun(command);
 411 }
 412
 413 /**
 414  * Called before a command is run (when calling run() method). Not thread-safe. Caller's responsability
 415  * to acquire GIL if needed.
 416  */
 417 int PyInterp_Interp::beforeRun()
 418 {
 419   return 0;
 420 }
 421
 422 /*!
 423   \brief Run Python command (used internally). Not thread-safe. GIL acquisition is caller's responsability.
 424   \param command Python command
 425   \param addToHistory if \c true (default), the command is added to the commands history
 426   \return command status
 427 */
 428 int PyInterp_Interp::simpleRun(const char *command, const bool addToHistory)
 429 {
 430   if( addToHistory && strcmp(command,"") != 0 ) {
 431     _history.push_back(command);
 432     _ith = _history.end();
 433   }
 434
 435   // Current stdout and stderr are saved
 436   PyObject * oldOut = PySys_GetObject((char*)"stdout");
 437   PyObject * oldErr = PySys_GetObject((char*)"stderr");
 438   // Keep them alive (PySys_GetObject returned a *borrowed* ref!)
 439   Py_INCREF(oldOut);
 440   Py_INCREF(oldErr);
 441
 442   // Redirect outputs to SALOME Python console before treatment
 443   PySys_SetObject((char*)"stderr",_verr);
 444   PySys_SetObject((char*)"stdout",_vout);
 445
 446   int ier = compile_command(command, _global_context, _local_context);
 447
 448   // Outputs are redirected to what they were before
 449   PySys_SetObject((char*)"stdout",oldOut);
 450   PySys_SetObject((char*)"stderr",oldErr);
 451
 452   return ier;
 453 }
 454
 455 /*!
 456   \brief Get previous command in the commands history.
 457   \return previous command
 458 */
 459 const char * PyInterp_Interp::getPrevious()
 460 {
 461   if(_ith != _history.begin()){
 462     _ith--;
 463     return (*_ith).c_str();
 464   }
 465   else
 466     return BEGIN_HISTORY_PY;
 467 }
 468
 469 /*!
 470   \brief Get next command in the commands history.
 471   \return next command
 472 */
 473 const char * PyInterp_Interp::getNext()
 474 {
 475   if(_ith != _history.end()){
 476     _ith++;
 477   }
 478   if (_ith == _history.end())
 479     return TOP_HISTORY_PY;
 480   else
 481     return (*_ith).c_str();
 482 }
 483
 484 /*!
 485   \brief Set Python standard output device hook.
 486   \param cb callback function
 487   \param data callback function parameters
 488 */
 489 void PyInterp_Interp::setvoutcb(PyOutChanged* cb, void* data)
 490 {
 491   ((PyStdOut*)_vout)->_cb=cb;
 492   ((PyStdOut*)_vout)->_data=data;
 493 }
 494
 495 /*!
 496   \brief Set Python standard error device hook.
 497   \param cb callback function
 498   \param data callback function parameters
 499 */
 500 void PyInterp_Interp::setverrcb(PyOutChanged* cb, void* data)
 501 {
 502   ((PyStdOut*)_verr)->_cb=cb;
 503   ((PyStdOut*)_verr)->_data=data;
 504 }