poe

util.c (11059B)

---

 /* This program is licensed under the terms of GNU GPL v3 or (at your option)
  * any later version. Copyright (C) 2021-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 "draw.h"
 #include "termbox.h"
 #include "po.h"
 #include "util.h"
 
 /* 32-bit string constants */
 const uint32_t bslash_en[] = {0x0000005c, 0x0000006e, 0};
 const uint32_t space_dot[] = {0x00000020, 0x0000002e, 0};
 
 extern int match_msgstr_ending;
 
 /* max - max Unicode characters to convert from UTF-8
  * Returns: number of processed Unicode characters */
 size_t
 u8_string_to_unicode(uint32_t* us, const char* s, const size_t max)
 {
 	uint32_t* pus = us;
 	uint32_t uch;
 	size_t added = 0;
 	int u8_len   = 0;
 
 	assert((s != NULL) && (us != NULL));
 	while (*s)
 	{
 		u8_len = tb_utf8_char_to_unicode(&uch, s);
 		if (added + 1 > max)
 			break;
 		if (u8_len > 0)
 		{
 			*pus++ = uch;
 			s += u8_len;
 			added++;
 		}
 	}
 	*pus++ = 0;
 	return added;
 }
 
 /* max - max Unicode characters to convert to UTF-8
  * Returns: number of processed Unicode characters */
 size_t
 unicode_string_to_u8(char* s, const uint32_t* us, const size_t max)
 {
 	char ch[8];
 	char* ps	    = NULL;
 	const uint32_t* pus = us;
 	size_t added	    = 0;
 	size_t len;
 
 	assert((s != NULL) && (us != NULL));
 	ps = s;
 	while (*pus)
 	{
 		len = tb_utf8_unicode_to_char(ch, *pus);
 		if (added + 1 > max)
 			return added;
 		memccpy(ps, ch, 0, len);
 		ps += len;
 		added++;
 		pus++;
 	}
 	*ps = 0;
 	return added;
 }
 
 /*
  * Returns: -1 on error
  */
 ssize_t
 u32_match_msgid_ending(struct DrawState* state, const uint32_t* msgid,
 	uint32_t* msgstr, size_t max)
 {
 	uint32_t* buf	  = NULL;
 	ssize_t buf_len	  = 0;
 	ssize_t msgid_len = 0;
 
 	assert((state != NULL) && (msgstr != NULL));
 	if (!msgid)
 		return 0;
 
 	buf = calloc(max + 1, sizeof(uint32_t));
 	if (!buf)
 		goto u32_match_msgid_ending_alloc_error;
 
 	buf_len	  = u32_strncpy(buf, msgstr, (max + 1) * sizeof(uint32_t));
 	msgid_len = u32_strlen(msgid);
 
 	if (msgid_len > 1 && u32_starts_with(msgid + msgid_len - 2, bslash_en))
 	{
 		if (!(buf_len > 1
 			    && u32_starts_with(buf + buf_len - 2, bslash_en)))
 		{
 			buf_len += 2;
 			buf[buf_len - 2] = BSLASH;
 			buf[buf_len - 1] = EN;
 			buf[buf_len]	 = 0;
 		}
 	}
 	else if (match_msgstr_ending && msgid_len > 0
 		&& u32_strstr(space_dot, msgid + msgid_len - 1))
 	{
 		if (!(buf_len > 0 && u32_strstr(space_dot, buf + buf_len - 1)))
 		{
 			buf_len++;
 			buf[buf_len - 1] = msgid[msgid_len - 1];
 			buf[buf_len]	 = 0;
 		}
 	}
 	else if (match_msgstr_ending && buf_len > 1
 		&& u32_starts_with(buf + buf_len - 2, bslash_en))
 	{
 		buf_len -= 2;
 		buf[buf_len] = 0;
 	}
 	else if (match_msgstr_ending && buf_len > 0
 		&& u32_strstr(space_dot, buf + buf_len - 1))
 	{
 		buf_len--;
 		buf[buf_len] = 0;
 	}
 
 	u32_strncpy(msgstr, buf, max);
 	free(buf);
 	return buf_len;
 
 u32_match_msgid_ending_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return -1;
 }
 
 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
 u32_count_chars(const uint32_t* s, const uint32_t ch)
 {
 	const uint32_t* ps = s;
 	size_t result	   = 0;
 	assert(s != NULL);
 	while (*ps)
 	{
 		if (*ps == ch)
 			result++;
 		ps++;
 	}
 	return result;
 }
 
 size_t
 u32_count_strings(const uint32_t* haystack, const uint32_t* needle)
 {
 	const uint32_t* phaystack = haystack;
 	size_t needle_len	  = 0;
 	size_t result		  = 0;
 
 	assert((haystack != NULL) && (needle != NULL));
 	needle_len = u32_strlen(needle);
 	if (!needle_len)
 		return 0;
 
 	while (*phaystack)
 	{
 		if (u32_starts_with(phaystack, needle))
 			result++;
 		phaystack++;
 	}
 	return result;
 }
 
 /*
  * Returns: -1 on error
  */
 ssize_t
 u32_encode_tabs(struct DrawState* state, uint32_t* s, size_t max)
 {
 	uint32_t* buf  = NULL;
 	uint32_t* pbuf = NULL;
 	uint32_t* ps   = s;
 	size_t newlen  = 0;
 
 	assert((state != NULL) && (s != NULL));
 	buf = calloc(max + 1, sizeof(uint32_t));
 	if (!buf)
 		goto u32_encode_tabs_alloc_error;
 	pbuf = buf;
 	while (*ps)
 	{
 		if (*ps == '\t')
 		{
 			*pbuf++ = '\\';
 			*pbuf++ = 't';
 			ps++;
 			newlen += 2;
 		}
 		else
 		{
 			*pbuf++ = *ps++;
 			newlen++;
 		}
 	}
 	*pbuf = 0;
 	u32_strncpy(s, buf, max);
 	free(buf);
 	return newlen;
 
 u32_encode_tabs_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return -1;
 }
 
 /*
  * Returns: -1 on error
  */
 ssize_t
 u32_decode_tabs(struct DrawState* state, uint32_t* s, size_t max)
 {
 	uint32_t* buf  = NULL;
 	uint32_t* pbuf = NULL;
 	uint32_t* ps   = s;
 	size_t newlen  = 0;
 
 	assert((state != NULL) && (s != NULL));
 	buf = calloc(max + 1, sizeof(uint32_t));
 	if (!buf)
 		goto u32_decode_tabs_alloc_error;
 	pbuf = buf;
 	while (*ps && (size_t)(ps - s) < max)
 	{
 		if (*ps == '\\' && *(ps + 1) == 't')
 		{
 			*pbuf++ = '\t';
 			ps += 2;
 			newlen++;
 		}
 		else
 		{
 			*pbuf++ = *ps++;
 			newlen++;
 		}
 	}
 	*pbuf = 0;
 	u32_strncpy(s, buf, max);
 	free(buf);
 	return newlen;
 
 u32_decode_tabs_alloc_error:
 	state->error = ERR_CANT_ALLOC;
 	return -1;
 }
 
 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_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;
 }
 
 size_t
 u32_strncpy(uint32_t* to, const uint32_t* from, size_t max)
 {
 	const uint32_t* pfrom = from;
 	size_t copied	      = 0;
 	assert((to != NULL) && (from != NULL));
 	/* pfrom - from < max - 1 ... except we can't reliably subtract with
 	 * size_t */
 	while (*pfrom && pfrom + 1 < max + from)
 	{
 		*to++ = *pfrom++;
 		copied++;
 	}
 	*to = 0;
 	return copied;
 }
 
 /*
  * to   - u32 string to concatenate to
  * from - u32 string to concatenate
  * max  - total combined string size */
 size_t
 u32_strncat(uint32_t* to, const uint32_t* from, size_t max)
 {
 	const uint32_t* pfrom = from;
 	size_t copied	      = 0;
 	assert((to != NULL) && (from != NULL));
 	while (*to && copied + 1 < max)
 	{
 		to++;
 		copied++;
 	}
 	while (*pfrom && copied + 1 < max)
 	{
 		*to++ = *pfrom++;
 		copied++;
 	}
 	*to = 0;
 	return copied;
 }
 
 size_t
 u32_u8_strncpy(uint32_t* to, const char* from, size_t max)
 {
 	uint32_t* ufrom = calloc(max + 1, sizeof(uint32_t));
 	size_t len;
 	assert(to != NULL);
 	if (!ufrom)
 		return 0;
 	u8_string_to_unicode(ufrom, from, max);
 	len = u32_strncpy(to, ufrom, max);
 	free(ufrom);
 	return len;
 }
 
 /*
  * Returns: -1 on error
  */
 ssize_t
 u8_u32_strncpy(char* to, const uint32_t* from, size_t max)
 {
 	char* cfrom = NULL;
 	size_t len;
 	assert(to != NULL);
 	cfrom = calloc(max + 1, 1);
 	if (!cfrom)
 		return -1;
 	unicode_string_to_u8(cfrom, from, max);
 	len = strlen(cfrom);
 	strncpy(to, cfrom, max);
 	if (len && len < max)
 		to[len] = 0;
 	free(cfrom);
 	return len;
 }
 
 /* wrap - if >0, also wrap lines
  */
 size_t
 u32_lines_in_string(const uint32_t* s, const int include_eol, const size_t wrap)
 {
 	size_t result	   = 1;
 	const uint32_t* ps = NULL;
 	// int last_empty	   = 0;
 
 	if (!s)
 		return result;
 
 	ps = s;
 	while (*ps)
 	{
 		u32_next_line(s, &ps, include_eol, wrap);
 		if (*ps)
 			result++;
 	}
 	/*if (ps > s + 1 && *(ps - 2) == '\\' && *(ps - 1) == 'n')
 		last_empty = 1;*/
 	return result;	      // + last_empty;
 }
 
 /*
  * returns line length
  * s - entire string (multiple lines)
  * next_line - pointer to the next line; if NULL, only line length is returned
  * wrap - wrap lines to this many characters (runes); if 0, don't wrap
  */
 size_t
 u32_next_line(const uint32_t* s, const uint32_t** next_line,
 	const int include_eol, const size_t wrap)
 {
 	size_t result	       = 0;
 	const uint32_t* ps     = NULL;
 	const uint32_t* start  = NULL;
 	size_t last_nonblank   = 0;
 	int have_last_nonblank = 0;
 
 	if (!s)
 		return result;
 
 	start = s;
 	if (next_line)
 		start = *next_line;
 	ps = start;
 	while (*ps)
 	{
 		if (wrap > 0 && result > wrap)
 		{
 			size_t cutoff = wrap;
 
 			if (have_last_nonblank)
 				cutoff = last_nonblank + 1;
 			if (next_line)
 				*next_line = start + cutoff;
 
 			return cutoff;
 		}
 
 		if (*ps == '\\' && *(ps + 1) == 'n')
 		{
 			if (next_line)
 				*next_line = ps + 2;
 			return result + (include_eol ? 2 : 0);
 		}
 
 		if (!u32_is_word_boundary(*ps, 1)
 			&& u32_is_word_boundary(*(ps + 1), 1))
 		{
 			last_nonblank	   = ps + 1 - start;
 			have_last_nonblank = 1;
 		}
 
 		ps++;
 		result++;
 	}
 
 	if (next_line)
 		*next_line = ps;
 
 	return result;
 }
 
 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;
 }
 
 /*
 void
 poe_log(const char* msg, ...)
 {
 	va_list args;
 	va_start(args, msg);
 	FILE* log = fopen("/tmp/poe.log", "at");
 	vfprintf(log, msg, args);
 	va_end(args);
 	fclose(log);
 }*/