wip

Author: LanderlYoung

backend/Python/PyEngine.cc

@@ -17,16 +17,18 @@
 
 #include "PyEngine.h"
 #include "../../src/Utils.h"
+#include "pydebug.h"
+#include "pylifecycle.h"
 
 namespace script::py_backend {
 
-PyEngine::PyEngine(std::shared_ptr<utils::MessageQueue> queue) {}
+PyEngine::PyEngine(std::shared_ptr<utils::MessageQueue> queue) { Py_Initialize(); }
 
 PyEngine::PyEngine() : PyEngine(std::shared_ptr<utils::MessageQueue>{}) {}
 
 PyEngine::~PyEngine() = default;
 
-void PyEngine::destroy() noexcept {}
+void PyEngine::destroy() noexcept { ScriptEngine::destroyUserData(); }
 
 Local<Value> PyEngine::get(const Local<String>& key) { return Local<Value>(); }
 
@@ -50,9 +52,9 @@ void PyEngine::gc() {}
 
 void PyEngine::adjustAssociatedMemory(int64_t count) {}
 
-ScriptLanguage PyEngine::getLanguageType() { return ScriptLanguage::kJavaScript; }
+ScriptLanguage PyEngine::getLanguageType() { return ScriptLanguage::kPython; }
 
-std::string PyEngine::getEngineVersion() { return ""; }
+std::string PyEngine::getEngineVersion() { return Py_GetVersion(); }
 
 bool PyEngine::isDestroying() const { return false; }
 

backend/Python/PyEngine.h

@@ -20,6 +20,7 @@
 #include "../../src/Engine.h"
 #include "../../src/Exception.h"
 #include "../../src/utils/MessageQueue.h"
+#include "PyHelper.h"
 
 namespace script::py_backend {
 

backend/Python/PyHelper.cc

@@ -15,4 +15,29 @@
  * limitations under the License.
  */
 
-#include "PyHelper.hpp"
+#include "PyHelper.hpp"
+
+namespace script::py_backend {
+
+PyObject* checkException(PyObject* obj) {
+  if (!obj) {
+    checkException();
+  }
+  return obj;
+}
+
+int checkException(int ret) {
+  if (ret == -1) {
+    checkException();
+  }
+  return ret;
+}
+
+void checkException() {
+  auto err = PyErr_Occurred();
+  if (err) {
+    // TODO
+  }
+}
+
+}  // namespace script::py_backend

backend/Python/PyHelper.h

@@ -19,7 +19,10 @@
 
 #include "../../src/foundation.h"
 
-// docs: https://docs.python.org/3/c-api/index.html
+// docs:
+// https://docs.python.org/3/c-api/index.html
+// https://docs.python.org/3/extending/embedding.html
+// https://docs.python.org/2/c-api/init.html#thread-state-and-the-global-interpreter-lock
 
 SCRIPTX_BEGIN_INCLUDE_LIBRARY
 #ifndef PY_SSIZE_T_CLEAN
@@ -28,4 +31,10 @@ SCRIPTX_BEGIN_INCLUDE_LIBRARY
 #include <Python.h>
 SCRIPTX_END_INCLUDE_LIBRARY
 
-namespace script::py_backend {}
+namespace script::py_backend {
+
+PyObject* checkException(PyObject* obj);
+int checkException(int ret);
+void checkException();
+
+}  // namespace script::py_backend

backend/Python/PyHelper.hpp

@@ -16,6 +16,16 @@
  */
 
 #pragma once
+#include "../../src/Reference.h"
 #include "PyHelper.h"
 
-namespace script::py_backend {}
+namespace script::py_backend {
+
+struct py_interop {
+  template <class T>
+  static Local<T> makeLocal(PyObject* ref) {
+    return Local<T>(ref);
+  }
+};
+
+}  // namespace script::py_backend

backend/Python/PyValue.cc

@@ -19,21 +19,39 @@
 #include "../../src/Reference.h"
 #include "../../src/Scope.h"
 #include "../../src/Value.h"
+#include "PyHelper.hpp"
+
+using script::py_backend::checkException;
+using script::py_backend::py_interop;
 
 namespace script {
 
-Local<Object> Object::newObject() { TEMPLATE_NOT_IMPLEMENTED(); }
+template <typename T>
+Local<T> checkAndMakeLocal(PyObject* ref) {
+  return py_interop::makeLocal<T>(checkException(ref));
+}
+
+// for python this creates an empty dict
+Local<Object> Object::newObject() { return checkAndMakeLocal<Object>(PyDict_New()); }
 
 Local<Object> Object::newObjectImpl(const Local<Value>& type, size_t size,
                                     const Local<Value>* args) {
   TEMPLATE_NOT_IMPLEMENTED();
 }
 
-Local<String> String::newString(const char* utf8) { TEMPLATE_NOT_IMPLEMENTED(); }
+Local<String> String::newString(const char* utf8) {
+  return checkAndMakeLocal<String>(PyBytes_FromString(utf8));
+}
 
-Local<String> String::newString(std::string_view utf8) { TEMPLATE_NOT_IMPLEMENTED(); }
+Local<String> String::newString(std::string_view utf8) {
+  return checkAndMakeLocal<String>(
+      PyBytes_FromStringAndSize(utf8.data(), static_cast<Py_ssize_t>(utf8.length())));
+}
 
-Local<String> String::newString(const std::string& utf8) { TEMPLATE_NOT_IMPLEMENTED(); }
+Local<String> String::newString(const std::string& utf8) {
+  return checkAndMakeLocal<String>(
+      PyBytes_FromStringAndSize(utf8.c_str(), static_cast<Py_ssize_t>(utf8.length())));
+}
 
 #if defined(__cpp_char8_t)
 
@@ -51,19 +69,29 @@ Local<String> String::newString(const std::u8string& utf8) { return newString(ut
 
 Local<Number> Number::newNumber(float value) { return newNumber(static_cast<double>(value)); }
 
-Local<Number> Number::newNumber(double value) { TEMPLATE_NOT_IMPLEMENTED(); }
+Local<Number> Number::newNumber(double value) {
+  return checkAndMakeLocal<Number>(PyLong_FromDouble(value));
+}
 
-Local<Number> Number::newNumber(int32_t value) { return newNumber(static_cast<double>(value)); }
+Local<Number> Number::newNumber(int32_t value) {
+  return checkAndMakeLocal<Number>(PyLong_FromLong(static_cast<long>(value)));
+}
 
-Local<Number> Number::newNumber(int64_t value) { return newNumber(static_cast<double>(value)); }
+Local<Number> Number::newNumber(int64_t value) {
+  return checkAndMakeLocal<Number>(PyLong_FromLongLong(static_cast<long long>(value)));
+}
 
-Local<Boolean> Boolean::newBoolean(bool value) { TEMPLATE_NOT_IMPLEMENTED(); }
+Local<Boolean> Boolean::newBoolean(bool value) {
+  return checkAndMakeLocal<Boolean>(PyBool_FromLong(value));
+}
 
 Local<Function> Function::newFunction(script::FunctionCallback callback) {
   TEMPLATE_NOT_IMPLEMENTED();
 }
 
-Local<Array> Array::newArray(size_t size) { TEMPLATE_NOT_IMPLEMENTED(); }
+Local<Array> Array::newArray(size_t size) {
+  return checkAndMakeLocal<Array>(PyList_New(static_cast<Py_ssize_t>(size)));
+}
 
 Local<Array> Array::newArrayImpl(size_t size, const Local<Value>* args) {
   TEMPLATE_NOT_IMPLEMENTED();

backend/Python/trait/TraitException.h

@@ -16,6 +16,8 @@
  */
 
 #pragma once
+#include <string>
+#include "../../src/types.h"
 
 namespace script {
 

backend/Python/trait/TraitIncludes.h

@@ -22,5 +22,5 @@
 #include "../PyReference.hpp"
 
 // global marco
-#define SCRIPTX_BACKEND_TEMPLATE
-#define SCRIPTX_LANG_NONE
+#define SCRIPTX_BACKEND_PYTHON
+#define SCRIPTX_LANG_PYTHON

backend/Python/trait/TraitNative.h

@@ -16,6 +16,7 @@
  */
 
 #pragma once
+#include "../../src/types.h"
 
 namespace script {
 

backend/Python/trait/TraitReference.h

@@ -20,22 +20,23 @@
 #include <cstdint>
 #include <string>
 #include "../../src/types.h"
+#include "../PyHelper.h"
 
 namespace script::internal {
 
 template <typename T>
 struct ImplType<Local<T>> {
-  using type = int;
+  using type = PyObject*;
 };
 
 template <typename T>
 struct ImplType<Global<T>> {
-  using type = int;
+  using type = PyObject*;
 };
 
 template <typename T>
 struct ImplType<Weak<T>> {
-  using type = int;
+  using type = PyObject*;
 };
 
 }  // namespace script::internal