#include <stdio.h>
char *
-bb_vprintf_at(bb_t *bb, uint ofs, const char *fmt, va_list args)
+bb_vprintf_at(bb_t *bb, size_t ofs, const char *fmt, va_list args)
{
bb_grow(bb, ofs + 1);
va_list args2;
}
char *
-bb_printf_at(bb_t *bb, uint ofs, const char *fmt, ...)
+bb_printf_at(bb_t *bb, size_t ofs, const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
* See @bb_printf().
**/
char *bb_vprintf(bb_t *bb, const char *fmt, va_list args);
+
/**
* printf() into a growing buffer.
* Generates a `'\0'`-terminated string at the beginning of the buffer
* See @bb_vprintf().
**/
char *bb_printf(bb_t *bb, const char *fmt, ...);
+
/**
* Like @bb_vprintf(), but it does not start at the beginning of the
* buffer, but @ofs bytes further.
* Returns pointer to the new string (eg. @ofs bytes after the
* beginning of buffer).
**/
-char *bb_vprintf_at(bb_t *bb, uint ofs, const char *fmt, va_list args);
+char *bb_vprintf_at(bb_t *bb, size_t ofs, const char *fmt, va_list args);
+
/**
* Like @bb_vprintf_at(), but it takes individual arguments.
**/
-char *bb_printf_at(bb_t *bb, uint ofs, const char *fmt, ...);
+char *bb_printf_at(bb_t *bb, size_t ofs, const char *fmt, ...);
#endif
void *stdin_data(struct mempool *pool) {
struct fastbuf *fb = bopen_fd(0, NULL); // Read from stdin
- uint amount;
+ size_t amount;
char *ptr = mp_start(pool, 1024);
while(amount = bread(fb, ptr, 1024)) { // Read a block
ptr += amount; // Move after it
* Start a new continuous block and prepare for writing (see <<mempool:mp_start()>>).
* Provide the memory pool you want to use for this block as @mp.
**/
-void fbpool_start(struct fbpool *fb, struct mempool *mp, uint init_size);
+void fbpool_start(struct fbpool *fb, struct mempool *mp, size_t init_size);
/**
* Close the block and return the address of its start (see <<mempool:mp_end()>>).
* The length can be determined by calling <<mempool:mp_size(mp, ptr)>>.
}
void
-fbpool_start(struct fbpool *b, struct mempool *mp, uint init_size)
+fbpool_start(struct fbpool *b, struct mempool *mp, size_t init_size)
{
b->mp = mp;
b->fb.buffer = b->fb.bstop = b->fb.bptr = mp_start(mp, init_size);
* length of available memory.
**/
typedef struct BUF_T {
- uint len;
+ size_t len;
GBUF_TYPE *ptr;
} BUF_T;
* Use <<fun__GENERIC_LINK_|GBUF_PREFIX|grow|,`GBUF_PREFIX(grow)()`>>
* for growing.
**/
-static void UNUSED GBUF_PREFIX(set_size)(BUF_T *b, uint len)
+static void UNUSED GBUF_PREFIX(set_size)(BUF_T *b, size_t len)
{
b->len = len;
b->ptr = xrealloc(b->ptr, len * sizeof(GBUF_TYPE));
#ifdef GBUF_TRACE
- GBUF_TRACE(STRINGIFY_EXPANDED(BUF_T) " growing to %u items", len);
+ GBUF_TRACE(STRINGIFY_EXPANDED(BUF_T) " growing to %zu items", len);
#endif
}
-static void UNUSED GBUF_PREFIX(do_grow)(BUF_T *b, uint len)
+static void UNUSED GBUF_PREFIX(do_grow)(BUF_T *b, size_t len)
{
if (len < 2*b->len) // to ensure logarithmic cost
len = 2*b->len;
* any more) by
* <<fun__GENERIC_LINK_|GBUF_PREFIX|set_size|,`GBUF_PREFIX(set_size)()`>>.
**/
-static inline GBUF_TYPE *GBUF_PREFIX(grow)(BUF_T *b, uint len)
+static inline GBUF_TYPE *GBUF_PREFIX(grow)(BUF_T *b, size_t len)
{
if (unlikely(len > b->len))
GBUF_PREFIX(do_grow)(b, len);
*/
int
-careful_read(int fd, void *buf, int len)
+careful_read(int fd, void *buf, size_t len)
{
byte *pos = buf;
while (len)
{
- int l = read(fd, pos, len);
+ ssize_t l = read(fd, pos, len);
if (l < 0)
return -1;
if (!l)
}
int
-careful_write(int fd, const void *buf, int len)
+careful_write(int fd, const void *buf, size_t len)
{
const byte *pos = buf;
while (len)
{
- int l = write(fd, pos, len);
+ ssize_t l = write(fd, pos, len);
if (l < 0)
return -1;
if (!l)
#include <sys/mman.h>
void *
-mmap_file(const char *name, uint *len, int writeable)
+mmap_file(const char *name, size_t *len, int writeable)
{
- int fd = open(name, writeable ? O_RDWR : O_RDONLY);
- struct stat st;
+ int fd = ucw_open(name, writeable ? O_RDWR : O_RDONLY);
+ ucw_stat_t st;
void *x;
if (fd < 0)
die("open(%s): %m", name);
- if (fstat(fd, &st) < 0)
+ if (ucw_fstat(fd, &st) < 0)
die("fstat(%s): %m", name);
+ if ((uintmax_t)st.st_size > SIZE_MAX)
+ die("mmap(%s): File too large", name);
if (len)
*len = st.st_size;
if (st.st_size)
}
void
-munmap_file(void *start, uint len)
+munmap_file(void *start, size_t len)
{
munmap(start, len);
}
/* io-mmap.c */
-void *mmap_file(const char *name, uint *len, int writeable);
-void munmap_file(void *start, uint len);
+void *mmap_file(const char *name, size_t *len, int writeable);
+void munmap_file(void *start, size_t len);
/* io-careful.c */
-int careful_read(int fd, void *buf, int len);
-int careful_write(int fd, const void *buf, int len);
+int careful_read(int fd, void *buf, size_t len);
+int careful_write(int fd, const void *buf, size_t len);
/* io-sync.c */
#include <string.h>
static char *
-mp_vprintf_at(struct mempool *mp, uint ofs, const char *fmt, va_list args)
+mp_vprintf_at(struct mempool *mp, size_t ofs, const char *fmt, va_list args)
{
char *ret = mp_grow(mp, ofs + 1) + ofs;
va_list args2;
char *
mp_append_vprintf(struct mempool *mp, char *ptr, const char *fmt, va_list args)
{
- uint ofs = mp_open(mp, ptr);
+ size_t ofs = mp_open(mp, ptr);
ASSERT(ofs && !ptr[ofs - 1]);
return mp_vprintf_at(mp, ofs - 1, fmt, args);
}
{
if (!s)
return NULL;
- uint l = strlen(s) + 1;
+ size_t l = strlen(s) + 1;
char *t = mp_alloc_fast_noalign(p, l);
memcpy(t, s, l);
return t;
}
void *
-mp_memdup(struct mempool *p, const void *s, uint len)
+mp_memdup(struct mempool *p, const void *s, size_t len)
{
void *t = mp_alloc_fast(p, len);
memcpy(t, s, len);
va_copy(a, args);
while (x = va_arg(a, char *))
cnt++;
- uint *sizes = alloca(cnt * sizeof(uint));
- uint len = 1;
+ size_t *sizes = alloca(cnt * sizeof(*sizes));
+ size_t len = 1;
cnt = 0;
va_end(a);
va_copy(a, args);
char *
mp_strjoin(struct mempool *p, char **a, uint n, uint sep)
{
- uint sizes[n];
- uint len = 1;
+ size_t sizes[n];
+ size_t len = 1;
for (uint i=0; i<n; i++)
len += sizes[i] = strlen(a[i]);
if (sep && n)
}
char *
-mp_str_from_mem(struct mempool *a, const void *mem, uint len)
+mp_str_from_mem(struct mempool *a, const void *mem, size_t len)
{
char *str = mp_alloc_noalign(a, len+1);
memcpy(str, mem, len);
#include <string.h>
#define MP_CHUNK_TAIL ALIGN_TO(sizeof(struct mempool_chunk), CPU_STRUCT_ALIGN)
-#define MP_SIZE_MAX (~0U - MP_CHUNK_TAIL - CPU_PAGE_SIZE)
+#define MP_SIZE_MAX (SIZE_MAX - MP_CHUNK_TAIL - CPU_PAGE_SIZE)
struct mempool_chunk {
#ifdef CONFIG_DEBUG
struct mempool *pool; // Can be useful when analysing coredump for memory leaks
#endif
struct mempool_chunk *next;
- uint size;
+ size_t size;
};
-static uint
-mp_align_size(uint size)
+static size_t
+mp_align_size(size_t size)
{
#ifdef CONFIG_UCW_POOL_IS_MMAP
return ALIGN_TO(size + MP_CHUNK_TAIL, CPU_PAGE_SIZE) - MP_CHUNK_TAIL;
}
void
-mp_init(struct mempool *pool, uint chunk_size)
+mp_init(struct mempool *pool, size_t chunk_size)
{
chunk_size = mp_align_size(MAX(sizeof(struct mempool), chunk_size));
*pool = (struct mempool) {
}
static void *
-mp_new_big_chunk(struct mempool *pool, uint size)
+mp_new_big_chunk(struct mempool *pool, size_t size)
{
struct mempool_chunk *chunk;
chunk = xmalloc(size + MP_CHUNK_TAIL) + size;
}
static void *
-mp_new_chunk(struct mempool *pool, uint size)
+mp_new_chunk(struct mempool *pool, size_t size)
{
#ifdef CONFIG_UCW_POOL_IS_MMAP
struct mempool_chunk *chunk;
}
struct mempool *
-mp_new(uint chunk_size)
+mp_new(size_t chunk_size)
{
chunk_size = mp_align_size(MAX(sizeof(struct mempool), chunk_size));
struct mempool_chunk *chunk = mp_new_chunk(NULL, chunk_size);
}
void *
-mp_alloc_internal(struct mempool *pool, uint size)
+mp_alloc_internal(struct mempool *pool, size_t size)
{
struct mempool_chunk *chunk;
if (size <= pool->threshold)
else if (likely(size <= MP_SIZE_MAX))
{
pool->idx = 1;
- uint aligned = ALIGN_TO(size, CPU_STRUCT_ALIGN);
+ size_t aligned = ALIGN_TO(size, CPU_STRUCT_ALIGN);
chunk = mp_new_big_chunk(pool, aligned);
chunk->next = pool->state.last[1];
#ifdef CONFIG_DEBUG
return pool->last_big = (void *)chunk - aligned;
}
else
- die("Cannot allocate %u bytes from a mempool", size);
+ die("Cannot allocate %zu bytes from a mempool", size);
}
void *
-mp_alloc(struct mempool *pool, uint size)
+mp_alloc(struct mempool *pool, size_t size)
{
return mp_alloc_fast(pool, size);
}
void *
-mp_alloc_noalign(struct mempool *pool, uint size)
+mp_alloc_noalign(struct mempool *pool, size_t size)
{
return mp_alloc_fast_noalign(pool, size);
}
void *
-mp_alloc_zero(struct mempool *pool, uint size)
+mp_alloc_zero(struct mempool *pool, size_t size)
{
void *ptr = mp_alloc_fast(pool, size);
bzero(ptr, size);
}
void *
-mp_start_internal(struct mempool *pool, uint size)
+mp_start_internal(struct mempool *pool, size_t size)
{
void *ptr = mp_alloc_internal(pool, size);
pool->state.free[pool->idx] += size;
}
void *
-mp_start(struct mempool *pool, uint size)
+mp_start(struct mempool *pool, size_t size)
{
return mp_start_fast(pool, size);
}
void *
-mp_start_noalign(struct mempool *pool, uint size)
+mp_start_noalign(struct mempool *pool, size_t size)
{
return mp_start_fast_noalign(pool, size);
}
void *
-mp_grow_internal(struct mempool *pool, uint size)
+mp_grow_internal(struct mempool *pool, size_t size)
{
if (unlikely(size > MP_SIZE_MAX))
- die("Cannot allocate %u bytes of memory", size);
- uint avail = mp_avail(pool);
+ die("Cannot allocate %zu bytes of memory", size);
+ size_t avail = mp_avail(pool);
void *ptr = mp_ptr(pool);
if (pool->idx)
{
- uint amortized = likely(avail <= MP_SIZE_MAX / 2) ? avail * 2 : MP_SIZE_MAX;
+ size_t amortized = likely(avail <= MP_SIZE_MAX / 2) ? avail * 2 : MP_SIZE_MAX;
amortized = MAX(amortized, size);
amortized = ALIGN_TO(amortized, CPU_STRUCT_ALIGN);
struct mempool_chunk *chunk = pool->state.last[1], *next = chunk->next;
}
}
-uint
+size_t
mp_open(struct mempool *pool, void *ptr)
{
return mp_open_fast(pool, ptr);
}
void *
-mp_realloc(struct mempool *pool, void *ptr, uint size)
+mp_realloc(struct mempool *pool, void *ptr, size_t size)
{
return mp_realloc_fast(pool, ptr, size);
}
void *
-mp_realloc_zero(struct mempool *pool, void *ptr, uint size)
+mp_realloc_zero(struct mempool *pool, void *ptr, size_t size)
{
- uint old_size = mp_open_fast(pool, ptr);
+ size_t old_size = mp_open_fast(pool, ptr);
ptr = mp_grow(pool, size);
if (size > old_size)
bzero(ptr + old_size, size - old_size);
}
void *
-mp_spread_internal(struct mempool *pool, void *p, uint size)
+mp_spread_internal(struct mempool *pool, void *p, size_t size)
{
void *old = mp_ptr(pool);
void *new = mp_grow_internal(pool, p-old+size);
* You should use this one as an opaque handle only, the insides are internal.
**/
struct mempool_state {
- uint free[2];
+ size_t free[2];
void *last[2];
struct mempool_state *next;
};
struct ucw_allocator allocator;
struct mempool_state state;
void *unused, *last_big;
- uint chunk_size, threshold, idx;
+ size_t chunk_size, threshold;
+ uns idx;
u64 total_size;
};
/**
* Initialize a given mempool structure.
- * @chunk_size must be in the interval `[1, UINT_MAX / 2]`.
+ * @chunk_size must be in the interval `[1, SIZE_MAX / 2]`.
* It will allocate memory by this large chunks and take
* memory to satisfy requests from them.
*
* Memory pools can be treated as <<trans:respools,resources>>, see <<trans:res_mempool()>>.
**/
-void mp_init(struct mempool *pool, uint chunk_size);
+void mp_init(struct mempool *pool, size_t chunk_size);
/**
* Allocate and initialize a new memory pool.
*
* Memory pools can be treated as <<trans:respools,resources>>, see <<trans:res_mempool()>>.
**/
-struct mempool *mp_new(uint chunk_size);
+struct mempool *mp_new(size_t chunk_size);
/**
* Cleanup mempool initialized by mp_init or mp_new.
***/
/* For internal use only, do not call directly */
-void *mp_alloc_internal(struct mempool *pool, uint size) LIKE_MALLOC;
+void *mp_alloc_internal(struct mempool *pool, size_t size) LIKE_MALLOC;
/**
* The function allocates new @size bytes on a given memory pool.
* `CPU_STRUCT_ALIGN` bytes and this condition remains true also
* after future reallocations.
**/
-void *mp_alloc(struct mempool *pool, uint size);
+void *mp_alloc(struct mempool *pool, size_t size);
/**
* The same as @mp_alloc(), but the result may be unaligned.
**/
-void *mp_alloc_noalign(struct mempool *pool, uint size);
+void *mp_alloc_noalign(struct mempool *pool, size_t size);
/**
* The same as @mp_alloc(), but fills the newly allocated memory with zeroes.
**/
-void *mp_alloc_zero(struct mempool *pool, uint size);
+void *mp_alloc_zero(struct mempool *pool, size_t size);
/**
* Inlined version of @mp_alloc().
**/
-static inline void *mp_alloc_fast(struct mempool *pool, uint size)
+static inline void *mp_alloc_fast(struct mempool *pool, size_t size)
{
- uint avail = pool->state.free[0] & ~(CPU_STRUCT_ALIGN - 1);
+ size_t avail = pool->state.free[0] & ~(size_t)(CPU_STRUCT_ALIGN - 1);
if (size <= avail)
{
pool->state.free[0] = avail - size;
/**
* Inlined version of @mp_alloc_noalign().
**/
-static inline void *mp_alloc_fast_noalign(struct mempool *pool, uint size)
+static inline void *mp_alloc_fast_noalign(struct mempool *pool, size_t size)
{
if (size <= pool->state.free[0])
{
***/
/* For internal use only, do not call directly */
-void *mp_start_internal(struct mempool *pool, uint size) LIKE_MALLOC;
-void *mp_grow_internal(struct mempool *pool, uint size);
-void *mp_spread_internal(struct mempool *pool, void *p, uint size);
+void *mp_start_internal(struct mempool *pool, size_t size) LIKE_MALLOC;
+void *mp_grow_internal(struct mempool *pool, size_t size);
+void *mp_spread_internal(struct mempool *pool, void *p, size_t size);
static inline uint mp_idx(struct mempool *pool, void *ptr)
{
* Keep in mind that you can't make any other pool allocations
* before you "close" the growing buffer with @mp_end().
*/
-void *mp_start(struct mempool *pool, uint size);
-void *mp_start_noalign(struct mempool *pool, uint size);
+void *mp_start(struct mempool *pool, size_t size);
+void *mp_start_noalign(struct mempool *pool, size_t size);
/**
* Inlined version of @mp_start().
**/
-static inline void *mp_start_fast(struct mempool *pool, uint size)
+static inline void *mp_start_fast(struct mempool *pool, size_t size)
{
- uint avail = pool->state.free[0] & ~(CPU_STRUCT_ALIGN - 1);
+ size_t avail = pool->state.free[0] & ~(size_t)(CPU_STRUCT_ALIGN - 1);
if (size <= avail)
{
pool->idx = 0;
/**
* Inlined version of @mp_start_noalign().
**/
-static inline void *mp_start_fast_noalign(struct mempool *pool, uint size)
+static inline void *mp_start_fast_noalign(struct mempool *pool, size_t size)
{
if (size <= pool->state.free[0])
{
* Return the number of bytes available for extending the growing buffer.
* (Before a reallocation will be needed).
**/
-static inline uint mp_avail(struct mempool *pool)
+static inline size_t mp_avail(struct mempool *pool)
{
return pool->state.free[pool->idx];
}
* change its starting position. The content will be unchanged to the minimum
* of the old and new sizes; newly allocated memory will be uninitialized.
* Multiple calls to mp_grow() have amortized linear cost wrt. the maximum value of @size. */
-static inline void *mp_grow(struct mempool *pool, uint size)
+static inline void *mp_grow(struct mempool *pool, size_t size)
{
return (size <= mp_avail(pool)) ? mp_ptr(pool) : mp_grow_internal(pool, size);
}
* Ensure that there is at least @size bytes free after @p,
* if not, reallocate and adjust @p.
**/
-static inline void *mp_spread(struct mempool *pool, void *p, uint size)
+static inline void *mp_spread(struct mempool *pool, void *p, size_t size)
{
- return (((uint)((byte *)pool->state.last[pool->idx] - (byte *)p) >= size) ? p : mp_spread_internal(pool, p, size));
+ return (((size_t)((byte *)pool->state.last[pool->idx] - (byte *)p) >= size) ? p : mp_spread_internal(pool, p, size));
}
/**
* the last byte in the buffer, returns a pointer after the last byte
* of the new (possibly reallocated) buffer.
**/
-static inline void *mp_append_block(struct mempool *pool, void *p, const void *block, uint size)
+static inline void *mp_append_block(struct mempool *pool, void *p, const void *block, size_t size)
{
char *q = mp_spread(pool, p, size);
memcpy(q, block, size);
/**
* Return size in bytes of the last allocated memory block (with @mp_alloc() or @mp_end()).
**/
-static inline uint mp_size(struct mempool *pool, void *ptr)
+static inline size_t mp_size(struct mempool *pool, void *ptr)
{
uint idx = mp_idx(pool, ptr);
return ((byte *)pool->state.last[idx] - (byte *)ptr) - pool->state.free[idx];
* for growing and return its size in bytes. The contents and the start pointer
* remain unchanged. Do not forget to call @mp_end() to close it.
**/
-uint mp_open(struct mempool *pool, void *ptr);
+size_t mp_open(struct mempool *pool, void *ptr);
/**
* Inlined version of @mp_open().
**/
-static inline uint mp_open_fast(struct mempool *pool, void *ptr)
+static inline size_t mp_open_fast(struct mempool *pool, void *ptr)
{
pool->idx = mp_idx(pool, ptr);
- uint size = ((byte *)pool->state.last[pool->idx] - (byte *)ptr) - pool->state.free[pool->idx];
+ size_t size = ((byte *)pool->state.last[pool->idx] - (byte *)ptr) - pool->state.free[pool->idx];
pool->state.free[pool->idx] += size;
return size;
}
* to the new @size. Behavior is similar to @mp_grow(), but the resulting
* block is closed.
**/
-void *mp_realloc(struct mempool *pool, void *ptr, uint size);
+void *mp_realloc(struct mempool *pool, void *ptr, size_t size);
/**
* The same as @mp_realloc(), but fills the additional bytes (if any) with zeroes.
**/
-void *mp_realloc_zero(struct mempool *pool, void *ptr, uint size);
+void *mp_realloc_zero(struct mempool *pool, void *ptr, size_t size);
/**
* Inlined version of @mp_realloc().
**/
-static inline void *mp_realloc_fast(struct mempool *pool, void *ptr, uint size)
+static inline void *mp_realloc_fast(struct mempool *pool, void *ptr, size_t size)
{
mp_open_fast(pool, ptr);
ptr = mp_grow(pool, size);
***/
char *mp_strdup(struct mempool *, const char *) LIKE_MALLOC; /** Makes a copy of a string on a mempool. Returns NULL for NULL string. **/
-void *mp_memdup(struct mempool *, const void *, uint) LIKE_MALLOC; /** Makes a copy of a memory block on a mempool. **/
+void *mp_memdup(struct mempool *, const void *, size_t) LIKE_MALLOC; /** Makes a copy of a memory block on a mempool. **/
/**
* Concatenates all passed strings. The last parameter must be NULL.
* This will concatenate two strings:
* Convert memory block to a string. Makes a copy of the given memory block
* in the mempool @p, adding an extra terminating zero byte at the end.
**/
-char *mp_str_from_mem(struct mempool *p, const void *mem, uint len) LIKE_MALLOC;
+char *mp_str_from_mem(struct mempool *p, const void *mem, size_t len) LIKE_MALLOC;
/***
}
void
-mem_to_hex(char *dest, const byte *src, uint bytes, uint flags)
+mem_to_hex(char *dest, const byte *src, size_t bytes, uns flags)
{
uint sep = flags & 0xff;
}
const char *
-hex_to_mem(byte *dest, const char *src, uint max_bytes, uint flags)
+hex_to_mem(byte *dest, const char *src, size_t max_bytes, uns flags)
{
uint sep = flags & 0xff;
while (max_bytes-- && Cxdigit(src[0]) && Cxdigit(src[1]))
#include <ucw/string.h>
#ifdef CONFIG_DARWIN
-uint
-strnlen(const char *str, uint n)
+size_t
+strnlen(const char *str, size_t n)
{
const char *end = str + n;
const char *c;
return start;
}
-uint
-str_count_char(const char *str, uint chr)
+size_t
+str_count_char(const char *str, uns chr)
{
const byte *s = str;
- uint i = 0;
+ size_t i = 0;
while (*s)
if (*s++ == chr)
i++;
/* string.c */
#ifdef CONFIG_DARWIN
-uint strnlen(const char *str, uint n); // NOAPI
+size_t strnlen(const char *str, size_t n); // NOAPI
#endif
/**
char *str_format_flags(char *dest, const char *fmt, uint flags);
/** Counts occurrences of @chr in @str. **/
-uint str_count_char(const char *str, uint chr);
+size_t str_count_char(const char *str, uns chr);
/* str-esc.c */
* not be separated), possibly OR-ed with `MEM_TO_HEX_UPCASE` when upper-case
* characters should be used.
**/
-void mem_to_hex(char *dest, const byte *src, uint bytes, uint flags);
+void mem_to_hex(char *dest, const byte *src, size_t bytes, uns flags);
/**
* An inverse function to @mem_to_hex(). Takes a hexdump of at most @max_bytes
* bytes and stores the bytes to a buffer starting at @dest. Returns a pointer
* at the first character after the dump.
**/
-const char *hex_to_mem(byte *dest, const char *src, uint max_bytes, uint flags);
+const char *hex_to_mem(byte *dest, const char *src, size_t max_bytes, uns flags);
// Bottom 8 bits of flags are an optional separator of bytes, the rest is:
#define MEM_TO_HEX_UPCASE 0x100
#include <ucw/lib.h>
#include <ucw/unicode.h>
-uint
+size_t
utf8_strlen(const byte *str)
{
- uint len = 0;
+ size_t len = 0;
while (*str)
{
UTF8_SKIP(str);
return len;
}
-uint
-utf8_strnlen(const byte *str, uint n)
+size_t
+utf8_strnlen(const byte *str, size_t n)
{
- uint len = 0;
+ size_t len = 0;
const byte *end = str + n;
while (str < end)
{
* Count the number of Unicode characters in a zero-terminated UTF-8 string.
* Returned value for corrupted encoding is undefined, but is never greater than strlen().
**/
-uint utf8_strlen(const byte *str);
+size_t utf8_strlen(const byte *str);
/**
* Same as @utf8_strlen(), but returns at most @n characters.
**/
-uint utf8_strnlen(const byte *str, uint n);
+size_t utf8_strnlen(const byte *str, size_t n);
#endif
projects / libucw.git / commitdiff