Mercurial > hg > idav / changeset

--- a/application/config.c	Sun Oct 19 21:20:08 2025 +0200
+++ b/application/config.c	Mon Nov 10 21:52:51 2025 +0100
@@ -31,7 +31,6 @@
 #include <string.h>
 #include <sys/types.h>
 #include <cx/hash_map.h>
-#include <cx/utils.h>
 #include <errno.h>
 #include <libxml/tree.h>
 
@@ -41,6 +40,8 @@
 #include <libidav/utils.h>
 #include <libidav/config.h>
 
+#include <cx/streams.h>
+
 #define xstreq(a,b) xmlStrEqual(BAD_CAST a, BAD_CAST b)
 #define xstrEQ(a,b) !xmlStrcasecmp(BAD_CAST a, BAD_CAST b)
 

--- a/libidav/crypto.c	Sun Oct 19 21:20:08 2025 +0200
+++ b/libidav/crypto.c	Mon Nov 10 21:52:51 2025 +0100
@@ -381,12 +381,12 @@
     SHA256_Init(ctx);
 }
 
-void dav_sha256_update(DAV_SHA_CTX *ctx, const void *data, size_t length) {
+void dav_sha256_update(DAV_SHA_CTX *ctx, const char *data, size_t length) {
     SHA256_Update(ctx, data, length);
 }
 
-void dav_sha256_final(char *md, DAV_SHA_CTX *ctx) {
-    SHA256_Final(md, ctx);
+void dav_sha256_final(DAV_SHA_CTX *ctx, unsigned char *buf) {
+    SHA256_Final(buf, ctx);
 }
 
 #else
@@ -848,13 +848,16 @@
     return ctx;
 }
 
+void dav_sha256_init(DAV_SHA_CTX *ctx) {
+    CC_SHA256_Init(ctx);
+}
+
 void dav_sha256_update(DAV_SHA_CTX *ctx, const char *data, size_t len) {
     CC_SHA256_Update(ctx, data, len);
 }
 
 void dav_sha256_final(DAV_SHA_CTX *ctx, unsigned char *buf) {
     CC_SHA256_Final(buf, ctx);
-    free(ctx);
 }
 
 DavKey* dav_pw2key(const char *password, const unsigned char *salt, int saltlen, int pwfunc, int enc) {
@@ -1422,7 +1425,7 @@
     DAV_SHA_CTX *ctx = dav_sha256_create();
     if(ctx) {
         dav_sha256_update(ctx, data, len);
-        dav_sha256_final(ctx, hash);
+        dav_sha256_final_free(ctx, hash);
     }
     return util_hexstr(hash, DAV_SHA256_DIGEST_LENGTH);
 }
@@ -1448,7 +1451,6 @@
     
     // cleanup
     cng_cleanup(ctx->hAlg, NULL, ctx->hHash, ctx->pbHashObject);
-    free(ctx);
 }
 
 DavKey* dav_pw2key(const char *password, const unsigned char *salt, int saltlen, int pwfunc, int enc) {
@@ -1514,7 +1516,10 @@
 }
 #endif
 
