Merge pull request #3 from puerts/dev

chexiongsheng · web-flow · commit 7431cc6d99b2 · 2025-02-26T14:10:01.000+08:00
合入Dev
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -68,7 +68,8 @@ if(MSVC)
     xcheck_add_c_compiler_flag(/wd4996) # -Wdeprecated-declarations
     xcheck_add_c_compiler_flag(/wd5045) # Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified
     xcheck_add_c_compiler_flag(/wd4514)
-    xcheck_add_c_compiler_flag(/wd4514)
+    xcheck_add_c_compiler_flag(/wd4146)
+    xcheck_add_c_compiler_flag(/wd4334)
     xcheck_add_c_compiler_flag(-fchar8_t)
     xcheck_add_c_compiler_flag(/Zc:char8_t)
 endif()
@@ -193,15 +194,10 @@ target_compile_options(PapiQjs PRIVATE
         -fno-rtti
     >
     $<$<CXX_COMPILER_ID:MSVC>:
-        /EHa-
-        /EHsc
-        /EHsc-
-        /GR-  # 禁用RTTI
+        /EHa-  # 禁用异常处理
+        /GR-   # 禁用RTTI
     >
 )
-#if(MSVC)
-#target_compile_options(PapiQjs PRIVATE /EHsc)
-#endif()
 
 target_compile_definitions(PapiRegister PUBLIC BUILDING_REGISTER_API_SHARED)
 target_compile_options(PapiRegister PRIVATE
@@ -213,7 +209,6 @@ target_compile_options(PapiRegister PRIVATE
     >
     $<$<CXX_COMPILER_ID:MSVC>:
         /EHa-
-        /EHsc-
         /GR-  # 禁用RTTI
     >
 )
diff --git a/quickjs/quickjs.c b/quickjs/quickjs.c
@@ -55893,4 +55893,13 @@ JS_BOOL JS_GetArrayBufferViewInfo(JSContext *ctx, JSValueConst obj,
     return TRUE;
 }
 
+int JS_ValueRefCount(JSContext *ctx, JSValue v)
+{
+    if (JS_VALUE_HAS_REF_COUNT(v)) {
+        JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
+        return p->ref_count;
+    }
+    return -1;
+}
+
 /*-------end additional function---------*/
diff --git a/quickjs/quickjs.h b/quickjs/quickjs.h
@@ -1049,6 +1049,8 @@ JS_BOOL JS_GetArrayBufferViewInfo(JSContext *ctx, JSValueConst obj,
                                size_t *pbyte_length,
                                size_t *pbytes_per_element);
 
+int JS_ValueRefCount(JSContext *ctx, JSValue v);
+
 /*-------end additional function---------*/
 
 #ifdef __cplusplus
diff --git a/source/CppObjectMapper.cpp b/source/CppObjectMapper.cpp
@@ -251,7 +251,7 @@ JSValue CppObjectMapper::CreateClass(const puerts::JSClassDefinition* ClassDefin
             {
                 return JS_Throw(ctx, CppObjectMapper::CreateError(ctx, "no initialize function"));
             }
-        }, 0, 0, 3, &ctor_data[0]);
+        }, 0, 0, 3, &ctor_data[0]); // ref_count: 1
 
         JS_SetConstructorBit(ctx, func, 1);
 
@@ -295,11 +295,22 @@ JSValue CppObjectMapper::CreateClass(const puerts::JSClassDefinition* ClassDefin
             ++FunctionInfo;
         }
 
-        JS_SetConstructor(ctx, func, proto);
+        JS_SetConstructor(ctx, func, proto); // func ref_count: 2
         JS_FreeValue(ctx, proto);
 
+        if (ClassDefinition->SuperTypeId)
+        {
+            if (auto SuperDefinition = puerts::FindClassByID(ClassDefinition->SuperTypeId))
+            {
+                JSValue super_func = CreateClass(SuperDefinition);
+                JSValue parent_proto = JS_GetProperty(ctx, super_func, JS_ATOM_prototype);
+                JS_SetPrototype(ctx, proto, parent_proto);
+                JS_FreeValue(ctx, parent_proto);
+            }
+        }
+
         TypeIdToFunctionMap[ClassDefinition->TypeId] = func;
-        JS_DupValue(ctx, func); //JS_FreeValue in Cleanup
+        //printf("register class %s, tid:%p, rc:%d, obj:%p\n", ClassDefinition->ScriptName, ClassDefinition->TypeId, JS_ValueRefCount(ctx, func), JS_VALUE_GET_PTR(func));
         return func;
     }
     return it->second;
