src/scriptinst.cpp

   1 /*********************************
   2 ** Tsunagari Tile Engine        **
   3 ** scriptinst.cpp               **
   4 ** Copyright 2011-2012 OmegaSDG **
   5 *********************************/
   6
   7 // "OmegaSDG" is defined as Michael D. Reiley and Paul Merrill.
   8
   9 // **********
  10 // Permission is hereby granted, free of charge, to any person obtaining a copy
  11 // of this software and associated documentation files (the "Software"), to
  12 // deal in the Software without restriction, including without limitation the
  13 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  14 // sell copies of the Software, and to permit persons to whom the Software is
  15 // furnished to do so, subject to the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be included in
  18 // all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  25 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  26 // IN THE SOFTWARE.
  27 // **********
  28
  29 // from Python
  30 #include <import.h>
  31
  32 #include "log.h"
  33 #include "python.h"
  34 #include "reader.h"
  35 #include "scriptinst.h"
  36
  37
  38 struct validate_visitor : public boost::static_visitor<bool>
  39 {
  40         bool operator()(BytecodeRef bc) const
  41         {
  42                 if (!bc) {
  43                         Log::err("ScriptInst", "<null script>: script not valid");
  44                         return false;
  45                 }
  46                 if (!bc->valid()) {
  47                         Log::err("ScriptInst", bc->filename() +
  48                                 ": script not valid");
  49                         return false;
  50                 }
  51                 return true;
  52         }
  53
  54         bool operator()(boost::python::object) const
  55         {
  56                 return true;
  57         }
  58 };
  59
  60
  61 struct invoke_visitor : public boost::static_visitor<bool>
  62 {
  63         bool operator()(BytecodeRef bc) const
  64         {
  65                 return (bc && bc->valid()) ? bc->execute() : false;
  66         }
  67
  68         bool operator()(boost::python::object callable) const
  69         {
  70                 try {
  71                         inPythonScript++;
  72                         callable();
  73                         inPythonScript--;
  74                         return true;
  75                 } catch (boost::python::error_already_set) {
  76                         inPythonScript--;
  77                         // XXX: How does this interact with a C++/Python callstack?
  78                         //Log::err("Python", "Originating from " + source + ":");
  79                         pythonErr();
  80                         return false;
  81                 }
  82         }
  83 };
  84
  85
  86
  87 ScriptInst::ScriptInst(const std::string& source)
  88         : data(Reader::getBytecode(source))
  89 {
  90         if (!validate()) {
  91                 Log::err("ScriptInst", "Error loading " + source);
  92         }
  93 }
  94
  95
  96 ScriptInst::ScriptInst(boost::python::object callable)
  97         : data(callable)
  98 {
  99 }
 100
 101
 102 bool ScriptInst::validate()
 103 {
 104         return boost::apply_visitor(validate_visitor(), data);
 105 }
 106
 107
 108 bool ScriptInst::invoke()
 109 {
 110         return boost::apply_visitor(invoke_visitor(), data);
 111 }
 112
 113
 114 struct topython_visitor : public boost::static_visitor<PyObject*>
 115 {
 116         PyObject* operator()(BytecodeRef bc) const
 117         {
 118                 boost::python::object str;
 119                 if (bc)
 120                         str = boost::python::object(bc->filename());
 121                 else
 122                         str = boost::python::object("");
 123                 return boost::python::incref(str.ptr());
 124         }
 125
 126         PyObject* operator()(boost::python::object callable) const
 127         {
 128                 return boost::python::incref(callable.ptr());
 129         }
 130 };
 131
 132
 133 struct scriptinst_to_python
 134 {
 135         static PyObject* convert(ScriptInst script)
 136         {
 137                 return boost::apply_visitor(topython_visitor(), script.data);
 138         }
 139 };
 140
 141
 142 struct scriptinst_from_python
 143 {
 144         scriptinst_from_python()
 145         {
 146                 boost::python::converter::registry::push_back(
 147                         &convertible,
 148                         &construct,
 149                         boost::python::type_id<ScriptInst>());
 150         }
 151
 152         // Can this be converted to a ScriptInst?
 153         static void* convertible(PyObject* obj)
 154         {
 155                 //bool callable = obj->ob_type->tp_call != NULL;
 156                 //const char* tp_name = obj->ob_type->tp_name;
 157                 // XXX: Return non-NULL only if string or
 158                 // callable (fn or lambda?).
 159                 return obj;
 160         }
 161
 162         // Convert. boost::python provides us with a chunch of memory that we
 163         // have to construct in-place.
 164         static void construct(
 165                 PyObject* obj,
 166                 boost::python::converter::rvalue_from_python_stage1_data* data)
 167         {
 168                 // Prevent compilation name collisions with "object" by making
 169                 // it "bp::object".
 170                 namespace bp = boost::python;
 171
 172                 void* storage =
 173                     ((bp::converter::rvalue_from_python_storage<ScriptInst>*)data)
 174                                 ->storage.bytes;
 175
 176                 if (PyString_Check(obj)) {
 177                         const char* value = PyString_AsString(obj);
 178                         new (storage) ScriptInst(value);
 179                 }
 180                 else {
 181                         // By default, the PyObject is a borrowed reference,
 182                         // which means it hasn't been incref'd.
 183                         bp::handle<> hndl(bp::borrowed(obj));
 184                         new (storage) ScriptInst(bp::object(hndl));
 185                 }
 186
 187                 data->convertible = storage;
 188         }
 189 };
 190
 191
 192 void exportScriptInst()
 193 {
 194         using namespace boost::python;
 195
 196         to_python_converter<ScriptInst, scriptinst_to_python>();
 197         scriptinst_from_python();
 198 }
 199