-
+void dav_sha256_final_free(DAV_SHA_CTX *ctx, unsigned char *buf) {
+    dav_sha256_final(ctx, buf);
+    free(ctx);
+}
 
 CxBuffer* aes_encrypt_buffer(CxBuffer *in, DavKey *key) {
     CxBuffer *encbuf = cxBufferCreate(NULL, in->size, cxDefaultAllocator, CX_BUFFER_FREE_CONTENTS|CX_BUFFER_AUTO_EXTEND);

--- a/libidav/crypto.h	Sun Oct 19 21:20:08 2025 +0200
+++ b/libidav/crypto.h	Mon Nov 10 21:52:51 2025 +0100
@@ -159,6 +159,7 @@
 DAV_SHA_CTX* dav_sha256_create(void);
 void dav_sha256_update(DAV_SHA_CTX *ctx, const char *data, size_t len);
 void dav_sha256_final(DAV_SHA_CTX *ctx, unsigned char *buf);
+void dav_sha256_final_free(DAV_SHA_CTX *ctx, unsigned char *buf);
 
 DavKey* dav_pw2key(const char *password, const unsigned char *salt, int saltlen, int pwfunc, int enc);
 

--- a/libidav/davqlexec.c	Sun Oct 19 21:20:08 2025 +0200
+++ b/libidav/davqlexec.c	Mon Nov 10 21:52:51 2025 +0100
@@ -31,7 +31,6 @@
 #include <string.h>
 #include <inttypes.h>
 
-#include <cx/utils.h>
 #include <cx/map.h>
 #include <cx/hash_map.h>
 #include <cx/printf.h>

--- a/libidav/davqlparser.c	Sun Oct 19 21:20:08 2025 +0200
+++ b/libidav/davqlparser.c	Mon Nov 10 21:52:51 2025 +0100
@@ -27,7 +27,6 @@
  */
 
 #include "davqlparser.h"
-#include <cx/utils.h>
 #include <cx/linked_list.h>
 #include <cx/printf.h>
 #include <string.h>

--- a/libidav/methods.c	Sun Oct 19 21:20:08 2025 +0200
+++ b/libidav/methods.c	Mon Nov 10 21:52:51 2025 +0100
@@ -36,7 +36,6 @@
 #include "session.h"
 #include "xml.h"
 
-#include <cx/utils.h>
 #include <cx/printf.h>
 #include <cx/hash_map.h>
 
@@ -481,10 +480,6 @@
 DavResource* parse_propfind_response(DavSession *sn, DavResource *root, CxBuffer *response) {
     char *url = NULL;
     curl_easy_getinfo(sn->handle, CURLINFO_EFFECTIVE_URL, &url);
-    if(!root) {
-        printf("methods.c: TODO: remove\n");
-        root = dav_resource_new_href(sn, util_url_path(url)); // TODO: remove
-    }
     
     //printf("%.*s\n\n", response->size, response->space);
     xmlDoc *doc = xmlReadMemory(response->space, response->size, url, NULL, 0);

--- a/libidav/pwdstore.c	Sun Oct 19 21:20:08 2025 +0200
+++ b/libidav/pwdstore.c	Mon Nov 10 21:52:51 2025 +0100
@@ -34,7 +34,8 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include <cx/utils.h>
+#include <cx/streams.h> 
+
 #include <cx/hash_map.h>
 
 #ifdef _WIN32
@@ -263,7 +264,7 @@
 }
 
 static void remove_list_entries(PwdStore *s, const char *id) {
-    CxIterator i = cxListMutIterator(s->locations);
+    CxIterator i = cxListIterator(s->locations);
     cx_foreach(PwdIndexEntry*, ie, i) {
         if(!strcmp(ie->id, id)) {
             cxIteratorFlagRemoval(i);
@@ -271,7 +272,7 @@
             break;
         }
     }
-    i = cxListMutIterator(s->noloc);
+    i = cxListIterator(s->noloc);
     cx_foreach(PwdIndexEntry*, ie, i) {
         if(!strcmp(ie->id, id)) {
             cxIteratorFlagRemoval(i);

--- a/libidav/resource.c	Sun Oct 19 21:20:08 2025 +0200
+++ b/libidav/resource.c	Mon Nov 10 21:52:51 2025 +0100
@@ -37,7 +37,6 @@
 #include "methods.h"
 #include "crypto.h"
 #include <cx/buffer.h>
-#include <cx/utils.h>
 #include <cx/hash_map.h>
 #include <cx/printf.h>
 #include <cx/mempool.h>
@@ -835,7 +834,7 @@
     HashStream *s = stream;
     if(offset == 0 && whence == SEEK_SET) {
         unsigned char buf[DAV_SHA256_DIGEST_LENGTH];
-        dav_sha256_final(s->sha, buf);
+        dav_sha256_final_free(s->sha, buf);
         s->sha = NULL;
     } else {
         s->error = 1;
@@ -938,7 +937,7 @@
                     data->length);
             
             if(hstr.sha) {
-                dav_sha256_final(hstr.sha, (unsigned char*)data->hash);
+                dav_sha256_final_free(hstr.sha, (unsigned char*)data->hash);
                 char *hash = util_hexstr((unsigned char*)data->hash, 32);
                 dav_set_string_property_ns(res, DAV_NS, "content-hash", hash);
                 free(hash);
@@ -1599,7 +1598,7 @@
             property->value = n->children ? dav_convert_xml(sn, n->children) : NULL;
             
             cxmutstr propkey = dav_property_key(property->ns->name, property->name);
-            cxMapPut(map, cx_hash_key_cxstr(propkey), property);
+            cxMapPut(map, propkey, property);
             cx_strfree(&propkey);
         }
         n = n->next;

--- a/libidav/utils.c	Sun Oct 19 21:20:08 2025 +0200
+++ b/libidav/utils.c	Mon Nov 10 21:52:51 2025 +0100
@@ -34,7 +34,6 @@
 #include <ctype.h>
 #include <cx/string.h>
 #include <cx/buffer.h>
-#include <cx/utils.h>
 #include <cx/printf.h>
 #include <libxml/tree.h>
 #include <curl/curl.h>
@@ -348,10 +347,81 @@
     return path;
 }
 
+char* util_url_encode(DavSession *sn, const char *url) {
+    CURL *handle = sn ? sn->handle : NULL;
+#if LIBCURL_VERSION_NUM < 0x075200
+    int cleanup_handle = 0;
+    if(!handle) {
+        handle = curl_easy_init();
+        cleanup_handle = 1;
+    }
+#endif
+    
+    char *esc = curl_easy_escape(handle, url, strlen(url));
+    char *ret = esc ? strdup(esc) : NULL;
+    curl_free(esc);
+
+#if LIBCURL_VERSION_NUM < 0x075200
+    if(cleanup_handle) {
+        curl_easy_cleanup(handle);
+    }
+#endif
+    
+    return ret;
+}
+
 char* util_url_decode(DavSession *sn, const char *url) {
-    char *unesc = curl_easy_unescape(sn->handle, url, strlen(url), NULL);
-    char *ret = strdup(unesc);
+    CURL *handle = sn ? sn->handle : NULL;
+#if LIBCURL_VERSION_NUM < 0x075200
+    int cleanup_handle = 0;
+    if(!handle) {
+        handle = curl_easy_init();
+        cleanup_handle = 1;
+    }
+#endif
+    
+    char *unesc = curl_easy_unescape(handle, url, strlen(url), NULL);
+    char *ret = unesc ? strdup(unesc) : NULL;
     curl_free(unesc);
+
+#if LIBCURL_VERSION_NUM < 0x075200
+    if(cleanup_handle) {
+        curl_easy_cleanup(handle);
+    }
+#endif
+    
+    return ret;
+}
+
+cxmutstr util_url_encode_s(const CxAllocator *a, cxstring url) {
+    CURL *handle = NULL;
+#if LIBCURL_VERSION_NUM < 0x075200
+    handle = curl_easy_init();
+#endif
+    
+    char *esc = curl_easy_escape(handle, url.ptr, url.length);
+    cxmutstr ret = esc ? cx_strdup_a(a, cx_str(esc)) : (cxmutstr){NULL, 0};
+    curl_free(esc);
+    
+#if LIBCURL_VERSION_NUM < 0x075200
+    curl_easy_cleanup(handle);
+#endif
+    return ret;
+}
+
+cxmutstr util_url_decode_s(const CxAllocator *a, cxstring url) {
+    CURL *handle = NULL;
+#if LIBCURL_VERSION_NUM < 0x075200
+    handle = curl_easy_init();
+#endif
+    
+    char *unesc = curl_easy_unescape(handle, url.ptr, url.length, NULL);
+    cxmutstr ret = unesc ? cx_strdup_a(a, cx_str(unesc)) : (cxmutstr){NULL, 0};
+    curl_free(unesc);
+    
+#if LIBCURL_VERSION_NUM < 0x075200
+    curl_easy_cleanup(handle);
+#endif
     return ret;
 }
 

--- a/libidav/utils.h	Sun Oct 19 21:20:08 2025 +0200
+++ b/libidav/utils.h	Mon Nov 10 21:52:51 2025 +0100
@@ -76,7 +76,10 @@
 cxstring util_url_base_s(cxstring url);
 const char* util_url_path(const char *url);
 cxstring util_url_path_s(cxstring url);
+char* util_url_encode(DavSession *sn, const char *url);
 char* util_url_decode(DavSession *sn, const char *url);
+cxmutstr util_url_encode_s(const CxAllocator *a, cxstring url);
+cxmutstr util_url_decode_s(const CxAllocator *a, cxstring url);
 const char* util_resource_name(const char *url);
 const char* util_resource_name_c(const char *url, char pathseparator);
 const char* util_path_file_name(const char *url);

--- a/libidav/webdav.c	Sun Oct 19 21:20:08 2025 +0200
+++ b/libidav/webdav.c	Mon Nov 10 21:52:51 2025 +0100
@@ -36,7 +36,6 @@
 #include "session.h"
 #include "methods.h"
 #include <cx/buffer.h>
-#include <cx/utils.h>
 #include <cx/linked_list.h>
 #include <cx/hash_map.h>
 #include <cx/compare.h>
@@ -353,8 +352,8 @@
     int ret = 0;
     dav_context_lock(context);
     CxList *sessions = context->sessions;
-    ssize_t i = cxListFind(sessions, sn);
-    if(i >= 0) {
+    size_t i = cxListFind(sessions, sn);
+    if(cxListIndexValid(sessions, i)) {
         cxListRemove(sessions, i);
     } else {
         ret = 1;

--- a/libidav/xml.c	Sun Oct 19 21:20:08 2025 +0200
+++ b/libidav/xml.c	Mon Nov 10 21:52:51 2025 +0100
@@ -30,7 +30,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include <cx/utils.h>
 #include <cx/printf.h>
 
 #include "xml.h"

--- a/ucx/array_list.c	Sun Oct 19 21:20:08 2025 +0200
+++ b/ucx/array_list.c	Mon Nov 10 21:52:51 2025 +0100
@@ -50,7 +50,7 @@
 }
 
 CxArrayReallocator cx_array_default_reallocator_impl = {
-        cx_array_default_realloc, NULL, NULL, 0, 0
+        cx_array_default_realloc, NULL, NULL
 };
 
 CxArrayReallocator *cx_array_default_reallocator = &cx_array_default_reallocator_impl;
@@ -72,11 +72,11 @@
     }
 
     // retrieve the pointer to the actual allocator
-    const CxAllocator *al = alloc->ptr1;
+    const CxAllocator *al = alloc->allocator;
 
     // check if the array is still located on the stack
     void *newmem;
-    if (array == alloc->ptr2) {
+    if (array == alloc->stack_ptr) {
         newmem = cxMalloc(al, n);
         if (newmem != NULL && array != NULL) {
             memcpy(newmem, array, old_capacity*elem_size);
@@ -89,27 +89,45 @@
 
 struct cx_array_reallocator_s cx_array_reallocator(
         const struct cx_allocator_s *allocator,
-        const void *stackmem
+        const void *stack_ptr
 ) {
     if (allocator == NULL) {
         allocator = cxDefaultAllocator;
     }
     return (struct cx_array_reallocator_s) {
             cx_array_advanced_realloc,
-            (void*) allocator, (void*) stackmem,
-            0, 0
+            allocator, stack_ptr,
     };
 }
 
 // LOW LEVEL ARRAY LIST FUNCTIONS
 
-static size_t cx_array_align_capacity(
-        size_t cap,
-        size_t alignment,
-        size_t max
+/**
+ * Intelligently calculates a new capacity, reserving some more
+ * elements than required to prevent too many allocations.
+ *
+ * @param current_capacity the current capacity of the array
+ * @param needed_capacity the required capacity of the array
+ * @param maximum_capacity the maximum capacity (given by the data type)
+ * @return the new capacity
+ */
+static size_t cx_array_grow_capacity(
+    size_t current_capacity,
+    size_t needed_capacity,
+    size_t maximum_capacity
 ) {
-    if (cap > max - alignment) {
-        return cap;
+    if (current_capacity >= needed_capacity) {
+        return current_capacity;
+    }
+    size_t cap = needed_capacity;
+    size_t alignment;
+    if (cap < 128) alignment = 16;
+    else if (cap < 1024) alignment = 64;
+    else if (cap < 8192) alignment = 512;
+    else alignment = 1024;
+
+    if (cap - 1 > maximum_capacity - alignment) {
+        return maximum_capacity;
     } else {
         return cap - (cap % alignment) + alignment;
     }
@@ -177,10 +195,6 @@
 
     // reallocate if possible
     if (newcap > oldcap) {
-        // calculate new capacity (next number divisible by 16)
-        newcap = cx_array_align_capacity(newcap, 16, max_size);
-
-        // perform reallocation
         void *newmem = reallocator->realloc(
                 *array, oldcap, newcap, elem_size, reallocator
         );
@@ -270,22 +284,18 @@
     }
 
     // check if resize is required
-    size_t minsize = index + elem_count;
-    size_t newsize = oldsize < minsize ? minsize : oldsize;
+    const size_t minsize = index + elem_count;
+    const size_t newsize = oldsize < minsize ? minsize : oldsize;
 
-    // reallocate if possible
-    size_t newcap = oldcap;
-    if (newsize > oldcap) {
-        // check, if we need to repair the src pointer
+    // reallocate if necessary
+    const size_t newcap = cx_array_grow_capacity(oldcap, newsize, max_size);
+    if (newcap > oldcap) {
+        // check if we need to repair the src pointer
         uintptr_t targetaddr = (uintptr_t) *target;
         uintptr_t srcaddr = (uintptr_t) src;
         bool repairsrc = targetaddr <= srcaddr
                          && srcaddr < targetaddr + oldcap * elem_size;
 
-        // calculate new capacity (next number divisible by 16)
-        newcap = cx_array_align_capacity(newsize, 16, max_size);
-        assert(newcap > newsize);
-
         // perform reallocation
         void *newmem = reallocator->realloc(
                 *target, oldcap, newcap, elem_size, reallocator
@@ -368,16 +378,16 @@
     }
 
     // store some counts
-    size_t old_size = *size;
-    size_t old_capacity = *capacity;
+    const size_t old_size = *size;
+    const size_t old_capacity = *capacity;
     // the necessary capacity is the worst case assumption, including duplicates
-    size_t needed_capacity = old_size + elem_count;
+    const size_t needed_capacity = cx_array_grow_capacity(old_capacity,
+        old_size + elem_count, SIZE_MAX);
 
     // if we need more than we have, try a reallocation
     if (needed_capacity > old_capacity) {
-        size_t new_capacity = cx_array_align_capacity(needed_capacity, 16, SIZE_MAX);
         void *new_mem = reallocator->realloc(
-                *target, old_capacity, new_capacity, elem_size, reallocator
+                *target, old_capacity, needed_capacity, elem_size, reallocator
         );
         if (new_mem == NULL) {
             // give it up right away, there is no contract
@@ -385,7 +395,7 @@
             return 1;  // LCOV_EXCL_LINE
         }
         *target = new_mem;
-        *capacity = new_capacity;
+        *capacity = needed_capacity;
     }
 
     // now we have guaranteed that we can insert everything
@@ -782,8 +792,8 @@
 
     // guarantee enough capacity
     if (arl->capacity < list->collection.size + n) {
-        size_t new_capacity = list->collection.size + n;
-        new_capacity = new_capacity - (new_capacity % 16) + 16;
+        const size_t new_capacity = cx_array_grow_capacity(arl->capacity,
+            list->collection.size + n, SIZE_MAX);
         if (cxReallocateArray(
                 list->collection.allocator,
                 &arl->data, new_capacity,
@@ -881,7 +891,7 @@
         const void *elem,
         int prepend
 ) {
-    struct cx_list_s *list = iter->src_handle.m;
+    struct cx_list_s *list = iter->src_handle;
     if (iter->index < list->collection.size) {
         if (cx_arl_insert_element(list,
                 iter->index + 1 - prepend, elem) == NULL) {
@@ -1092,7 +1102,7 @@
 
 static bool cx_arl_iter_valid(const void *it) {
     const struct cx_iterator_s *iter = it;
-    const struct cx_list_s *list = iter->src_handle.c;
+    const struct cx_list_s *list = iter->src_handle;
     return iter->index < list->collection.size;
 }
 
@@ -1105,31 +1115,39 @@
     struct cx_iterator_s *iter = it;
     if (iter->base.remove) {
         iter->base.remove = false;
-        cx_arl_remove(iter->src_handle.m, iter->index, 1, NULL);
+        cx_arl_remove(iter->src_handle, iter->index, 1, NULL);
         iter->elem_count--;
     } else {
         iter->index++;
         iter->elem_handle =
                 ((char *) iter->elem_handle)
-                + ((const struct cx_list_s *) iter->src_handle.c)->collection.elem_size;
+                + ((const struct cx_list_s *) iter->src_handle)->collection.elem_size;
     }
 }
 
 static void cx_arl_iter_prev(void *it) {
     struct cx_iterator_s *iter = it;
-    const cx_array_list *list = iter->src_handle.c;
     if (iter->base.remove) {
         iter->base.remove = false;
-        cx_arl_remove(iter->src_handle.m, iter->index, 1, NULL);
+        cx_arl_remove(iter->src_handle, iter->index, 1, NULL);
         iter->elem_count--;
     }
     iter->index--;
+    cx_array_list *list = iter->src_handle;
     if (iter->index < list->base.collection.size) {
         iter->elem_handle = ((char *) list->data)
                             + iter->index * list->base.collection.elem_size;
     }
 }
 
+static int cx_arl_change_capacity(
+        struct cx_list_s *list,
+        size_t new_capacity
+) {
+    cx_array_list *arl = (cx_array_list *)list;
+    return cxReallocateArray(list->collection.allocator,
+        &arl->data, new_capacity, list->collection.elem_size);
+}
 
 static struct cx_iterator_s cx_arl_iterator(
         const struct cx_list_s *list,
@@ -1139,7 +1157,7 @@
     struct cx_iterator_s iter;
 
     iter.index = index;
-    iter.src_handle.c = list;
+    iter.src_handle = (void*)list;
     iter.elem_handle = cx_arl_at(list, index);
     iter.elem_size = list->collection.elem_size;
     iter.elem_count = list->collection.size;
@@ -1147,7 +1165,7 @@
     iter.base.current = cx_arl_iter_current;
     iter.base.next = backwards ? cx_arl_iter_prev : cx_arl_iter_next;
     iter.base.remove = false;
-    iter.base.mutating = false;
+    iter.base.allow_remove = true;
 
     return iter;
 }
@@ -1167,6 +1185,7 @@
         cx_arl_sort,
         cx_arl_compare,
         cx_arl_reverse,
+        cx_arl_change_capacity,
         cx_arl_iterator,
 };
 

--- a/ucx/cx/allocator.h	Sun Oct 19 21:20:08 2025 +0200
+++ b/ucx/cx/allocator.h	Mon Nov 10 21:52:51 2025 +0100
@@ -46,36 +46,22 @@
     /**
      * The allocator's malloc() implementation.
      */
-    void *(*malloc)(
-            void *data,
-            size_t n
-    );
+    void *(*malloc)(void *data, size_t n);
 
     /**
      * The allocator's realloc() implementation.
      */
-    void *(*realloc)(
-            void *data,
-            void *mem,
-            size_t n
-    );
+    void *(*realloc)(void *data, void *mem, size_t n);
 
     /**
      * The allocator's calloc() implementation.
      */
-    void *(*calloc)(
-            void *data,
-            size_t nmemb,
-            size_t size
-    );
+    void *(*calloc)(void *data, size_t nmemb, size_t size);
 
     /**
      * The allocator's free() implementation.
      */
-    void (*free)(
-            void *data,
-            void *mem
-    );
+    void (*free)(void *data, void *mem);
 } cx_allocator_class;
 
 /**
@@ -100,15 +86,13 @@
 /**
  * A pre-defined allocator using standard library malloc() etc.
  */
-cx_attr_export
-extern const CxAllocator * const cxStdlibAllocator;
+CX_EXPORT extern const CxAllocator * const cxStdlibAllocator;
 
 /**
  * The default allocator that is used by UCX.
  * Initialized with cxStdlibAllocator, but you may change it.
  */
-cx_attr_export
-extern const CxAllocator * cxDefaultAllocator;
+CX_EXPORT extern const CxAllocator * cxDefaultAllocator;
 
 /**
  * Function pointer type for destructor functions.
@@ -133,10 +117,33 @@
  * @param data an optional pointer to custom data
  * @param memory a pointer to the object to destruct
   */
-typedef void (*cx_destructor_func2)(
-        void *data,
-        void *memory
-);
+typedef void (*cx_destructor_func2)(void *data, void *memory);
+
+
+/**
+ * Function pointer type for clone functions.
+ *
+ * A clone function is supposed to create a deep copy of the memory pointed to
+ * by the @p source pointer.
+ * If the @p target pointer is non-null, the clone function is supposed to store
+ * the copy into that memory region.
+ * Otherwise, the clone function shall use the specified @p allocator to create
+ * a new object.
+ *
+ * The return value of a clone function is always a pointer to the target
+ * memory region, or @c NULL if any allocation failed.
+ * A clone function SHOULD NOT fail for any other reason than an allocation
+ * failure.
+ *
+ * @param target the target memory or @c NULL, if memory shall be allocated
+ * @param source the source memory
+ * @param allocator the allocator that shall be used
+ * @param data optional additional data
+ * @return either the specified @p target, a pointer to the allocated memory,
+ * or @c NULL, if any error occurred
+ */
+typedef void*(cx_clone_func)(void *target, const void *source,
+                             const CxAllocator *allocator, void *data);
 
 /**
  * Reallocate a previously allocated block and changes the pointer in-place,
@@ -153,13 +160,8 @@
  * @retval non-zero failure
  * @see cx_reallocatearray()
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_reallocate_(
-        void **mem,
-        size_t n
-);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_reallocate_(void **mem, size_t n);
 
 /**
  * Reallocate a previously allocated block and changes the pointer in-place,
@@ -180,14 +182,8 @@
  * @retval non-zero failure
  * @see cx_reallocate()
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_reallocatearray_(
-        void **mem,
-        size_t nmemb,
-        size_t size
-);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_reallocatearray_(void **mem, size_t nmemb, size_t size);
 
 /**
  * Reallocate a previously allocated block and changes the pointer in-place,
@@ -244,11 +240,7 @@
  * @param mem a pointer to the block to free
  */
 cx_attr_nonnull_arg(1)
-cx_attr_export
-void cxFree(
-        const CxAllocator *allocator,
-        void *mem
-);
+CX_EXPORT void cxFree(const CxAllocator *allocator, void *mem);
 
 /**
  * Allocate @p n bytes of memory.
@@ -257,16 +249,9 @@
  * @param n the number of bytes
  * @return a pointer to the allocated memory
  */
-cx_attr_nodiscard
-cx_attr_nonnull
-cx_attr_malloc
-cx_attr_dealloc_ucx
-cx_attr_allocsize(2)
-cx_attr_export
-void *cxMalloc(
-        const CxAllocator *allocator,
-        size_t n
-);
+cx_attr_nodiscard cx_attr_nonnull
+cx_attr_malloc cx_attr_dealloc_ucx cx_attr_allocsize(2)
+CX_EXPORT void *cxMalloc(const CxAllocator *allocator, size_t n);
 
 /**
  * Reallocate the previously allocated block in @p mem, making the new block
@@ -281,16 +266,9 @@
  * @param n the new size in bytes
  * @return a pointer to the reallocated memory
  */
-cx_attr_nodiscard
-cx_attr_nonnull_arg(1)
-cx_attr_dealloc_ucx
-cx_attr_allocsize(3)
-cx_attr_export
-void *cxRealloc(
-        const CxAllocator *allocator,
-        void *mem,
-        size_t n
-);
+cx_attr_nodiscard cx_attr_nonnull_arg(1)
+cx_attr_dealloc_ucx cx_attr_allocsize(3)
+CX_EXPORT void *cxRealloc(const CxAllocator *allocator, void *mem, size_t n);
 
 /**
  * Reallocate the previously allocated block in @p mem, making the new block
@@ -310,17 +288,10 @@
  * @param size the size of each element
  * @return a pointer to the reallocated memory
  */
-cx_attr_nodiscard
-cx_attr_nonnull_arg(1)
-cx_attr_dealloc_ucx
-cx_attr_allocsize(3, 4)
-cx_attr_export
-void *cxReallocArray(
-        const CxAllocator *allocator,
-        void *mem,
-        size_t nmemb,
-        size_t size
-);
+cx_attr_nodiscard cx_attr_nonnull_arg(1)
+cx_attr_dealloc_ucx cx_attr_allocsize(3, 4)
+CX_EXPORT void *cxReallocArray(const CxAllocator *allocator,
+        void *mem, size_t nmemb, size_t size);
 
 /**
  * Reallocate a previously allocated block and changes the pointer in-place,
@@ -338,14 +309,8 @@
  * @retval zero success
  * @retval non-zero failure
  */
-cx_attr_nodiscard
-cx_attr_nonnull
-cx_attr_export
-int cxReallocate_(
-        const CxAllocator *allocator,
-        void **mem,
-        size_t n
-);
+cx_attr_nodiscard cx_attr_nonnull
+CX_EXPORT int cxReallocate_(const CxAllocator *allocator, void **mem, size_t n);
 
 /**
  * Reallocate a previously allocated block and changes the pointer in-place,
@@ -385,15 +350,9 @@
  * @retval zero success
  * @retval non-zero on failure
  */
-cx_attr_nodiscard
-cx_attr_nonnull
-cx_attr_export
-int cxReallocateArray_(
-        const CxAllocator *allocator,
-        void **mem,
-        size_t nmemb,
-        size_t size
-);
+cx_attr_nodiscard cx_attr_nonnull
+CX_EXPORT int cxReallocateArray_(const CxAllocator *allocator,
+        void **mem, size_t nmemb, size_t size);
 
 /**
  * Reallocate a previously allocated block and changes the pointer in-place,
@@ -425,17 +384,9 @@
  * @param size the size of each element in bytes
  * @return a pointer to the allocated memory
  */
-cx_attr_nonnull_arg(1)
-cx_attr_nodiscard
-cx_attr_malloc
-cx_attr_dealloc_ucx
-cx_attr_allocsize(2, 3)
-cx_attr_export
-void *cxCalloc(
-        const CxAllocator *allocator,
-        size_t nmemb,
-        size_t size
-);
+cx_attr_nonnull_arg(1) cx_attr_nodiscard
+cx_attr_malloc cx_attr_dealloc_ucx cx_attr_allocsize(2, 3)
+CX_EXPORT void *cxCalloc(const CxAllocator *allocator, size_t nmemb, size_t size);
 
 /**
  * Allocate @p n bytes of memory and sets every byte to zero.
@@ -444,16 +395,9 @@
  * @param n the number of bytes
  * @return a pointer to the allocated memory
  */
-cx_attr_nodiscard
-cx_attr_nonnull
-cx_attr_malloc
-cx_attr_dealloc_ucx
-cx_attr_allocsize(2)
-cx_attr_export
-void *cxZalloc(
-        const CxAllocator *allocator,
-        size_t n
-);
+cx_attr_nodiscard cx_attr_nonnull
+cx_attr_malloc cx_attr_dealloc_ucx cx_attr_allocsize(2)
+CX_EXPORT void *cxZalloc(const CxAllocator *allocator, size_t n);
 
 /**
  * Convenience macro that invokes cxMalloc() with the cxDefaultAllocator.

--- a/ucx/cx/array_list.h	Sun Oct 19 21:20:08 2025 +0200
+++ b/ucx/cx/array_list.h	Mon Nov 10 21:52:51 2025 +0100
@@ -47,8 +47,7 @@
  * The maximum item size in an array list that fits into
  * a stack buffer when swapped.
  */
-cx_attr_export
-extern const unsigned cx_array_swap_sbo_size;
+CX_EXPORT extern const unsigned cx_array_swap_sbo_size;
 
 /**
  * Declares variables for an array that can be used with the convenience macros.
@@ -172,10 +171,9 @@
      * Reallocates space for the given array.
      *
      * Implementations are not required to free the original array.
-     * This allows reallocation of static memory by allocating heap memory
-     * and copying the array contents. The information in the custom fields of
-     * the referenced allocator can be used to track the state of the memory
-     * or to transport other additional data.
+     * This allows reallocation of static or stack memory by allocating heap memory
+     * and copying the array contents; namely when @c stack_ptr in this struct
+     * is not @c NULL and @p array equals @c stack_ptr.
      *
      * @param array the array to reallocate
      * @param old_capacity the old number of elements
@@ -184,33 +182,18 @@
      * @param alloc a reference to this allocator
      * @return a pointer to the reallocated memory or @c NULL on failure
      */
-    cx_attr_nodiscard
-    cx_attr_nonnull_arg(5)
-    cx_attr_allocsize(3, 4)
-    void *(*realloc)(
-            void *array,
-            size_t old_capacity,
-            size_t new_capacity,
-            size_t elem_size,
-            struct cx_array_reallocator_s *alloc
-    );
+    void *(*realloc)( void *array, size_t old_capacity, size_t new_capacity,
+            size_t elem_size, struct cx_array_reallocator_s *alloc);
 
     /**
-     * Custom data pointer.
+     * The allocator that shall be used for the reallocations.
      */
-    void *ptr1;
-    /**
-     * Custom data pointer.
-     */
-    void *ptr2;
+    const CxAllocator *allocator;
     /**
-     * Custom data integer.
+     * Optional pointer to stack memory
+     * if the array is originally located on the stack.
      */
-    size_t int1;
-    /**
-     * Custom data integer.
-     */
-    size_t int2;
+    const void *stack_ptr;
 };
 
 /**
@@ -221,32 +204,28 @@
 /**
  * A default array reallocator that is based on the cxDefaultAllocator.
  */
-cx_attr_export
-extern CxArrayReallocator *cx_array_default_reallocator;
+CX_EXPORT extern CxArrayReallocator *cx_array_default_reallocator;
 
 /**
  * Creates a new array reallocator.
  *
  * When @p allocator is @c NULL, the cxDefaultAllocator will be used.
  *
- * When @p stackmem is not @c NULL, the reallocator is supposed to be used
- * @em only for the specific array initially located at @p stackmem.
+ * When @p stack_ptr is not @c NULL, the reallocator is supposed to be used
+ * @em only for the specific array initially located at @p stack_ptr.
  * When reallocation is needed, the reallocator checks if the array is
- * still located at @p stackmem and copies the contents to the heap.
+ * still located at @p stack_ptr and copies the contents to the heap.
  *
  * @note Invoking this function with both arguments being @c NULL will return a
  * reallocator that behaves like #cx_array_default_reallocator.
  *
  * @param allocator the allocator this reallocator shall be based on
- * @param stackmem the address of the array when the array is initially located
+ * @param stack_ptr the address of the array when the array is initially located
  * on the stack or shall not reallocate in place
  * @return an array reallocator
  */
-cx_attr_export
-CxArrayReallocator cx_array_reallocator(
-        const struct cx_allocator_s *allocator,
-        const void *stackmem
-);
+CX_EXPORT CxArrayReallocator cx_array_reallocator(
+        const struct cx_allocator_s *allocator, const void *stack_ptr);
 
 /**
  * Reserves memory for additional elements.
@@ -266,6 +245,9 @@
  * Supported are 0, 1, 2, and 4, as well as 8 if running on a 64-bit
  * architecture. If set to zero, the native word width is used.
  *
+ * @note This function will reserve the minimum required capacity to hold
+ * the additional elements and does not perform an overallocation.
+ *
  * @param array a pointer to the target array
  * @param size a pointer to the size of the array
  * @param capacity a pointer to the capacity of the array
@@ -279,16 +261,9 @@
  * @see cx_array_reallocator()
  */
 cx_attr_nonnull_arg(1, 2, 3)
-cx_attr_export
-int cx_array_reserve(
-        void **array,
-        void *size,
-        void *capacity,
-        unsigned width,
-        size_t elem_size,
-        size_t elem_count,
-        CxArrayReallocator *reallocator
-);
+CX_EXPORT int cx_array_reserve(void **array, void *size, void *capacity,
+        unsigned width, size_t elem_size, size_t elem_count,
+        CxArrayReallocator *reallocator);
 
 /**
  * Copies elements from one array to another.
@@ -308,6 +283,9 @@
  * Supported are 0, 1, 2, and 4, as well as 8 if running on a 64-bit
  * architecture. If set to zero, the native word width is used.
  *
+ * @note When this function does reallocate the array, it may allocate more
+ * space than required to avoid further allocations in the near future.
+ *
  * @param target a pointer to the target array
  * @param size a pointer to the size of the target array
  * @param capacity a pointer to the capacity of the target array
@@ -321,20 +299,12 @@
  * @retval zero success
  * @retval non-zero failure
  * @see cx_array_reallocator()
+ * @see cx_array_reserve()
  */
 cx_attr_nonnull_arg(1, 2, 3, 6)
-cx_attr_export
-int cx_array_copy(
-        void **target,
-        void *size,
-        void *capacity,
-        unsigned width,
-        size_t index,
-        const void *src,
-        size_t elem_size,
-        size_t elem_count,
-        CxArrayReallocator *reallocator
-);
+CX_EXPORT int cx_array_copy(void **target, void *size, void *capacity, unsigned width,
+        size_t index, const void *src, size_t elem_size, size_t elem_count,
+        CxArrayReallocator *reallocator);
 
 /**
  * Convenience macro that uses cx_array_copy() with a default layout and
@@ -482,17 +452,9 @@
  * @retval non-zero failure
  */
 cx_attr_nonnull_arg(1, 2, 3, 5)
-cx_attr_export
-int cx_array_insert_sorted(
-        void **target,
-        size_t *size,
-        size_t *capacity,
-        cx_compare_func cmp_func,
-        const void *src,
-        size_t elem_size,
-        size_t elem_count,
-        CxArrayReallocator *reallocator
-);
+CX_EXPORT int cx_array_insert_sorted(void **target, size_t *size, size_t *capacity,
+        cx_compare_func cmp_func, const void *src, size_t elem_size, size_t elem_count,
+        CxArrayReallocator *reallocator);
 
 /**
  * Inserts an element into a sorted array.
@@ -500,7 +462,7 @@
  * If the target array is not already sorted with respect
  * to the specified @p cmp_func, the behavior is undefined.
  *
- * If the capacity is insufficient to hold the new data, a reallocation
+ * If the capacity is not enough to hold the new data, a reallocation
  * attempt is made.
  *
  * The \@ SIZE_TYPE is flexible and can be any unsigned integer type.
@@ -611,17 +573,9 @@
  * @retval non-zero failure
  */
 cx_attr_nonnull_arg(1, 2, 3, 5)
-cx_attr_export
-int cx_array_insert_unique(
-        void **target,
-        size_t *size,
-        size_t *capacity,
-        cx_compare_func cmp_func,
-        const void *src,
-        size_t elem_size,
-        size_t elem_count,
-        CxArrayReallocator *reallocator
-);
+CX_EXPORT int cx_array_insert_unique(void **target, size_t *size, size_t *capacity,
+        cx_compare_func cmp_func, const void *src, size_t elem_size, size_t elem_count,
+        CxArrayReallocator *reallocator);
 
 /**
  * Inserts an element into a sorted array if it does not exist.
@@ -738,14 +692,8 @@
  * @see cx_array_binary_search()
  */
 cx_attr_nonnull
-cx_attr_export
-size_t cx_array_binary_search_inf(
-        const void *arr,
-        size_t size,
-        size_t elem_size,
-        const void *elem,
-        cx_compare_func cmp_func
-);
+CX_EXPORT size_t cx_array_binary_search_inf(const void *arr, size_t size,
+        size_t elem_size, const void *elem, cx_compare_func cmp_func);
 
 /**
  * Searches an item in a sorted array.
@@ -764,14 +712,8 @@
  * @see cx_array_binary_search_sup()
  */
 cx_attr_nonnull
-cx_attr_export
-size_t cx_array_binary_search(
-        const void *arr,
-        size_t size,
-        size_t elem_size,
-        const void *elem,
-        cx_compare_func cmp_func
-);
+CX_EXPORT size_t cx_array_binary_search(const void *arr, size_t size,
+        size_t elem_size, const void *elem, cx_compare_func cmp_func);
 
 /**
  * Searches the smallest upper bound in a sorted array.
@@ -796,14 +738,8 @@
  * @see cx_array_binary_search()
  */
 cx_attr_nonnull
-cx_attr_export
-size_t cx_array_binary_search_sup(
-        const void *arr,
-        size_t size,
-        size_t elem_size,
-        const void *elem,
-        cx_compare_func cmp_func
-);
+CX_EXPORT size_t cx_array_binary_search_sup(const void *arr, size_t size,
+        size_t elem_size, const void *elem, cx_compare_func cmp_func);
 
 /**
  * Swaps two array elements.
@@ -814,13 +750,7 @@
  * @param idx2 index of the second element
  */
 cx_attr_nonnull
-cx_attr_export
-void cx_array_swap(
-        void *arr,
-        size_t elem_size,
-        size_t idx1,
-        size_t idx2
-);
+CX_EXPORT void cx_array_swap(void *arr, size_t elem_size, size_t idx1, size_t idx2);
 
 /**
  * Allocates an array list for storing elements with @p elem_size bytes each.
@@ -841,13 +771,8 @@
 cx_attr_nodiscard
 cx_attr_malloc
 cx_attr_dealloc(cxListFree, 1)
-cx_attr_export
-CxList *cxArrayListCreate(
-        const CxAllocator *allocator,
-        cx_compare_func comparator,
-        size_t elem_size,
-        size_t initial_capacity
-);
+CX_EXPORT CxList *cxArrayListCreate(const CxAllocator *allocator,
+        cx_compare_func comparator, size_t elem_size, size_t initial_capacity);
 
 /**
  * Allocates an array list for storing elements with @p elem_size bytes each.

--- a/ucx/cx/buffer.h	Sun Oct 19 21:20:08 2025 +0200
+++ b/ucx/cx/buffer.h	Mon Nov 10 21:52:51 2025 +0100
@@ -227,14 +227,8 @@
  * @return zero on success, non-zero if a required allocation failed
  */
 cx_attr_nonnull_arg(1)
-cx_attr_export
-int cxBufferInit(
-        CxBuffer *buffer,
-        void *space,
-        size_t capacity,
-        const CxAllocator *allocator,
-        int flags
-);
+CX_EXPORT int cxBufferInit(CxBuffer *buffer, void *space, size_t capacity,
+        const CxAllocator *allocator, int flags);
 
 /**
  * Configures the buffer for flushing.
@@ -251,11 +245,7 @@
  * @see cxBufferWrite()
  */
 cx_attr_nonnull
-cx_attr_export
-int cxBufferEnableFlushing(
-    CxBuffer *buffer,
-    CxBufferFlushConfig config
-);
+CX_EXPORT int cxBufferEnableFlushing(CxBuffer *buffer, CxBufferFlushConfig config);
 
 /**
  * Destroys the buffer contents.
@@ -267,8 +257,7 @@
  * @see cxBufferInit()
  */
 cx_attr_nonnull
-cx_attr_export
-void cxBufferDestroy(CxBuffer *buffer);
+CX_EXPORT void cxBufferDestroy(CxBuffer *buffer);
 
 /**
  * Deallocates the buffer.
@@ -279,8 +268,7 @@
  * @param buffer the buffer to deallocate
  * @see cxBufferCreate()
  */
-cx_attr_export
-void cxBufferFree(CxBuffer *buffer);
+CX_EXPORT void cxBufferFree(CxBuffer *buffer);
 
 /**
  * Allocates and initializes a fresh buffer.
@@ -306,16 +294,9 @@
  * @param flags buffer features (see cx_buffer_s.flags)
  * @return a pointer to the buffer on success, @c NULL if a required allocation failed
  */
-cx_attr_malloc
-cx_attr_dealloc(cxBufferFree, 1)
-cx_attr_nodiscard
-cx_attr_export
-CxBuffer *cxBufferCreate(
-        void *space,
-        size_t capacity,
-        const CxAllocator *allocator,
-        int flags
-);
+cx_attr_malloc cx_attr_dealloc(cxBufferFree, 1) cx_attr_nodiscard
+CX_EXPORT CxBuffer *cxBufferCreate(void *space, size_t capacity,
+        const CxAllocator *allocator, int flags);
 
 /**
  * Shifts the contents of the buffer by the given offset.
@@ -354,11 +335,7 @@
  * @see cxBufferShiftRight()
  */
 cx_attr_nonnull
-cx_attr_export
-int cxBufferShift(
-        CxBuffer *buffer,
-        off_t shift
-);
+CX_EXPORT int cxBufferShift(CxBuffer *buffer, off_t shift);
 
 /**
  * Shifts the buffer to the right.
@@ -371,11 +348,7 @@
  * @see cxBufferShift()
  */
 cx_attr_nonnull
-cx_attr_export
-int cxBufferShiftRight(
-        CxBuffer *buffer,
-        size_t shift
-);
+CX_EXPORT int cxBufferShiftRight(CxBuffer *buffer, size_t shift);
 
 /**
  * Shifts the buffer to the left.
@@ -388,11 +361,7 @@
  * @see cxBufferShift()
  */
 cx_attr_nonnull
-cx_attr_export
-int cxBufferShiftLeft(
-        CxBuffer *buffer,
-        size_t shift
-);
+CX_EXPORT int cxBufferShiftLeft(CxBuffer *buffer, size_t shift);
 
 
 /**
@@ -416,12 +385,7 @@
  *
  */
 cx_attr_nonnull
-cx_attr_export
-int cxBufferSeek(
-        CxBuffer *buffer,
-        off_t offset,
-        int whence
-);
+CX_EXPORT int cxBufferSeek(CxBuffer *buffer, off_t offset, int whence);
 
 /**
  * Clears the buffer by resetting the position and deleting the data.
@@ -436,8 +400,7 @@
  * @see cxBufferReset()
  */
 cx_attr_nonnull
-cx_attr_export
-void cxBufferClear(CxBuffer *buffer);
+CX_EXPORT void cxBufferClear(CxBuffer *buffer);
 
 /**
  * Resets the buffer by resetting the position and size to zero.
@@ -449,8 +412,7 @@
  * @see cxBufferClear()
  */
 cx_attr_nonnull
-cx_attr_export
-void cxBufferReset(CxBuffer *buffer);
+CX_EXPORT void cxBufferReset(CxBuffer *buffer);
 
 /**
  * Tests, if the buffer position has exceeded the buffer size.
@@ -460,10 +422,8 @@
  * byte of the buffer's contents
  * @retval false otherwise
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-bool cxBufferEof(const CxBuffer *buffer);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT bool cxBufferEof(const CxBuffer *buffer);
 
 
 /**
@@ -481,11 +441,7 @@
  * @see cxBufferShrink()
  */
 cx_attr_nonnull
-cx_attr_export
-int cxBufferMinimumCapacity(
-        CxBuffer *buffer,
-        size_t capacity
-);
+CX_EXPORT int cxBufferMinimumCapacity(CxBuffer *buffer, size_t capacity);
 
 /**
  * Shrinks the capacity of the buffer to fit its current size.
@@ -504,11 +460,7 @@
  * @see cxBufferMinimumCapacity()
  */
 cx_attr_nonnull
-cx_attr_export
-void cxBufferShrink(
-        CxBuffer *buffer,
-        size_t reserve
-);
+CX_EXPORT void cxBufferShrink(CxBuffer *buffer, size_t reserve);
 
 /**
  * Writes data to a CxBuffer.
@@ -552,13 +504,8 @@
  * @see cxBufferRead()
  */
 cx_attr_nonnull
-cx_attr_export
-size_t cxBufferWrite(
-        const void *ptr,
-        size_t size,
-        size_t nitems,
-        CxBuffer *buffer
-);
+CX_EXPORT size_t cxBufferWrite(const void *ptr, size_t size,
+        size_t nitems, CxBuffer *buffer);
 
 /**
  * Appends data to a CxBuffer.
@@ -580,13 +527,8 @@
  * @see cxBufferRead()
  */
 cx_attr_nonnull
-cx_attr_export
-size_t cxBufferAppend(
-        const void *ptr,
-        size_t size,
-        size_t nitems,
-        CxBuffer *buffer
-);
+CX_EXPORT size_t cxBufferAppend(const void *ptr, size_t size,
+        size_t nitems, CxBuffer *buffer);
 
 /**
  * Performs a single flush-run on the specified buffer.
@@ -642,8 +584,7 @@
  * @see cxBufferEnableFlushing()
  */
 cx_attr_nonnull
-cx_attr_export
-size_t cxBufferFlush(CxBuffer *buffer);
+CX_EXPORT size_t cxBufferFlush(CxBuffer *buffer);
 
 /**
  * Reads data from a CxBuffer.
@@ -661,13 +602,8 @@
  * @see cxBufferAppend()
  */
 cx_attr_nonnull
-cx_attr_export
-size_t cxBufferRead(
-        void *ptr,
-        size_t size,
-        size_t nitems,
-        CxBuffer *buffer
-);
+CX_EXPORT size_t cxBufferRead(void *ptr, size_t size,
+        size_t nitems, CxBuffer *buffer);
 
 /**
  * Writes a character to a buffer.
@@ -689,11 +625,7 @@
  * @see cxBufferTerminate()
  */
 cx_attr_nonnull
-cx_attr_export
-int cxBufferPut(
-        CxBuffer *buffer,
-        int c
-);
+CX_EXPORT int cxBufferPut(CxBuffer *buffer, int c);
 
 /**
  * Writes a terminating zero to a buffer at the current position.
@@ -707,8 +639,7 @@
  * @return zero, if the terminator could be written, non-zero otherwise
  */
 cx_attr_nonnull
-cx_attr_export
-int cxBufferTerminate(CxBuffer *buffer);
+CX_EXPORT int cxBufferTerminate(CxBuffer *buffer);
 
 /**
  * Writes a string to a buffer.
@@ -719,13 +650,8 @@
  * @param str the zero-terminated string
  * @return the number of bytes written
  */
-cx_attr_nonnull
-cx_attr_cstr_arg(2)
-cx_attr_export
-size_t cxBufferPutString(
-        CxBuffer *buffer,
-        const char *str
-);
+cx_attr_nonnull cx_attr_cstr_arg(2)
+CX_EXPORT size_t cxBufferPutString(CxBuffer *buffer, const char *str);
 
 /**
  * Gets a character from a buffer.
@@ -736,8 +662,7 @@
  * @return the character or @c EOF, if the end of the buffer is reached
  */
 cx_attr_nonnull
-cx_attr_export
-int cxBufferGet(CxBuffer *buffer);
+CX_EXPORT int cxBufferGet(CxBuffer *buffer);
 
 #ifdef __cplusplus
 }

--- a/ucx/cx/collection.h	Sun Oct 19 21:20:08 2025 +0200
+++ b/ucx/cx/collection.h	Mon Nov 10 21:52:51 2025 +0100
@@ -151,7 +151,15 @@
  * @retval true if the elements are currently sorted wrt. the collection's compare function
  * @retval false if the order of elements is unknown
  */
-#define cxCollectionSorted(c) ((c)->collection.sorted)
+#define cxCollectionSorted(c) ((c)->collection.sorted || (c)->collection.size == 0)
+
+/**
+ * Sets the compare function for a collection.
+ *
+ * @param c a pointer to a struct that contains #CX_COLLECTION_BASE
+ * @param func (@c cx_compare_func) the compare function that shall be used by @c c
+ */
+#define cxCollectionCompareFunc(c, func) (c)->collection.cmpfunc = (func)
 
 /**
  * Sets a simple destructor function for this collection.

--- a/ucx/cx/common.h	Sun Oct 19 21:20:08 2025 +0200
+++ b/ucx/cx/common.h	Mon Nov 10 21:52:51 2025 +0100
@@ -265,15 +265,32 @@
 #define _Thread_local __declspec(thread)
 #endif // _MSC_VER
 
+// ---------------------------------------------------------------------------
+//       Exported and inlined functions
+// ---------------------------------------------------------------------------
+
 #if defined(CX_WINDLL_EXPORT)
-#define cx_attr_export __declspec(dllexport)
+#define CX_EXPORT __declspec(dllexport)
 #elif defined(CX_WINDLL)
-#define cx_attr_export __declspec(dllimport)
+#define CX_EXPORT __declspec(dllimport)
 #else
 /** Only used for building Windows DLLs. */
-#define cx_attr_export
+#define CX_EXPORT
 #endif // CX_WINDLL / CX_WINDLL_EXPORT
 
+#ifdef __GNUC__
+/**
+ * Declares a function to be inlined.
+ */
+#define CX_INLINE __attribute__((always_inline)) static inline
+#else
+#define CX_INLINE static inline
+#endif
+/**
+ * Declares a compatibility function for C++ builds.
+ */
+#define CX_CPPDECL static inline
+
 // ---------------------------------------------------------------------------
 //       Useful function pointers
 // ---------------------------------------------------------------------------
@@ -281,22 +298,12 @@
 /**
  * Function pointer compatible with fwrite-like functions.
  */
-typedef size_t (*cx_write_func)(
-        const void *,
-        size_t,
-        size_t,
-        void *
-);
+typedef size_t (*cx_write_func)(const void*, size_t, size_t, void*);
 
 /**
  * Function pointer compatible with fread-like functions.
  */
-typedef size_t (*cx_read_func)(
-        void *,
-        size_t,
-        size_t,
-        void *
-);
+typedef size_t (*cx_read_func)(void*, size_t, size_t, void*);
 
 // ---------------------------------------------------------------------------
 //       Utility macros
@@ -348,9 +355,7 @@
 #if __cplusplus
 extern "C"
 #endif
-cx_attr_export int cx_szmul_impl(size_t a, size_t b, size_t *result);
+CX_EXPORT int cx_szmul_impl(size_t a, size_t b, size_t *result);
 #endif // cx_szmul
 
-
-
 #endif // UCX_COMMON_H

--- a/ucx/cx/common.h.orig	Sun Oct 19 21:20:08 2025 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,138 +0,0 @@
-/*
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
- *
- * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   1. Redistributions of source code must retain the above copyright
- *      notice, this list of conditions and the following disclaimer.
- *
- *   2. Redistributions in binary form must reproduce the above copyright
- *      notice, this list of conditions and the following disclaimer in the
- *      documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-/**
- * \file common.h
- *
- * \brief Common definitions and feature checks.
- *
- * \author Mike Becker
- * \author Olaf Wintermann
- * \version 3.0
- * \copyright 2-Clause BSD License
- *
- * \mainpage UAP Common Extensions
- * Library with common and useful functions, macros and data structures.
- * <p>
- * Latest available source:<br>
- * <a href="https://sourceforge.net/projects/ucx/files/">https://sourceforge.net/projects/ucx/files/</a>
- * </p>
- *
- * <p>
- * Repositories:<br>
- * <a href="https://sourceforge.net/p/ucx/code">https://sourceforge.net/p/ucx/code</a>
- * -&nbsp;or&nbsp;-
- * <a href="https://develop.uap-core.de/hg/ucx">https://develop.uap-core.de/hg/ucx</a>
- * </p>
- *
- * <h2>LICENCE</h2>
- *
- * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   1. Redistributions of source code must retain the above copyright
- *      notice, this list of conditions and the following disclaimer.
- *
- *   2. Redistributions in binary form must reproduce the above copyright
- *      notice, this list of conditions and the following disclaimer in the
- *      documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef UCX_COMMON_H
-#define UCX_COMMON_H
-
-/** Major UCX version as integer constant. */
-#define UCX_VERSION_MAJOR   3
-
-/** Minor UCX version as integer constant. */
-#define UCX_VERSION_MINOR   0
-
-/** Version constant which ensures to increase monotonically. */
-#define UCX_VERSION (((UCX_VERSION_MAJOR)<<16)|UCX_VERSION_MINOR)
-
-#define __attribute__(...) 
-
-#include <stdlib.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include <stdint.h>
-
-/**
- * Function pointer compatible with fwrite-like functions.
- */
-typedef size_t (*cx_write_func)(
-        void const *,
-        size_t,
-        size_t,
-        void *
-);
-
-/**
- * Function pointer compatible with fread-like functions.
- */
-typedef size_t (*cx_read_func)(
-        void *,
-        size_t,
-        size_t,
-        void *
-);
-
-#ifdef _WIN32
-
-#ifdef __MINGW32__
-#include <sys/types.h>
-#endif // __MINGW32__
-
-#else // !_WIN32
-
-#include <sys/types.h>
-
-#endif // _WIN32
-
-#ifndef __GNUC__
-/**
- * Removes GNU C attributes where they are not supported.
- */
-#define __attribute__(x)
-#endif
-
-#endif // UCX_COMMON_H

--- a/ucx/cx/compare.h	Sun Oct 19 21:20:08 2025 +0200
+++ b/ucx/cx/compare.h	Mon Nov 10 21:52:51 2025 +0100
@@ -54,13 +54,7 @@
  * can be used, but they are NOT compatible with this function
  * pointer.
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-typedef int (*cx_compare_func)(
-    const void *left,
-    const void *right
-);
+typedef int (*cx_compare_func)(const void *left, const void *right);
 
 /**
  * Compares two integers of type int.
@@ -74,10 +68,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_int(const void *i1, const void *i2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_int(const void *i1, const void *i2);
 
 /**
  * Compares two integers of type int.
@@ -89,8 +81,7 @@
  * @retval 1 if the left argument is greater than the right argument
  */
 cx_attr_nodiscard
-cx_attr_export
-int cx_vcmp_int(int i1, int i2);
+CX_EXPORT int cx_vcmp_int(int i1, int i2);
 
 /**
  * Compares two integers of type long int.
@@ -104,10 +95,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_longint(const void *i1, const void *i2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_longint(const void *i1, const void *i2);
 
 /**
  * Compares two integers of type long int.
@@ -119,8 +108,7 @@
  * @retval 1 if the left argument is greater than the right argument
  */
 cx_attr_nodiscard
-cx_attr_export
-int cx_vcmp_longint(long int i1, long int i2);
+CX_EXPORT int cx_vcmp_longint(long int i1, long int i2);
 
 /**
  * Compares two integers of type long long.
@@ -134,10 +122,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_longlong(const void *i1, const void *i2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_longlong(const void *i1, const void *i2);
 
 /**
  * Compares two integers of type long long.
@@ -149,8 +135,7 @@
  * @retval 1 if the left argument is greater than the right argument
  */
 cx_attr_nodiscard
-cx_attr_export
-int cx_vcmp_longlong(long long int i1, long long int i2);
+CX_EXPORT int cx_vcmp_longlong(long long int i1, long long int i2);
 
 /**
  * Compares two integers of type int16_t.
@@ -164,10 +149,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_int16(const void *i1, const void *i2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_int16(const void *i1, const void *i2);
 
 /**
  * Compares two integers of type int16_t.
@@ -179,8 +162,7 @@
  * @retval 1 if the left argument is greater than the right argument
  */
 cx_attr_nodiscard
-cx_attr_export
-int cx_vcmp_int16(int16_t i1, int16_t i2);
+CX_EXPORT int cx_vcmp_int16(int16_t i1, int16_t i2);
 
 /**
  * Compares two integers of type int32_t.
@@ -194,10 +176,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_int32(const void *i1, const void *i2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_int32(const void *i1, const void *i2);
 
 /**
  * Compares two integers of type int32_t.
@@ -209,8 +189,7 @@
  * @retval 1 if the left argument is greater than the right argument
  */
 cx_attr_nodiscard
-cx_attr_export
-int cx_vcmp_int32(int32_t i1, int32_t i2);
+CX_EXPORT int cx_vcmp_int32(int32_t i1, int32_t i2);
 
 /**
  * Compares two integers of type int64_t.
@@ -224,10 +203,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_int64(const void *i1, const void *i2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_int64(const void *i1, const void *i2);
 
 /**
  * Compares two integers of type int64_t.
@@ -239,8 +216,7 @@
  * @retval 1 if the left argument is greater than the right argument
  */
 cx_attr_nodiscard
-cx_attr_export
-int cx_vcmp_int64(int64_t i1, int64_t i2);
+CX_EXPORT int cx_vcmp_int64(int64_t i1, int64_t i2);
 
 /**
  * Compares two integers of type unsigned int.
@@ -254,10 +230,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_uint(const void *i1, const void *i2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_uint(const void *i1, const void *i2);
 
 /**
  * Compares two integers of type unsigned int.
@@ -269,8 +243,7 @@
  * @retval 1 if the left argument is greater than the right argument
  */
 cx_attr_nodiscard
-cx_attr_export
-int cx_vcmp_uint(unsigned int i1, unsigned int i2);
+CX_EXPORT int cx_vcmp_uint(unsigned int i1, unsigned int i2);
 
 /**
  * Compares two integers of type unsigned long int.
@@ -284,10 +257,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_ulongint(const void *i1, const void *i2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_ulongint(const void *i1, const void *i2);
 
 /**
  * Compares two integers of type unsigned long int.
@@ -299,8 +270,7 @@
  * @retval 1 if the left argument is greater than the right argument
  */
 cx_attr_nodiscard
-cx_attr_export
-int cx_vcmp_ulongint(unsigned long int i1, unsigned long int i2);
+CX_EXPORT int cx_vcmp_ulongint(unsigned long int i1, unsigned long int i2);
 
 /**
  * Compares two integers of type unsigned long long.
@@ -314,10 +284,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_ulonglong(const void *i1, const void *i2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_ulonglong(const void *i1, const void *i2);
 
 /**
  * Compares two integers of type unsigned long long.
@@ -329,8 +297,7 @@
  * @retval 1 if the left argument is greater than the right argument
  */
 cx_attr_nodiscard
-cx_attr_export
-int cx_vcmp_ulonglong(unsigned long long int i1, unsigned long long int i2);
+CX_EXPORT int cx_vcmp_ulonglong(unsigned long long int i1, unsigned long long int i2);
 
 /**
  * Compares two integers of type uint16_t.
@@ -344,10 +311,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_uint16(const void *i1, const void *i2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_uint16(const void *i1, const void *i2);
 
 /**
  * Compares two integers of type uint16_t.
@@ -359,8 +324,7 @@
  * @retval 1 if the left argument is greater than the right argument
  */
 cx_attr_nodiscard
-cx_attr_export
-int cx_vcmp_uint16(uint16_t i1, uint16_t i2);
+CX_EXPORT int cx_vcmp_uint16(uint16_t i1, uint16_t i2);
 
 /**
  * Compares two integers of type uint32_t.
@@ -374,10 +338,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_uint32(const void *i1, const void *i2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_uint32(const void *i1, const void *i2);
 
 /**
  * Compares two integers of type uint32_t.
@@ -389,8 +351,7 @@
  * @retval 1 if the left argument is greater than the right argument
  */
 cx_attr_nodiscard
-cx_attr_export
-int cx_vcmp_uint32(uint32_t i1, uint32_t i2);
+CX_EXPORT int cx_vcmp_uint32(uint32_t i1, uint32_t i2);
 
 /**
  * Compares two integers of type uint64_t.
@@ -404,10 +365,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_uint64(const void *i1, const void *i2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_uint64(const void *i1, const void *i2);
 
 /**
  * Compares two integers of type uint64_t.
@@ -419,8 +378,7 @@
  * @retval 1 if the left argument is greater than the right argument
  */
 cx_attr_nodiscard
-cx_attr_export
-int cx_vcmp_uint64(uint64_t i1, uint64_t i2);
+CX_EXPORT int cx_vcmp_uint64(uint64_t i1, uint64_t i2);
 
 /**
  * Compares two integers of type size_t.
@@ -434,10 +392,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_size(const void *i1, const void *i2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_size(const void *i1, const void *i2);
 
 /**
  * Compares two integers of type size_t.
@@ -449,8 +405,7 @@
  * @retval 1 if the left argument is greater than the right argument
  */
 cx_attr_nodiscard
-cx_attr_export
-int cx_vcmp_size(size_t i1, size_t i2);
+CX_EXPORT int cx_vcmp_size(size_t i1, size_t i2);
 
 /**
  * Compares two real numbers of type float with precision 1e-6f.
@@ -464,10 +419,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_float(const void *f1, const void *f2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_float(const void *f1, const void *f2);
 
 /**
  * Compares two real numbers of type float with precision 1e-6f.
@@ -479,8 +432,7 @@
  * @retval 1 if the left argument is greater than the right argument
  */
 cx_attr_nodiscard
-cx_attr_export
-int cx_vcmp_float(float f1, float f2);
+CX_EXPORT int cx_vcmp_float(float f1, float f2);
 
 /**
  * Compares two real numbers of type double with precision 1e-14.
@@ -494,10 +446,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_double(const void *d1, const void *d2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_double(const void *d1, const void *d2);
 
 /**
  * Compares two real numbers of type double with precision 1e-14.
@@ -509,8 +459,7 @@
  * @retval 1 if the left argument is greater than the right argument
  */
 cx_attr_nodiscard
-cx_attr_export
-int cx_vcmp_double(double d1, double d2);
+CX_EXPORT int cx_vcmp_double(double d1, double d2);
 
 /**
  * Compares the integer representation of two pointers.
@@ -524,10 +473,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_intptr(const void *ptr1, const void *ptr2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_intptr(const void *ptr1, const void *ptr2);
 
 /**
  * Compares the integer representation of two pointers.
@@ -539,8 +486,7 @@
  * @retval 1 if the left argument is greater than the right argument
  */
 cx_attr_nodiscard
-cx_attr_export
-int cx_vcmp_intptr(intptr_t ptr1, intptr_t ptr2);
+CX_EXPORT int cx_vcmp_intptr(intptr_t ptr1, intptr_t ptr2);
 
 /**
  * Compares the unsigned integer representation of two pointers.
@@ -554,10 +500,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_uintptr(const void *ptr1, const void *ptr2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_uintptr(const void *ptr1, const void *ptr2);
 
 /**
  * Compares the unsigned integer representation of two pointers.
@@ -569,8 +513,7 @@
  * @retval 1 if the left argument is greater than the right argument
  */
 cx_attr_nodiscard
-cx_attr_export
-int cx_vcmp_uintptr(uintptr_t ptr1, uintptr_t ptr2);
+CX_EXPORT int cx_vcmp_uintptr(uintptr_t ptr1, uintptr_t ptr2);
 
 /**
  * Compares the pointers specified in the arguments without dereferencing.
@@ -581,10 +524,8 @@
  * @retval 0 if both arguments are equal
  * @retval 1 if the left argument is greater than the right argument
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-int cx_cmp_ptr(const void *ptr1, const void *ptr2);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT int cx_cmp_ptr(const void *ptr1, const void *ptr2);
 
 #ifdef __cplusplus
 } // extern "C"

--- a/ucx/cx/hash_key.h	Sun Oct 19 21:20:08 2025 +0200
+++ b/ucx/cx/hash_key.h	Mon Nov 10 21:52:51 2025 +0100
@@ -79,8 +79,7 @@
  * @see cx_hash_key()
  */
 cx_attr_nonnull
-cx_attr_export
-void cx_hash_murmur(CxHashKey *key);
+CX_EXPORT void cx_hash_murmur(CxHashKey *key);
 
 /**
  * Mixes up a 32-bit integer to be used as a hash.
@@ -90,8 +89,7 @@
  * @param x the integer
  * @return the hash
  */
-cx_attr_export
-uint32_t cx_hash_u32(uint32_t x);
+CX_EXPORT uint32_t cx_hash_u32(uint32_t x);
 
 /**
  * Mixes up a 64-bit integer to be used as a hash.
@@ -101,8 +99,7 @@
  * @param x the integer
  * @return the hash
  */
-cx_attr_export
-uint64_t cx_hash_u64(uint64_t x);
+CX_EXPORT uint64_t cx_hash_u64(uint64_t x);
 
 /**
  * Computes a hash key from a 32-bit integer.
@@ -111,8 +108,7 @@
  * @return the hash key
  */
 cx_attr_nodiscard
-cx_attr_export
-CxHashKey cx_hash_key_u32(uint32_t x);
+CX_EXPORT CxHashKey cx_hash_key_u32(uint32_t x);
 
 /**
  * Computes a hash key from a 64-bit integer.
@@ -121,8 +117,7 @@
  * @return the hash key
  */
 cx_attr_nodiscard
-cx_attr_export
-CxHashKey cx_hash_key_u64(uint64_t x);
+CX_EXPORT CxHashKey cx_hash_key_u64(uint64_t x);
 
 /**
  * Computes a hash key from a string.
@@ -132,10 +127,8 @@
  * @param str the string
  * @return the hash key
  */
-cx_attr_nodiscard
-cx_attr_cstr_arg(1)
-cx_attr_export
-CxHashKey cx_hash_key_str(const char *str);
+cx_attr_nodiscard cx_attr_cstr_arg(1)
+CX_EXPORT CxHashKey cx_hash_key_str(const char *str);
 
 /**
  * Computes a hash key from a string.
@@ -148,12 +141,8 @@
  * @param str the string
  * @return the hash key
  */
-cx_attr_nodiscard
-cx_attr_cstr_arg(1)
-cx_attr_export
-static inline CxHashKey cx_hash_key_ustr(const unsigned char *str) {
-    return cx_hash_key_str((const char*)str);
-}
+cx_attr_nodiscard cx_attr_cstr_arg(1)
+CX_EXPORT CxHashKey cx_hash_key_ustr(const unsigned char *str);
 
 /**
  * Computes a hash key from a byte array.
@@ -162,13 +151,8 @@
  * @param len the length
  * @return the hash key
  */
-cx_attr_nodiscard
-cx_attr_access_r(1, 2)
-cx_attr_export
-CxHashKey cx_hash_key_bytes(
-        const unsigned char *bytes,
-        size_t len
-);
+cx_attr_nodiscard cx_attr_access_r(1, 2)
+CX_EXPORT CxHashKey cx_hash_key_bytes(const unsigned char *bytes, size_t len);
 
 /**
  * Computes a hash key for an arbitrary object.
@@ -183,11 +167,7 @@
  */
 cx_attr_nodiscard
 cx_attr_access_r(1, 2)
-cx_attr_export
-CxHashKey cx_hash_key(
-        const void *obj,
-        size_t len
-);
+CX_EXPORT CxHashKey cx_hash_key(const void *obj, size_t len);
 
 /**
  * Computes a hash key from a UCX string.
@@ -196,9 +176,7 @@
  * @return the hash key
  */
 cx_attr_nodiscard
-static inline CxHashKey cx_hash_key_cxstr(cxstring str) {
-    return cx_hash_key(str.ptr, str.length);
-}
+CX_EXPORT CxHashKey cx_hash_key_cxstr(cxstring str);
 
 /**
  * Computes a hash key from a UCX string.
@@ -207,9 +185,7 @@
  * @return the hash key
  */
 cx_attr_nodiscard
-static inline CxHashKey cx_hash_key_mutstr(cxmutstr str) {
-    return cx_hash_key(str.ptr, str.length);
-}
+CX_EXPORT CxHashKey cx_hash_key_mutstr(cxmutstr str);
 
 /**
  * The identity function for the CX_HASH_KEY() macro.
@@ -219,7 +195,7 @@
  * @return a copy of the key
  */
 cx_attr_nodiscard
-static inline CxHashKey cx_hash_key_identity(CxHashKey key) {
+CX_INLINE CxHashKey cx_hash_key_identity(CxHashKey key) {
     return key;
 }
 
@@ -249,25 +225,16 @@
 #endif // __cplusplus
 
 /**
- * Computes a hash key from a UCX string.
- * Convenience macro that accepts both cxstring and cxmutstr.
- * @deprecated use the CX_HASH_KEY() macro instead
- * @param str (@c cxstring or @c cxmutstr) the string
- * @return (@c CxHashKey) the hash key
- */
-#define cx_hash_key_cxstr(str) cx_hash_key_cxstr(cx_strcast(str))
-
-/**
  * Compare function for hash keys.
  *
- * @param left the first key
- * @param right the second key
+ * The pointers are untyped to be compatible with the cx_compare_func signature.
+ *
+ * @param left (@c CxHashKey*) the first key
+ * @param right (@c CxHashKey*) the second key
  * @return zero when the keys equal, non-zero when they differ
  */
-cx_attr_nodiscard
-cx_attr_nonnull
-cx_attr_export
-int cx_hash_key_cmp(const CxHashKey *left, const CxHashKey *right);
+cx_attr_nodiscard cx_attr_nonnull
+CX_EXPORT int cx_hash_key_cmp(const void *left, const void *right);
 
 #ifdef __cplusplus
 } // extern "C"
@@ -276,31 +243,31 @@
 // Overloads of CX_HASH_KEY (the C++ version of a _Generic)
 // ----------------------------------------------------------
 
-static inline CxHashKey CX_HASH_KEY(CxHashKey key) {
+CX_CPPDECL CxHashKey CX_HASH_KEY(CxHashKey key) {
     return key;
 }
 
-static inline CxHashKey CX_HASH_KEY(cxstring str) {
+CX_CPPDECL CxHashKey CX_HASH_KEY(cxstring str) {
     return cx_hash_key_cxstr(str);
 }
 
-static inline CxHashKey CX_HASH_KEY(cxmutstr str) {
+CX_CPPDECL CxHashKey CX_HASH_KEY(cxmutstr str) {
     return cx_hash_key_mutstr(str);
 }
 
-static inline CxHashKey CX_HASH_KEY(const char *str) {
+CX_CPPDECL CxHashKey CX_HASH_KEY(const char *str) {
     return cx_hash_key_str(str);
 }
 
-static inline CxHashKey CX_HASH_KEY(const unsigned char *str) {
+CX_CPPDECL CxHashKey CX_HASH_KEY(const unsigned char *str) {
     return cx_hash_key_ustr(str);
 }
 
-static inline CxHashKey CX_HASH_KEY(uint32_t key) {
+CX_CPPDECL CxHashKey CX_HASH_KEY(uint32_t key) {
     return cx_hash_key_u32(key);
 }
 
-static inline CxHashKey CX_HASH_KEY(uint64_t key) {
+CX_CPPDECL CxHashKey CX_HASH_KEY(uint64_t key) {
     return cx_hash_key_u64(key);
 }
 #endif

--- a/ucx/cx/hash_map.h	Sun Oct 19 21:20:08 2025 +0200
+++ b/ucx/cx/hash_map.h	Mon Nov 10 21:52:51 2025 +0100
@@ -83,15 +83,9 @@
  * @param buckets the initial number of buckets in this hash map
  * @return a pointer to the new hash map
  */
-cx_attr_nodiscard
-cx_attr_malloc
-cx_attr_dealloc(cxMapFree, 1)
-cx_attr_export
-CxMap *cxHashMapCreate(
-        const CxAllocator *allocator,
-        size_t itemsize,
-        size_t buckets
-);
+cx_attr_nodiscard cx_attr_malloc cx_attr_dealloc(cxMapFree, 1)
+CX_EXPORT CxMap *cxHashMapCreate(const CxAllocator *allocator,
+        size_t itemsize, size_t buckets);
 
 /**
  * Creates a new hash map with a default number of buckets.
@@ -129,8 +123,7 @@
  * @retval non-zero if a memory allocation error occurred
  */
 cx_attr_nonnull
-cx_attr_export
-int cxMapRehash(CxMap *map);
+CX_EXPORT int cxMapRehash(CxMap *map);
 
 
 #ifdef __cplusplus

--- a/ucx/cx/iterator.h	Sun Oct 19 21:20:08 2025 +0200
+++ b/ucx/cx/iterator.h	Mon Nov 10 21:52:51 2025 +0100
@@ -50,7 +50,10 @@
      * True if the iterator points to valid data.
      */
     bool (*valid)(const void *);
-
+    /**
+     * Original implementation in case the function needs to be wrapped.
+     */
+    bool (*valid_impl)(const void *);
     /**
      * Returns a pointer to the current element.
      *
@@ -62,7 +65,6 @@
      * Original implementation in case the function needs to be wrapped.
      */
     void *(*current_impl)(const void *);
-
     /**
      * Advances the iterator.
      *
@@ -76,7 +78,7 @@
     /**
      * Indicates whether this iterator may remove elements.
      */
-    bool mutating;
+    bool allow_remove;
     /**
      * Internal flag for removing the current element when advancing.
      */
@@ -112,16 +114,7 @@
     /**
      * Handle for the source collection, if any.
      */
-    union {
-        /**
-         * Access for mutating iterators.
-         */
-        void *m;
-        /**
-         * Access for normal iterators.
-         */
-        const void *c;
-    } src_handle;
+    void *src_handle;
 
     /**
      * If the iterator is position-aware, contains the index of the element in the underlying collection.
@@ -149,7 +142,7 @@
  * to be "position-aware", which means that they keep track of the current index within the collection.
  *
  * @note Objects that are pointed to by an iterator are always mutable through that iterator. However,
- * any concurrent mutation of the collection other than by this iterator makes this iterator invalid,
+ * any concurrent mutation of the collection other than by this iterator makes this iterator obsolete,
  * and it must not be used anymore.
  */
 typedef struct cx_iterator_s CxIterator;
@@ -182,13 +175,12 @@
 #define cxIteratorNext(iter) (iter).base.next(&iter)
 
 /**
- * Flags the current element for removal if this iterator is mutating.
- *
- * Does nothing for non-mutating iterators.
+ * Flags the current element for removal if the iterator allows it.
  *
  * @param iter the iterator
+ * @return @c true if removal is allowed, @c false otherwise
  */
-#define cxIteratorFlagRemoval(iter) (iter).base.remove |= (iter).base.mutating
+#define cxIteratorFlagRemoval(iter) ((iter).base.remove = (iter).base.allow_remove)
 
 /**
  * Obtains a reference to an arbitrary iterator.
@@ -222,22 +214,34 @@
  * use cxIteratorPtr() to create an iterator which directly
  * yields the stored pointers.
  *
+ * While the iterator is in use, the array may only be altered by removing
+ * elements through #cxIteratorFlagRemoval(). Every other change to the array
+ * will bring this iterator to an undefined state.
+ *
+ * When @p remove_keeps_order is set to @c false, removing an element will only
+ * move the last element to the position of the removed element, instead of
+ * moving all subsequent elements by one. Usually, when the order of elements is
+ * not important, this parameter should be set to @c false.
+ *
  * @param array a pointer to the array (can be @c NULL)
  * @param elem_size the size of one array element
  * @param elem_count the number of elements in the array
+ * @param remove_keeps_order @c true if the order of elements must be preserved
+ * when removing an element
  * @return an iterator for the specified array
  * @see cxIteratorPtr()
  */
 cx_attr_nodiscard
-cx_attr_export
-CxIterator cxIterator(
-        const void *array,
-        size_t elem_size,
-        size_t elem_count
-);
+CX_EXPORT CxIterator cxIterator(const void *array,
+        size_t elem_size, size_t elem_count, bool remove_keeps_order);
 
 /**
- * Creates a mutating iterator for the specified plain array.
+ * Creates an iterator for the specified plain pointer array.
+ *
+ * This iterator assumes that every element in the array is a pointer
+ * and yields exactly those pointers during iteration (on the other
+ * hand, an iterator created with cxIterator() would return the
+ * addresses of those pointers within the array).
  *
  * While the iterator is in use, the array may only be altered by removing
  * elements through #cxIteratorFlagRemoval(). Every other change to the array
@@ -248,67 +252,16 @@
  * moving all subsequent elements by one. Usually, when the order of elements is
  * not important, this parameter should be set to @c false.
  *
- * The @p array can be @c NULL, in which case the iterator will be immediately
- * initialized such that #cxIteratorValid() returns @c false.
- *
- *
- * @param array a pointer to the array (can be @c NULL)
- * @param elem_size the size of one array element
- * @param elem_count the number of elements in the array
- * @param remove_keeps_order @c true if the order of elements must be preserved
- * when removing an element
- * @return an iterator for the specified array
- */
-cx_attr_nodiscard
-cx_attr_export
-CxIterator cxMutIterator(
-        void *array,
-        size_t elem_size,
-        size_t elem_count,
-        bool remove_keeps_order
-);
-
-/**
- * Creates an iterator for the specified plain pointer array.
- *
- * This iterator assumes that every element in the array is a pointer
- * and yields exactly those pointers during iteration (on the other
- * hand, an iterator created with cxIterator() would return the
- * addresses of those pointers within the array).
- *
- * @param array a pointer to the array (can be @c NULL)
- * @param elem_count the number of elements in the array
- * @return an iterator for the specified array
- * @see cxIterator()
- */
-cx_attr_nodiscard
-cx_attr_export
-CxIterator cxIteratorPtr(
-        const void *array,
-        size_t elem_count
-);
-
-/**
- * Creates a mutating iterator for the specified plain pointer array.
- *
- * This is the mutating variant of cxIteratorPtr(). See also
- * cxMutIterator().
- *
  * @param array a pointer to the array (can be @c NULL)
  * @param elem_count the number of elements in the array
  * @param remove_keeps_order @c true if the order of elements must be preserved
  * when removing an element
  * @return an iterator for the specified array
- * @see cxMutIterator()
- * @see cxIteratorPtr()
+ * @see cxIterator()
  */
 cx_attr_nodiscard
-cx_attr_export
-CxIterator cxMutIteratorPtr(
-        void *array,
-        size_t elem_count,
-        bool remove_keeps_order
-);
+CX_EXPORT CxIterator cxIteratorPtr(const void *array, size_t elem_count,
+        bool remove_keeps_order);
 
 #ifdef __cplusplus
 } // extern "C"

--- a/ucx/cx/json.h	Sun Oct 19 21:20:08 2025 +0200
+++ b/ucx/cx/json.h	Mon Nov 10 21:52:51 2025 +0100
@@ -475,8 +475,7 @@
  * @return new JSON writer settings
  */
 cx_attr_nodiscard
-cx_attr_export
-CxJsonWriter cxJsonWriterCompact(void);
+CX_EXPORT CxJsonWriter cxJsonWriterCompact(void);
 
 /**
  * Creates a default writer configuration for pretty output.
@@ -485,8 +484,7 @@
  * @return new JSON writer settings
  */
 cx_attr_nodiscard
-cx_attr_export
-CxJsonWriter cxJsonWriterPretty(bool use_spaces);
+CX_EXPORT CxJsonWriter cxJsonWriterPretty(bool use_spaces);
 
 /**
  * Writes a JSON value to a buffer or stream.
@@ -507,13 +505,8 @@
  * @retval non-zero when no or not all data could be written
  */
 cx_attr_nonnull_arg(1, 2, 3)
-cx_attr_export
-int cxJsonWrite(
-    void* target,
-    const CxJsonValue* value,
-    cx_write_func wfunc,
-    const CxJsonWriter* settings
-);
+CX_EXPORT int cxJsonWrite(void* target, const CxJsonValue* value,
+        cx_write_func wfunc, const CxJsonWriter* settings);
 
 /**
  * Initializes the JSON interface.
@@ -523,8 +516,7 @@
  * @see cxJsonDestroy()
  */
 cx_attr_nonnull_arg(1)
-cx_attr_export
-void cxJsonInit(CxJson *json, const CxAllocator *allocator);
+CX_EXPORT void cxJsonInit(CxJson *json, const CxAllocator *allocator);
 
 /**
  * Destroys the JSON interface.
@@ -533,8 +525,7 @@
  * @see cxJsonInit()
  */
 cx_attr_nonnull
-cx_attr_export
-void cxJsonDestroy(CxJson *json);
+CX_EXPORT void cxJsonDestroy(CxJson *json);
 
 /**
  * Destroys and re-initializes the JSON interface.
@@ -545,11 +536,7 @@
  * @param json the JSON interface
  */
 cx_attr_nonnull
-static inline void cxJsonReset(CxJson *json) {
-    const CxAllocator *allocator = json->allocator;
-    cxJsonDestroy(json);
-    cxJsonInit(json, allocator);
-}
+CX_EXPORT void cxJsonReset(CxJson *json);
 
 /**
  * Fills the input buffer.
@@ -569,10 +556,8 @@
  * @retval non-zero internal allocation error
  * @see cxJsonFill()
  */
-cx_attr_nonnull
-cx_attr_access_r(2, 3)
-cx_attr_export
-int cxJsonFilln(CxJson *json, const char *buf, size_t len);
+cx_attr_nonnull cx_attr_access_r(2, 3)
+CX_EXPORT int cxJsonFilln(CxJson *json, const char *buf, size_t len);
 
 
 /**
@@ -584,7 +569,7 @@
  * @retval non-zero internal allocation error
  */
 cx_attr_nonnull
-static inline int cx_json_fill(CxJson *json, cxstring str) {
+CX_INLINE int cx_json_fill(CxJson *json, cxstring str) {
     return cxJsonFilln(json, str.ptr, str.length);
 }
 
@@ -616,8 +601,7 @@
  * @see cxJsonArrAddValues()
  */
 cx_attr_nodiscard
-cx_attr_export
-CxJsonValue* cxJsonCreateObj(const CxAllocator* allocator);
+CX_EXPORT CxJsonValue* cxJsonCreateObj(const CxAllocator* allocator);
 
 /**
  * Creates a new (empty) JSON array.
@@ -628,8 +612,7 @@
  * @see cxJsonArrAddValues()
  */
 cx_attr_nodiscard
-cx_attr_export
-CxJsonValue* cxJsonCreateArr(const CxAllocator* allocator);
+CX_EXPORT CxJsonValue* cxJsonCreateArr(const CxAllocator* allocator);
 
 /**
  * Creates a new JSON number value.
@@ -641,8 +624,7 @@
  * @see cxJsonArrAddNumbers()
  */
 cx_attr_nodiscard
-cx_attr_export
-CxJsonValue* cxJsonCreateNumber(const CxAllocator* allocator, double num);
+CX_EXPORT CxJsonValue* cxJsonCreateNumber(const CxAllocator* allocator, double num);
 
 /**
  * Creates a new JSON number value based on an integer.
@@ -654,8 +636,7 @@
  * @see cxJsonArrAddIntegers()
  */
 cx_attr_nodiscard
-cx_attr_export
-CxJsonValue* cxJsonCreateInteger(const CxAllocator* allocator, int64_t num);
+CX_EXPORT CxJsonValue* cxJsonCreateInteger(const CxAllocator* allocator, int64_t num);
 
 /**
  * Creates a new JSON string.
@@ -667,11 +648,8 @@
  * @see cxJsonObjPutString()
  * @see cxJsonArrAddStrings()
  */
-cx_attr_nodiscard
-cx_attr_nonnull_arg(2)
-cx_attr_cstr_arg(2)
-cx_attr_export
-CxJsonValue* cxJsonCreateString(const CxAllocator* allocator, const char *str);
+cx_attr_nodiscard cx_attr_nonnull_arg(2) cx_attr_cstr_arg(2)
+CX_EXPORT CxJsonValue* cxJsonCreateString(const CxAllocator* allocator, const char *str);
 
 /**
  * Creates a new JSON string.
@@ -684,8 +662,7 @@
  * @see cxJsonArrAddCxStrings()
  */
 cx_attr_nodiscard
-cx_attr_export
-CxJsonValue* cxJsonCreateCxString(const CxAllocator* allocator, cxstring str);
+CX_EXPORT CxJsonValue* cxJsonCreateCxString(const CxAllocator* allocator, cxstring str);
 
 /**
  * Creates a new JSON literal.
@@ -697,8 +674,7 @@
  * @see cxJsonArrAddLiterals()
  */
 cx_attr_nodiscard
-cx_attr_export
-CxJsonValue* cxJsonCreateLiteral(const CxAllocator* allocator, CxJsonLiteral lit);
+CX_EXPORT CxJsonValue* cxJsonCreateLiteral(const CxAllocator* allocator, CxJsonLiteral lit);
 
 /**
  * Adds number values to a JSON array.
@@ -709,10 +685,8 @@
  * @retval zero success
  * @retval non-zero allocation failure
  */
-cx_attr_nonnull
-cx_attr_access_r(2, 3)
-cx_attr_export
-int cxJsonArrAddNumbers(CxJsonValue* arr, const double* num, size_t count);
+cx_attr_nonnull cx_attr_access_r(2, 3)
+CX_EXPORT int cxJsonArrAddNumbers(CxJsonValue* arr, const double* num, size_t count);
 
 /**
  * Adds number values, of which all are integers, to a JSON array.
@@ -723,10 +697,8 @@
  * @retval zero success
  * @retval non-zero allocation failure
  */
-cx_attr_nonnull
-cx_attr_access_r(2, 3)
-cx_attr_export
-int cxJsonArrAddIntegers(CxJsonValue* arr, const int64_t* num, size_t count);
+cx_attr_nonnull cx_attr_access_r(2, 3)
+CX_EXPORT int cxJsonArrAddIntegers(CxJsonValue* arr, const int64_t* num, size_t count);
 
 /**
  * Adds strings to a JSON array.
@@ -740,10 +712,8 @@
  * @retval non-zero allocation failure
  * @see cxJsonArrAddCxStrings()
  */
-cx_attr_nonnull
-cx_attr_access_r(2, 3)
-cx_attr_export
-int cxJsonArrAddStrings(CxJsonValue* arr, const char* const* str, size_t count);
+cx_attr_nonnull cx_attr_access_r(2, 3)
+CX_EXPORT int cxJsonArrAddStrings(CxJsonValue* arr, const char* const* str, size_t count);
 
 /**
  * Adds strings to a JSON array.
@@ -757,10 +727,8 @@
  * @retval non-zero allocation failure
  * @see cxJsonArrAddStrings()
  */
-cx_attr_nonnull
-cx_attr_access_r(2, 3)
-cx_attr_export
-int cxJsonArrAddCxStrings(CxJsonValue* arr, const cxstring* str, size_t count);
+cx_attr_nonnull cx_attr_access_r(2, 3)
+CX_EXPORT int cxJsonArrAddCxStrings(CxJsonValue* arr, const cxstring* str, size_t count);
 
 /**
  * Adds literals to a JSON array.
@@ -771,10 +739,8 @@
  * @retval zero success
  * @retval non-zero allocation failure
  */
-cx_attr_nonnull
-cx_attr_access_r(2, 3)
-cx_attr_export
-int cxJsonArrAddLiterals(CxJsonValue* arr, const CxJsonLiteral* lit, size_t count);
+cx_attr_nonnull cx_attr_access_r(2, 3)
+CX_EXPORT int cxJsonArrAddLiterals(CxJsonValue* arr, const CxJsonLiteral* lit, size_t count);
 
 /**
  * Add arbitrary values to a JSON array.
@@ -788,10 +754,8 @@
  * @retval zero success
  * @retval non-zero allocation failure
  */
-cx_attr_nonnull
-cx_attr_access_r(2, 3)
-cx_attr_export
-int cxJsonArrAddValues(CxJsonValue* arr, CxJsonValue* const* val, size_t count);
+cx_attr_nonnull cx_attr_access_r(2, 3)
+CX_EXPORT int cxJsonArrAddValues(CxJsonValue* arr, CxJsonValue* const* val, size_t count);
 
 /**
  * Adds or replaces a value within a JSON object.
@@ -808,8 +772,7 @@
  * @retval non-zero allocation failure
  */
 cx_attr_nonnull
-cx_attr_export
-int cxJsonObjPut(CxJsonValue* obj, cxstring name, CxJsonValue* child);
+CX_EXPORT int cxJsonObjPut(CxJsonValue* obj, cxstring name, CxJsonValue* child);
 
 /**
  * Creates a new JSON object and adds it to an existing object.
@@ -821,8 +784,7 @@
  * @see cxJsonCreateObj()
  */
 cx_attr_nonnull
-cx_attr_export
-CxJsonValue* cxJsonObjPutObj(CxJsonValue* obj, cxstring name);
+CX_EXPORT CxJsonValue* cxJsonObjPutObj(CxJsonValue* obj, cxstring name);
 
 /**
  * Creates a new JSON array and adds it to an object.
@@ -834,8 +796,7 @@
  * @see cxJsonCreateArr()
  */
 cx_attr_nonnull
-cx_attr_export
-CxJsonValue* cxJsonObjPutArr(CxJsonValue* obj, cxstring name);
+CX_EXPORT CxJsonValue* cxJsonObjPutArr(CxJsonValue* obj, cxstring name);
 
 /**
  * Creates a new JSON number and adds it to an object.
@@ -848,8 +809,7 @@
  * @see cxJsonCreateNumber()
  */
 cx_attr_nonnull
-cx_attr_export
-CxJsonValue* cxJsonObjPutNumber(CxJsonValue* obj, cxstring name, double num);
+CX_EXPORT CxJsonValue* cxJsonObjPutNumber(CxJsonValue* obj, cxstring name, double num);
 
 /**
  * Creates a new JSON number, based on an integer, and adds it to an object.
@@ -862,8 +822,7 @@
  * @see cxJsonCreateInteger()
  */
 cx_attr_nonnull
-cx_attr_export
-CxJsonValue* cxJsonObjPutInteger(CxJsonValue* obj, cxstring name, int64_t num);
+CX_EXPORT CxJsonValue* cxJsonObjPutInteger(CxJsonValue* obj, cxstring name, int64_t num);
 
 /**
  * Creates a new JSON string and adds it to an object.
@@ -877,10 +836,8 @@
  * @see cxJsonObjPut()
  * @see cxJsonCreateString()
  */
-cx_attr_nonnull
-cx_attr_cstr_arg(3)
-cx_attr_export
-CxJsonValue* cxJsonObjPutString(CxJsonValue* obj, cxstring name, const char* str);
+cx_attr_nonnull cx_attr_cstr_arg(3)
+CX_EXPORT CxJsonValue* cxJsonObjPutString(CxJsonValue* obj, cxstring name, const char* str);
 
 /**
  * Creates a new JSON string and adds it to an object.
@@ -895,8 +852,7 @@
  * @see cxJsonCreateCxString()
  */
 cx_attr_nonnull
-cx_attr_export
-CxJsonValue* cxJsonObjPutCxString(CxJsonValue* obj, cxstring name, cxstring str);
+CX_EXPORT CxJsonValue* cxJsonObjPutCxString(CxJsonValue* obj, cxstring name, cxstring str);
 
 /**
  * Creates a new JSON literal and adds it to an object.
@@ -909,8 +865,7 @@
  * @see cxJsonCreateLiteral()
  */
 cx_attr_nonnull
-cx_attr_export
-CxJsonValue* cxJsonObjPutLiteral(CxJsonValue* obj, cxstring name, CxJsonLiteral lit);
+CX_EXPORT CxJsonValue* cxJsonObjPutLiteral(CxJsonValue* obj, cxstring name, CxJsonLiteral lit);
 
 /**
  * Recursively deallocates the memory of a JSON value.
@@ -923,8 +878,7 @@
  *
  * @param value the value
  */
-cx_attr_export
-void cxJsonValueFree(CxJsonValue *value);
+CX_EXPORT void cxJsonValueFree(CxJsonValue *value);
 
 /**
  * Tries to obtain the next JSON value.
@@ -948,10 +902,8 @@
  * @retval CX_JSON_FORMAT_ERROR_NUMBER the JSON text contains an illegally formatted number
  * @retval CX_JSON_FORMAT_ERROR_UNEXPECTED_TOKEN JSON syntax error
  */
-cx_attr_nonnull
-cx_attr_access_w(2)
-cx_attr_export
-CxJsonStatus cxJsonNext(CxJson *json, CxJsonValue **value);
+cx_attr_nonnull cx_attr_access_w(2)
+CX_EXPORT CxJsonStatus cxJsonNext(CxJson *json, CxJsonValue **value);
 
 /**
  * Checks if the specified value is a JSON object.
@@ -961,7 +913,7 @@
  * @retval false otherwise
  */
 cx_attr_nonnull
-static inline bool cxJsonIsObject(const CxJsonValue *value) {
+CX_INLINE bool cxJsonIsObject(const CxJsonValue *value) {
     return value->type == CX_JSON_OBJECT;
 }
 
@@ -973,7 +925,7 @@
  * @retval false otherwise
  */
 cx_attr_nonnull
-static inline bool cxJsonIsArray(const CxJsonValue *value) {
+CX_INLINE bool cxJsonIsArray(const CxJsonValue *value) {
     return value->type == CX_JSON_ARRAY;
 }
 
@@ -985,7 +937,7 @@
  * @retval false otherwise
  */
 cx_attr_nonnull
-static inline bool cxJsonIsString(const CxJsonValue *value) {
+CX_INLINE bool cxJsonIsString(const CxJsonValue *value) {
     return value->type == CX_JSON_STRING;
 }
 
@@ -1001,7 +953,7 @@
  * @see cxJsonIsInteger()
  */
 cx_attr_nonnull
-static inline bool cxJsonIsNumber(const CxJsonValue *value) {
+CX_INLINE bool cxJsonIsNumber(const CxJsonValue *value) {
     return value->type == CX_JSON_NUMBER || value->type == CX_JSON_INTEGER;
 }
 
@@ -1014,7 +966,7 @@
  * @see cxJsonIsNumber()
  */
 cx_attr_nonnull
-static inline bool cxJsonIsInteger(const CxJsonValue *value) {
+CX_INLINE bool cxJsonIsInteger(const CxJsonValue *value) {
     return value->type == CX_JSON_INTEGER;
 }
 
@@ -1031,7 +983,7 @@
  * @see cxJsonIsNull()
  */
 cx_attr_nonnull
-static inline bool cxJsonIsLiteral(const CxJsonValue *value) {
+CX_INLINE bool cxJsonIsLiteral(const CxJsonValue *value) {
     return value->type == CX_JSON_LITERAL;
 }
 
@@ -1045,7 +997,7 @@
  * @see cxJsonIsFalse()
  */
 cx_attr_nonnull
-static inline bool cxJsonIsBool(const CxJsonValue *value) {
+CX_INLINE bool cxJsonIsBool(const CxJsonValue *value) {
     return cxJsonIsLiteral(value) && value->value.literal != CX_JSON_NULL;
 }
 
@@ -1062,7 +1014,7 @@
  * @see cxJsonIsFalse()
  */
 cx_attr_nonnull
-static inline bool cxJsonIsTrue(const CxJsonValue *value) {
+CX_INLINE bool cxJsonIsTrue(const CxJsonValue *value) {
     return cxJsonIsLiteral(value) && value->value.literal == CX_JSON_TRUE;
 }
 
@@ -1079,7 +1031,7 @@
  * @see cxJsonIsTrue()
  */
 cx_attr_nonnull
-static inline bool cxJsonIsFalse(const CxJsonValue *value) {
+CX_INLINE bool cxJsonIsFalse(const CxJsonValue *value) {
     return cxJsonIsLiteral(value) && value->value.literal == CX_JSON_FALSE;
 }
 
@@ -1092,7 +1044,7 @@
  * @see cxJsonIsLiteral()
  */
 cx_attr_nonnull
-static inline bool cxJsonIsNull(const CxJsonValue *value) {
+CX_INLINE bool cxJsonIsNull(const CxJsonValue *value) {
     return cxJsonIsLiteral(value) && value->value.literal == CX_JSON_NULL;
 }
 
@@ -1105,11 +1057,8 @@
  * @return the value represented as C string
  * @see cxJsonIsString()
  */
-cx_attr_nonnull
-cx_attr_returns_nonnull
-static inline char *cxJsonAsString(const CxJsonValue *value) {
-    return value->value.string.ptr;
-}
+cx_attr_nonnull  cx_attr_returns_nonnull
+CX_EXPORT char *cxJsonAsString(const CxJsonValue *value);
 
 /**
  * Obtains a UCX string from the given JSON value.
@@ -1121,9 +1070,7 @@
  * @see cxJsonIsString()
  */
 cx_attr_nonnull
-static inline cxstring cxJsonAsCxString(const CxJsonValue *value) {
-    return cx_strcast(value->value.string);
-}
+CX_EXPORT cxstring cxJsonAsCxString(const CxJsonValue *value);
 
 /**
  * Obtains a mutable UCX string from the given JSON value.
@@ -1135,9 +1082,7 @@
  * @see cxJsonIsString()
  */
 cx_attr_nonnull
-static inline cxmutstr cxJsonAsCxMutStr(const CxJsonValue *value) {
-    return value->value.string;
-}
+CX_EXPORT cxmutstr cxJsonAsCxMutStr(const CxJsonValue *value);
 
 /**
  * Obtains a double-precision floating-point value from the given JSON value.
@@ -1149,13 +1094,7 @@
  * @see cxJsonIsNumber()
  */
 cx_attr_nonnull
-static inline double cxJsonAsDouble(const CxJsonValue *value) {
-    if (value->type == CX_JSON_INTEGER) {
-        return (double) value->value.integer;
-    } else {
-        return value->value.number;
-    }
-}
+CX_EXPORT double cxJsonAsDouble(const CxJsonValue *value);
 
 /**
  * Obtains a 64-bit signed integer from the given JSON value.
@@ -1170,13 +1109,7 @@
  * @see cxJsonIsInteger()
  */
 cx_attr_nonnull
-static inline int64_t cxJsonAsInteger(const CxJsonValue *value) {
-    if (value->type == CX_JSON_INTEGER) {
-        return value->value.integer;
-    } else {
-        return (int64_t) value->value.number;
-    }
-}
+CX_EXPORT int64_t cxJsonAsInteger(const CxJsonValue *value);
 
 /**
  * Obtains a Boolean value from the given JSON value.
@@ -1189,7 +1122,7 @@
  * @see cxJsonIsLiteral()
  */
 cx_attr_nonnull
-static inline bool cxJsonAsBool(const CxJsonValue *value) {
+CX_INLINE bool cxJsonAsBool(const CxJsonValue *value) {
     return value->value.literal == CX_JSON_TRUE;
 }
 
@@ -1203,7 +1136,7 @@
  * @see cxJsonIsArray()
  */
 cx_attr_nonnull
-static inline size_t cxJsonArrSize(const CxJsonValue *value) {
+CX_INLINE size_t cxJsonArrSize(const CxJsonValue *value) {
     return value->value.array.array_size;
 }
 
@@ -1221,10 +1154,8 @@
  * @return the value at the specified index
  * @see cxJsonIsArray()
  */
-cx_attr_nonnull
-cx_attr_returns_nonnull
-cx_attr_export
-CxJsonValue *cxJsonArrGet(const CxJsonValue *value, size_t index);
+cx_attr_nonnull cx_attr_returns_nonnull
+CX_EXPORT CxJsonValue *cxJsonArrGet(const CxJsonValue *value, size_t index);
 
 /**
  * Removes an element from a JSON array.
@@ -1240,8 +1171,7 @@
  * @see cxJsonIsArray()
  */
 cx_attr_nonnull
-cx_attr_export
-CxJsonValue *cxJsonArrRemove(CxJsonValue *value, size_t index);
+CX_EXPORT CxJsonValue *cxJsonArrRemove(CxJsonValue *value, size_t index);
 
 /**
  * Returns an iterator over the JSON array elements.
@@ -1254,10 +1184,8 @@
  * @return an iterator over the array elements
  * @see cxJsonIsArray()
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-CxIterator cxJsonArrIter(const CxJsonValue *value);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT CxIterator cxJsonArrIter(const CxJsonValue *value);
 
 /**
  * Returns an iterator over the JSON object members.
@@ -1271,10 +1199,8 @@
  * @return an iterator over the object members
  * @see cxJsonIsObject()
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-CxIterator cxJsonObjIter(const CxJsonValue *value);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT CxIterator cxJsonObjIter(const CxJsonValue *value);
 
 /**
  * Internal function, do not use.
@@ -1282,10 +1208,8 @@
  * @param name the key to look up
  * @return the value corresponding to the key
  */
-cx_attr_nonnull
-cx_attr_returns_nonnull
-cx_attr_export
-CxJsonValue *cx_json_obj_get(const CxJsonValue *value, cxstring name);
+cx_attr_nonnull cx_attr_returns_nonnull
+CX_EXPORT CxJsonValue *cx_json_obj_get(const CxJsonValue *value, cxstring name);
 
 /**
  * Returns a value corresponding to a key in a JSON object.
@@ -1310,8 +1234,7 @@
  * @return the value corresponding to the key or @c NULL when the key is not part of the object
  */
 cx_attr_nonnull
-cx_attr_export
-CxJsonValue *cx_json_obj_remove(CxJsonValue *value, cxstring name);
+CX_EXPORT CxJsonValue *cx_json_obj_remove(CxJsonValue *value, cxstring name);
 
 /**
  * Removes and returns a value corresponding to a key in a JSON object.

--- a/ucx/cx/kv_list.h	Sun Oct 19 21:20:08 2025 +0200
+++ b/ucx/cx/kv_list.h	Mon Nov 10 21:52:51 2025 +0100
@@ -66,15 +66,9 @@
  * @see cxKvListAsMap()
  * @see cxKvListAsList()
  */
-cx_attr_nodiscard
-cx_attr_malloc
-cx_attr_dealloc(cxListFree, 1)
-cx_attr_export
-CxList *cxKvListCreate(
-        const CxAllocator *allocator,
-        cx_compare_func comparator,
-        size_t elem_size
-);
+cx_attr_nodiscard cx_attr_malloc cx_attr_dealloc(cxListFree, 1)
+CX_EXPORT CxList *cxKvListCreate(const CxAllocator *allocator,
+        cx_compare_func comparator, size_t elem_size);
 
 /**
  * Allocates a linked list with a lookup-map for storing elements with @p elem_size bytes each.
@@ -97,15 +91,9 @@
  * @see cxKvListAsMap()
  * @see cxKvListAsList()
  */
-cx_attr_nodiscard
-cx_attr_malloc
-cx_attr_dealloc(cxMapFree, 1)
-cx_attr_export
-CxMap *cxKvListCreateAsMap(
-        const CxAllocator *allocator,
-        cx_compare_func comparator,
-        size_t elem_size
-);
+cx_attr_nodiscard cx_attr_malloc cx_attr_dealloc(cxMapFree, 1)
+CX_EXPORT CxMap *cxKvListCreateAsMap(const CxAllocator *allocator,
+        cx_compare_func comparator, size_t elem_size);
 
 /**
  * Allocates a linked list with a lookup-map for storing elements with @p elem_size bytes each.
@@ -158,11 +146,8 @@
  * @param map a map pointer that was returned by a call to cxKvListAsMap()
  * @return the original list pointer
  */
-cx_attr_nodiscard
-cx_attr_nonnull
-cx_attr_returns_nonnull
-cx_attr_export
-CxList *cxKvListAsList(CxMap *map);
+cx_attr_nodiscard cx_attr_nonnull cx_attr_returns_nonnull
+CX_EXPORT CxList *cxKvListAsList(CxMap *map);
 
 /**
  * Converts a map pointer belonging to a key-value-List back to the original list pointer.
@@ -170,11 +155,8 @@
  * @param list a list created by cxKvListCreate() or cxKvListCreateSimple()
  * @return a map pointer that lets you use the list as if it was a map
  */
-cx_attr_nodiscard
-cx_attr_nonnull
-cx_attr_returns_nonnull
-cx_attr_export
-CxMap *cxKvListAsMap(CxList *list);
+cx_attr_nodiscard cx_attr_nonnull cx_attr_returns_nonnull
+CX_EXPORT CxMap *cxKvListAsMap(CxList *list);
 
 /**
  * Sets or updates the key of a list item.
@@ -190,8 +172,7 @@
  * @see cxKvListSetKey()
  */
 cx_attr_nonnull
-cx_attr_export
-int cx_kv_list_set_key(CxList *list, size_t index, CxHashKey key);
+CX_EXPORT int cx_kv_list_set_key(CxList *list, size_t index, CxHashKey key);
 
 /**
  * Inserts an item into the list at the specified index and associates it with the specified key.
@@ -205,8 +186,7 @@
  * @see cxKvListInsert()
  */
 cx_attr_nonnull
-cx_attr_export
-int cx_kv_list_insert(CxList *list, size_t index, CxHashKey key, void *value);
+CX_EXPORT int cx_kv_list_insert(CxList *list, size_t index, CxHashKey key, void *value);
 
 /**
  * Sets or updates the key of a list item.
@@ -250,8 +230,7 @@
  * @retval non-zero the index is out of bounds
  */
 cx_attr_nonnull
-cx_attr_export
-int cxKvListRemoveKey(CxList *list, size_t index);
+CX_EXPORT int cxKvListRemoveKey(CxList *list, size_t index);
 
 /**
  * Returns the key of a list item.
@@ -261,8 +240,7 @@
  * @return a pointer to the key or @c NULL when the index is out of bounds or the item does not have a key
  */
 cx_attr_nonnull
-cx_attr_export
-const CxHashKey *cxKvListGetKey(CxList *list, size_t index);
+CX_EXPORT const CxHashKey *cxKvListGetKey(CxList *list, size_t index);
 
 /**
  * Adds an item into the list and associates it with the specified key.

--- a/ucx/cx/linked_list.h	Sun Oct 19 21:20:08 2025 +0200
+++ b/ucx/cx/linked_list.h	Mon Nov 10 21:52:51 2025 +0100
@@ -90,15 +90,9 @@
  * @param elem_size the size of each element in bytes
  * @return the created list
  */
-cx_attr_nodiscard
-cx_attr_malloc
-cx_attr_dealloc(cxListFree, 1)
-cx_attr_export
-CxList *cxLinkedListCreate(
-        const CxAllocator *allocator,
-        cx_compare_func comparator,
-        size_t elem_size
-);
+cx_attr_nodiscard cx_attr_malloc cx_attr_dealloc(cxListFree, 1)
+CX_EXPORT CxList *cxLinkedListCreate(const CxAllocator *allocator,
+        cx_compare_func comparator, size_t elem_size);
 
 /**
  * Allocates a linked list for storing elements with @p elem_size bytes each.
@@ -115,7 +109,7 @@
  * @return (@c CxList*) the created list
  */
 #define cxLinkedListCreateSimple(elem_size) \
-    cxLinkedListCreate(NULL, NULL, elem_size)
+        cxLinkedListCreate(NULL, NULL, elem_size)
 
 /**
  * Finds the node at a certain index.
@@ -134,15 +128,9 @@
  * @param index the search index
  * @return the node found at the specified index
  */
-cx_attr_nonnull
-cx_attr_nodiscard
-cx_attr_export
-void *cx_linked_list_at(
-        const void *start,
-        size_t start_index,
-        ptrdiff_t loc_advance,
-        size_t index
-);
+cx_attr_nonnull cx_attr_nodiscard
+CX_EXPORT void *cx_linked_list_at(const void *start,size_t start_index,
+        ptrdiff_t loc_advance, size_t index);
 
 /**
  * Finds the node containing an element within a linked list.
@@ -157,15 +145,9 @@
  * @return a pointer to the found node or @c NULL if no matching node was found
  */
 cx_attr_nonnull_arg(1, 4, 5)
-cx_attr_export
-void *cx_linked_list_find(
-        const void *start,
-        ptrdiff_t loc_advance,
-        ptrdiff_t loc_data,
-        cx_compare_func cmp_func,
-        const void *elem,
-        size_t *found_index
-);
+CX_EXPORT void *cx_linked_list_find(const void *start, ptrdiff_t loc_advance,
+        ptrdiff_t loc_data, cx_compare_func cmp_func, const void *elem,
+        size_t *found_index);
 
 /**
  * Finds the first node in a linked list.
@@ -178,13 +160,8 @@
  * @param loc_prev the location of the @c prev pointer
  * @return a pointer to the first node
  */
-cx_attr_nonnull
-cx_attr_returns_nonnull
-cx_attr_export
-void *cx_linked_list_first(
-        const void *node,
-        ptrdiff_t loc_prev
-);
+cx_attr_nonnull cx_attr_returns_nonnull
+CX_EXPORT void *cx_linked_list_first(const void *node, ptrdiff_t loc_prev);
 
 /**
  * Finds the last node in a linked list.
@@ -197,13 +174,8 @@
  * @param loc_next the location of the @c next pointer
  * @return a pointer to the last node
  */
-cx_attr_nonnull
-cx_attr_returns_nonnull
-cx_attr_export
-void *cx_linked_list_last(
-        const void *node,
-        ptrdiff_t loc_next
-);
+cx_attr_nonnull cx_attr_returns_nonnull
+CX_EXPORT void *cx_linked_list_last(const void *node, ptrdiff_t loc_next);
 
 /**
  * Finds the predecessor of a node in case it is not linked.
@@ -216,12 +188,7 @@
  * @return the node or @c NULL if @p node has no predecessor
  */
 cx_attr_nonnull
-cx_attr_export
-void *cx_linked_list_prev(
-        const void *begin,
-        ptrdiff_t loc_next,
-        const void *node
-);
+CX_EXPORT void *cx_linked_list_prev(const void *begin, ptrdiff_t loc_next, const void *node);
 
 /**
  * Adds a new node to a linked list.
@@ -236,14 +203,7 @@
  * @param new_node a pointer to the node that shall be appended
  */
 cx_attr_nonnull_arg(5)
-cx_attr_export
-void cx_linked_list_add(
-        void **begin,
-        void **end,
-        ptrdiff_t loc_prev,
-        ptrdiff_t loc_next,
-        void *new_node
-);
+CX_EXPORT void cx_linked_list_add(void **begin, void **end, ptrdiff_t loc_prev, ptrdiff_t loc_next, void *new_node);
 
 /**
  * Prepends a new node to a linked list.
@@ -258,14 +218,7 @@
  * @param new_node a pointer to the node that shall be prepended
  */
 cx_attr_nonnull_arg(5)
-cx_attr_export
-void cx_linked_list_prepend(
-        void **begin,
-        void **end,
-        ptrdiff_t loc_prev,
-        ptrdiff_t loc_next,
-        void *new_node
-);
+CX_EXPORT void cx_linked_list_prepend(void **begin, void **end, ptrdiff_t loc_prev, ptrdiff_t loc_next, void *new_node);
 
 /**
  * Links two nodes.
@@ -276,13 +229,7 @@
  * @param loc_next the location of a @c next pointer within your node struct (required)
  */
 cx_attr_nonnull
-cx_attr_export
-void cx_linked_list_link(
-        void *left,
-        void *right,
-        ptrdiff_t loc_prev,
-        ptrdiff_t loc_next
-);
+CX_EXPORT void cx_linked_list_link(void *left, void *right, ptrdiff_t loc_prev, ptrdiff_t loc_next);
 
 /**
  * Unlinks two nodes.
@@ -295,13 +242,7 @@
  * @param loc_next the location of a @c next pointer within your node struct (required)
  */
 cx_attr_nonnull
-cx_attr_export
-void cx_linked_list_unlink(
-        void *left,
-        void *right,
-        ptrdiff_t loc_prev,
-        ptrdiff_t loc_next
-);
+CX_EXPORT void cx_linked_list_unlink(void *left, void *right, ptrdiff_t loc_prev, ptrdiff_t loc_next);
 
 /**
  * Inserts a new node after a given node of a linked list.
@@ -318,15 +259,8 @@
  * @param new_node a pointer to the node that shall be inserted
  */
 cx_attr_nonnull_arg(6)
-cx_attr_export
-void cx_linked_list_insert(
-        void **begin,
-        void **end,
-        ptrdiff_t loc_prev,
-        ptrdiff_t loc_next,
-        void *node,
-        void *new_node
-);
+CX_EXPORT void cx_linked_list_insert(void **begin, void **end,
+        ptrdiff_t loc_prev, ptrdiff_t loc_next, void *node, void *new_node);
 
 /**
  * Inserts a chain of nodes after a given node of a linked list.
@@ -349,16 +283,8 @@
  * @param insert_end a pointer to the last node of the chain (or NULL if the last node shall be determined)
  */
 cx_attr_nonnull_arg(6)
-cx_attr_export
-void cx_linked_list_insert_chain(
-        void **begin,
-        void **end,
-        ptrdiff_t loc_prev,
-        ptrdiff_t loc_next,
-        void *node,
-        void *insert_begin,
-        void *insert_end
-);
+CX_EXPORT void cx_linked_list_insert_chain(void **begin, void **end,
+        ptrdiff_t loc_prev, ptrdiff_t loc_next, void *node, void *insert_begin, void *insert_end);
 
 /**
  * Inserts a node into a sorted linked list.
@@ -375,15 +301,8 @@
  * @param cmp_func a compare function that will receive the node pointers
  */
 cx_attr_nonnull_arg(1, 5, 6)
-cx_attr_export
-void cx_linked_list_insert_sorted(
-        void **begin,
-        void **end,
-        ptrdiff_t loc_prev,
-        ptrdiff_t loc_next,
-        void *new_node,
-        cx_compare_func cmp_func
-);
+CX_EXPORT void cx_linked_list_insert_sorted(void **begin, void **end,
+        ptrdiff_t loc_prev, ptrdiff_t loc_next, void *new_node, cx_compare_func cmp_func);
 
 /**
  * Inserts a chain of nodes into a sorted linked list.
@@ -405,15 +324,8 @@
  * @param cmp_func a compare function that will receive the node pointers
  */
 cx_attr_nonnull_arg(1, 5, 6)
-cx_attr_export
-void cx_linked_list_insert_sorted_chain(
-        void **begin,
-        void **end,
-        ptrdiff_t loc_prev,
-        ptrdiff_t loc_next,
-        void *insert_begin,
-        cx_compare_func cmp_func
-);
+CX_EXPORT void cx_linked_list_insert_sorted_chain(void **begin, void **end,
+        ptrdiff_t loc_prev, ptrdiff_t loc_next, void *insert_begin, cx_compare_func cmp_func);
 
 /**
  * Inserts a node into a sorted linked list if no other node with the same value already exists.
@@ -432,15 +344,8 @@
  * @retval non-zero when a node with the same value already exists
  */
 cx_attr_nonnull_arg(1, 5, 6)
-cx_attr_export
-int cx_linked_list_insert_unique(
-        void **begin,
-        void **end,
-        ptrdiff_t loc_prev,
-        ptrdiff_t loc_next,
-        void *new_node,
-        cx_compare_func cmp_func
-);
+CX_EXPORT int cx_linked_list_insert_unique(void **begin, void **end,
+        ptrdiff_t loc_prev, ptrdiff_t loc_next, void *new_node, cx_compare_func cmp_func);
 
 /**
  * Inserts a chain of nodes into a sorted linked list, avoiding duplicates.
@@ -460,17 +365,9 @@
  * @param cmp_func a compare function that will receive the node pointers
  * @return a pointer to a new chain with all duplicates that were not inserted (or @c NULL when there were no duplicates)
  */
-cx_attr_nonnull_arg(1, 5, 6)
-cx_attr_nodiscard
-cx_attr_export
-void *cx_linked_list_insert_unique_chain(
-        void **begin,
-        void **end,
-        ptrdiff_t loc_prev,
-        ptrdiff_t loc_next,
-        void *insert_begin,
-        cx_compare_func cmp_func
-);
+cx_attr_nonnull_arg(1, 5, 6) cx_attr_nodiscard
+CX_EXPORT void *cx_linked_list_insert_unique_chain(void **begin, void **end,
+        ptrdiff_t loc_prev, ptrdiff_t loc_next, void *insert_begin, cx_compare_func cmp_func);
 
 /**
  * Removes a chain of nodes from the linked list.
@@ -494,15 +391,8 @@
  * @return the actual number of nodes that were removed (can be less when the list did not have enough nodes)
  */
 cx_attr_nonnull_arg(5)
-cx_attr_export
-size_t cx_linked_list_remove_chain(
-        void **begin,
-        void **end,
-        ptrdiff_t loc_prev,
-        ptrdiff_t loc_next,
-        void *node,
-        size_t num
-);
+CX_EXPORT size_t cx_linked_list_remove_chain(void **begin, void **end,
+        ptrdiff_t loc_prev, ptrdiff_t loc_next, void *node, size_t num);
 
 /**
  * Removes a node from the linked list.
@@ -524,15 +414,8 @@
  * @param node the node to remove
  */
 cx_attr_nonnull_arg(5)
-static inline void cx_linked_list_remove(
-        void **begin,
-        void **end,
-        ptrdiff_t loc_prev,
-        ptrdiff_t loc_next,
-        void *node
-) {
-    cx_linked_list_remove_chain(begin, end, loc_prev, loc_next, node, 1);
-}
+CX_EXPORT void cx_linked_list_remove(void **begin, void **end,
+        ptrdiff_t loc_prev, ptrdiff_t loc_next, void *node);
 
 /**
  * Determines the size of a linked list starting with @p node.
@@ -542,11 +425,7 @@
  * @return the size of the list or zero if @p node is @c NULL
  */
 cx_attr_nodiscard
-cx_attr_export
-size_t cx_linked_list_size(
-        const void *node,
-        ptrdiff_t loc_next
-);
+CX_EXPORT size_t cx_linked_list_size(const void *node, ptrdiff_t loc_next);
 
 /**
  * Sorts a linked list based on a comparison function.
@@ -571,15 +450,8 @@
  * @param cmp_func the compare function defining the sort order
  */
 cx_attr_nonnull_arg(1, 6)
-cx_attr_export
-void cx_linked_list_sort(
-        void **begin,
-        void **end,
-        ptrdiff_t loc_prev,
-        ptrdiff_t loc_next,
-        ptrdiff_t loc_data,
-        cx_compare_func cmp_func
-);
+CX_EXPORT void cx_linked_list_sort(void **begin, void **end,
+        ptrdiff_t loc_prev, ptrdiff_t loc_next, ptrdiff_t loc_data, cx_compare_func cmp_func);
 
 
 /**
@@ -596,14 +468,8 @@
  * right list, positive if the left list is larger than the right list, zero if both lists are equal.
  */
 cx_attr_nonnull_arg(5)
-cx_attr_export
-int cx_linked_list_compare(
-        const void *begin_left,
-        const void *begin_right,
-        ptrdiff_t loc_advance,
-        ptrdiff_t loc_data,
-        cx_compare_func cmp_func
-);
+CX_EXPORT int cx_linked_list_compare(const void *begin_left, const void *begin_right,
+        ptrdiff_t loc_advance, ptrdiff_t loc_data, cx_compare_func cmp_func);
 
 /**
  * Reverses the order of the nodes in a linked list.
@@ -614,13 +480,7 @@
  * @param loc_next the location of a @c next pointer within your node struct (required)
  */
 cx_attr_nonnull_arg(1)
-cx_attr_export
-void cx_linked_list_reverse(
-        void **begin,
-        void **end,
-        ptrdiff_t loc_prev,
-        ptrdiff_t loc_next
-);
+CX_EXPORT void cx_linked_list_reverse(void **begin, void **end, ptrdiff_t loc_prev, ptrdiff_t loc_next);
 
 #ifdef __cplusplus
 } // extern "C"