diff --git a/source/PapiQuickjsImpl.cpp b/source/PapiQuickjsImpl.cpp
@@ -197,6 +197,7 @@ pesapi_value pesapi_create_class(pesapi_env env, const void* type_id)
     auto ctx = qjsContextFromPesapiEnv(env);
     auto ret = allocValueInCurrentScope(ctx);
     *ret = pesapi::qjsimpl::CppObjectMapper::Get(ctx)->CreateClassByID(type_id);
+    JS_DupValue(ctx, *ret);
     return pesapiValueFromQjsValue(ret);
 }
 
@@ -471,7 +472,7 @@ pesapi_value pesapi_get_arg(pesapi_callback_info pinfo, int index)
     }
 }
 
-PESAPI_EXTERN pesapi_env pesapi_get_env(pesapi_callback_info pinfo)
+pesapi_env pesapi_get_env(pesapi_callback_info pinfo)
 {
     return pesapiEnvFromQjsContext(pinfo->ctx);
 }
@@ -623,7 +624,13 @@ void pesapi_close_scope_placement(pesapi_scope scope)
 
 pesapi_value_ref pesapi_create_value_ref(pesapi_env env, pesapi_value pvalue, uint32_t internal_field_count)
 {
-    return {};
+    auto ctx = qjsContextFromPesapiEnv(env);
+    size_t totalSize = sizeof(pesapi_value_ref__) + sizeof(void*) * internal_field_count;
+    auto ret = (pesapi_value_ref)malloc(totalSize);
+    memset(ret, 0, totalSize);
+    JSValue* v = qjsValueFromPesapiValue(pvalue);
+    new (ret) pesapi_value_ref__(ctx, *v, internal_field_count);
+    return ret;
 }
 
 pesapi_value_ref pesapi_duplicate_value_ref(pesapi_value_ref value_ref)
@@ -646,16 +653,31 @@ void pesapi_release_value_ref(pesapi_value_ref value_ref)
 
 pesapi_value pesapi_get_value_from_ref(pesapi_env env, pesapi_value_ref value_ref)
 {
-    return {};
+    auto ctx = qjsContextFromPesapiEnv(env);
+    JSValue* v = allocValueInCurrentScope(ctx);
+    *v = JS_DupValue(ctx, value_ref->value_persistent);
+    return pesapiValueFromQjsValue(v);
 }
 
 void pesapi_set_ref_weak(pesapi_env env, pesapi_value_ref value_ref)
 {
+    auto ctx = qjsContextFromPesapiEnv(env);
+    JS_FreeValue(ctx, value_ref->value_persistent);
 }
 
 bool pesapi_set_owner(pesapi_env env, pesapi_value pvalue, pesapi_value powner)
 {
-    return false;
+    auto ctx = qjsContextFromPesapiEnv(env);
+    JSValue* obj = qjsValueFromPesapiValue(pvalue);
+    JSValue* owner = qjsValueFromPesapiValue(powner);
+    if (JS_IsObject(*owner))
+    {
+        JSAtom key = JS_NewAtom(ctx, "_p_i_only_one_child");
+        JS_DupValue(ctx, *obj);
+        JS_SetProperty(ctx, *owner, key, *obj);
+        JS_FreeAtom(ctx, key);
+    }
+    return true;
 }
 
 pesapi_env_ref pesapi_get_ref_associated_env(pesapi_value_ref value_ref)
@@ -665,7 +687,8 @@ pesapi_env_ref pesapi_get_ref_associated_env(pesapi_value_ref value_ref)
 
 void** pesapi_get_ref_internal_fields(pesapi_value_ref value_ref, uint32_t* pinternal_field_count)
 {
-    return {};
+    *pinternal_field_count = value_ref->internal_field_count;
+    return &value_ref->internal_fields[0];
 }
 
 pesapi_value pesapi_get_property(pesapi_env env, pesapi_value pobject, const char* key)
