src/scriptinst.cpp

   1 #include "log.h"
   2 #include "python.h"
   3 #include "resourcer.h"
   4 #include "scriptinst.h"
   5
   6 struct validate_visitor : public boost::static_visitor<bool>
   7 {
   8         std::string context;
   9
  10         validate_visitor(const std::string& context) : context(context) {}
  11
  12         bool operator()(void*) const
  13         {
  14                 return true;
  15         }
  16
  17         bool operator()(ScriptInst::strref ref) const
  18         {
  19                 Resourcer* rc = Resourcer::instance();
  20
  21                 if (ref.filename.empty()) {
  22                         Log::err(context,
  23                                 "script filename is empty");
  24                         return false;
  25                 }
  26
  27                 if (!rc->resourceExists(ref.filename)) {
  28                         Log::err(context,
  29                                 ref.filename + "script file not found");
  30                         return false;
  31                 }
  32
  33                 return true;
  34         }
  35
  36         bool operator()(boost::python::object) const
  37         {
  38                 return true;
  39         }
  40 };
  41
  42 struct invoke_visitor : public boost::static_visitor<bool>
  43 {
  44         bool operator()(void*) const
  45         {
  46                 return true;
  47         }
  48
  49         bool operator()(ScriptInst::strref ref) const
  50         {
  51                 Resourcer* rc = Resourcer::instance();
  52
  53                 if (ref.funcname.size()) {
  54                         rc->runPythonScript(ref.filename);
  55                         return pythonExec(ref.funccall);
  56                 }
  57                 else {
  58                         return rc->runPythonScript(ref.filename);
  59                 }
  60         }
  61
  62         bool operator()(boost::python::object pyfn) const
  63         {
  64                 try {
  65                         inPythonScript++;
  66                         pyfn();
  67                         inPythonScript--;
  68                         return true;
  69                 } catch (boost::python::error_already_set) {
  70                         inPythonScript--;
  71                         pythonErr();
  72                         return false;
  73                 }
  74         }
  75 };
  76
  77 ScriptInst::ScriptInst()
  78         : data((void*)NULL)
  79 {
  80 }
  81
  82 ScriptInst::ScriptInst(const std::string& strloc)
  83 {
  84         size_t colon = strloc.find(':');
  85         strref ref;
  86         if (colon == std::string::npos) {
  87                 ref.filename = strloc;
  88         }
  89         else {
  90                 ref.filename = strloc.substr(0, colon);
  91                 ref.funcname = strloc.substr(colon + 1);
  92                 ref.funccall = pythonCompile(
  93                         "<Tsunagari trigger>",
  94                         (ref.funcname).c_str()
  95                 );
  96         }
  97         data = ref;
  98 }
  99
 100 ScriptInst::ScriptInst(boost::python::object pyfn)
 101         : data(pyfn)
 102 {
 103 }
 104
 105 bool ScriptInst::validate(const std::string& context)
 106 {
 107         return boost::apply_visitor(validate_visitor(context), data);
 108 }
 109
 110 bool ScriptInst::invoke()
 111 {
 112         return boost::apply_visitor(invoke_visitor(), data);
 113 }
 114
 115
 116
 117
 118
 119
 120
 121
 122 struct topython_visitor : public boost::static_visitor<PyObject*>
 123 {
 124         PyObject* operator()(void*) const
 125         {
 126                 using namespace boost::python;
 127
 128                 return incref(Py_None);
 129         }
 130
 131         PyObject* operator()(ScriptInst::strref ref) const
 132         {
 133                 using namespace boost::python;
 134
 135                 object str;
 136                 if (ref.funcname.size())
 137                         str = object(ref.filename + ":" + ref.funcname);
 138                 else
 139                         str = object(ref.filename);
 140                 return incref(str.ptr());
 141         }
 142
 143         PyObject* operator()(boost::python::object pyfn) const
 144         {
 145                 using namespace boost::python;
 146
 147                 return incref(pyfn.ptr());
 148         }
 149 };
 150
 151
 152 struct scriptinst_to_python
 153 {
 154         static PyObject* convert(ScriptInst script)
 155         {
 156                 return boost::apply_visitor(topython_visitor(), script.data);
 157         }
 158 };
 159
 160
 161 struct scriptinst_from_python
 162 {
 163         scriptinst_from_python()
 164         {
 165                 boost::python::converter::registry::push_back(
 166                         &convertible,
 167                         &construct,
 168                         boost::python::type_id<ScriptInst>());
 169         }
 170
 171         // Can this be converted to a ScriptInst?
 172         static void* convertible(PyObject* obj)
 173         {
 174                 // XXX: Return non-NULL only if string or
 175                 // callable (fn or lambda?).
 176                 return obj;
 177         }
 178
 179         // Convert. boost::python provides us with a chunch of memory that we
 180         // have to construct in-place.
 181         static void construct(
 182                 PyObject* obj,
 183                 boost::python::converter::rvalue_from_python_stage1_data* data)
 184         {
 185                 using namespace boost::python;
 186
 187                 void* storage =
 188                         ((converter::rvalue_from_python_storage<ScriptInst>*)data)
 189                                 ->storage.bytes;
 190
 191                 if (PyString_Check(obj)) {
 192                         const char* value = PyString_AsString(obj);
 193                         new (storage) ScriptInst(value);
 194                 }
 195                 else {
 196                         // By default, the PyObject is a borrowed reference,
 197                         // which means it hasn't been incref'd.
 198                         handle<> hndl(borrowed(obj));
 199                         new (storage) ScriptInst(object(hndl));
 200                 }
 201
 202                 data->convertible = storage;
 203         }
 204 };
 205
 206 void exportScriptInst()
 207 {
 208         using namespace boost::python;
 209
 210         to_python_converter<ScriptInst, scriptinst_to_python>();
 211         scriptinst_from_python();
 212 }
 213