@idlizer/arktscgen 2.1.2 → 2.1.7

package/build/libarkts-copy/README.md

@@ -0,0 +1,36 @@
+## libarkts
+
+Wrapper library which provides tsc-like __ArkTS__ compiler API 
+
+Implemented with koala interop technology 
+
+### Prerequisites
+
+node >= 18
+meson >= 0.62
+
+Having following .npmrc: https://gitee.com/openharmony-sig/arkcompiler_ets_frontend/wikis/npmrc
+
+```
+cd ~/arkcompiler_ets_frontend 
+npm i
+cd ./ui2abc/libarkts/
+npm i
+npm run compile
+```
+
+### Structure
+
+- ```compatible``` - __ArkTS__ / __typescript__ plugins
+- ```input``` - code samples to be compiled with __ArkTS__ / __typescript__
+- ```native``` - node module wrapper for __es2panda.so__
+- ```src``` - plugin API sources
+- ```test``` - plugin API tests
+
+### How to run
+```
+npm run run
+node build/api/es2panda.js --help
+```
+
+Runs __ArkTS__ compiler for __./input/main.sts__ invoking plugins specified in __arktsconfig.json__

package/build/libarkts-copy/generator/options.json5

@@ -1,47 +1,98 @@
 {
+    "irHack": [
+        "AnnotationUsage",
+        "ETSFunctionType",
+        "ETSUnionType",
+        "ETSNullType",
+        "ETSUndefinedType",
+    ],
     "ignore": {
-        "interfaces": {
-            "es2panda_Impl": [
-                "*"
-            ],
-            "es2panda_SourcePosition": [ // until idl is fixed
-                "*"
-            ],
-            "es2panda_LabelPair": [
-                "*"
-            ],
-            "AnnotationDeclaration": [
-                "PropertiesPtrConst" // interferes create-to-param matching
-            ],
-            "AnnotationUsage": [
-                "PropertiesPtrConst" // interferes create-to-param matching
-            ],
-            "TSInterfaceBody": [
-                "BodyPtr" // interferes create-to-param matching
-            ],
-            "Signature": [
-                "ProtectionFlagConst", // u8
-            ],
-            "ETSReExportDeclaration": [
-                "Create", // sequence<String>
-                "Update", // sequence<String>
-                "GetUserPathsConst" // sequence<String>
-            ],
-            "CharLiteral": [
-                "Create1", // KShort,
-                "Update1", // KShort
-                "CharConst", // KShort
-            ],
-            "ForUpdateStatement": [ // forbidden naming
-                "Update"
-            ],
-            "CallExpression": [
-                "Update" // differs from handwritten
-            ],
-            "TryStatement": [
-                "AddFinalizerInsertion" // idl missing const
-            ],
-        }
+        "full": [
+            "es2panda_Impl",
+            "es2panda_Config",
+            "es2panda_ExternalSource",
+        ],
+        "partial": [
+            {
+                interface: "MethodDefinition",
+                methods: [
+                    "GetOverloadInfo",  // return type is wrong
+                ]
+            },
+            {
+                interface: "AnnotationDeclaration",
+                methods: [
+                    "PropertiesPtrConst" // interfaces create-to-param matching
+                ]
+            },
+            {
+                interface: "NumberLiteral",
+                methods: [
+                    "SetInt",
+                    "SetLong",
+                    "SetDouble",
+                    "SetFloat"
+                ]
+            },
+            {
+                interface: "AnnotationUsage",
+                methods: [
+                    "PropertiesPtrConst" // interfaces create-to-param matching
+                ]
+            },
+            {
+                interface: "TSInterfaceBody",
+                methods: [
+                    "BodyPtr" // interfaces create-to-param matching
+                ]
+            },
+            {
+                interface: "Signature",
+                methods: [
+                    "ProtectionFlagConst" // u8
+                ]
+            },
+            {
+                interface: "ETSReExportDeclaration",
+                methods: [
+                    "Create", // sequence<String>
+                    "Update", // sequence<String>
+                    "GetUserPathsConst" // sequence<String>
+                ]
+            },
+            {
+                interface: "CharLiteral",
+                methods: [
+                    "Create1", // KShort,
+                    "Update1", // KShort
+                    "CharConst", // KShort
+                ]
+            },
+            {
+                interface: "ForUpdateStatement",
+                methods: [
+                    "Update" // forbidden naming
+                ]
+            },
+            {
+                interface: "CallExpression",
+                methods: [
+                    "Update" // differs from handwritten
+                ]
+            },
+            {
+                interface: "TryStatement",
+                methods: [
+                    "AddFinalizerInsertion" // idl missing const
+                ]
+            },
+            {
+                interface: "MemberExpression",
+                methods: [
+                    "SetExtensionAccessorType" // ETSFunction type ambiguity
+                ]
+            },
+        ]
     },
     nonNullable: [
         {
@@ -148,8 +199,26 @@
                 {
                     name: "FunctionConst",
                     types: ["returnType"]
+                },
+            ]
+        },
+        {
+            name: "ETSFunctionType",
+            methods: [
+                {
+                    name: "ReturnTypeConst",
+                    types: ["returnType"]
+                }
+            ]
+        },
+        {
+            name: "TSTypeAliasDeclaration",
+            methods: [
+                {
+                    name: "TypeAnnotationConst",
+                    types: ["returnType"]
                 }
             ]
         },
-    ]
-}
+    ],
+}

