sled

util.c (4979B)

---

 /* This program is licensed under the terms of GNU GPL v3 or (at your option)
  * any later version. Copyright (C) 2022-2026  Страхиња Радић.
  * See the file LICENSE for exact copyright and license details. */
 #include <assert.h>
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "limit.h"
 #include "termbox.h"
 #include "util.h"
 
 /* Whitespace definition for determining word boundaries */
 #define B_WS " \v\t"
 /* Full word boundary delimiter definition */
 #define B_FULL " \v\t()[]{},.;:/\\"
 
 size_t
 u8_string_to_unicode(uint32_t* us, const char* s, const ssize_t max)
 {
 	uint32_t uch;
 	uint32_t* pus  = us;
 	const char* ps = s;
 	int u8_len     = 0;
 	size_t added   = 0;
 
 	assert(s != NULL);
 	while (ps - s < max && *ps)
 	{
 		u8_len = tb_utf8_char_to_unicode(&uch, ps);
 		if (!u8_len)
 		{
 			uch    = U32_REPL_CHAR;
 			u8_len = 1;
 		}
 		added++;
 		ps += u8_len;
 		*pus++ = uch;
 	}
 	*pus = 0;
 	return added;
 }
 
 size_t
 unicode_string_to_u8(char* s, const uint32_t* us, const ssize_t max)
 {
 	char ch[8];
 	char* ps	    = NULL;
 	const uint32_t* pus = us;
 	size_t len;
 	size_t added = 0;
 
 	assert((s != NULL) && (us != NULL));
 	ps = s;
 	while (pus - us < max && *pus)
 	{
 		len = tb_utf8_unicode_to_char(ch, *pus);
 		if (len < 0)
 			return added;
 		memccpy(ps, ch, 0, len);
 		ps += len;
 		added++;
 		pus++;
 	}
 	*ps = 0;
 	return added;
 }
 
 int
 u32_has_nonblanks(const uint32_t* s)
 {
 	const uint32_t* ps = s;
 
 	assert(s != NULL);
 	while (*ps)
 	{
 		if (!u32_is_word_boundary(*ps, 1))
 			return 1;
 		ps++;
 	}
 	return 0;
 }
 
 uint32_t*
 u32_memccpy(uint32_t* dst, const uint32_t* src, uint32_t c, size_t len)
 {
 	size_t copied = 0;
 	assert((dst != NULL) && (src != NULL));
 	while ((*dst++ = *src++) != c && copied < len)
 		copied++;
 	if (copied == len)
 		return NULL;
 	return dst;
 }
 
 /* len is the max length of src in bytes */
 uint32_t*
 u32_u8_memccpy(uint32_t* dst, const char* src, uint32_t c, size_t len)
 {
 	const char* psrc = src;
 	uint32_t uch;
 	size_t copied = 0;
 	int u8_len;
 
 	assert((dst != NULL) && (src != NULL));
 	do
 	{
 		if (!*psrc)
 		{
 			*dst++ = 0;
 			break;
 		}
 		u8_len = tb_utf8_char_to_unicode(&uch, psrc);
 		if (u8_len < 0)
 		{
 			/* error, replace uch with "error char" */
 			uch    = 0xFFFD;
 			u8_len = -u8_len;
 		}
 		psrc += u8_len;
 		copied += u8_len;
 		if (copied >= len)
 			return NULL;
 	} while ((*dst++ = uch) != c && copied < len);
 	return dst;
 }
 
 size_t
 u8_strlen(const char* s)
 {
 	const char* ps = s;
 	uint32_t uc;
 	size_t len;
 	size_t result = 0;
 	assert(s != NULL);
 	while (*ps)
 	{
 		len = tb_utf8_char_to_unicode(&uc, ps);
 		result += len;
 		ps++;
 	}
 	return result;
 }
 
 size_t
 u32_strlen(const uint32_t* s)
 {
 	const uint32_t* ps = s;
 	size_t len	   = 0;
 	assert(s != NULL);
 	while (*ps++)
 		len++;
 	return len;
 }
 
 const uint32_t*
 u32_strstr(const uint32_t* haystack, const uint32_t* needle)
 {
 	const uint32_t* ph = haystack;
 	assert((haystack != NULL) && (needle != NULL));
 	while (*ph)
 	{
 		if (u32_starts_with(ph, needle))
 			return ph;
 		ph++;
 	}
 	return NULL;
 }
 
 const uint32_t*
 u32_strrstr(const uint32_t* haystack, const uint32_t* needle,
 	const uint32_t* haystack_tail)
 {
 	size_t needle_len = u32_strlen(needle);
 	const uint32_t* ph;
 
 	assert((haystack != NULL) && (haystack_tail != NULL)
 		&& (needle != NULL));
 	if (needle_len > (size_t)(haystack_tail - haystack))
 		return NULL;
 
 	ph = haystack_tail - needle_len;
 
 strrstr_loop:
 	if (u32_starts_with(ph, needle))
 		return ph;
 	if (ph != haystack)
 		ph--;
 	else
 		goto strrstr_end;
 	goto strrstr_loop;
 strrstr_end:
 	return NULL;
 }
 
 const uint32_t*
 u32_strchr(const uint32_t* haystack, const uint32_t needle)
 {
 	const uint32_t* ph = haystack;
 	assert(haystack != NULL);
 	while (*ph)
 	{
 		if (*ph == needle)
 			return ph;
 		ph++;
 	}
 	return NULL;
 }
 
 int
 is_word_boundary(const char ch, const int strictly_whitespace)
 {
 	return strictly_whitespace ? strchr(B_WS, ch) != NULL
 				   : strchr(B_FULL, ch) != NULL;
 }
 
 int
 u32_is_word_boundary(const uint32_t ch, const int strictly_whitespace)
 {
 	static uint32_t uws[sizeof(B_WS) + 1];
 	static uint32_t ufull[sizeof(B_FULL) + 1];
 	if (!*uws)
 	{
 		(void)u8_string_to_unicode(uws, B_WS, sizeof(B_WS));
 		(void)u8_string_to_unicode(ufull, B_FULL, sizeof(B_FULL));
 	}
 	return strictly_whitespace ? u32_strchr(uws, ch) != NULL
 				   : u32_strchr(ufull, ch) != NULL;
 }
 
 int
 starts_with(const char* s, const char* with)
 {
 	assert((s != NULL) && (with != NULL));
 	while (*s && *s == *with)
 	{
 		if (*s != *with)
 			return 0;
 		s++;
 		with++;
 	}
 	return *with == 0;
 }
 
 int
 u32_starts_with(const uint32_t* s, const uint32_t* with)
 {
 	assert((s != NULL) && (with != NULL));
 	while (*s && *s == *with)
 	{
 		if (*s != *with)
 			return 0;
 		s++;
 		with++;
 	}
 	return *with == 0;
 }
 
 const char*
 u8_basename(const char* path)
 {
 	const char* ppath;
 	assert(path != NULL);
 	ppath = path + strlen(path);
 	while (ppath != path && *ppath != '/')
 		ppath--;
 	if (*ppath == '/')
 		ppath++;
 	return ppath;
 }