koffi 2.7.1 → 2.7.3

package/src/core/libcc/libcc.hh

@@ -249,14 +249,6 @@ extern "C" void AssertMessage(const char *filename, int line, const char *cond);
     #define RG_UNREACHABLE() __assume(0)
 #endif
 
-#if defined(__EMSCRIPTEN__)
-    #define RG_EXPORT EMSCRIPTEN_KEEPALIVE
-#elif defined(_WIN32)
-    #define RG_EXPORT __declspec(dllexport)
-#else
-    #define RG_EXPORT __attribute__((visibility("default")))
-#endif
-
 #define RG_DELETE_COPY(Cls) \
     Cls(const Cls&) = delete; \
     Cls &operator=(const Cls&) = delete;
@@ -1221,11 +1213,7 @@ public:
         RG_ASSERT(len <= N - count);
 
         T *first = data + len;
-#if __cplusplus >= 201703L
         if constexpr(!std::is_trivial<T>::value) {
-#else
-        if (true) {
-#endif
             for (Size i = 0; i < count; i++) {
                 new (data + len) T();
                 len++;
@@ -1323,11 +1311,7 @@ public:
     {
         RemoveFrom(0);
         Grow(other.capacity);
-#if __cplusplus >= 201703L
         if constexpr(!std::is_trivial<T>::value) {
-#else
-        if (true) {
-#endif
             for (Size i = 0; i < other.len; i++) {
                 ptr[i] = other.ptr[i];
             }
@@ -1432,11 +1416,7 @@ public:
         Grow(count);
 
         T *first = ptr + len;
-#if __cplusplus >= 201703L
         if constexpr(!std::is_trivial<T>::value) {
-#else
-        if (true) {
-#endif
             for (Size i = 0; i < count; i++) {
                 new (ptr + len) T();
                 len++;
@@ -1454,11 +1434,7 @@ public:
         Grow();
 
         T *first = ptr + len;
-#if __cplusplus >= 201703L
         if constexpr(!std::is_trivial<T>::value) {
-#else
-        if (true) {
-#endif
             new (ptr + len) T;
         }
         ptr[len++] = value;
@@ -1470,11 +1446,7 @@ public:
 
         T *first = ptr + len;
         for (const T &value: values) {
-#if __cplusplus >= 201703L
             if constexpr(!std::is_trivial<T>::value) {
-#else
-            if (true) {
-#endif
                 new (ptr + len) T;
             }
             ptr[len++] = value;
@@ -1486,11 +1458,7 @@ public:
     {
         RG_ASSERT(first >= 0 && first <= len);
 
-#if __cplusplus >= 201703L
         if constexpr(!std::is_trivial<T>::value) {
-#else
-        if (true) {
-#endif
             for (Size i = first; i < len; i++) {
                 ptr[i].~T();
             }
@@ -1796,11 +1764,7 @@ private:
     void DeleteValues([[maybe_unused]] iterator_type begin,
                       [[maybe_unused]] iterator_type end)
     {
-#if __cplusplus >= 201703L
         if constexpr(!std::is_trivial<T>::value) {
-#else
-        if (true) {
-#endif
             for (iterator_type it = begin; it != end; ++it) {
                 it->~T();
             }
@@ -2077,11 +2041,7 @@ public:
     }
     ~HashTable()
     {
-#if __cplusplus >= 201703L
         if constexpr(std::is_trivial<ValueType>::value) {
-#else
-        if (false) {
-#endif
             count = 0;
             Rehash(0);
         } else {
@@ -2278,11 +2238,7 @@ private:
     template <typename T = KeyType>
     const ValueType *Find(Size *idx, const T &key) const
     {
-#if __cplusplus >= 201703L
         if constexpr(std::is_pointer<ValueType>::value) {
-#else
-        if (false) {
-#endif
             while (data[*idx]) {
                 const KeyType &it_key = Handler::GetKey(data[*idx]);
                 if (Handler::TestKeys(it_key, key))
@@ -3184,18 +3140,22 @@ static inline void Log(LogLevel level, const char *ctx, const char *fmt, Args...
 
 // Shortcut log functions
 #ifdef RG_DEBUG
-template <typename... Args>
-static inline void LogDebug(Args... args) { Log(LogLevel::Debug, "Debug", args...); }
+    const char *DebugLogContext(const char *filename, int line);
+
+    #define LogDebug(...) Log(LogLevel::Debug, DebugLogContext(__FILE__, __LINE__) __VA_OPT__(,) __VA_ARGS__)
+    #define LogInfo(...) Log(LogLevel::Info, nullptr __VA_OPT__(,) __VA_ARGS__)
+    #define LogWarning(...) Log(LogLevel::Warning, DebugLogContext(__FILE__, __LINE__) __VA_OPT__(,) __VA_ARGS__)
+    #define LogError(...) Log(LogLevel::Error, DebugLogContext(__FILE__, __LINE__) __VA_OPT__(,) __VA_ARGS__)
 #else
-template <typename... Args>
-static inline void LogDebug(Args...) {}
+    template <typename... Args>
+    static inline void LogDebug(Args...) {}
+    template <typename... Args>
+    static inline void LogInfo(Args... args) { Log(LogLevel::Info, nullptr, args...); }
+    template <typename... Args>
+    static inline void LogWarning(Args... args) { Log(LogLevel::Warning, "Warning: ", args...); }
+    template <typename... Args>
+    static inline void LogError(Args... args) { Log(LogLevel::Error, "Error: ", args...); }
 #endif
-template <typename... Args>
-static inline void LogInfo(Args... args) { Log(LogLevel::Info, nullptr, args...); }
-template <typename... Args>
-static inline void LogWarning(Args... args) { Log(LogLevel::Warning, "Warning", args...); }
-template <typename... Args>
-static inline void LogError(Args... args) { Log(LogLevel::Error, "Error", args...); }
 
 void SetLogHandler(const std::function<LogFunc> &func);
 void DefaultLogHandler(LogLevel level, const char *ctx, const char *msg);
@@ -3301,7 +3261,7 @@ static inline bool TestStrI(Span<const char> str1, const char *str2)
     return (i == str1.len) && !str2[i];
 }
 static inline bool TestStrI(const char *str1, Span<const char> str2)
-    { return TestStr(str2, str1); }
+    { return TestStrI(str2, str1); }
 static inline bool TestStrI(const char *str1, const char *str2)
 {
     Size i = 0;
@@ -4344,8 +4304,8 @@ enum class CompressionSpeed {
     Fast
 };
 
-class StreamDecompressor;
-class StreamCompressor;
+class StreamDecoder;
+class StreamEncoder;
 
 class StreamReader {
     RG_DELETE_COPY(StreamReader)
@@ -4383,8 +4343,7 @@ class StreamReader {
         bool eof = false;
     } source;
 
-    CompressionType compression_type = CompressionType::None;
-    StreamDecompressor *decompressor = nullptr;
+    StreamDecoder *decoder = nullptr;
 
     int64_t raw_len = -1;
     Size raw_read = 0;
@@ -4408,6 +4367,9 @@ public:
         : StreamReader() { Open(func, filename, compression_type); }
     ~StreamReader() { Close(true); }
 
+    // Call before Open!
+    void SetDecoder(StreamDecoder *decoder);
+
     bool Open(Span<const uint8_t> buf, const char *filename = nullptr,
               CompressionType compression_type = CompressionType::None);
     bool Open(FILE *fp, const char *filename,
@@ -4421,7 +4383,6 @@ public:
     bool Rewind();
 
     const char *GetFileName() const { return filename; }
-    CompressionType GetCompressionType() const { return compression_type; }
     int64_t GetReadLimit() { return read_max; }
     bool IsValid() const { return filename && !error; }
     bool IsEOF() const { return eof; }
@@ -4449,62 +4410,38 @@ private:
 
     Size ReadRaw(Size max_len, void *out_buf);
 
-    friend class StreamDecompressor;
+    friend class StreamDecoder;
 };
 
-static inline Size ReadFile(const char *filename, CompressionType compression_type, Span<uint8_t> out_buf)
-{
-    StreamReader st(filename, compression_type);
-    return st.Read(out_buf);
-}
 static inline Size ReadFile(const char *filename, Span<uint8_t> out_buf)
 {
     StreamReader st(filename);
     return st.Read(out_buf);
 }
-static inline Size ReadFile(const char *filename, CompressionType compression_type, Span<char> out_buf)
-{
-    StreamReader st(filename, compression_type);
-    return st.Read(out_buf);
-}
 static inline Size ReadFile(const char *filename, Span<char> out_buf)
 {
     StreamReader st(filename);
     return st.Read(out_buf);
 }
-
-static inline Size ReadFile(const char *filename, Size max_len, CompressionType compression_type,
-                            HeapArray<uint8_t> *out_buf)
-{
-    StreamReader st(filename, compression_type);
-    return st.ReadAll(max_len, out_buf);
-}
 static inline Size ReadFile(const char *filename, Size max_len, HeapArray<uint8_t> *out_buf)
 {
     StreamReader st(filename);
     return st.ReadAll(max_len, out_buf);
 }
-static inline Size ReadFile(const char *filename, Size max_len, CompressionType compression_type,
-                            HeapArray<char> *out_buf)
-{
-    StreamReader st(filename, compression_type);
-    return st.ReadAll(max_len, out_buf);
-}
 static inline Size ReadFile(const char *filename, Size max_len, HeapArray<char> *out_buf)
 {
     StreamReader st(filename);
     return st.ReadAll(max_len, out_buf);
 }
 
-class StreamDecompressor {
+class StreamDecoder {
 protected:
     StreamReader *reader;
 
 public:
-    StreamDecompressor(StreamReader *reader) : reader(reader) {}
-    virtual ~StreamDecompressor() {}
+    StreamDecoder(StreamReader *reader) : reader(reader) {}
+    virtual ~StreamDecoder() {}
 
-    virtual bool Init(CompressionType type) = 0;
     virtual Size Read(Size max_len, void *out_buf) = 0;
 
 protected:
@@ -4517,7 +4454,7 @@ protected:
     void SetEOF(bool eof) { reader->eof = eof; }
 };
 
-typedef StreamDecompressor *CreateDecompressorFunc(StreamReader *reader);
+typedef StreamDecoder *CreateDecompressorFunc(StreamReader *reader, CompressionType type);
 
 class StreamDecompressorHelper {
 public:
@@ -4525,9 +4462,9 @@ public:
 };
 
 #define RG_REGISTER_DECOMPRESSOR(Type, Cls) \
-    static StreamDecompressor *RG_UNIQUE_NAME(CreateDecompressor)(StreamReader *reader) \
+    static StreamDecoder *RG_UNIQUE_NAME(CreateDecompressor)(StreamReader *reader, CompressionType type) \
     { \
-        StreamDecompressor *decompressor = new Cls(reader); \
+        StreamDecoder *decompressor = new Cls(reader, type); \
         return decompressor; \
     } \
     static StreamDecompressorHelper RG_UNIQUE_NAME(CreateDecompressorHelper)((Type), RG_UNIQUE_NAME(CreateDecompressor))
@@ -4601,9 +4538,7 @@ class StreamWriter {
         bool vt100;
     } dest;
 
-    CompressionType compression_type = CompressionType::None;
-    CompressionSpeed compression_speed = CompressionSpeed::Default;
-    StreamCompressor *compressor = nullptr;
+    StreamEncoder *encoder = nullptr;
 
     int64_t raw_written = 0;
 
@@ -4633,6 +4568,9 @@ public:
         : StreamWriter() { Open(func, filename, compression_type, compression_speed); }
     ~StreamWriter() { Close(true); }
 
+    // Call before Open!
+    void SetEncoder(StreamEncoder *encoder);
+
     bool Open(HeapArray<uint8_t> *mem, const char *filename = nullptr,
               CompressionType compression_type = CompressionType::None,
               CompressionSpeed compression_speed = CompressionSpeed::Default);
@@ -4655,8 +4593,6 @@ public:
     bool Flush();
 
     const char *GetFileName() const { return filename; }
-    CompressionType GetCompressionType() const { return compression_type; }
-    CompressionSpeed GetCompressionSpeed() const { return compression_speed; }
     bool IsVt100() const { return dest.vt100; }
     bool IsValid() const { return filename && !error; }
 
@@ -4677,33 +4613,30 @@ private:
 
     bool WriteRaw(Span<const uint8_t> buf);
 
-    friend class StreamCompressor;
+    friend class StreamEncoder;
 };
 
-static inline bool WriteFile(Span<const uint8_t> buf, const char *filename, unsigned int flags = 0,
-                             CompressionType compression_type = CompressionType::None)
+static inline bool WriteFile(Span<const uint8_t> buf, const char *filename, unsigned int flags = 0)
 {
-    StreamWriter st(filename, flags, compression_type);
+    StreamWriter st(filename, flags);
     st.Write(buf);
     return st.Close();
 }
-static inline bool WriteFile(Span<const char> buf, const char *filename, unsigned int flags = 0,
-                             CompressionType compression_type = CompressionType::None)
+static inline bool WriteFile(Span<const char> buf, const char *filename, unsigned int flags = 0)
 {
-    StreamWriter st(filename, flags, compression_type);
+    StreamWriter st(filename, flags);
     st.Write(buf);
     return st.Close();
 }
 
-class StreamCompressor {
+class StreamEncoder {
 protected:
     StreamWriter *writer;
 
 public:
-    StreamCompressor(StreamWriter *writer) : writer(writer) {}
-    virtual ~StreamCompressor() {}
+    StreamEncoder(StreamWriter *writer) : writer(writer) {}
+    virtual ~StreamEncoder() {}
 
-    virtual bool Init(CompressionType type, CompressionSpeed speed) = 0;
     virtual bool Write(Span<const uint8_t> buf) = 0;
     virtual bool Finalize() = 0;
 
@@ -4714,7 +4647,7 @@ protected:
     bool WriteRaw(Span<const uint8_t> buf) { return writer->WriteRaw(buf); }
 };
 
-typedef StreamCompressor *CreateCompressorFunc(StreamWriter *writer);
+typedef StreamEncoder *CreateCompressorFunc(StreamWriter *writer, CompressionType type, CompressionSpeed speed);
 
 class StreamCompressorHelper {
 public:
@@ -4722,9 +4655,9 @@ public:
 };
 
 #define RG_REGISTER_COMPRESSOR(Type, Cls) \
-    static StreamCompressor *RG_UNIQUE_NAME(CreateCompressor)(StreamWriter *writer) \
+    static StreamEncoder *RG_UNIQUE_NAME(CreateCompressor)(StreamWriter *writer, CompressionType type, CompressionSpeed speed) \
     { \
-        StreamCompressor *compressor = new Cls(writer); \
+        StreamEncoder *compressor = new Cls(writer, type, speed); \
         return compressor; \
     } \
     static StreamCompressorHelper RG_UNIQUE_NAME(CreateCompressorHelper)((Type), RG_UNIQUE_NAME(CreateCompressor))
@@ -4934,6 +4867,36 @@ bool OptionToEnum(Span<const OptionDesc> options, Span<const char> str, T *out_v
     return false;
 }
 
+template <typename T>
+bool OptionToEnumI(Span<const char *const> options, Span<const char> str, T *out_value)
+{
+    for (Size i = 0; i < options.len; i++) {
+        const char *opt = options[i];
+
+        if (TestStrI(opt, str)) {
+            *out_value = (T)i;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+template <typename T>
+bool OptionToEnumI(Span<const OptionDesc> options, Span<const char> str, T *out_value)
+{
+    for (Size i = 0; i < options.len; i++) {
+        const OptionDesc &desc = options[i];
+
+        if (TestStrI(desc.name, str)) {
+            *out_value = (T)i;
+            return true;
+        }
+    }
+
+    return false;
+}
+
 template <typename T>
 bool OptionToFlag(Span<const char *const> options, Span<const char> str, T *out_flags, bool enable = true)
 {
@@ -4964,6 +4927,36 @@ bool OptionToFlag(Span<const OptionDesc> options, Span<const char> str, T *out_f
     return false;
 }
 
+template <typename T>
+bool OptionToFlagI(Span<const char *const> options, Span<const char> str, T *out_flags, bool enable = true)
+{
+    for (Size i = 0; i < options.len; i++) {
+        const char *opt = options[i];
+
+        if (TestStrI(opt, str)) {
+            *out_flags = ApplyMask(*out_flags, 1u << i, enable);
+            return true;
+        }
+    }
+
+    return false;
+}
+
+template <typename T>
+bool OptionToFlagI(Span<const OptionDesc> options, Span<const char> str, T *out_flags, bool enable = true)
+{
+    for (Size i = 0; i < options.len; i++) {
+        const OptionDesc &desc = options[i];
+
+        if (TestStrI(desc.name, str)) {
+            *out_flags = ApplyMask(*out_flags, 1u << i, enable);
+            return true;
+        }
+    }
+
+    return false;
+}
+
 // ------------------------------------------------------------------------
 // Console prompter (simplified readline)
 // ------------------------------------------------------------------------

package/src/core/libcc/lz4.cc

@@ -27,7 +27,7 @@
 
 namespace RG {
 
-class LZ4Decompressor: public StreamDecompressor {
+class LZ4Decompressor: public StreamDecoder {
     LZ4F_dctx *decoder = nullptr;
     bool done = false;
 
@@ -39,25 +39,23 @@ class LZ4Decompressor: public StreamDecompressor {
     Size out_len = 0;
 
 public:
-    LZ4Decompressor(StreamReader *reader) : StreamDecompressor(reader) {}
+    LZ4Decompressor(StreamReader *reader, CompressionType type);
     ~LZ4Decompressor();
 
-    bool Init(CompressionType type) override;
     Size Read(Size max_len, void *out_buf) override;
 };
 
-LZ4Decompressor::~LZ4Decompressor()
-{
-    LZ4F_freeDecompressionContext(decoder);
-}
-
-bool LZ4Decompressor::Init(CompressionType)
+LZ4Decompressor::LZ4Decompressor(StreamReader *reader, CompressionType)
+    : StreamDecoder(reader) 
 {
     LZ4F_errorCode_t err = LZ4F_createDecompressionContext(&decoder, LZ4F_VERSION);
     if (LZ4F_isError(err))
         throw std::bad_alloc();
+}
 
-    return true;
+LZ4Decompressor::~LZ4Decompressor()
+{
+    LZ4F_freeDecompressionContext(decoder);
 }
 
 Size LZ4Decompressor::Read(Size max_len, void *user_buf)
@@ -106,27 +104,22 @@ Size LZ4Decompressor::Read(Size max_len, void *user_buf)
     RG_UNREACHABLE();
 }
 
-class LZ4Compressor: public StreamCompressor {
+class LZ4Compressor: public StreamEncoder {
     LZ4F_cctx *encoder = nullptr;
     LZ4F_preferences_t prefs = {};
 
     HeapArray<uint8_t> dynamic_buf;
 
 public:
-    LZ4Compressor(StreamWriter *writer) : StreamCompressor(writer) {}
+    LZ4Compressor(StreamWriter *writer, CompressionType type, CompressionSpeed speed);
     ~LZ4Compressor();
 
-    bool Init(CompressionType type, CompressionSpeed speed) override;
     bool Write(Span<const uint8_t> buf) override;
     bool Finalize() override;
 };
 
-LZ4Compressor::~LZ4Compressor()
-{
-    LZ4F_freeCompressionContext(encoder);
-}
-
-bool LZ4Compressor::Init(CompressionType, CompressionSpeed speed)
+LZ4Compressor::LZ4Compressor(StreamWriter *writer, CompressionType, CompressionSpeed speed)
+    : StreamEncoder(writer)
 {
     LZ4F_errorCode_t err = LZ4F_createCompressionContext(&encoder, LZ4F_VERSION);
     if (LZ4F_isError(err))
@@ -141,15 +134,15 @@ bool LZ4Compressor::Init(CompressionType, CompressionSpeed speed)
     dynamic_buf.Grow(LZ4F_HEADER_SIZE_MAX);
 
     size_t ret = LZ4F_compressBegin(encoder, dynamic_buf.end(), dynamic_buf.capacity - dynamic_buf.len, &prefs);
-
-    if (LZ4F_isError(ret)) {
-        LogError("Failed to start LZ4 stream for '%1': %2", GetFileName(), LZ4F_getErrorName(ret));
-        return false;
-    }
+    if (LZ4F_isError(ret))
+        throw std::bad_alloc();
 
     dynamic_buf.len += ret;
+}
 
-    return true;
+LZ4Compressor::~LZ4Compressor()
+{
+    LZ4F_freeCompressionContext(encoder);
 }
 
 bool LZ4Compressor::Write(Span<const uint8_t> buf)

package/src/core/libcc/miniz.cc

@@ -26,7 +26,7 @@
 
 namespace RG {
 
-class MinizDecompressor: public StreamDecompressor {
+class MinizDecompressor: public StreamDecoder {
     tinfl_decompressor inflator;
     bool done = false;
 
@@ -45,21 +45,19 @@ class MinizDecompressor: public StreamDecompressor {
     Size uncompressed_size = 0;
 
 public:
-    MinizDecompressor(StreamReader *reader) : StreamDecompressor(reader) {}
+    MinizDecompressor(StreamReader *reader, CompressionType type);
     ~MinizDecompressor() {}
 
-    bool Init(CompressionType type) override;
     Size Read(Size max_len, void *out_buf) override;
 };
 
-bool MinizDecompressor::Init(CompressionType type)
+MinizDecompressor::MinizDecompressor(StreamReader *reader, CompressionType type)
+    : StreamDecoder(reader)
 {
     static_assert(RG_SIZE(out_buf) >= TINFL_LZ_DICT_SIZE);
 
     tinfl_init(&inflator);
     is_gzip = (type == CompressionType::Gzip);
-
-    return true;
 }
 
 Size MinizDecompressor::Read(Size max_len, void *user_buf)
@@ -217,7 +215,7 @@ truncated_error:
     return -1;
 }
 
-class MinizCompressor: public StreamCompressor {
+class MinizCompressor: public StreamEncoder {
     tdefl_compressor deflator;
 
     // Gzip support
@@ -229,10 +227,9 @@ class MinizCompressor: public StreamCompressor {
     LocalArray<uint8_t, 1024> small_buf;
 
 public:
-    MinizCompressor(StreamWriter *writer) : StreamCompressor(writer) {}
+    MinizCompressor(StreamWriter *writer, CompressionType type, CompressionSpeed speed);
     ~MinizCompressor() {}
 
-    bool Init(CompressionType type, CompressionSpeed speed) override;
     bool Write(Span<const uint8_t> buf) override;
     bool Finalize() override;
 
@@ -240,7 +237,8 @@ private:
     bool WriteDeflate(Span<const uint8_t> buf);
 };
 
-bool MinizCompressor::Init(CompressionType type, CompressionSpeed speed)
+MinizCompressor::MinizCompressor(StreamWriter *writer, CompressionType type, CompressionSpeed speed)
+    : StreamEncoder(writer)
 {
     is_gzip = (type == CompressionType::Gzip);
 
@@ -256,10 +254,7 @@ bool MinizCompressor::Init(CompressionType type, CompressionSpeed speed)
         MinizCompressor *compressor = (MinizCompressor *)udata;
         return (int)compressor->WriteRaw(MakeSpan((uint8_t *)buf, len));
     }, this, flags);
-    if (status != TDEFL_STATUS_OKAY) {
-        LogError("Failed to initialize Deflate compression for '%1'", GetFileName());
-        return false;
-    }
+    RG_ASSERT(status == TDEFL_STATUS_OKAY);
 
     if (is_gzip) {
         static uint8_t gzip_header[] = {
@@ -271,11 +266,8 @@ bool MinizCompressor::Init(CompressionType type, CompressionSpeed speed)
             0           // OS
         };
 
-        if (!WriteRaw(gzip_header))
-            return false;
+        WriteRaw(gzip_header);
     }
-
-    return true;
 }
 
 bool MinizCompressor::Write(Span<const uint8_t> buf)

package/src/koffi/src/call.cc

@@ -1269,7 +1269,7 @@ void CallData::PopOutArguments()
                 RG_ASSERT(array.IsArray());
                 RG_ASSERT(array.Length() == 1);
 
-                Size len = WideStringLength((const char16_t *)out.ptr, out.max_len);
+                Size len = NullTerminatedLength((const char16_t *)out.ptr, out.max_len);
                 Napi::String str = Napi::String::New(env, (const char16_t *)out.ptr, len);
 
                 array.Set(0u, str);

package/src/koffi/src/util.cc

@@ -779,17 +779,6 @@ void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
     }
 }
 
-Size WideStringLength(const char16_t *str16, Size max)
-{
-    Size len = 0;
-
-    while (len < max && str16[len]) {
-        len++;
-    }
-
-    return len;
-}
-
 Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type)
 {
     InstanceData *instance = env.GetInstanceData<InstanceData>();
@@ -873,7 +862,7 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
         case PrimitiveKind::Int16: {
             if (type->hint == ArrayHint::String) {
                 const char16_t *ptr = (const char16_t *)origin;
-                Size count = WideStringLength(ptr, len);
+                Size count = NullTerminatedLength(ptr, len);
 
                 Napi::String str = Napi::String::New(env, ptr, count);
                 return str;
@@ -1186,7 +1175,12 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
                 } break;
                 case PrimitiveKind::Int16: 
                 case PrimitiveKind::UInt16: {
-                    Size count = WideStringLength((const char16_t *)ptr, RG_SIZE_MAX);
+                    Size count = NullTerminatedLength((const char16_t *)ptr, RG_SIZE_MAX);
+                    type = MakeArrayType(instance, type, count);
+                } break;
+
+                case PrimitiveKind::Pointer: {
+                    Size count = NullTerminatedLength((const void **)ptr, RG_SIZE_MAX);
                     type = MakeArrayType(instance, type, count);
                 } break;