Add more python support

.github/workflows/unit_tests.yml

@@ -56,7 +56,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        backends: [ V8, JavaScriptCore, Lua, Empty ]
+        backends: [ V8, JavaScriptCore, Lua, Python, Empty ]
         build_type:
           - Debug
           - Release

CMakeLists.txt

@@ -39,7 +39,7 @@ set(SCRIPTX_BACKEND_LIST
         )
 
 # set options, choose which ScriptX Backend to use, V8 or JSC or etc...
-set(SCRIPTX_BACKEND "" CACHE STRING "choose which ScriptX Backend(Implementation) to use, V8 or JavaScriptCore or etc...")
+set(SCRIPTX_BACKEND "${SCRIPTX_BACKEND}" CACHE STRING "choose which ScriptX Backend(Implementation) to use, V8 or JavaScriptCore or etc...")
 set_property(CACHE SCRIPTX_BACKEND PROPERTY STRINGS "${SCRIPTX_BACKEND_LIST}")
 option(SCRIPTX_NO_EXCEPTION_ON_BIND_FUNCTION "don't throw exception on defineClass generated bound function/get/set, return null & log instead. default to OFF" OFF)
 option(SCRIPTX_FEATURE_INSPECTOR "enable inspector feature, default to OFF" OFF)
@@ -177,4 +177,4 @@ message(STATUS "Configuring ScriptX using backend ${SCRIPTX_BACKEND}.")
 message(STATUS "Configuring ScriptX option SCRIPTX_NO_EXCEPTION_ON_BIND_FUNCTION ${SCRIPTX_NO_EXCEPTION_ON_BIND_FUNCTION}.")
 message(STATUS "Configuring ScriptX feature SCRIPTX_FEATURE_INSPECTOR ${SCRIPTX_FEATURE_INSPECTOR}.")
 
-include(${SCRIPTX_DIR}/docs/doxygen/CMakeLists.txt)
+include(${SCRIPTX_DIR}/docs/doxygen/CMakeLists.txt)

README-zh.md

@@ -125,11 +125,11 @@ ScriptX通过一系列的技术手段实现了脚本的异常和C++异常相互
 
 ScriptX 设计的时候充分考虑到API的易用性，包括操作友好简单，不易出错，错误信息明显，便于定位问题等。在这样的指导思想之下ScriptX做了很多原生引擎做不了的事情。
 
-比如：V8在destory的时候是不执行GC的，导致很多绑定的native类不能释放。ScriptX做了额外的逻辑处理这个情况。
+比如：V8在destroy的时候是不执行GC的，导致很多绑定的native类不能释放。ScriptX做了额外的逻辑处理这个情况。
 
 V8和JSCore要求在finalize回调中不能调用ScriptX的其他API，否则会crash，这也导致代码逻辑很难实现。ScriptX借助MessageQueue完美规避这个问题。
 
-V8和JSCore的全局引用都必须在engine destory之前全部释放掉，否则就会引起crash、不能destory等问题。ScriptX则保证在Engine destory的时候主动reset所有 Global / Weak 引用。
+V8和JSCore的全局引用都必须在engine destroy之前全部释放掉，否则就会引起crash、不能destroy等问题。ScriptX则保证在Engine destroy的时候主动reset所有 Global / Weak 引用。
 
 ## 6. 简单高效的绑定API
 

backend/JavaScriptCore/JscEngine.cc

@@ -19,6 +19,7 @@
 #include "../../src/Native.hpp"
 #include "JscEngine.hpp"
 #include "JscHelper.h"
