py arguments & newFunction

Author: LanderlYoung

backend/Python/PyHelper.h

@@ -34,6 +34,8 @@ SCRIPTX_END_INCLUDE_LIBRARY
 
 namespace script::py_backend {
 
+class PyEngine;
+
 PyObject* checkException(PyObject* obj);
 int checkException(int ret);
 void checkException();

backend/Python/PyHelper.hpp

@@ -16,16 +16,37 @@
  */
 
 #pragma once
+#include "../../src/Native.hpp"
 #include "../../src/Reference.h"
 #include "PyHelper.h"
 
-namespace script::py_backend {
+namespace script {
 
 struct py_interop {
-  template <class T>
+  template <typename T>
   static Local<T> makeLocal(PyObject* ref) {
     return Local<T>(ref);
   }
+
+  /**
+   * @return stolen ref.
+   */
+  template <typename T>
+  static PyObject* toPy(const Local<T>& ref) {
+    return Py_XNewRef(ref.val_);
+  }
+
+  /**
+   * @return borrowed ref.
+   */
+  template <typename T>
+  static PyObject* asPy(const Local<T>& ref) {
+    return ref.val_;
+  }
+
+  static Arguments makeArguments(py_backend::PyEngine* engine, PyObject* self, PyObject* args) {
+    return Arguments(py_backend::ArgumentsData{engine, self, args});
+  }
 };
 
-}  // namespace script::py_backend
+}  // namespace script

backend/Python/PyNative.cc

@@ -15,23 +15,37 @@
  * limitations under the License.
  */
 
-#include <ScriptX/ScriptX.h>
+#include "../../src/Native.hpp"
+#include "PyEngine.h"
+#include "PyHelper.hpp"
 
 namespace script {
 
 Arguments::Arguments(InternalCallbackInfoType callbackInfo) : callbackInfo_(callbackInfo) {}
 
 Arguments::~Arguments() = default;
 
-Local<Object> Arguments::thiz() const { TEMPLATE_NOT_IMPLEMENTED(); }
+Local<Object> Arguments::thiz() const {
+  return py_interop::makeLocal<Value>(callbackInfo_.self).asObject();
+}
 
-bool Arguments::hasThiz() const { TEMPLATE_NOT_IMPLEMENTED(); }
+bool Arguments::hasThiz() const { return callbackInfo_.self != nullptr; }
 
-size_t Arguments::size() const { TEMPLATE_NOT_IMPLEMENTED(); }
+size_t Arguments::size() const {
+  if (!callbackInfo_.args) {
+    return 0;
+  }
+  return PyTuple_Size(callbackInfo_.args);
+}
 
-Local<Value> Arguments::operator[](size_t i) const { return {}; }
+Local<Value> Arguments::operator[](size_t i) const {
+  if (i < size()) {
+    return py_interop::makeLocal<Value>(PyTuple_GetItem(callbackInfo_.args, i));
+  }
+  return {};
+}
 
-ScriptEngine* Arguments::engine() const { return nullptr; }
+ScriptEngine* Arguments::engine() const { return callbackInfo_.engine; }
 
 ScriptClass::ScriptClass(const script::Local<script::Object>& scriptObject) : internalState_() {
   TEMPLATE_NOT_IMPLEMENTED();

backend/Python/PyValue.cc

@@ -85,8 +85,54 @@ Local<Boolean> Boolean::newBoolean(bool value) {
   return checkAndMakeLocal<Boolean>(PyBool_FromLong(value));
 }
 
+namespace {
+
+static constexpr const char* kFunctionDataName = "capsule_function_data";
+
+struct FunctionData {
+  FunctionCallback function;
+  py_backend::PyEngine* engine = nullptr;
+};
+
+}  // namespace
+
 Local<Function> Function::newFunction(script::FunctionCallback callback) {
-  TEMPLATE_NOT_IMPLEMENTED();
+  auto callbackIns = std::make_unique<FunctionData>();
+  callbackIns->engine = EngineScope::currentEngineAs<py_backend::PyEngine>();
+  callbackIns->function = std::move(callback);
+
+  PyMethodDef method{};
+  method.ml_name = "ScriptX_native_method";
+  method.ml_flags = METH_O;
+  method.ml_doc = "ScriptX Function::newFunction";
+  method.ml_meth = [](PyObject* self, PyObject* args) -> PyObject* {
+    auto ptr = PyCapsule_GetPointer(self, kFunctionDataName);
+    if (ptr == nullptr) {
+      // TODO: exception
+    } else {
+      auto data = static_cast<FunctionData*>(ptr);
+      try {
+        auto ret = data->function(py_interop::makeArguments(nullptr, self, args));
+        return py_interop::toPy(ret);
+      } catch (Exception& e) {
+        // TODO: exception
+      }
+    }
+    return nullptr;
+  };
+
+  auto ctx = PyCapsule_New(callbackIns.get(), kFunctionDataName, [](PyObject* cap) {
+    auto ptr = PyCapsule_GetPointer(cap, kFunctionDataName);
+    delete static_cast<FunctionData*>(ptr);
+  });
+
+  PyObject* closure = PyCFunction_New(&method, ctx);
+
+  Py_XDECREF(ctx);
+
+  // todo: check exception
+  callbackIns.release();
+  return Local<Function>(closure);
 }
 
 Local<Array> Array::newArray(size_t size) {

backend/Python/trait/TraitNative.h

@@ -17,14 +17,16 @@
 
 #pragma once
 #include "../../src/types.h"
+#include "../PyHelper.h"
 
 namespace script {
 
 namespace py_backend {
 
 struct ArgumentsData {
-  int stackBase;
-  size_t size;
+  mutable PyEngine* engine;
+  PyObject* self;
+  PyObject* args;
 };
 
 struct ScriptClassState {

backend/Python/trait/TraitUtils.h

@@ -20,9 +20,7 @@
 
 namespace script {
 
-namespace py_backend {
 struct py_interop;
-}
 
 template <>
 struct internal::ImplType<StringHolder> {
@@ -31,7 +29,7 @@ struct internal::ImplType<StringHolder> {
 
 template <>
 struct internal::ImplType<internal::interop> {
-  using type = py_backend::py_interop;
+  using type = py_interop;
 };
 
 }  // namespace script