@idlizer/arktscgen 2.1.5 → 2.1.9-arktscgen-4

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

@@ -14,19 +14,70 @@
  */
 
 #include <common.h>
+#include <utility>
 
 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()
+{
+    return &currentArena;
+}
+
+void StageArena::add(void* pointer)
+{
+    if (pointer)
+        allocated.push_back(pointer);
+}
+
+void StageArena::cleanup()
+{
+    if (totalSize > 0 && false)
+        printf("cleanup %d objects %d bytes\n", (int)allocated.size(), (int)totalSize);
+    for (auto it : allocated) {
+        free(it);
+    }
+    totalSize = 0;
+    allocated.clear();
+}
+
+StageArena::StageArena()
+{
+    totalSize = 0;
+}
+
+StageArena::~StageArena()
+{
+    cleanup();
+}
+
+char* StageArena::strdup(const char* string)
+{
+    auto* arena = StageArena::instance();
+    auto size = strlen(string) + 1;
+    char* memory = (char*)arena->alloc(size);
+    memcpy(memory, string, size);
+    return memory;
+}
+
+void* StageArena::alloc(size_t size)
+{
+    void* result = malloc(size);
+    totalSize += size;
+    add(result);
+    return result;
+}
 
 #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__
@@ -42,30 +93,98 @@ static es2panda_Impl *impl = nullptr;
 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;
+    }
+
+    // find by DEFAULT_SDK_PATH
+    pathArray = {DEFAULT_SDK_PATH, PLUGIN_DIR, LIB_DIR, NAME};
+    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);
+
+    return NULL;
 }
 
-es2panda_Impl *GetImpl() {
-    if (impl) {
-        return impl;
+es2panda_Impl *GetImplSlow()
+{
+    if (es2pandaImplementation) {
+        return es2pandaImplementation;
     }
     auto library = FindLibrary();
     if (!library) {
-        throw std::runtime_error("No library (es2panda_lib.cc)");
+        printf("No library (es2panda_lib.cc)");
+        abort();
     }
     auto symbol = findSymbol(library, "es2panda_GetImpl");
     if (!symbol) {
-        throw std::runtime_error("No entry point");
+        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)
@@ -73,41 +192,26 @@ es2panda_ContextState intToState(KInt state)
     return es2panda_ContextState(state);
 }
 
-string getString(KStringPtr ptr) {
+string getString(KStringPtr ptr)
+{
     return ptr.data();
 }
 
-char* getStringCopy(KStringPtr& ptr) {
-    return strdup(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)
-    );
+char* getStringCopy(KStringPtr& ptr)
+{
+    return StageArena::strdup(ptr.c_str() ? ptr.c_str() : "");
 }
 
 KNativePointer impl_CreateConfig(KInt argc, KStringArray argvPtr) {
     const std::size_t headerLen = 4;
 
-    const char** argv = new const char*[argc];
+    const char** argv = StageArena::allocArray<const char*>(argc);
     std::size_t position = headerLen;
     std::size_t strLen;
     for (std::size_t i = 0; i < static_cast<std::size_t>(argc); ++i) {
         strLen = unpackUInt(argvPtr + position);
         position += headerLen;
-        argv[i] = strdup(std::string(reinterpret_cast<const char*>(argvPtr + position), strLen).c_str());
+        argv[i] = StageArena::strdup(std::string(reinterpret_cast<const char*>(argvPtr + position), strLen).c_str());
         position += strLen;
     }
     return GetImpl()->CreateConfig(argc, argv);
@@ -121,12 +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);
-    return nullptr;
+    StageArena::instance()->cleanup();
 }
-KOALA_INTEROP_1(DestroyContext, KNativePointer, KNativePointer)
+KOALA_INTEROP_V1(DestroyContext, KNativePointer)
 
 KNativePointer impl_UpdateCallExpression(
     KNativePointer contextPtr,
@@ -148,7 +252,7 @@ KNativePointer impl_UpdateCallExpression(
 
     auto nn = GetImpl()->CreateCallExpression(
         context, callee, arguments, argumentsLen, typeParams, optional, trailingComma
-    ); 
+    );
     GetImpl()->AstNodeSetOriginalNode(context, nn, node);
     return nn;
 }
@@ -208,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);
 }
 
@@ -222,10 +327,74 @@ KNativePointer impl_AstNodeChildren(
     cachedChildren.clear();
 
     GetImpl()->AstNodeIterateConst(context, node, visitChild);
-    return new std::vector(cachedChildren);
+    return StageArena::clone(cachedChildren);
 }
 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,14 +41,92 @@
 
 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);
 
+class StageArena {
+    std::vector<void*> allocated;
+    size_t totalSize;
+  public:
+    StageArena();
+    ~StageArena();
+    static StageArena* instance();
+    template <typename T>
+    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)
+    {
+        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)
+    {
+        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)
+    {
+        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)
+    {
+        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)
+    {
+        return alloc<std::vector<const void*>, const T*, const T*>(arg, arg + count);
+    }
+    void* alloc(size_t size);
+    static char* strdup(const char* original);
+    void add(void* pointer);
+    void cleanup();
+};
+
 #endif // COMMON_H