package/build/libarkts-copy/native/meson.build

@@ -1,3 +1,16 @@
+# 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.
+
 project(
     'es2panda_interop',
     'cpp',

package/build/libarkts-copy/native/meson_options.txt

@@ -1,3 +1,16 @@
+# 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.
+
 option(
     'node_modules_dir',
     type : 'string',

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

@@ -39,7 +39,7 @@ KNativePointer impl_AnnotationAllowedAnnotations(KNativePointer contextPtr, KNat
     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
     std::size_t params_len = 0;
     auto annotations = GetImpl()->AnnotationAllowedAnnotations(context, node, &params_len);
-    return new std::vector<void*>(annotations, annotations + params_len);
+    return StageArena::cloneVector(annotations, params_len);
 }
 KOALA_INTEROP_3(AnnotationAllowedAnnotations, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
 
@@ -49,10 +49,11 @@ KNativePointer impl_AnnotationAllowedAnnotationsConst(KNativePointer contextPtr,
     auto node = reinterpret_cast<es2panda_AstNode*>(nodePtr);
     std::size_t params_len = 0;
     auto annotations = GetImpl()->AnnotationAllowedAnnotationsConst(context, node, &params_len);
-    return new std::vector<void*>(annotations, annotations + params_len);
+    return StageArena::cloneVector(annotations, params_len);
 }
 KOALA_INTEROP_3(AnnotationAllowedAnnotationsConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
 
+/*
 KNativePointer impl_AstNodeVariableConst(KNativePointer contextPtr, KNativePointer nodePtr)
 {
     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
@@ -61,6 +62,7 @@ KNativePointer impl_AstNodeVariableConst(KNativePointer contextPtr, KNativePoint
     return GetImpl()->AstNodeVariableConst(context, node);
 }
 KOALA_INTEROP_2(AstNodeVariableConst, KNativePointer, KNativePointer, KNativePointer)
+*/
 
 KNativePointer impl_VariableDeclaration(KNativePointer contextPtr, KNativePointer variablePtr)
 {
@@ -80,6 +82,7 @@ KNativePointer impl_DeclNode(KNativePointer contextPtr, KNativePointer declPtr)
 }
 KOALA_INTEROP_2(DeclNode, KNativePointer, KNativePointer, KNativePointer)
 
+/*
 KNativePointer impl_AstNodeScopeConst(KNativePointer contextPtr, KNativePointer nodePtr)
 {
     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
@@ -87,7 +90,7 @@ KNativePointer impl_AstNodeScopeConst(KNativePointer contextPtr, KNativePointer
     return GetImpl()->AstNodeScopeConst(context, node);
 }
 KOALA_INTEROP_2(AstNodeScopeConst, KNativePointer, KNativePointer, KNativePointer)
-
+*/
 KNativePointer impl_ScopeSetParent(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer parentPtr)
 {
     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
@@ -98,6 +101,7 @@ KNativePointer impl_ScopeSetParent(KNativePointer contextPtr, KNativePointer nod
 }
 KOALA_INTEROP_3(ScopeSetParent, KNativePointer, KNativePointer, KNativePointer, KNativePointer)
 
+/*
 KNativePointer impl_CreateNumberLiteral(KNativePointer contextPtr, KDouble value)
 {
     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
@@ -105,6 +109,7 @@ KNativePointer impl_CreateNumberLiteral(KNativePointer contextPtr, KDouble value
     return GetImpl()->CreateNumberLiteral(context, value);
 }
 KOALA_INTEROP_2(CreateNumberLiteral, KNativePointer, KNativePointer, KDouble)
+*/
 
 KNativePointer impl_ETSParserCreateExpression(KNativePointer contextPtr, KStringPtr& sourceCodePtr, KInt flagsT)
 {
@@ -146,7 +151,7 @@ KOALA_INTEROP_1(ContextProgram, KNativePointer, KNativePointer)
 
 KNativePointer impl_ProgramAst(KNativePointer contextPtr, KNativePointer programPtr)
 {
-    auto context = reinterpret_cast<es2panda_Context*>(programPtr);
+    auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
     auto program = reinterpret_cast<es2panda_Program*>(programPtr);
     return GetImpl()->ProgramAst(context, program);
 }
@@ -185,10 +190,11 @@ KNativePointer impl_ContextErrorMessage(KNativePointer contextPtr)
 {
     auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
 
-    return new string(GetImpl()->ContextErrorMessage(context));
+    return StageArena::strdup(GetImpl()->ContextErrorMessage(context));
 }
 KOALA_INTEROP_1(ContextErrorMessage, KNativePointer, KNativePointer)
 
+/*
 KNativePointer impl_CallExpressionSignature(KNativePointer context, KNativePointer classInstance)
 {
     const auto _context = reinterpret_cast<es2panda_Context*>(context);
@@ -197,7 +203,7 @@ KNativePointer impl_CallExpressionSignature(KNativePointer context, KNativePoint
     return result;
 }
 KOALA_INTEROP_2(CallExpressionSignature, KNativePointer, KNativePointer, KNativePointer)
-
+*/
 KNativePointer impl_SignatureFunction(KNativePointer context, KNativePointer classInstance)
 {
     const auto _context = reinterpret_cast<es2panda_Context*>(context);
@@ -222,15 +228,15 @@ static KNativePointer impl_ProgramExternalSources(KNativePointer contextPtr, KNa
     auto&& instance = reinterpret_cast<es2panda_Program *>(instancePtr);
     std::size_t source_len = 0;
     auto external_sources = GetImpl()->ProgramExternalSources(context, instance, &source_len);
-    return new std::vector<void*>(external_sources, external_sources + source_len);
+    return StageArena::cloneVector(external_sources, source_len);
 }
 KOALA_INTEROP_2(ProgramExternalSources, KNativePointer, KNativePointer, KNativePointer);
 
 static KNativePointer impl_ExternalSourceName(KNativePointer instance)
 {
     auto&& _instance_ = reinterpret_cast<es2panda_ExternalSource *>(instance);
-    auto&& _result_ = GetImpl()->ExternalSourceName(_instance_);
-    return new std::string(_result_);
+    auto&& result = GetImpl()->ExternalSourceName(_instance_);
+    return StageArena::strdup(result);
 }
 KOALA_INTEROP_1(ExternalSourceName, KNativePointer, KNativePointer);
 
@@ -239,7 +245,7 @@ static KNativePointer impl_ExternalSourcePrograms(KNativePointer instance)
     auto&& _instance_ = reinterpret_cast<es2panda_ExternalSource *>(instance);
     std::size_t program_len = 0;
     auto programs = GetImpl()->ExternalSourcePrograms(_instance_, &program_len);
-    return new std::vector<void*>(programs, programs + program_len);
+    return StageArena::cloneVector(programs, program_len);
 }
 KOALA_INTEROP_1(ExternalSourcePrograms, KNativePointer, KNativePointer);
 
@@ -263,3 +269,65 @@ KBoolean impl_IsETSFunctionType(KNativePointer nodePtr)
     return GetImpl()->IsETSFunctionType(node);
 }
 KOALA_INTEROP_1(IsETSFunctionType, KBoolean, KNativePointer)
+
+KNativePointer impl_ETSParserBuildImportDeclaration(KNativePointer context, KInt importKinds, KNativePointerArray specifiers, KUInt specifiersSequenceLength, KNativePointer source, KNativePointer program, KInt importFlag)
+{
+    const auto _context = reinterpret_cast<es2panda_Context*>(context);
+    const auto _kinds = static_cast<Es2pandaImportKinds>(importKinds);
+    const auto _specifiers = reinterpret_cast<es2panda_AstNode**>(specifiers);
+    const auto _specifiersSequenceLength = static_cast<size_t>(specifiersSequenceLength);
+    const auto _source = reinterpret_cast<es2panda_AstNode*>(source);
+    const auto _program = reinterpret_cast<es2panda_Program*>(program);
+    const auto _importFlag = static_cast<Es2pandaImportFlags>(importFlag);
+
+    return GetImpl()->ETSParserBuildImportDeclaration(_context, _kinds, _specifiers, _specifiersSequenceLength, _source, _program, _importFlag);
+}
+KOALA_INTEROP_7(ETSParserBuildImportDeclaration, KNativePointer, KNativePointer, KInt, KNativePointerArray, KUInt, KNativePointer, KNativePointer, KInt)
+
+void impl_InsertETSImportDeclarationAndParse(KNativePointer context, KNativePointer program, KNativePointer importDeclaration)
+{
+    const auto _context = reinterpret_cast<es2panda_Context*>(context);
+    const auto _program = reinterpret_cast<es2panda_Program*>(program);
+    const auto _import = reinterpret_cast<es2panda_AstNode*>(importDeclaration);
+    GetImpl()->InsertETSImportDeclarationAndParse(_context, _program, _import);
+}
+KOALA_INTEROP_V3(InsertETSImportDeclarationAndParse, KNativePointer, KNativePointer, KNativePointer)
+
+KNativePointer impl_ETSParserGetImportPathManager(KNativePointer contextPtr)
+{
+    auto context = reinterpret_cast<es2panda_Context*>(contextPtr);
+    return GetImpl()->ETSParserGetImportPathManager(context);
+}
+KOALA_INTEROP_1(ETSParserGetImportPathManager, KNativePointer, KNativePointer);
+
+KNativePointer impl_CreateSourcePosition(KNativePointer context, KInt index, KInt line)
+{
+    auto&& _context_ = reinterpret_cast<es2panda_Context *>(context);
+    return GetImpl()->CreateSourcePosition(_context_, index, line);
+}
+KOALA_INTEROP_3(CreateSourcePosition, KNativePointer, KNativePointer, KInt, KInt);
+
+KInt impl_SourcePositionIndex(KNativePointer context, KNativePointer instance)
+{
+    auto&& _context_ = reinterpret_cast<es2panda_Context *>(context);
+    auto&& _instance_ = reinterpret_cast<es2panda_SourcePosition *>(instance);
+    return GetImpl()->SourcePositionIndex(_context_, _instance_);
+}
+KOALA_INTEROP_2(SourcePositionIndex, KInt, KNativePointer, KNativePointer);
+
+KInt impl_SourcePositionLine(KNativePointer context, KNativePointer instance)
+{
+    auto&& _context_ = reinterpret_cast<es2panda_Context *>(context);
+    auto&& _instance_ = reinterpret_cast<es2panda_SourcePosition *>(instance);
+    return GetImpl()->SourcePositionLine(_context_, _instance_);
+}
+KOALA_INTEROP_2(SourcePositionLine, KInt, KNativePointer, KNativePointer);
+
+KNativePointer impl_CreateSourceRange(KNativePointer context, KNativePointer start, KNativePointer end)
+{
+    auto&& _context_ = reinterpret_cast<es2panda_Context *>(context);
+    auto&& _start_ = reinterpret_cast<es2panda_SourcePosition *>(start);
+    auto&& _end_ = reinterpret_cast<es2panda_SourcePosition *>(end);
+    return GetImpl()->CreateSourceRange(_context_, _start_, _end_);
+}
+KOALA_INTEROP_3(CreateSourceRange, KNativePointer, KNativePointer, KNativePointer, KNativePointer);

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

@@ -14,11 +14,56 @@
  */
 
 #include <common.h>
+#include <utility>
 
 using std::string, std::cout, std::endl, std::vector;
 
 static es2panda_Impl *impl = 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"
@@ -58,11 +103,13 @@ es2panda_Impl *GetImpl() {
     }
     auto library = FindLibrary();
     if (!library) {
-        throw std::runtime_error("No library (es2panda_lib.cc)");
+        printf("No library (es2panda_lib.cc)"); // TODO: dont use throw for ohos build
+        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;
@@ -78,7 +125,7 @@ string getString(KStringPtr ptr) {
 }
 
 char* getStringCopy(KStringPtr& ptr) {
-    return strdup(ptr.c_str());
+    return StageArena::strdup(ptr.c_str() ? ptr.c_str() : "");
 }
 
 inline KUInt unpackUInt(const KByte* bytes) {
@@ -91,7 +138,7 @@ inline KUInt unpackUInt(const KByte* bytes) {
     const KUInt BYTE_2_SHIFT = 16;
     const KUInt BYTE_3_SHIFT = 24;
     return (
-        bytes[BYTE_0] 
+        bytes[BYTE_0]
         | (bytes[BYTE_1] << BYTE_1_SHIFT)
         | (bytes[BYTE_2] << BYTE_2_SHIFT)
         | (bytes[BYTE_3] << BYTE_3_SHIFT)
@@ -101,13 +148,13 @@ inline KUInt unpackUInt(const KByte* bytes) {
 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);
@@ -124,6 +171,7 @@ KOALA_INTEROP_1(DestroyConfig, KNativePointer, KNativePointer)
 KNativePointer 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)
@@ -148,7 +196,7 @@ KNativePointer impl_UpdateCallExpression(
 
     auto nn = GetImpl()->CreateCallExpression(
         context, callee, arguments, argumentsLen, typeParams, optional, trailingComma
-    ); 
+    );
     GetImpl()->AstNodeSetOriginalNode(context, nn, node);
     return nn;
 }
@@ -222,7 +270,7 @@ 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)
 

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

@@ -36,4 +36,52 @@ inline KUInt unpackUInt(const KByte* bytes);
 
 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