@@ -726,7 +749,16 @@ void pesapi_set_property_uint32(pesapi_env env, pesapi_value pobject, uint32_t k
 
 pesapi_value pesapi_call_function(pesapi_env env, pesapi_value pfunc, pesapi_value this_object, int argc, const pesapi_value argv[])
 {
-    return {};
+    auto ctx = qjsContextFromPesapiEnv(env);
+    JSValue* func = qjsValueFromPesapiValue(pfunc);
+    JSValue* thisObj = this_object ? qjsValueFromPesapiValue(this_object) : &literal_values_undefined;
+    JSValue *js_argv = (JSValue*)alloca(argc * sizeof(JSValue));
+    for (int i = 0; i < argc; ++i) {
+        js_argv[i] = *qjsValueFromPesapiValue(argv[i]);
+    }
+    JSValue* ret = allocValueInCurrentScope(ctx);
+    *ret = JS_Call(ctx, *func, *thisObj, argc, js_argv);
+    return pesapiValueFromQjsValue(ret);
 }
 
 pesapi_value pesapi_eval(pesapi_env env, const uint8_t* code, size_t code_size, const char* path)
diff --git a/test/papi_qjs_base_test.cpp b/test/papi_qjs_base_test.cpp
@@ -7,12 +7,24 @@
 namespace pesapi {
 namespace qjsimpl {
 
-struct TestStruct {
+struct TestStructBase {
+    TestStructBase(int b) {
+        this->b = b;
+    }
+
+    int b;
+    int Foo(int a)
+    {
+        return a + b;
+    }
+};
+
+struct TestStruct : public TestStructBase {
     static int ctor_count;
     static int dtor_count;
     static TestStruct* lastCtorObject;
     static TestStruct* lastDtorObject;
-    TestStruct(int a) {
+    TestStruct(int a) : TestStructBase(a - 1) {
         this->a = a;
         ctor_count++;
         lastCtorObject = this;
@@ -37,6 +49,8 @@ struct TestStruct {
     }
 };
 
+const void* baseTypeId = "TestStructBase";
+
 const void* typeId = "TestStruct";
 
 int TestStruct::ctor_count = 0;
@@ -57,6 +71,33 @@ static void TestStructFinalize(struct pesapi_ffi* apis, void* ptr, void* class_d
     delete (TestStruct*)ptr;
 }
 
+static void BGetterWrap(struct pesapi_ffi* apis, pesapi_callback_info info)
+{
+    auto env = apis->get_env(info);
+    auto self = apis->get_this(info);
+    auto obj = (TestStructBase*)apis->get_native_object_ptr(env, self);
+    apis->add_return(info, apis->create_int32(env, obj->b));
+}
+
+static void BSetterWrap(struct pesapi_ffi* apis, pesapi_callback_info info)
+{
+    auto env = apis->get_env(info);
+    auto self = apis->get_this(info);
+    auto obj = (TestStructBase*)apis->get_native_object_ptr(env, self);
+    auto p0 = apis->get_arg(info, 0);
+    obj->b = apis->get_value_int32(env, p0);
+}
+
+static void BaseFooWrap(struct pesapi_ffi* apis, pesapi_callback_info info)
+{
+    auto env = apis->get_env(info);
+    auto self = apis->get_this(info);
+    auto obj = (TestStructBase*)apis->get_native_object_ptr(env, self);
+    auto p0 = apis->get_arg(info, 0);
+    int a = apis->get_value_int32(env, p0);
+    apis->add_return(info, apis->create_int32(env, obj->Foo(a)));
+}
+
 static void AddWrap(struct pesapi_ffi* apis, pesapi_callback_info info)
 {
     auto env = apis->get_env(info);
@@ -131,7 +172,25 @@ static void IncWrap(struct pesapi_ffi* apis, pesapi_callback_info info)
 
 class PApiBaseTest : public ::testing::Test {
 public:
-    static void SetUpTestCase() { 
+    static void SetUpTestCase() {
+        // 封装TestStructBase
+        const int base_properties_count = 2;
+        pesapi_property_descriptor base_properties = pesapi_alloc_property_descriptors(base_properties_count);
+        pesapi_set_property_info(base_properties, 0, "b", false, BGetterWrap, BSetterWrap, NULL, NULL, NULL);
+        pesapi_set_method_info(base_properties, 1, "Foo", false, BaseFooWrap, NULL, NULL);
+        pesapi_define_class(baseTypeId, NULL, "TestStructBase", 
+            [](struct pesapi_ffi* apis, pesapi_callback_info info) -> void* { // Ctor
+                auto env = apis->get_env(info);
+                auto p0 = apis->get_arg(info, 0);
+                int b = apis->get_value_int32(env, p0);
+                return new TestStructBase(b);
+            },
+            [](struct pesapi_ffi* apis, void* ptr, void* class_data, void* env_private) { // Finalize
+                delete static_cast<TestStructBase*>(ptr);
+            }, 
+            base_properties_count, base_properties, NULL);
+
+        // 封装TestStruct
         const int properties_count = 6;
         pesapi_property_descriptor properties = pesapi_alloc_property_descriptors(properties_count);
         pesapi_set_method_info(properties, 0, "Add", true, AddWrap, NULL, NULL);
@@ -140,7 +199,7 @@ class PApiBaseTest : public ::testing::Test {
         pesapi_set_property_info(properties, 3, "ctor_count", true, CtorCountGetterWrap, CtorCountSetterWrap, NULL, NULL, NULL);
         pesapi_set_method_info(properties, 4, "GetSelf", false, GetSelfWrap, NULL, NULL);
         pesapi_set_method_info(properties, 5, "Inc", false, IncWrap, NULL, NULL);
-        pesapi_define_class(typeId, NULL, "TestStruct", TestStructCtor, TestStructFinalize, properties_count, properties, NULL);
+        pesapi_define_class(typeId, baseTypeId, "TestStruct", TestStructCtor, TestStructFinalize, properties_count, properties, NULL);
     }
 
     static void TearDownTestCase() {
@@ -473,6 +532,26 @@ TEST_F(PApiBaseTest, ReturnAObject) {
     ASSERT_TRUE(apis->get_value_bool(env, ret));
 }
 
+TEST_F(PApiBaseTest, MutiObject) {
+    auto env = apis->get_env_from_ref(env_ref);
+
+    auto code = R"(
+                (function() {
+                    const TestStruct = loadClass('TestStruct');
+                    for (let i = 0; i < 1000; ++i) {
+                        const obj = new TestStruct(123);
+                        const self = obj.GetSelf();
+                    }
+                })();
+              )";
+    auto ret = apis->eval(env, (const uint8_t*)(code), strlen(code), "test.js");
+    if (apis->has_caught(scope))
+    {
+        printf("%s\n", apis->get_exception_as_string(scope, true));
+    }
+    ASSERT_FALSE(apis->has_caught(scope));
+}
+
 TEST_F(PApiBaseTest, RefArgument) {
     auto env = apis->get_env_from_ref(env_ref);
 
@@ -495,6 +574,53 @@ TEST_F(PApiBaseTest, RefArgument) {
     EXPECT_EQ(5, apis->get_value_int32(env, ret));
 }
 
+TEST_F(PApiBaseTest, CallFunction) {
+    auto env = apis->get_env_from_ref(env_ref);
+
+    auto code = R"(
+                function sub(x, y) {
+                    return x - y;
+                }
+                sub;
+              )";
+    auto ret = apis->eval(env, (const uint8_t*)(code), strlen(code), "test.js");
+    if (apis->has_caught(scope))
+    {
+        printf("%s\n", apis->get_exception_as_string(scope, true));
+    }
+    ASSERT_FALSE(apis->has_caught(scope));
+    ASSERT_TRUE(apis->is_function(env, ret));
+    pesapi_value argv[2] {apis->create_int32(env, 5), apis->create_int32(env, 3)};
+    auto func_call_ret = apis->call_function(env, ret, nullptr, 2, argv);
+    ASSERT_TRUE(apis->is_int32(env, func_call_ret));
+    EXPECT_EQ(2, apis->get_value_int32(env, func_call_ret));
+}
+
+TEST_F(PApiBaseTest, SuperAccess) {
+    auto env = apis->get_env_from_ref(env_ref);
+
+    auto code = R"(
+                (function() {
+                    const TestStruct = loadClass('TestStruct');
+                    const obj = new TestStruct(123);
+                    let ret = "" + obj.b + ":"; // 122
+                    obj.b = 5
+                    ret += obj.Foo(6); // 11
+                    return ret;
+                })();
+              )";
+    auto ret = apis->eval(env, (const uint8_t*)(code), strlen(code), "test.js");
+    if (apis->has_caught(scope))
+    {
+        printf("%s\n", apis->get_exception_as_string(scope, true));
+    }
+    ASSERT_FALSE(apis->has_caught(scope));
+    ASSERT_TRUE(apis->is_string(env, ret));
+    char buff[1024];
+    size_t len = sizeof(buff);
+    const char* str = apis->get_value_string_utf8(env, ret, buff, &len);
+    EXPECT_STREQ("122:11", str);
+}
 
 } // namespace qjsimpl
 } // namespace pesapi

Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,8 @@ if(MSVC)`
`68`	`68`	`xcheck_add_c_compiler_flag(/wd4996) # -Wdeprecated-declarations`
`69`	`69`	`xcheck_add_c_compiler_flag(/wd5045) # Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified`
`70`	`70`	`xcheck_add_c_compiler_flag(/wd4514)`
`71`		`- xcheck_add_c_compiler_flag(/wd4514)`
	`71`	`+ xcheck_add_c_compiler_flag(/wd4146)`
	`72`	`+ xcheck_add_c_compiler_flag(/wd4334)`
`72`	`73`	`xcheck_add_c_compiler_flag(-fchar8_t)`
`73`	`74`	`xcheck_add_c_compiler_flag(/Zc:char8_t)`
`74`	`75`	`endif()`
`@@ -193,15 +194,10 @@ target_compile_options(PapiQjs PRIVATE`
`193`	`194`	`-fno-rtti`
`194`	`195`	`>`
`195`	`196`	`$<$<CXX_COMPILER_ID:MSVC>:`
`196`		`- /EHa-`
`197`		`- /EHsc`
`198`		`- /EHsc-`
`199`		`- /GR- # 禁用RTTI`
	`197`	`+ /EHa- # 禁用异常处理`
	`198`	`+ /GR- # 禁用RTTI`
`200`	`199`	`>`
`201`	`200`	`)`
`202`		`-#if(MSVC)`
`203`		`-#target_compile_options(PapiQjs PRIVATE /EHsc)`
`204`		`-#endif()`
`205`	`201`
`206`	`202`	`target_compile_definitions(PapiRegister PUBLIC BUILDING_REGISTER_API_SHARED)`
`207`	`203`	`target_compile_options(PapiRegister PRIVATE`
`@@ -213,7 +209,6 @@ target_compile_options(PapiRegister PRIVATE`
`213`	`209`	`>`
`214`	`210`	`$<$<CXX_COMPILER_ID:MSVC>:`
`215`	`211`	`/EHa-`
`216`		`- /EHsc-`
`217`	`212`	`/GR- # 禁用RTTI`
`218`	`213`	`>`
`219`	`214`	`)`
Original file line number	Diff line number	Diff line change
`@@ -197,6 +197,7 @@ pesapi_value pesapi_create_class(pesapi_env env, const void* type_id)`
`197`	`197`	`auto ctx = qjsContextFromPesapiEnv(env);`
`198`	`198`	`auto ret = allocValueInCurrentScope(ctx);`
`199`	`199`	`*ret = pesapi::qjsimpl::CppObjectMapper::Get(ctx)->CreateClassByID(type_id);`
	`200`	`+ JS_DupValue(ctx, *ret);`
`200`	`201`	`return pesapiValueFromQjsValue(ret);`
`201`	`202`	`}`
`202`	`203`
`@@ -471,7 +472,7 @@ pesapi_value pesapi_get_arg(pesapi_callback_info pinfo, int index)`
`471`	`472`	`}`
`472`	`473`	`}`
`473`	`474`
`474`		`-PESAPI_EXTERN pesapi_env pesapi_get_env(pesapi_callback_info pinfo)`
	`475`	`+pesapi_env pesapi_get_env(pesapi_callback_info pinfo)`
`475`	`476`	`{`
`476`	`477`	`return pesapiEnvFromQjsContext(pinfo->ctx);`
`477`	`478`	`}`
`@@ -623,7 +624,13 @@ void pesapi_close_scope_placement(pesapi_scope scope)`
`623`	`624`
`624`	`625`	`pesapi_value_ref pesapi_create_value_ref(pesapi_env env, pesapi_value pvalue, uint32_t internal_field_count)`
`625`	`626`	`{`
`626`		`- return {};`
	`627`	`+ auto ctx = qjsContextFromPesapiEnv(env);`
	`628`	`+ size_t totalSize = sizeof(pesapi_value_ref__) + sizeof(void) internal_field_count;`
	`629`	`+ auto ret = (pesapi_value_ref)malloc(totalSize);`
	`630`	`+ memset(ret, 0, totalSize);`
	`631`	`+ JSValue* v = qjsValueFromPesapiValue(pvalue);`
	`632`	`+ new (ret) pesapi_value_ref__(ctx, *v, internal_field_count);`
	`633`	`+ return ret;`
`627`	`634`	`}`
`628`	`635`
`629`	`636`	`pesapi_value_ref pesapi_duplicate_value_ref(pesapi_value_ref value_ref)`
`@@ -646,16 +653,31 @@ void pesapi_release_value_ref(pesapi_value_ref value_ref)`
`646`	`653`
`647`	`654`	`pesapi_value pesapi_get_value_from_ref(pesapi_env env, pesapi_value_ref value_ref)`
`648`	`655`	`{`
`649`		`- return {};`
	`656`	`+ auto ctx = qjsContextFromPesapiEnv(env);`
	`657`	`+ JSValue* v = allocValueInCurrentScope(ctx);`
	`658`	`+ *v = JS_DupValue(ctx, value_ref->value_persistent);`
	`659`	`+ return pesapiValueFromQjsValue(v);`
`650`	`660`	`}`
`651`	`661`
`652`	`662`	`void pesapi_set_ref_weak(pesapi_env env, pesapi_value_ref value_ref)`
`653`	`663`	`{`
	`664`	`+ auto ctx = qjsContextFromPesapiEnv(env);`
	`665`	`+ JS_FreeValue(ctx, value_ref->value_persistent);`
`654`	`666`	`}`
`655`	`667`
`656`	`668`	`bool pesapi_set_owner(pesapi_env env, pesapi_value pvalue, pesapi_value powner)`
`657`	`669`	`{`
`658`		`- return false;`
	`670`	`+ auto ctx = qjsContextFromPesapiEnv(env);`
	`671`	`+ JSValue* obj = qjsValueFromPesapiValue(pvalue);`
	`672`	`+ JSValue* owner = qjsValueFromPesapiValue(powner);`
	`673`	`+ if (JS_IsObject(*owner))`
	`674`	`+ {`
	`675`	`+ JSAtom key = JS_NewAtom(ctx, "_p_i_only_one_child");`
	`676`	`+ JS_DupValue(ctx, *obj);`
	`677`	`+ JS_SetProperty(ctx, owner, key, obj);`
	`678`	`+ JS_FreeAtom(ctx, key);`
	`679`	`+ }`
	`680`	`+ return true;`
`659`	`681`	`}`
`660`	`682`
`661`	`683`	`pesapi_env_ref pesapi_get_ref_associated_env(pesapi_value_ref value_ref)`
`@@ -665,7 +687,8 @@ pesapi_env_ref pesapi_get_ref_associated_env(pesapi_value_ref value_ref)`
`665`	`687`
`666`	`688`	`void** pesapi_get_ref_internal_fields(pesapi_value_ref value_ref, uint32_t* pinternal_field_count)`
`667`	`689`	`{`
`668`		`- return {};`
	`690`	`+ *pinternal_field_count = value_ref->internal_field_count;`
	`691`	`+ return &value_ref->internal_fields[0];`
`669`	`692`	`}`
`670`	`693`
`671`	`694`	`pesapi_value pesapi_get_property(pesapi_env env, pesapi_value pobject, const char* key)`
`@@ -726,7 +749,16 @@ void pesapi_set_property_uint32(pesapi_env env, pesapi_value pobject, uint32_t k`
`726`	`749`
`727`	`750`	`pesapi_value pesapi_call_function(pesapi_env env, pesapi_value pfunc, pesapi_value this_object, int argc, const pesapi_value argv[])`
`728`	`751`	`{`
`729`		`- return {};`
	`752`	`+ auto ctx = qjsContextFromPesapiEnv(env);`
	`753`	`+ JSValue* func = qjsValueFromPesapiValue(pfunc);`
	`754`	`+ JSValue* thisObj = this_object ? qjsValueFromPesapiValue(this_object) : &literal_values_undefined;`
	`755`	`+ JSValue js_argv = (JSValue)alloca(argc * sizeof(JSValue));`
	`756`	`+ for (int i = 0; i < argc; ++i) {`
	`757`	`+ js_argv[i] = *qjsValueFromPesapiValue(argv[i]);`
	`758`	`+ }`
	`759`	`+ JSValue* ret = allocValueInCurrentScope(ctx);`
	`760`	`+ ret = JS_Call(ctx, func, *thisObj, argc, js_argv);`
	`761`	`+ return pesapiValueFromQjsValue(ret);`
`730`	`762`	`}`
`731`	`763`
`732`	`764`	`pesapi_value pesapi_eval(pesapi_env env, const uint8_t* code, size_t code_size, const char* path)`