+#include "../../src/utils/Helper.hpp"
 
 namespace script::jsc_backend {
 
@@ -177,6 +178,27 @@ script::Local<script::Value> JscEngine::eval(const script::Local<script::String>
   return eval(script, {});
 }
 
+Local<Value> JscEngine::loadFile(const Local<String>& scriptFile) {
+  if(scriptFile.toString().empty())
+    throw Exception("script file no found");
+  Local<Value> content = internal::readAllFileContent(scriptFile);
+  if(content.isNull())
+    throw Exception("can't load script file");
+
+  std::string sourceFilePath = scriptFile.toString();
+  std::size_t pathSymbol = sourceFilePath.rfind("/");
+  if(pathSymbol != -1)
+    sourceFilePath = sourceFilePath.substr(pathSymbol + 1);
+  else
+  {
+    pathSymbol = sourceFilePath.rfind("\\");
+    if(pathSymbol != -1)
+      sourceFilePath = sourceFilePath.substr(pathSymbol + 1);
+  }
+  Local<String> sourceFileName = String::newString(sourceFilePath);
+  return eval(content.asString(), sourceFileName);
+}
+
 std::shared_ptr<utils::MessageQueue> JscEngine::messageQueue() { return messageQueue_; }
 
 void JscEngine::gc() {

backend/JavaScriptCore/JscEngine.h

@@ -86,6 +86,8 @@ class JscEngine : public ::script::ScriptEngine {
   Local<Value> eval(const Local<String>& script) override;
   using ScriptEngine::eval;
 
+  Local<Value> loadFile(const Local<String>& scriptFile) override;
+
   std::shared_ptr<utils::MessageQueue> messageQueue() override;
 
   void gc() override;

backend/Lua/LuaEngine.cc

@@ -28,6 +28,7 @@
 #include "LuaHelper.hpp"
 #include "LuaReference.hpp"
 #include "LuaScope.hpp"
+#include "../../src/utils/Helper.hpp"
 
 // ref https://www.lua.org/manual/5.1/manual.html
 // https://www.lua.org/wshop14/Zykov.pdf
@@ -259,6 +260,27 @@ Local<Value> LuaEngine::eval(const Local<String>& script, const Local<Value>& so
   return lua_backend::callFunction({}, {}, 0, nullptr);
 }
 
+Local<Value> LuaEngine::loadFile(const Local<String>& scriptFile) {
+  if(scriptFile.toString().empty())
+    throw Exception("script file no found");
+  Local<Value> content = internal::readAllFileContent(scriptFile);
+  if(content.isNull())
+    throw Exception("can't load script file");
+
+  std::string sourceFilePath = scriptFile.toString();
+  std::size_t pathSymbol = sourceFilePath.rfind("/");
+  if(pathSymbol != -1)
+    sourceFilePath = sourceFilePath.substr(pathSymbol + 1);
+  else
+  {
+    pathSymbol = sourceFilePath.rfind("\\");
+    if(pathSymbol != -1)
+      sourceFilePath = sourceFilePath.substr(pathSymbol + 1);
+  }
+  Local<String> sourceFileName = String::newString(sourceFilePath);
+  return eval(content.asString(), sourceFileName);
+}
+
 Arguments LuaEngine::makeArguments(LuaEngine* engine, int stackBase, size_t paramCount,
                                    bool isInstanceFunc) {
   lua_backend::ArgumentsData argumentsData{engine, stackBase, paramCount, isInstanceFunc};

backend/Lua/LuaEngine.h

@@ -77,6 +77,8 @@ class LuaEngine : public ScriptEngine {
   Local<Value> eval(const Local<String>& script) override;
   using ScriptEngine::eval;
 
+  Local<Value> loadFile(const Local<String>& scriptFile) override;
+
   std::shared_ptr<utils::MessageQueue> messageQueue() override;
 
   void gc() override;

backend/Lua/LuaLocalReference.cc

@@ -43,6 +43,28 @@ void ensureNonnull(int index) {
   throw Exception("NullPointerException");
 }
 
+bool judgeIsArray(int index)
+{
+  auto lua = currentLua();
+  int currectArrIndex = 0;
+
+  lua_pushnil(lua); 
+
+  while (lua_next(lua, index))
+  {
+      // Copy current key and judge it's type
+      lua_pushvalue(lua, -2);
+      if(!lua_isnumber(lua,-1) || lua_tonumber(lua,-1) != ++currectArrIndex)
+      {
+        lua_pop(lua, 3);
+        return false;
+      }
+      lua_pop(lua, 2);
+  }
+  return true;
+}
+
+
 }  // namespace lua_backend
 
 #define REF_IMPL_BASIC_FUNC(ValueType)                                                           \
@@ -149,8 +171,11 @@ ValueKind Local<Value>::getKind() const {
   } else if (isByteBuffer()) {
     return ValueKind::kByteBuffer;
   } else if (type == LUA_TTABLE) {
-    // lua don't have array type, the are all tables
-    return ValueKind::kObject;
+    // Traverse the table to judge whether it is an array
+    if(isArray())
+      return ValueKind::kArray;
+    else
+      return ValueKind::kObject;
   } else {
     return ValueKind::kUnsupported;
   }
@@ -176,7 +201,11 @@ bool Local<Value>::isFunction() const {
   return val_ != 0 && lua_type(lua_backend::currentLua(), val_) == LUA_TFUNCTION;
 }
 
-bool Local<Value>::isArray() const { return isObject(); }
+bool Local<Value>::isArray() const { 
+  if(val_ == 0 || lua_type(lua_backend::currentLua(), val_) != LUA_TTABLE)
+    return false;
+  return lua_backend::judgeIsArray(val_);
+}
 
 bool Local<Value>::isByteBuffer() const {
   auto engine = lua_backend::currentEngine();
@@ -437,4 +466,4 @@ void Local<ByteBuffer>::commit() const {}
 
 void Local<ByteBuffer>::sync() const {}
 
-}  // namespace script
+}  // namespace script

backend/Python/PyEngine.cc

@@ -16,24 +16,87 @@
  */
 
 #include "PyEngine.h"
+#include <cstring>
 #include "../../src/Utils.h"
+#include "../../src/utils/Helper.hpp"
 
 namespace script::py_backend {
 
 PyEngine::PyEngine(std::shared_ptr<utils::MessageQueue> queue)
     : queue_(queue ? std::move(queue) : std::make_shared<utils::MessageQueue>()) {
-  Py_Initialize();
+  if (Py_IsInitialized() == 0) {
+    Py_SetStandardStreamEncoding("utf-8", nullptr);
+    // Python not initialized. Init main interpreter
+    Py_InitializeEx(0);
+    // Init threading environment
+    PyEval_InitThreads();
+    // Initialize type
+    namespaceType_ = makeNamespaceType();
+    staticPropertyType_ = makeStaticPropertyType();
+    defaultMetaType_ = makeDefaultMetaclass();
+    //  Save main thread state & release GIL
+    mainThreadState_ = PyEval_SaveThread();
+  }
+
+  // Resume main thread state (to execute Py_NewInterpreter)
+  PyThreadState* oldState = PyThreadState_Swap(mainThreadState_);
+
+  // If GIL is released, lock it
+  if (PyEngine::engineEnterCount_ == 0) {
+    PyEval_AcquireLock();
+  }
+  // Create new interpreter
+  PyThreadState* newSubState = Py_NewInterpreter();
+  if (!newSubState) {
+    throw Exception("Fail to create sub interpreter");
+  }
+  subInterpreterState_ = newSubState->interp;
+
+  // If GIL is released before, unlock it
+  if (PyEngine::engineEnterCount_ == 0) {
+    PyEval_ReleaseLock();
+  }
+  // Store created new sub thread state & recover old thread state stored before
+  subThreadState_.set(PyThreadState_Swap(oldState));
 }
 
 PyEngine::PyEngine() : PyEngine(nullptr) {}
 
 PyEngine::~PyEngine() = default;
 
-void PyEngine::destroy() noexcept { ScriptEngine::destroyUserData(); }
+void PyEngine::destroy() noexcept {
+  ScriptEngine::destroyUserData();  // TODO: solve this problem about Py_EndInterpreter
+  /*if (PyEngine::engineEnterCount_ == 0) {
+    // GIL is not locked. Just lock it
+    PyEval_AcquireLock();
+  }
+  // Swap to clear thread state & end sub interpreter
+  PyThreadState* oldThreadState = PyThreadState_Swap(subThreadState_.get());
+  Py_EndInterpreter(subThreadState_.get());
+  // Recover old thread state
+  PyThreadState_Swap(oldThreadState);
+
+  if (PyEngine::engineEnterCount_ == 0) {
+      // Unlock the GIL because it is not locked before
+      PyEval_ReleaseLock();
+  }*/
+}
 
-Local<Value> PyEngine::get(const Local<String>& key) { return Local<Value>(); }
+Local<Value> PyEngine::get(const Local<String>& key) {
+  PyObject* item = PyDict_GetItemString(getGlobalDict(), key.toStringHolder().c_str());
+  if (item)
+    return py_interop::toLocal<Value>(item);
+  else
+    return py_interop::toLocal<Value>(Py_None);
+}
 
-void PyEngine::set(const Local<String>& key, const Local<Value>& value) {}
+void PyEngine::set(const Local<String>& key, const Local<Value>& value) {
+  int result =
+      PyDict_SetItemString(getGlobalDict(), key.toStringHolder().c_str(), py_interop::getPy(value));
+  if (result != 0) {
+    checkPyErr();
+  }
+}
 
 Local<Value> PyEngine::eval(const Local<String>& script) { return eval(script, Local<Value>()); }
 
@@ -42,7 +105,38 @@ Local<Value> PyEngine::eval(const Local<String>& script, const Local<String>& so
 }
 
 Local<Value> PyEngine::eval(const Local<String>& script, const Local<Value>& sourceFile) {
-  return Local<Value>();
+  // Limitation: one line code must be expression (no "\n", no "=")
+  const char* source = script.toStringHolder().c_str();
+  bool oneLine = true;
+  if (strstr(source, "\n") != NULL)
+    oneLine = false;
+  else if (strstr(source, " = ") != NULL)
+    oneLine = false;
+  PyObject* result = PyRun_StringFlags(source, oneLine ? Py_eval_input : Py_file_input,
+                                       getGlobalDict(), nullptr, nullptr);
+  checkPyErr();
+  return py_interop::asLocal<Value>(result);
+}
+
+Local<Value> PyEngine::loadFile(const Local<String>& scriptFile) {
+  std::string sourceFilePath = scriptFile.toString();
+  if (sourceFilePath.empty()) {
+    throw Exception("script file no found");
+  }
+  Local<Value> content = internal::readAllFileContent(scriptFile);
+  if (content.isNull()) {
+    throw Exception("can't load script file");
+  }
+
+  std::size_t pathSymbol = sourceFilePath.rfind("/");
+  if (pathSymbol != -1) {
+    sourceFilePath = sourceFilePath.substr(pathSymbol + 1);
+  } else {
+    pathSymbol = sourceFilePath.rfind("\\");
+    if (pathSymbol != -1) sourceFilePath = sourceFilePath.substr(pathSymbol + 1);
+  }
+  Local<String> sourceFileName = String::newString(sourceFilePath);
+  return eval(content.asString(), sourceFileName);
 }
 
 std::shared_ptr<utils::MessageQueue> PyEngine::messageQueue() { return queue_; }
@@ -56,5 +150,4 @@ ScriptLanguage PyEngine::getLanguageType() { return ScriptLanguage::kPython; }
 std::string PyEngine::getEngineVersion() { return Py_GetVersion(); }
 
 bool PyEngine::isDestroying() const { return false; }
-
 }  // namespace script::py_backend