NLA SoC: Merge from 2.5
[blender.git] / source / gameengine / GameLogic / SCA_PythonController.cpp
1 /**
2  * Execute Python scripts
3  *
4  * $Id$
5  *
6  * ***** BEGIN GPL LICENSE BLOCK *****
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL LICENSE BLOCK *****
30  */
31
32 #include "SCA_PythonController.h"
33 #include "SCA_LogicManager.h"
34 #include "SCA_ISensor.h"
35 #include "SCA_IActuator.h"
36 #include "PyObjectPlus.h"
37 #include "compile.h"
38 #include "eval.h"
39 #include <algorithm>
40
41
42 #ifdef HAVE_CONFIG_H
43 #include <config.h>
44 #endif
45
46 // initialize static member variables
47 SCA_PythonController* SCA_PythonController::m_sCurrentController = NULL;
48
49
50 SCA_PythonController::SCA_PythonController(SCA_IObject* gameobj, int mode)
51         : SCA_IController(gameobj),
52         m_bytecode(NULL),
53         m_function(NULL),
54         m_function_argc(0),
55         m_bModified(true),
56         m_debug(false),
57         m_mode(mode),
58         m_pythondictionary(NULL)
59 {
60         
61 }
62
63 /*
64 //debugging
65 CValue*         SCA_PythonController::AddRef()
66 {
67         //printf("AddRef refcount = %i\n",GetRefCount());
68         return CValue::AddRef();
69 }
70 int                     SCA_PythonController::Release()
71 {
72         //printf("Release refcount = %i\n",GetRefCount());
73         return CValue::Release();
74 }
75 */
76
77
78
79 SCA_PythonController::~SCA_PythonController()
80 {
81         //printf("released python byte script\n");
82         
83         Py_XDECREF(m_bytecode);
84         Py_XDECREF(m_function);
85         
86         if (m_pythondictionary) {
87                 // break any circular references in the dictionary
88                 PyDict_Clear(m_pythondictionary);
89                 Py_DECREF(m_pythondictionary);
90         }
91 }
92
93
94
95 CValue* SCA_PythonController::GetReplica()
96 {
97         SCA_PythonController* replica = new SCA_PythonController(*this);
98         
99         /* why is this needed at all??? - m_bytecode is NULL'd below so this doesnt make sense
100          * but removing it crashes blender (with YoFrankie). so leave in for now - Campbell */
101         Py_XINCREF(replica->m_bytecode);
102         
103         Py_XINCREF(replica->m_function); // this is ok since its not set to NULL
104         replica->m_bModified = replica->m_bytecode == NULL;
105         
106         // The replica->m_pythondictionary is stolen - replace with a copy.
107         if (m_pythondictionary)
108                 replica->m_pythondictionary = PyDict_Copy(m_pythondictionary);
109                 
110         /*
111         // The other option is to incref the replica->m_pythondictionary -
112         // the replica objects can then share data.
113         if (m_pythondictionary)
114                 Py_INCREF(replica->m_pythondictionary);
115         */
116         
117         // this will copy properties and so on...
118         replica->ProcessReplica();
119
120         return replica;
121 }
122
123
124
125 void SCA_PythonController::SetScriptText(const STR_String& text)
126
127         m_scriptText = text;
128         m_bModified = true;
129 }
130
131
132
133 void SCA_PythonController::SetScriptName(const STR_String& name)
134 {
135         m_scriptName = name;
136 }
137
138
139
140 void SCA_PythonController::SetDictionary(PyObject*      pythondictionary)
141 {
142         if (m_pythondictionary)
143         {
144                 PyDict_Clear(m_pythondictionary);
145                 Py_DECREF(m_pythondictionary);
146         }
147         m_pythondictionary = PyDict_Copy(pythondictionary); /* new reference */
148         
149         /* Without __file__ set the sys.argv[0] is used for the filename
150          * which ends up with lines from the blender binary being printed in the console */
151         PyDict_SetItemString(m_pythondictionary, "__file__", PyUnicode_FromString(m_scriptName.Ptr()));
152         
153 }
154
155 int SCA_PythonController::IsTriggered(class SCA_ISensor* sensor)
156 {
157         if (std::find(m_triggeredSensors.begin(), m_triggeredSensors.end(), sensor) != 
158                 m_triggeredSensors.end())
159                 return 1;
160         return 0;
161 }
162
163 /* warning, self is not the SCA_PythonController, its a PyObjectPlus_Proxy */
164 PyObject* SCA_PythonController::sPyGetCurrentController(PyObject *self)
165 {
166         if(m_sCurrentController==NULL)
167         {
168                 PyErr_SetString(PyExc_SystemError, "GameLogic.getCurrentController(), this function is being run outside the python controllers context, or blenders internal state is corrupt.");
169                 return NULL;
170         }
171         return m_sCurrentController->GetProxy();
172 }
173
174 SCA_IActuator* SCA_PythonController::LinkedActuatorFromPy(PyObject *value)
175 {
176         // for safety, todo: only allow for registered actuators (pointertable)
177         // we don't want to crash gameengine/blender by python scripts
178         std::vector<SCA_IActuator*> lacts =  m_sCurrentController->GetLinkedActuators();
179         std::vector<SCA_IActuator*>::iterator it;
180         
181         if (PyUnicode_Check(value)) {
182                 /* get the actuator from the name */
183                 char *name= _PyUnicode_AsString(value);
184                 for(it = lacts.begin(); it!= lacts.end(); ++it) {
185                         if( name == (*it)->GetName() ) {
186                                 return *it;
187                         }
188                 }
189         }
190         else if (PyObject_TypeCheck(value, &SCA_IActuator::Type)) {
191                 PyObjectPlus *value_plus= BGE_PROXY_REF(value);
192                 for(it = lacts.begin(); it!= lacts.end(); ++it) {
193                         if( static_cast<SCA_IActuator*>(value_plus) == (*it) ) {
194                                 return *it;
195                         }
196                 }
197         }
198         
199         /* set the exception */
200         PyObject *value_str = PyObject_Repr(value); /* new ref */
201         PyErr_Format(PyExc_ValueError, "'%s' not in this python controllers actuator list", _PyUnicode_AsString(value_str));
202         Py_DECREF(value_str);
203         
204         return false;
205 }
206
207 /* warning, self is not the SCA_PythonController, its a PyObjectPlus_Proxy */
208 PyObject* SCA_PythonController::sPyAddActiveActuator(PyObject* self, PyObject* args)
209 {
210         ShowDeprecationWarning("GameLogic.addActiveActuator(act, bool)", "controller.activate(act) or controller.deactivate(act)");
211         
212         PyObject* ob1;
213         int activate;
214         if (!PyArg_ParseTuple(args, "Oi:addActiveActuator", &ob1,&activate))
215                 return NULL;
216         
217         SCA_IActuator* actu = LinkedActuatorFromPy(ob1);
218         if(actu==NULL)
219                 return NULL;
220         
221         bool boolval = (activate!=0);
222         m_sCurrentLogicManager->AddActiveActuator((SCA_IActuator*)actu,boolval);
223         Py_RETURN_NONE;
224 }
225
226 const char* SCA_PythonController::sPyGetCurrentController__doc__ = "getCurrentController()";
227 const char* SCA_PythonController::sPyAddActiveActuator__doc__= "addActiveActuator(actuator,bool)";
228
229 PyTypeObject SCA_PythonController::Type = {
230 #if (PY_VERSION_HEX >= 0x02060000)
231         PyVarObject_HEAD_INIT(NULL, 0)
232 #else
233         /* python 2.5 and below */
234         PyObject_HEAD_INIT( NULL )  /* required py macro */
235         0,                          /* ob_size */
236 #endif
237                 "SCA_PythonController",
238                 sizeof(PyObjectPlus_Proxy),
239                 0,
240                 py_base_dealloc,
241                 0,
242                 0,
243                 0,
244                 0,
245                 py_base_repr,
246                 0,0,0,0,0,0,0,0,0,
247                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
248                 0,0,0,0,0,0,0,
249                 Methods,
250                 0,
251                 0,
252                 &SCA_IController::Type,
253                 0,0,0,0,0,0,
254                 py_base_new
255 };
256
257 PyMethodDef SCA_PythonController::Methods[] = {
258         {"activate", (PyCFunction) SCA_PythonController::sPyActivate, METH_O},
259         {"deactivate", (PyCFunction) SCA_PythonController::sPyDeActivate, METH_O},
260         
261         //Deprecated functions ------>
262         {"setScript", (PyCFunction) SCA_PythonController::sPySetScript, METH_O},
263         {"getScript", (PyCFunction) SCA_PythonController::sPyGetScript, METH_NOARGS},
264         //<----- Deprecated
265         {NULL,NULL} //Sentinel
266 };
267
268 PyAttributeDef SCA_PythonController::Attributes[] = {
269         KX_PYATTRIBUTE_RW_FUNCTION("script", SCA_PythonController, pyattr_get_script, pyattr_set_script),
270         KX_PYATTRIBUTE_INT_RO("mode", SCA_PythonController, m_mode),
271         { NULL }        //Sentinel
272 };
273
274 void SCA_PythonController::ErrorPrint(const char *error_msg)
275 {
276         // didn't compile, so instead of compile, complain
277         // something is wrong, tell the user what went wrong
278         printf("%s - controller \"%s\":\n", error_msg, GetName().Ptr());
279         //PyRun_SimpleString(m_scriptText.Ptr());
280         PyErr_Print();
281         
282         /* Added in 2.48a, the last_traceback can reference Objects for example, increasing
283          * their user count. Not to mention holding references to wrapped data.
284          * This is especially bad when the PyObject for the wrapped data is free'd, after blender 
285          * has alredy dealocated the pointer */
286         PySys_SetObject( (char *)"last_traceback", NULL);
287         PyErr_Clear(); /* just to be sure */
288 }
289
290 bool SCA_PythonController::Compile()
291 {       
292         //printf("py script modified '%s'\n", m_scriptName.Ptr());
293         m_bModified= false;
294         
295         // if a script already exists, decref it before replace the pointer to a new script
296         if (m_bytecode) {
297                 Py_DECREF(m_bytecode);
298                 m_bytecode=NULL;
299         }
300         
301         // recompile the scripttext into bytecode
302         m_bytecode = Py_CompileString(m_scriptText.Ptr(), m_scriptName.Ptr(), Py_file_input);
303         
304         if (m_bytecode) {
305                 return true;
306         } else {
307                 ErrorPrint("Python error compiling script");
308                 return false;
309         }
310 }
311
312 bool SCA_PythonController::Import()
313 {
314         //printf("py module modified '%s'\n", m_scriptName.Ptr());
315         m_bModified= false;
316         
317         /* incase we re-import */
318         Py_XDECREF(m_function);
319         m_function= NULL;
320         
321         vector<STR_String> py_function_path = m_scriptText.Explode('.');
322         
323         if(py_function_path.size() < 2) {
324                 printf("Python module name formatting error \"%s\":\n\texpected \"SomeModule.Func\", got \"%s\"\n", GetName().Ptr(), m_scriptText.Ptr());
325                 return false;
326         }
327         
328         PyObject *mod = PyImport_ImportModule((char *)py_function_path[0].Ptr());
329         /* Dont reload yet, do this within the loop so packages reload too */
330         
331         if(mod==NULL) {
332                 ErrorPrint("Python module not found");
333                 return false;
334         }
335         /* 'mod' will be DECREF'd as 'base' 
336          * 'm_function' will be left holding a reference that the controller owns */
337         
338         PyObject *base= mod;
339         
340         for(unsigned int i=1; i < py_function_path.size(); i++) {
341                 if(m_debug && PyModule_Check(base)) { /* base could be a class */
342                         Py_DECREF(base); /* getting a new one so dont hold a ref to the old one */
343                         base= PyImport_ReloadModule(base);
344                         if (base==NULL) {
345                                 m_function= NULL;
346                                 break;
347                         }
348                 }
349                 
350                 m_function = PyObject_GetAttrString(base, py_function_path[i].Ptr());
351                 Py_DECREF(base);
352                 base = m_function; /* for the next loop if there is on */
353                 
354                 if(m_function==NULL) {
355                         break;
356                 }
357         }
358         
359         if(m_function==NULL) {
360                 if(PyErr_Occurred())
361                         ErrorPrint("Python controller found the module but could not access the function");
362                 else
363                         printf("Python module error \"%s\":\n \"%s\" module found but function missing\n", GetName().Ptr(), m_scriptText.Ptr());
364                 return false;
365         }
366         
367         if(!PyCallable_Check(m_function)) {
368                 Py_DECREF(m_function);
369                 printf("Python module function error \"%s\":\n \"%s\" not callable\n", GetName().Ptr(), m_scriptText.Ptr());
370                 return false;
371         }
372         
373         m_function_argc = 0; /* rare cases this could be a function that isnt defined in python, assume zero args */
374         if (PyFunction_Check(m_function)) {
375                 PyObject *py_arg_count = PyObject_GetAttrString(PyFunction_GET_CODE(m_function), "co_argcount");
376                 if(py_arg_count) {
377                         m_function_argc = PyLong_AsLong(py_arg_count);
378                         Py_DECREF(py_arg_count);
379                 }
380                 else {
381                         PyErr_Clear(); /* unlikely to fail but just incase */
382                 }
383         }
384         
385         if(m_function_argc > 1) {
386                 Py_DECREF(m_function);
387                 printf("Python module function has \"%s\":\n \"%s\" takes %d args, should be zero or 1 controller arg\n", GetName().Ptr(), m_scriptText.Ptr(), m_function_argc);
388                 return false;
389         }
390         
391         return true;
392 }
393
394 void SCA_PythonController::Trigger(SCA_LogicManager* logicmgr)
395 {
396         m_sCurrentController = this;
397         m_sCurrentLogicManager = logicmgr;
398         
399         PyObject *excdict=              NULL;
400         PyObject* resultobj=    NULL;
401         
402         switch(m_mode) {
403         case SCA_PYEXEC_SCRIPT:
404         {
405                 if (m_bModified)
406                         if (Compile()==false) // sets m_bModified to false
407                                 return;
408                 if (!m_bytecode)
409                         return;
410                 
411                 /*
412                  * This part here with excdict is a temporary patch
413                  * to avoid python/gameengine crashes when python
414                  * inadvertently holds references to game objects
415                  * in global variables.
416                  * 
417                  * The idea is always make a fresh dictionary, and
418                  * destroy it right after it is used to make sure
419                  * python won't hold any gameobject references.
420                  * 
421                  * Note that the PyDict_Clear _is_ necessary before
422                  * the Py_DECREF() because it is possible for the
423                  * variables inside the dictionary to hold references
424                  * to the dictionary (ie. generate a cycle), so we
425                  * break it by hand, then DECREF (which in this case
426                  * should always ensure excdict is cleared).
427                  */
428
429                 excdict= PyDict_Copy(m_pythondictionary);
430                 resultobj = PyEval_EvalCode((PyCodeObject*)m_bytecode, excdict, excdict);
431                 /* PyRun_SimpleString(m_scriptText.Ptr()); */
432                 break;
433         }
434         case SCA_PYEXEC_MODULE:
435         {
436                 if (m_bModified || m_debug)
437                         if (Import()==false) // sets m_bModified to false
438                                 return;
439                 if (!m_function)
440                         return;
441                 
442                 PyObject *args= NULL;
443                 
444                 if(m_function_argc==1) {
445                         args = PyTuple_New(1);
446                         PyTuple_SET_ITEM(args, 0, GetProxy());
447                 }
448                 
449                 resultobj = PyObject_CallObject(m_function, args);
450                 Py_XDECREF(args);
451                 break;
452         }
453         
454         } /* end switch */
455         
456         
457         
458         /* Free the return value and print the error */
459         if (resultobj)
460         {
461                 Py_DECREF(resultobj);
462         }
463         else
464         {
465                 // something is wrong, tell the user what went wrong
466                 printf("Python script error from controller \"%s\":\n", GetName().Ptr());
467                 PyErr_Print();
468                 
469                 /* Added in 2.48a, the last_traceback can reference Objects for example, increasing
470                  * their user count. Not to mention holding references to wrapped data.
471                  * This is especially bad when the PyObject for the wrapped data is free'd, after blender 
472                  * has alredy dealocated the pointer */
473                 PySys_SetObject( (char *)"last_traceback", NULL);
474                 PyErr_Clear(); /* just to be sure */
475         }
476         
477         if(excdict) /* Only for SCA_PYEXEC_SCRIPT types */
478         {
479                 /* clear after PyErrPrint - seems it can be using
480                  * something in this dictionary and crash? */
481                 PyDict_Clear(excdict);
482                 Py_DECREF(excdict);
483         }       
484         
485         m_triggeredSensors.clear();
486         m_sCurrentController = NULL;
487 }
488
489 PyObject* SCA_PythonController::PyActivate(PyObject *value)
490 {
491         if(m_sCurrentController != this) {
492                 PyErr_SetString(PyExc_SystemError, "Cannot add an actuator from a non-active controller");
493                 return NULL;
494         }
495         
496         SCA_IActuator* actu = LinkedActuatorFromPy(value);
497         if(actu==NULL)
498                 return NULL;
499         
500         m_sCurrentLogicManager->AddActiveActuator((SCA_IActuator*)actu, true);
501         Py_RETURN_NONE;
502 }
503
504 PyObject* SCA_PythonController::PyDeActivate(PyObject *value)
505 {
506         if(m_sCurrentController != this) {
507                 PyErr_SetString(PyExc_SystemError, "Cannot add an actuator from a non-active controller");
508                 return NULL;
509         }
510         
511         SCA_IActuator* actu = LinkedActuatorFromPy(value);
512         if(actu==NULL)
513                 return NULL;
514         
515         m_sCurrentLogicManager->AddActiveActuator((SCA_IActuator*)actu, false);
516         Py_RETURN_NONE;
517 }
518
519 /* 1. getScript */
520 PyObject* SCA_PythonController::PyGetScript()
521 {
522         ShowDeprecationWarning("getScript()", "the script property");
523         return PyUnicode_FromString(m_scriptText);
524 }
525
526 /* 2. setScript */
527 PyObject* SCA_PythonController::PySetScript(PyObject* value)
528 {
529         char *scriptArg = _PyUnicode_AsString(value);
530         
531         ShowDeprecationWarning("setScript()", "the script property");
532         
533         if (scriptArg==NULL) {
534                 PyErr_SetString(PyExc_TypeError, "expected a string (script name)");
535                 return NULL;
536         }
537         
538         /* set scripttext sets m_bModified to true, 
539                 so next time the script is needed, a reparse into byte code is done */
540
541         this->SetScriptText(scriptArg);
542         
543         Py_RETURN_NONE;
544 }
545
546 PyObject* SCA_PythonController::pyattr_get_script(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
547 {
548         //SCA_PythonController* self= static_cast<SCA_PythonController*>(static_cast<SCA_IController*>(static_cast<SCA_ILogicBrick*>(static_cast<CValue*>(static_cast<PyObjectPlus*>(self_v)))));
549         // static_cast<void *>(dynamic_cast<Derived *>(obj)) - static_cast<void *>(obj)
550
551         SCA_PythonController* self= static_cast<SCA_PythonController*>(self_v);
552         return PyUnicode_FromString(self->m_scriptText);
553 }
554
555
556
557 int SCA_PythonController::pyattr_set_script(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
558 {
559         SCA_PythonController* self= static_cast<SCA_PythonController*>(self_v);
560         
561         char *scriptArg = _PyUnicode_AsString(value);
562         
563         if (scriptArg==NULL) {
564                 PyErr_SetString(PyExc_TypeError, "controller.script = string: Python Controller, expected a string script text");
565                 return PY_SET_ATTR_FAIL;
566         }
567
568         /* set scripttext sets m_bModified to true, 
569                 so next time the script is needed, a reparse into byte code is done */
570         self->SetScriptText(scriptArg);
571                 
572         return PY_SET_ATTR_SUCCESS;
573 }
574
575
576 /* eof */