aboutsummaryrefslogtreecommitdiff
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/alloc/alloc_arena.c22
-rw-r--r--lib/alloc/alloc_heap.c31
-rw-r--r--lib/alloc/arena_alloc.c155
-rw-r--r--lib/alloc/arena_free.c20
-rw-r--r--lib/alloc/arena_realloc.c62
-rw-r--r--lib/alloc/arena_zero.c15
-rw-r--r--lib/alloc/bufalloc.c10
-rw-r--r--lib/alloc/bufalloc_noterm.c16
-rw-r--r--lib/alloc/heap_alloc.c76
-rw-r--r--lib/alloc/static_scratch_alloc.c44
-rw-r--r--lib/array/array_free.c12
-rw-r--r--lib/array/array_new.c29
-rw-r--r--lib/array/array_resz.c28
-rw-r--r--lib/unicode/string/u8casefold.c9
-rw-r--r--lib/unicode/string/u8lower.c9
-rw-r--r--lib/unicode/string/u8norm.c41
-rw-r--r--lib/unicode/string/u8title.c9
-rw-r--r--lib/unicode/string/u8upper.c9
18 files changed, 333 insertions, 264 deletions
diff --git a/lib/alloc/alloc_arena.c b/lib/alloc/alloc_arena.c
deleted file mode 100644
index 8d2aa11..0000000
--- a/lib/alloc/alloc_arena.c
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <stdlib.h>
-
-#include "alloc.h"
-#include "errors.h"
-#include "macros.h"
-
-void *
-alloc_arena(void *raw_ctx, void *ptr, size_t old, size_t new, size_t elemsz,
- size_t align)
-{
- struct arena_ctx *ctx = raw_ctx;
- ASSUME(ctx != nullptr);
- ASSUME(ctx->a != nullptr);
-
- void *p = arena_realloc(ctx->a, ptr, old, new, elemsz, align);
- if (new == 0 || p != nullptr)
- return p;
-
- if (ctx->jmp != nullptr)
- longjmp(*ctx->jmp, 1);
- err("arena_realloc:");
-}
diff --git a/lib/alloc/alloc_heap.c b/lib/alloc/alloc_heap.c
deleted file mode 100644
index fccfcfc..0000000
--- a/lib/alloc/alloc_heap.c
+++ /dev/null
@@ -1,31 +0,0 @@
-#include <errno.h>
-#include <setjmp.h>
-#include <stdckdint.h>
-#include <stddef.h>
-#include <stdlib.h>
-
-#include "alloc.h"
-#include "errors.h"
-
-void *
-alloc_heap(void *raw_ctx, void *ptr, size_t, size_t new, size_t elemsz, size_t)
-{
- if (new == 0) {
- free(ptr);
- return nullptr;
- }
-
- if (!ckd_mul(&new, new, elemsz)) {
- void *p = realloc(ptr, new);
- if (p != nullptr)
- return p;
- } else
- errno = EOVERFLOW;
-
- struct heap_ctx *ctx = raw_ctx;
- if (ctx == nullptr || ctx->jmp == nullptr)
- err("realloc:");
-
- longjmp(*ctx->jmp, 1);
- unreachable();
-}
diff --git a/lib/alloc/arena_alloc.c b/lib/alloc/arena_alloc.c
index 65123d4..d953423 100644
--- a/lib/alloc/arena_alloc.c
+++ b/lib/alloc/arena_alloc.c
@@ -1,80 +1,137 @@
+/* TODO: Support malloc() backend for systems without MAP_ANONYMOUS */
+
#include <sys/mman.h>
#include <errno.h>
+#include <setjmp.h>
#include <stdckdint.h>
-#include <stdlib.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
#include "_attrs.h"
+#include "_charN_t.h"
#include "alloc.h"
+#include "error.h"
#include "macros.h"
-#define IS_POW_2(n) ((n) != 0 && ((n) & ((n) - 1)) == 0)
+#define PAD(len, align) (((len) + (align) - 1) & ~((align) - 1))
-[[_mlib_pure, _mlib_inline]] static size_t pad(size_t, size_t);
-static struct _region *mkregion(size_t);
+struct arena_blk {
+ char8_t *head, *tail, *fngr;
+ struct arena_blk *next;
+};
-size_t
-pad(size_t len, size_t align)
-{
- return (len + align - 1) & ~(align - 1);
-}
+static void *alloc(allocator_t mem, ptrdiff_t nmemb, ptrdiff_t elemsz,
+ ptrdiff_t align);
+static void freeall(allocator_t mem);
+static arena_blk_t *mkblk(ptrdiff_t blksz);
+[[noreturn]] static void errjmp(jmp_buf *env);
-struct _region *
-mkregion(size_t cap)
+void *
+arena_alloc(allocator_t mem, alloc_mode_t mode, void *ptr, ptrdiff_t oldnmemb,
+ ptrdiff_t newnmemb, ptrdiff_t elemsz, ptrdiff_t align)
{
- struct _region *r = malloc(sizeof(struct _region));
- if (r == nullptr)
+ (void)ptr;
+ (void)oldnmemb;
+ switch (mode) {
+ case ALLOC_NEW:
+ return alloc(mem, newnmemb, elemsz, align);
+ case ALLOC_RESIZE:
+ /* TODO: Make this more efficient */
+ void *p = alloc(mem, newnmemb, elemsz, align);
+ memcpy(p, ptr, MIN(oldnmemb, newnmemb) * elemsz);
+ return p;
+ case ALLOC_FREE:
+ /* TODO: Allow freeing the very last allocation */
return nullptr;
- *r = (struct _region){
- .cap = cap,
- .data = mmap(nullptr, cap, PROT_READ | PROT_WRITE,
- MAP_PRIVATE | MAP_ANONYMOUS, -1, 0),
- };
- if (r->data == MAP_FAILED) {
- int save = errno;
- free(r);
- errno = save;
+ case ALLOC_FREEALL:
+ freeall(mem);
return nullptr;
+ default:
+ unreachable();
}
- r->last = r->data;
- return r;
}
void *
-arena_alloc(arena *a, size_t sz, size_t n, size_t align)
+alloc(allocator_t mem, ptrdiff_t nmemb, ptrdiff_t elemsz, ptrdiff_t align)
{
- ASSUME(a != nullptr);
- ASSUME(IS_POW_2(align));
+ arena_ctx_t *ctx = mem.ctx;
+ if (ctx->blksz == 0) {
+ long blksz = sysconf(_SC_PAGESIZE);
+ if (blksz == -1)
+ errjmp(mem.err);
+ ctx->blksz = blksz;
+ }
- if (ckd_mul(&sz, sz, n)) {
+ ptrdiff_t bufsz;
+ if (ckd_mul(&bufsz, nmemb, elemsz)) {
errno = EOVERFLOW;
- return nullptr;
+ errjmp(mem.err);
}
- for (struct _region *r = a->_head; r != nullptr; r = r->next) {
- size_t nlen, off = pad(r->len, align);
+ for (arena_blk_t *blk = ctx->_head; blk != nullptr; blk = blk->next) {
+ ptrdiff_t nbufsz, off = PAD((uintptr_t)blk->fngr, align);
+ if (ckd_add(&nbufsz, bufsz, off))
+ continue;
- /* Technically there are other ways to solve this… but at this point you
- might as well just fail */
- if (ckd_add(&nlen, off, sz)) {
- errno = EOVERFLOW;
- return nullptr;
+ if (blk->tail - blk->fngr >= nbufsz) {
+ void *p = blk->fngr + off;
+ blk->fngr += nbufsz;
+ return p;
}
+ }
- if (nlen <= r->cap) {
- void *ret = (char *)r->data + off;
- r->len = nlen;
- r->last = ret;
- return ret;
- }
+ /* No page exists that is large enough for our allocation */
+ ptrdiff_t padding = PAD(sizeof(arena_blk_t), align);
+
+ if (ckd_add(&bufsz, bufsz, sizeof(arena_blk_t))
+ || ckd_add(&bufsz, bufsz, padding))
+ {
+ errno = EOVERFLOW;
+ errjmp(mem.err);
}
+
+ arena_blk_t *blk = mkblk(MAX(bufsz, ctx->blksz));
+ if (blk == nullptr)
+ errjmp(mem.err);
+ blk->next = ctx->_head;
+ blk->fngr = blk->head + bufsz;
+ ctx->_head = blk;
+ return blk->head + sizeof(arena_blk_t) + padding;
+}
- /* No page exists with enough space */
- struct _region *r = mkregion(MAX(sz, a->_init));
- if (r == nullptr)
+void
+freeall(allocator_t mem)
+{
+ arena_ctx_t *ctx = mem.ctx;
+ arena_blk_t *blk = ctx->_head;
+ while (blk != nullptr) {
+ arena_blk_t *next = blk->next;
+ (void)munmap(blk, blk->tail - blk->head);
+ blk = next;
+ }
+ ctx->_head = nullptr;
+}
+
+static arena_blk_t *
+mkblk(ptrdiff_t blksz)
+{
+ arena_blk_t blk;
+ /* blk.next and blk.fngr get set by the caller */
+ blk.head = mmap(nullptr, blksz, PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANON, -1, 0);
+ if (blk.head == MAP_FAILED)
return nullptr;
- r->next = a->_head;
- r->len = sz;
- a->_head = r;
- return r->data;
+ blk.tail = blk.head + blksz;
+ return memcpy(blk.head, &blk, sizeof blk);
+}
+
+void
+errjmp(jmp_buf *env)
+{
+ if (env != nullptr)
+ longjmp(*env, 1);
+ err("arena_alloc:");
}
diff --git a/lib/alloc/arena_free.c b/lib/alloc/arena_free.c
deleted file mode 100644
index dc2b45e..0000000
--- a/lib/alloc/arena_free.c
+++ /dev/null
@@ -1,20 +0,0 @@
-#include <sys/mman.h>
-
-#include <stdlib.h>
-
-#include "alloc.h"
-#include "macros.h"
-
-void
-arena_free(arena *a)
-{
- ASSUME(a != nullptr);
-
- struct _region *cur, *next;
- for (cur = a->_head; cur != nullptr; cur = next) {
- next = cur->next;
- munmap(cur->data, cur->cap);
- free(cur);
- }
- a->_head = nullptr;
-}
diff --git a/lib/alloc/arena_realloc.c b/lib/alloc/arena_realloc.c
deleted file mode 100644
index 6877ae1..0000000
--- a/lib/alloc/arena_realloc.c
+++ /dev/null
@@ -1,62 +0,0 @@
-#include <errno.h>
-#include <stdckdint.h>
-#include <string.h>
-
-#include "alloc.h"
-#include "macros.h"
-
-void *
-arena_realloc(arena *a, void *ptr, size_t old, size_t new, size_t elemsz,
- size_t align)
-{
- ASSUME(a != nullptr);
-
- if (ptr == nullptr)
- return arena_alloc(a, new, elemsz, align);
-
- if (old == new)
- return ptr;
-
- struct _region *cur = a->_head;
- while (cur != nullptr) {
- if (ptr >= cur->data && (char *)ptr < (char *)cur->data + cur->cap)
- break;
- cur = cur->next;
- }
- if (cur == nullptr)
- cur = a->_head;
-
- /* cur now points to the region containing ‘ptr’ */
-
- /* If we are shrinking the buffer, then we don’t need to move our allocation
- and can just return it directly. As a minor optimization if the
- allocation we are shrinking is the last allocation in the current region,
- we can decrease the region length to make space for more future
- allocations. */
- if (old > new) {
- if (ptr == cur->last)
- cur->len -= (old - new) * elemsz;
- return ptr;
- }
-
- ASSUME(old < new);
-
- /* If we need to grow the given allocation, but it was the last allocation
- made in a region, then we first see if we can just eat more trailing free
- space in the region to avoid a memcpy(). */
- if (ptr == cur->last) {
- size_t need, free = cur->cap - cur->len;
- if (ckd_mul(&need, new - old, elemsz)) {
- errno = EOVERFLOW;
- return nullptr;
- }
- if (need <= free) {
- cur->len += need;
- return ptr;
- }
- }
-
- /* At this point we just make a new allocation and copy the data over */
- void *dst = arena_alloc(a, new, elemsz, align);
- return dst == nullptr ? nullptr : memcpy(dst, ptr, old * elemsz);
-}
diff --git a/lib/alloc/arena_zero.c b/lib/alloc/arena_zero.c
deleted file mode 100644
index 296007e..0000000
--- a/lib/alloc/arena_zero.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#include "alloc.h"
-#include "macros.h"
-
-void
-arena_zero(arena *a)
-{
- ASSUME(a != nullptr);
-
- struct _region *cur = a->_head;
- while (cur != nullptr) {
- cur->len = 0;
- cur->last = cur->data;
- cur = cur->next;
- }
-}
diff --git a/lib/alloc/bufalloc.c b/lib/alloc/bufalloc.c
deleted file mode 100644
index 264f242..0000000
--- a/lib/alloc/bufalloc.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include "alloc.h"
-#include "errors.h"
-
-void *
-bufalloc(void *p, size_t n, size_t m)
-{
- if ((p = bufalloc_noterm(p, n, m)) == nullptr)
- err("%s:", __func__);
- return p;
-}
diff --git a/lib/alloc/bufalloc_noterm.c b/lib/alloc/bufalloc_noterm.c
deleted file mode 100644
index e46d2a1..0000000
--- a/lib/alloc/bufalloc_noterm.c
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <errno.h>
-#include <stdckdint.h>
-#include <stdlib.h>
-
-#include "alloc.h"
-
-void *
-bufalloc_noterm(void *p, size_t n, size_t m)
-{
- if (ckd_mul(&n, n, m)) {
- errno = EOVERFLOW;
- return nullptr;
- }
-
- return realloc(p, n);
-}
diff --git a/lib/alloc/heap_alloc.c b/lib/alloc/heap_alloc.c
new file mode 100644
index 0000000..4779ff6
--- /dev/null
+++ b/lib/alloc/heap_alloc.c
@@ -0,0 +1,76 @@
+#include <assert.h>
+#include <stdckdint.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "alloc.h"
+#include "errors.h"
+
+[[noreturn]] static void oom(jmp_buf *env);
+
+void *
+heap_alloc(allocator_t mem, alloc_mode_t mode, void *ptr, ptrdiff_t oldnmemb,
+ ptrdiff_t newnmemb, ptrdiff_t elemsz, ptrdiff_t align)
+{
+ void *p;
+ ptrdiff_t oldsz, newsz;
+
+ switch (mode) {
+ case ALLOC_NEW:
+ if (ckd_mul(&newsz, newnmemb, elemsz))
+ oom(mem.err);
+ /* Malloc is guaranteed to return a pointer aligned to an
+ alignment that is suitable for all fundamental types. For
+ larger alignments we need to use specialized functionality. */
+ if ((size_t)align <= alignof(max_align_t)) {
+ if ((p = malloc(newsz)) == nullptr)
+ oom(mem.err);
+ } else {
+ if ((p = aligned_alloc(align, newsz)) == nullptr)
+ oom(mem.err);
+ }
+ return p;
+ case ALLOC_RESIZE:
+ if (ckd_mul(&newsz, newnmemb, elemsz))
+ oom(mem.err);
+ if (ckd_mul(&oldsz, oldnmemb, elemsz))
+ oom(mem.err);
+ if ((size_t)align <= alignof(max_align_t)) {
+ if ((p = realloc(ptr, newsz)) == nullptr)
+ oom(mem.err);
+ } else {
+ /* We were allocated using aligned_alloc(). Unfortunately
+ there is no way to reallocate a buffer aligned via
+ aligned_alloc() so we need to allocate a new buffer and do
+ a manual copy… */
+ if ((p = aligned_alloc(align, newsz)) == nullptr)
+ oom(mem.err);
+ memcpy(p, ptr, oldsz);
+#if 0
+ /* We would rather use free_aligned_size(), but it isn’t
+ available yet on most systems. */
+ free_aligned_sized(ptr, align, oldsz);
+#else
+ free(ptr);
+#endif
+ }
+ return p;
+ case ALLOC_FREE:
+ free(ptr);
+ return nullptr;
+ case ALLOC_FREEALL:
+ assert(!"Not implemented");
+ return nullptr;
+ default:
+ unreachable();
+ }
+}
+
+void
+oom(jmp_buf *env)
+{
+ if (env != nullptr)
+ longjmp(*env, 1);
+ err("heap_alloc:");
+}
diff --git a/lib/alloc/static_scratch_alloc.c b/lib/alloc/static_scratch_alloc.c
new file mode 100644
index 0000000..2489b98
--- /dev/null
+++ b/lib/alloc/static_scratch_alloc.c
@@ -0,0 +1,44 @@
+#include <errno.h>
+#include <setjmp.h>
+#include <stdckdint.h>
+#include <stdint.h>
+
+#include "alloc.h"
+#include "errors.h"
+
+[[noreturn]] static void oom(jmp_buf *env);
+
+void *
+static_scratch_alloc(allocator_t mem, alloc_mode_t mode, void *,
+ ptrdiff_t, ptrdiff_t newnmemb, ptrdiff_t elemsz,
+ ptrdiff_t align)
+{
+ st_buf_t *ctx = mem.ctx;
+
+ switch (mode) {
+ case ALLOC_NEW:
+ case ALLOC_RESIZE:
+ ptrdiff_t pad, avail, total;
+ if (ckd_mul(&total, newnmemb, elemsz))
+ oom(mem.err);
+ pad = -(uintptr_t)ctx->buf & (align - 1);
+ avail = ctx->len - pad;
+ if (avail < 0 || total > avail)
+ oom(mem.err);
+ return (char *)ctx->buf + pad;
+ case ALLOC_FREE:
+ case ALLOC_FREEALL:
+ return nullptr;
+ default:
+ unreachable();
+ }
+}
+
+void
+oom(jmp_buf *env)
+{
+ errno = ENOMEM;
+ if (env != nullptr)
+ longjmp(*env, 1);
+ err("static_scratch_alloc:");
+}
diff --git a/lib/array/array_free.c b/lib/array/array_free.c
new file mode 100644
index 0000000..0e5560e
--- /dev/null
+++ b/lib/array/array_free.c
@@ -0,0 +1,12 @@
+#include <stdint.h>
+
+#include "array.h"
+#include "alloc.h"
+
+void
+(array_free)(void *vptr, ptrdiff_t elemsz, ptrdiff_t align)
+{
+ ptrdiff_t pad = -sizeof(_mlib_arr_hdr_t) & (align - 1);
+ _mlib_arr_hdr_t *hdr = _mlib_array_hdr(vptr, align);
+ delete(hdr->mem, (uint8_t *)hdr, sizeof(*hdr) + pad + hdr->cap*elemsz);
+}
diff --git a/lib/array/array_new.c b/lib/array/array_new.c
new file mode 100644
index 0000000..7339ba5
--- /dev/null
+++ b/lib/array/array_new.c
@@ -0,0 +1,29 @@
+#include <stdckdint.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "array.h"
+#include "alloc.h"
+
+void *
+(array_new)(allocator_t mem, ptrdiff_t nmemb, ptrdiff_t elemsz, ptrdiff_t align)
+{
+ ptrdiff_t total, pad = -sizeof(_mlib_arr_hdr_t) & (align - 1);
+
+ /* Overflow; just call the allocator with the maximum size to force
+ proper error handling */
+ if (ckd_mul(&total, nmemb, elemsz)
+ || ckd_add(&total, total, pad)
+ || ckd_add(&total, total, sizeof(_mlib_arr_hdr_t)))
+ {
+ mem.alloc(mem, ALLOC_NEW, nullptr, 0,
+ PTRDIFF_MAX, PTRDIFF_MAX, PTRDIFF_MAX);
+ unreachable();
+ }
+
+ uint8_t *buf = new(mem, uint8_t, total);
+ _mlib_arr_hdr_t hdr = {0, nmemb, mem};
+ memcpy(buf, &hdr, sizeof(hdr));
+ return buf + sizeof(_mlib_arr_hdr_t) + pad;
+}
diff --git a/lib/array/array_resz.c b/lib/array/array_resz.c
new file mode 100644
index 0000000..d28a7a0
--- /dev/null
+++ b/lib/array/array_resz.c
@@ -0,0 +1,28 @@
+#include <stdckdint.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "array.h"
+#include "alloc.h"
+
+void *
+(array_resz)(void *ptr, ptrdiff_t ncap, ptrdiff_t elemsz, ptrdiff_t align)
+{
+ ptrdiff_t newsz, pad = -sizeof(_mlib_arr_hdr_t) & (align - 1);
+ _mlib_arr_hdr_t *hdr = _mlib_array_hdr(ptr, align);
+ /* Overflow; just call the allocator with the maximum size to force
+ proper error handling */
+ if (ckd_mul(&newsz, ncap, elemsz)
+ || ckd_add(&newsz, newsz, pad)
+ || ckd_add(&newsz, newsz, sizeof(_mlib_arr_hdr_t)))
+ {
+ hdr->mem.alloc(hdr->mem, ALLOC_NEW, nullptr, 0,
+ PTRDIFF_MAX, PTRDIFF_MAX, PTRDIFF_MAX);
+ unreachable();
+ }
+
+ ptrdiff_t oldsz = sizeof(_mlib_arr_hdr_t) + pad + hdr->cap*elemsz;
+ hdr = (_mlib_arr_hdr_t *)resz(hdr->mem, (uint8_t *)hdr, oldsz, newsz);
+ hdr->cap = ncap;
+ return (uint8_t *)hdr + sizeof(*hdr) + pad;
+}
diff --git a/lib/unicode/string/u8casefold.c b/lib/unicode/string/u8casefold.c
index e3a3402..fc9ed54 100644
--- a/lib/unicode/string/u8casefold.c
+++ b/lib/unicode/string/u8casefold.c
@@ -1,3 +1,4 @@
+#include <alloc.h>
#include <errno.h>
#include <stdckdint.h>
@@ -7,11 +8,9 @@
#include "unicode/string.h"
char8_t *
-u8casefold(size_t *dstn, u8view_t sv, enum caseflags flags, alloc_fn alloc,
- void *alloc_ctx)
+u8casefold(size_t *dstn, u8view_t sv, caseflags_t flags, allocator_t mem)
{
ASSUME(dstn != nullptr);
- ASSUME(alloc != nullptr);
size_t bufsz;
if (ckd_mul(&bufsz, sv.len, (size_t)U8CASEFOLD_SCALE)) {
@@ -19,7 +18,7 @@ u8casefold(size_t *dstn, u8view_t sv, enum caseflags flags, alloc_fn alloc,
return nullptr;
}
- char8_t *dst = alloc(alloc_ctx, nullptr, 0, bufsz, 1, alignof(char8_t));
+ char8_t *dst = new(mem, typeof(*dst), bufsz);
rune ch;
size_t n = 0;
@@ -30,5 +29,5 @@ u8casefold(size_t *dstn, u8view_t sv, enum caseflags flags, alloc_fn alloc,
}
*dstn = n;
- return alloc(alloc_ctx, dst, bufsz, n, 1, alignof(char8_t));
+ return resz(mem, dst, bufsz, n);
}
diff --git a/lib/unicode/string/u8lower.c b/lib/unicode/string/u8lower.c
index 2b1ec36..e553f98 100644
--- a/lib/unicode/string/u8lower.c
+++ b/lib/unicode/string/u8lower.c
@@ -2,6 +2,7 @@
#include <stdckdint.h>
#include "_attrs.h"
+#include "alloc.h"
#include "macros.h"
#include "mbstring.h"
#include "unicode/prop.h"
@@ -17,11 +18,9 @@ uprop_ccc_0_or_230(rune ch)
}
char8_t *
-u8lower(size_t *dstn, u8view_t sv, enum caseflags flags, alloc_fn alloc,
- void *alloc_ctx)
+u8lower(size_t *dstn, u8view_t sv, caseflags_t flags, allocator_t mem)
{
ASSUME(dstn != nullptr);
- ASSUME(alloc != nullptr);
struct lcctx ctx = {
.az_or_tr = flags & CF_LANG_AZ,
@@ -46,7 +45,7 @@ u8lower(size_t *dstn, u8view_t sv, enum caseflags flags, alloc_fn alloc,
return nullptr;
}
- char8_t *dst = alloc(alloc_ctx, nullptr, 0, bufsz, 1, alignof(char8_t));
+ char8_t *dst = new(mem, typeof(*dst), bufsz);
while (u8next(&ch, &sv)) {
rune next = 0;
@@ -103,5 +102,5 @@ u8lower(size_t *dstn, u8view_t sv, enum caseflags flags, alloc_fn alloc,
}
*dstn = n;
- return alloc(alloc_ctx, dst, bufsz, n, 1, alignof(char8_t));
+ return resz(mem, dst, bufsz, n);
}
diff --git a/lib/unicode/string/u8norm.c b/lib/unicode/string/u8norm.c
index 02156ea..c60fa5b 100644
--- a/lib/unicode/string/u8norm.c
+++ b/lib/unicode/string/u8norm.c
@@ -1,6 +1,10 @@
+#include <errno.h>
#include <inttypes.h>
+#include <stdckdint.h>
+#include <stddef.h>
#include <string.h>
+#include "alloc.h"
#include "macros.h"
#include "mbstring.h"
#include "unicode/_cm.h"
@@ -28,22 +32,20 @@ constexpr int TCNT = 28;
constexpr int NCNT = VCNT * TCNT;
constexpr int SCNT = LCNT * NCNT;
-static void decomp(char8_t *, size_t *, size_t, rune, enum normform);
+static void decomp(char8_t *, size_t *, size_t, rune, normform_t);
static void compbuf(char8_t *, size_t *);
static const qcfn qc_lookup[] = {
- [NF_NFC] = (qcfn)uprop_get_nfc_qc,
- [NF_NFD] = (qcfn)uprop_get_nfd_qc,
+ [NF_NFC] = (qcfn)uprop_get_nfc_qc,
+ [NF_NFD] = (qcfn)uprop_get_nfd_qc,
[NF_NFKC] = (qcfn)uprop_get_nfkc_qc,
[NF_NFKD] = (qcfn)uprop_get_nfkd_qc,
};
char8_t *
-u8norm(size_t *dstn, u8view_t src, alloc_fn alloc, void *ctx,
- enum normform nf)
+u8norm(size_t *dstn, u8view_t src, allocator_t mem, normform_t nf)
{
ASSUME(dstn != nullptr);
- ASSUME(alloc != nullptr);
ASSUME(BETWEEN(0, nf, 4));
{
@@ -57,30 +59,31 @@ u8norm(size_t *dstn, u8view_t src, alloc_fn alloc, void *ctx,
}
*dstn = src.len;
- char8_t *dst = alloc(ctx, nullptr, 0, src.len, 1, alignof(char8_t));
+ char8_t *dst = new(mem, typeof(*dst), src.len);
return memcpy(dst, src.p, src.len);
}
no:
- /* Pre-allocate a buffer with some initial capacity; there is no need to
- check for overflow when computing bufsz because alloc() will handle the
- overflow error for us. */
int scale = (nf & 0b10) ? NFKD_SCALE : NFD_SCALE;
- size_t bufsz = src.len * scale;
- char8_t *dst = alloc(ctx, nullptr, 0, src.len, scale, alignof(char8_t));
+ ptrdiff_t bufsz;
+ if (ckd_mul(&bufsz, src.len, scale)) {
+ errno = EOVERFLOW;
+ return nullptr;
+ }
+ char8_t *dst = new(mem, typeof(*dst), bufsz);
*dstn = 0;
for (rune ch; ucsnext(&ch, &src) != 0; decomp(dst, dstn, bufsz, ch, nf))
;
if (nf & 0b01)
compbuf(dst, dstn);
- return alloc(ctx, dst, src.len, *dstn, 1, alignof(char8_t));
+ return resz(mem, dst, bufsz, *dstn);
}
#define WRITE(ch) *dstn += rtoucs(dst + *dstn, bufsz - *dstn, (ch))
void
-decomp(char8_t *dst, size_t *dstn, size_t bufsz, rune ch, enum normform nf)
+decomp(char8_t *dst, size_t *dstn, size_t bufsz, rune ch, normform_t nf)
{
if (uprop_get_hst(ch) != HST_NA) {
int si = ch - SBASE;
@@ -96,8 +99,8 @@ decomp(char8_t *dst, size_t *dstn, size_t bufsz, rune ch, enum normform nf)
WRITE(v);
if (t != TBASE)
WRITE(t);
- } else if (((nf & 0b10) && uprop_get_dt(ch) != DT_NONE)
- || ((nf & 0b10) == 0 && uprop_get_dt(ch) == DT_CAN))
+ } else if (((nf & 0b10) != 0 && uprop_get_dt(ch) != DT_NONE)
+ || ((nf & 0b10) == 0 && uprop_get_dt(ch) == DT_CAN))
{
struct rview rv = uprop_get_dm(ch);
for (size_t i = 0; i < rv.len; i++)
@@ -170,12 +173,12 @@ compbuf(char8_t *dst, size_t *dstn)
/* Try Hangul composition */
if (comp == 0) {
if (BETWEEN(LBASE, L, LBASE + LCNT - 1)
- && BETWEEN(VBASE, C, VBASE + VCNT - 1))
+ && BETWEEN(VBASE, C, VBASE + VCNT - 1))
{
comp = SBASE + ((L - LBASE) * NCNT + (C - VBASE) * TCNT);
} else if (BETWEEN(TBASE, C, TBASE + TCNT - 1)
- && BETWEEN(SBASE, L, SBASE + SCNT - 1)
- && ((L - SBASE) % TCNT) == 0)
+ && BETWEEN(SBASE, L, SBASE + SCNT - 1)
+ && ((L - SBASE) % TCNT) == 0)
{
comp = L + (C - TBASE);
}
diff --git a/lib/unicode/string/u8title.c b/lib/unicode/string/u8title.c
index 3a85f4d..c0637ff 100644
--- a/lib/unicode/string/u8title.c
+++ b/lib/unicode/string/u8title.c
@@ -2,6 +2,7 @@
#include <stdckdint.h>
#include "_attrs.h"
+#include "alloc.h"
#include "macros.h"
#include "mbstring.h"
#include "unicode/prop.h"
@@ -18,11 +19,9 @@ uprop_ccc_0_or_230(rune ch)
}
char8_t *
-u8title(size_t *dstn, u8view_t sv, enum caseflags flags, alloc_fn alloc,
- void *alloc_ctx)
+u8title(size_t *dstn, u8view_t sv, caseflags_t flags, allocator_t mem)
{
ASSUME(dstn != nullptr);
- ASSUME(alloc != nullptr);
struct tcctx ctx_t;
struct lcctx ctx_l;
@@ -52,7 +51,7 @@ u8title(size_t *dstn, u8view_t sv, enum caseflags flags, alloc_fn alloc,
return nullptr;
}
- char8_t *dst = alloc(alloc_ctx, nullptr, 0, bufsz, 1, alignof(char8_t));
+ char8_t *dst = new(mem, typeof(*dst), bufsz);
while (u8next(&ch, &sv)) {
if (sv.p > word.p + word.len) {
@@ -134,5 +133,5 @@ u8title(size_t *dstn, u8view_t sv, enum caseflags flags, alloc_fn alloc,
}
*dstn = n;
- return alloc(alloc_ctx, dst, bufsz, n, 1, alignof(char8_t));
+ return resz(mem, dst, bufsz, n);
}
diff --git a/lib/unicode/string/u8upper.c b/lib/unicode/string/u8upper.c
index a77fcd8..ad10ef7 100644
--- a/lib/unicode/string/u8upper.c
+++ b/lib/unicode/string/u8upper.c
@@ -1,17 +1,16 @@
#include <errno.h>
#include <stdckdint.h>
+#include "alloc.h"
#include "macros.h"
#include "mbstring.h"
#include "unicode/prop.h"
#include "unicode/string.h"
char8_t *
-u8upper(size_t *dstn, u8view_t sv, enum caseflags flags, alloc_fn alloc,
- void *alloc_ctx)
+u8upper(size_t *dstn, u8view_t sv, caseflags_t flags, allocator_t mem)
{
ASSUME(dstn != nullptr);
- ASSUME(alloc != nullptr);
struct ucctx ctx = {
.az_or_tr = flags & CF_LANG_AZ,
@@ -25,7 +24,7 @@ u8upper(size_t *dstn, u8view_t sv, enum caseflags flags, alloc_fn alloc,
return nullptr;
}
- char8_t *dst = alloc(alloc_ctx, nullptr, 0, bufsz, 1, alignof(char8_t));
+ char8_t *dst = new(mem, typeof(*dst), bufsz);
rune ch;
size_t n = 0;
@@ -43,5 +42,5 @@ u8upper(size_t *dstn, u8view_t sv, enum caseflags flags, alloc_fn alloc,
}
*dstn = n;
- return alloc(alloc_ctx, dst, bufsz, n, 1, alignof(char8_t));
+ return resz(mem, dst, bufsz, n);
}