koffi 2.7.0 → 2.7.2

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;
@@ -1220,11 +1212,18 @@ public:
     {
         RG_ASSERT(len <= N - count);
 
-        T *it = data + len;
-        *it = {};
-        len += count;
+        T *first = data + len;
+        if constexpr(!std::is_trivial<T>::value) {
+            for (Size i = 0; i < count; i++) {
+                new (data + len) T();
+                len++;
+            }
+        } else {
+            memset_safe(first, 0, count * RG_SIZE(T));
+            len += count;
+        }
 
-        return it;
+        return first;
     }
 
     T *Append(const T &value)
@@ -1312,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];
             }
@@ -1421,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++;
@@ -1434,6 +1425,7 @@ public:
             memset_safe(first, 0, count * RG_SIZE(T));
             len += count;
         }
+
         return first;
     }
 
@@ -1442,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;
@@ -1458,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;
@@ -1474,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();
             }
@@ -1784,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();
             }
@@ -2065,11 +2041,7 @@ public:
     }
     ~HashTable()
     {
-#if __cplusplus >= 201703L
         if constexpr(std::is_trivial<ValueType>::value) {
-#else
-        if (false) {
-#endif
             count = 0;
             Rehash(0);
         } else {
@@ -2266,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))
@@ -3172,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);
@@ -3289,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;
@@ -4332,8 +4304,8 @@ enum class CompressionSpeed {
     Fast
 };
 
-class StreamDecompressor;
-class StreamCompressor;
+class StreamDecoder;
+class StreamEncoder;
 
 class StreamReader {
     RG_DELETE_COPY(StreamReader)
@@ -4371,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;
@@ -4396,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,
@@ -4409,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; }
@@ -4437,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:
@@ -4505,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:
@@ -4513,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))
@@ -4589,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;
 
@@ -4621,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);
@@ -4643,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; }
 
@@ -4665,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;
 
@@ -4702,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:
@@ -4710,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))
@@ -4887,7 +4832,9 @@ public:
         { return Test(test1, nullptr, type); }
 
     bool TestHasFailed() const { return test_failed; }
+
     void LogUnknownError() const;
+    void LogUnusedArguments() const;
 };
 
 template <typename T>
@@ -4920,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)
 {
@@ -4950,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/parser.cc

@@ -144,6 +144,10 @@ const TypeInfo *PrototypeParser::ParseType(int *out_directions)
     while (++offset < tokens.len && (tokens[offset] == '*' ||
                                      tokens[offset] == '!' ||
                                      tokens[offset] == "const"));
+    if (offset < tokens.len && tokens[offset] == "[") [[unlikely]] {
+        MarkError("Array types decay to pointers in prototypes (C standard), use pointers");
+        return instance->void_type;
+    }
     offset--;
 
     while (offset >= start) {