@idlizer/arktscgen 2.1.7 → 2.1.9-arktscgen-4

package/build/libarkts-copy/native/src/common.cc

@@ -18,20 +18,22 @@
 
 using std::string, std::cout, std::endl, std::vector;
 
-static es2panda_Impl *impl = nullptr;
-
+es2panda_Impl *es2pandaImplementation = nullptr;
 static thread_local StageArena currentArena;
 
-StageArena* StageArena::instance() {
+StageArena* StageArena::instance()
+{
     return &currentArena;
 }
 
-void StageArena::add(void* pointer) {
+void StageArena::add(void* pointer)
+{
     if (pointer)
         allocated.push_back(pointer);
 }
 
-void StageArena::cleanup() {
+void StageArena::cleanup()
+{
     if (totalSize > 0 && false)
         printf("cleanup %d objects %d bytes\n", (int)allocated.size(), (int)totalSize);
     for (auto it : allocated) {
@@ -41,15 +43,18 @@ void StageArena::cleanup() {
     allocated.clear();
 }
 
-StageArena::StageArena() {
+StageArena::StageArena()
+{
     totalSize = 0;
 }
 
-StageArena::~StageArena() {
+StageArena::~StageArena()
+{
     cleanup();
 }
 
-char* StageArena::strdup(const char* string) {
+char* StageArena::strdup(const char* string)
+{
     auto* arena = StageArena::instance();
     auto size = strlen(string) + 1;
     char* memory = (char*)arena->alloc(size);
@@ -57,7 +62,8 @@ char* StageArena::strdup(const char* string) {
     return memory;
 }
 
-void* StageArena::alloc(size_t size) {
+void* StageArena::alloc(size_t size)
+{
     void* result = malloc(size);
     totalSize += size;
     add(result);
@@ -67,11 +73,11 @@ void* StageArena::alloc(size_t size) {
 #ifdef KOALA_WINDOWS
     #include <windows.h>
     #define PLUGIN_DIR "windows_host_tools"
-    #define LIB_PREFIX ""
+    #define LIB_PREFIX "lib"
     #define LIB_SUFFIX ".dll"
 #endif
 
-#ifdef KOALA_LINUX
+#if defined(KOALA_LINUX) || defined(KOALA_MACOS)
     #include <dlfcn.h>
 
     #ifdef __x86_64__
@@ -87,23 +93,89 @@ void* StageArena::alloc(size_t size) {
 const char* DEFAULT_SDK_PATH = "../../../incremental/tools/panda/node_modules/@panda/sdk" ;
 const char* NAME = LIB_PREFIX "es2panda-public" LIB_SUFFIX;
 
+const char* LIB_ES2PANDA_PUBLIC = LIB_PREFIX "es2panda_public" LIB_SUFFIX;
+const char* IS_UI_FLAG = "IS_UI_FLAG";
+const char* NOT_UI_FLAG = "NOT_UI_FLAG";
+const string MODULE_SUFFIX = ".d.ets";
+const string ARKUI = "arkui";
+
+#ifdef KOALA_WINDOWS
+    const char *SEPARATOR = "\\";
+#else
+    const char *SEPARATOR = "/";
+#endif
+const char *LIB_DIR = "lib";
+
+static std::string ES2PANDA_LIB_PATH = "";
+
+std::string joinPath(vector<string> &paths)
+{
+    std::string res;
+    for (std::size_t i = 0; i < paths.size(); ++i) {
+        if (i == 0) {
+            res = paths[i];
+        } else {
+            res += SEPARATOR + paths[i];
+        }
+    }
+    return res;
+}
+
+void impl_SetUpSoPath(KStringPtr &soPath)
+{
+    ES2PANDA_LIB_PATH = std::string(soPath.c_str());
+}
+KOALA_INTEROP_V1(SetUpSoPath, KStringPtr);
+
+// todo: simplify this
 void* FindLibrary() {
+    void *res = NULL;
+    std::vector<std::string> pathArray;
+    
+    // find by SetUpSoPath
+    if (!ES2PANDA_LIB_PATH.empty()) {
+        pathArray = {ES2PANDA_LIB_PATH, LIB_DIR, LIB_ES2PANDA_PUBLIC};
+        res = loadLibrary(joinPath(pathArray));
+        if (res) {
+            return res;
+        }
+    }
+
+    // find by set PANDA_SDK_PATH
     char* envValue = getenv("PANDA_SDK_PATH");
-    if (!envValue) {
-        std::cout << "PANDA_SDK_PATH not specified, assuming " << DEFAULT_SDK_PATH << std::endl;
+    if (envValue) {
+        pathArray = {envValue, PLUGIN_DIR, LIB_DIR, NAME};
+        res = loadLibrary(joinPath(pathArray));
+        if (res) {
+            return res;
+        }
+    }
+
+    // find by set LD_LIBRARY_PATH
+    pathArray = {LIB_ES2PANDA_PUBLIC};
+    res = loadLibrary(joinPath(pathArray));
+    if (res) {
+        return res;
     }
-    std::string prefix = envValue ? std::string(envValue) : DEFAULT_SDK_PATH;
-    std::string libraryName = prefix + ("/" PLUGIN_DIR "/lib/") + NAME;
-    return loadLibrary(libraryName);
+
+    // find by DEFAULT_SDK_PATH
+    pathArray = {DEFAULT_SDK_PATH, PLUGIN_DIR, LIB_DIR, NAME};
+    res = loadLibrary(joinPath(pathArray));
+    if (res) {
+        return res;
+    }
+
+    return NULL;
 }
 
-es2panda_Impl *GetImpl() {
-    if (impl) {
-        return impl;
+es2panda_Impl *GetImplSlow()
+{
+    if (es2pandaImplementation) {
+        return es2pandaImplementation;
     }
     auto library = FindLibrary();
     if (!library) {
-        printf("No library (es2panda_lib.cc)"); // TODO: dont use throw for ohos build
+        printf("No library (es2panda_lib.cc)");
         abort();
     }
     auto symbol = findSymbol(library, "es2panda_GetImpl");
@@ -111,8 +183,8 @@ es2panda_Impl *GetImpl() {
         printf("no entry point");
         abort();
     }
-    impl = reinterpret_cast<es2panda_Impl *(*)(int)>(symbol)(ES2PANDA_LIB_VERSION);
-    return impl;
+    es2pandaImplementation = reinterpret_cast<es2panda_Impl *(*)(int)>(symbol)(ES2PANDA_LIB_VERSION);
+    return es2pandaImplementation;
 }
 
 es2panda_ContextState intToState(KInt state)
@@ -120,31 +192,16 @@ es2panda_ContextState intToState(KInt state)
     return es2panda_ContextState(state);
 }
 
-string getString(KStringPtr ptr) {
+string getString(KStringPtr ptr)
+{
     return ptr.data();
 }
 
-char* getStringCopy(KStringPtr& ptr) {
+char* getStringCopy(KStringPtr& ptr)
+{
     return StageArena::strdup(ptr.c_str() ? ptr.c_str() : "");
 }
 
-inline KUInt unpackUInt(const KByte* bytes) {
-    const KUInt BYTE_0 = 0;
-    const KUInt BYTE_1 = 1;
-    const KUInt BYTE_2 = 2;
-    const KUInt BYTE_3 = 3;
-
-    const KUInt BYTE_1_SHIFT = 8;
-    const KUInt BYTE_2_SHIFT = 16;
-    const KUInt BYTE_3_SHIFT = 24;
-    return (
-        bytes[BYTE_0]
-        | (bytes[BYTE_1] << BYTE_1_SHIFT)
-        | (bytes[BYTE_2] << BYTE_2_SHIFT)
-        | (bytes[BYTE_3] << BYTE_3_SHIFT)
-    );
-}
-
 KNativePointer impl_CreateConfig(KInt argc, KStringArray argvPtr) {
     const std::size_t headerLen = 4;
 
@@ -168,13 +225,12 @@ KNativePointer impl_DestroyConfig(KNativePointer configPtr) {
 }
 KOALA_INTEROP_1(DestroyConfig, KNativePointer, KNativePointer)
 
-KNativePointer impl_DestroyContext(KNativePointer contextPtr) {
+void impl_DestroyContext(KNativePointer contextPtr) {
     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
     GetImpl()->DestroyContext(context);
     StageArena::instance()->cleanup();
-    return nullptr;
 }
-KOALA_INTEROP_1(DestroyContext, KNativePointer, KNativePointer)
+KOALA_INTEROP_V1(DestroyContext, KNativePointer)
 
 KNativePointer impl_UpdateCallExpression(
     KNativePointer contextPtr,
@@ -256,7 +312,8 @@ KOALA_INTEROP_2(AstNodeUpdateChildren, KNativePointer, KNativePointer, KNativePo
 
 std::vector<void*> cachedChildren;
 
-static void visitChild(es2panda_AstNode *node) {
+static void visitChild(es2panda_AstNode *node)
+{
     cachedChildren.emplace_back(node);
 }
 
@@ -277,3 +334,67 @@ KOALA_INTEROP_2(AstNodeChildren, KNativePointer, KNativePointer, KNativePointer)
 /*
 -----------------------------------------------------------------------------------------------------------------------------
 */
+
+// From koala-wrapper
+// TODO check if some code should be generated
+
+void impl_MemInitialize()
+{
+    GetImpl()->MemInitialize();
+}
+KOALA_INTEROP_V0(MemInitialize)
+
+void impl_MemFinalize()
+{
+    GetImpl()->MemFinalize();
+}
+KOALA_INTEROP_V0(MemFinalize)
+
+static bool isUIHeaderFile(es2panda_Context* context, es2panda_Program* program)
+{
+    auto result = GetImpl()->ProgramFileNameWithExtensionConst(context, program);
+    string fileNameWithExtension(result);
+    result = GetImpl()->ProgramModuleNameConst(context, program);
+    string moduleName(result);
+
+    return fileNameWithExtension.length() >= MODULE_SUFFIX.length()
+        && fileNameWithExtension.substr(fileNameWithExtension.length() - MODULE_SUFFIX.length()) == MODULE_SUFFIX
+        && moduleName.find(ARKUI) != std::string::npos;
+}
+
+KBoolean impl_ProgramCanSkipPhases(KNativePointer context, KNativePointer program)
+{
+    KStringPtr isUiFlag(IS_UI_FLAG);
+    KStringPtr notUiFlag(NOT_UI_FLAG);
+    const auto _context = reinterpret_cast<es2panda_Context*>(context);
+    const auto _program = reinterpret_cast<es2panda_Program*>(program);
+    if (isUIHeaderFile(_context, _program)) {
+        return false;
+    }
+    std::size_t sourceLen;
+    const auto externalSources = reinterpret_cast<es2panda_ExternalSource **>
+        (GetImpl()->ProgramExternalSources(_context, _program, &sourceLen));
+    for (std::size_t i = 0; i < sourceLen; ++i) {
+        std::size_t programLen;
+        auto programs = GetImpl()->ExternalSourcePrograms(externalSources[i], &programLen);
+        for (std::size_t j = 0; j < programLen; ++j) {
+            if (isUIHeaderFile(_context, programs[j])) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+KOALA_INTEROP_2(ProgramCanSkipPhases, KBoolean, KNativePointer, KNativePointer)
+
+KNativePointer impl_AstNodeProgram(KNativePointer contextPtr, KNativePointer instancePtr)
+{
+    auto _context = reinterpret_cast<es2panda_Context*>(contextPtr);
+    auto _receiver = reinterpret_cast<es2panda_AstNode*>(instancePtr);
+
+    if (GetImpl()->AstNodeIsProgramConst(_context, _receiver)) {
+        return GetImpl()->ETSModuleProgram(_context, _receiver);
+    }
+    return impl_AstNodeProgram(_context, GetImpl()->AstNodeParent(_context, _receiver));
+}
+KOALA_INTEROP_2(AstNodeProgram, KNativePointer, KNativePointer, KNativePointer)

package/build/libarkts-copy/native/src/common.h

@@ -1,3 +1,18 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #ifndef COMMON_H
 #define COMMON_H
 
@@ -26,13 +41,37 @@
 
 using std::string, std::cout, std::endl, std::vector;
 
-es2panda_Impl *GetImpl();
+extern es2panda_Impl *es2pandaImplementation;
+
+es2panda_Impl *GetImplSlow();
+inline es2panda_Impl *GetImpl() {
+    if (es2pandaImplementation) {
+        return es2pandaImplementation;
+    }
+    return GetImplSlow();
+}
 
 string getString(KStringPtr ptr);
 
 char* getStringCopy(KStringPtr& ptr);
 
-inline KUInt unpackUInt(const KByte* bytes);
+inline KUInt unpackUInt(const KByte* bytes)
+{
+    const KUInt BYTE_0 = 0;
+    const KUInt BYTE_1 = 1;
+    const KUInt BYTE_2 = 2;
+    const KUInt BYTE_3 = 3;
+
+    const KUInt BYTE_1_SHIFT = 8;
+    const KUInt BYTE_2_SHIFT = 16;
+    const KUInt BYTE_3_SHIFT = 24;
+    return (
+        bytes[BYTE_0]
+        | (bytes[BYTE_1] << BYTE_1_SHIFT)
+        | (bytes[BYTE_2] << BYTE_2_SHIFT)
+        | (bytes[BYTE_3] << BYTE_3_SHIFT)
+    );
+}
 
 es2panda_ContextState intToState(KInt state);
 
@@ -44,38 +83,44 @@ class StageArena {
     ~StageArena();
     static StageArena* instance();
     template <typename T>
-    static T* alloc() {
+    static T* alloc()
+    {
         auto* arena = StageArena::instance();
         void* memory = arena->alloc(sizeof(T));
         return new (memory) T();
     }
     template <class T, class T1>
-    static T* alloc(T1 arg1) {
+    static T* alloc(T1 arg1)
+    {
         auto* arena = StageArena::instance();
         void* memory = arena->alloc(sizeof(T));
         return new (memory) T(std::forward(arg1));
     }
     template <class T, class T1, class T2>
-    static T* alloc(T1 arg1, T2 arg2) {
+    static T* alloc(T1 arg1, T2 arg2)
+    {
         auto* arena = StageArena::instance();
         void* memory = arena->alloc(sizeof(T));
         return new (memory) T(arg1, arg2);
     }
     template <typename T>
-    static T* allocArray(size_t count) {
+    static T* allocArray(size_t count)
+    {
         auto* arena = StageArena::instance();
         // align?
         void* memory = arena->alloc(sizeof(T) * count);
         return new (memory) T();
     }
     template <class T>
-    static T* clone(const T& arg) {
+    static T* clone(const T& arg)
+    {
         auto* arena = StageArena::instance();
         void* memory = arena->alloc(sizeof(T));
         return new (memory) T(arg);
     }
     template <class T>
-    static std::vector<const void*>* cloneVector(const T* arg, size_t count) {
+    static std::vector<const void*>* cloneVector(const T* arg, size_t count)
+    {
         return alloc<std::vector<const void*>, const T*, const T*>(arg, arg + count);
     }
     void* alloc(size_t size);