poe

util.c (8693B)

---

 /* This program is licensed under the terms of GNU GPL v3 or (at your option)
  * any later version. Copyright (C) 2021-2024  Страхиња Радић.
  * See the file LICENSE for exact copyright and license details. */
 
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "termbox.h"
 #include "po.h"
 #include "util.h"
 
 enum { UTLERRNONE = 0, UTLERROVFL = 1 };
 
 int utlerrno = UTLERRNONE;
 
 /* 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 uch;
 	uint32_t* pus = us;
 	int u8_len    = 0;
 	size_t added  = 0;
 
 	while (s && *s && u8_len != TB_ERR)
 	{
 		u8_len = tb_utf8_char_to_unicode(&uch, s);
 		if (added + 1 > max)
 			break;
 		*pus++ = uch;
 		if (u8_len != TB_ERR)
 		{
 			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 size_t s_size, const uint32_t* us,
 	const size_t max)
 {
 	char ch[8];
 	const uint32_t* pus = us;
 	size_t len;
 	size_t added = 0;
 
 	if (!pus)
 		return added;
 
 	*s = 0;
 	while (*pus)
 	{
 		size_t res;
 
 		len	= tb_utf8_unicode_to_char(ch, *pus);
 		ch[len] = 0;
 		res	= strlcat(s, ch, s_size);
 		if (res >= s_size)
 		{
 			utlerrno = UTLERROVFL;
 			return added;
 		}
 		added++;
 		pus++;
 		if (added + 1 > max)
 			break;
 	}
 	utlerrno = UTLERRNONE;
 	return added;
 }
 
 size_t
 u32_match_msgid_ending(const uint32_t* msgid, uint32_t* msgstr, size_t max)
 {
 	uint32_t* buf = calloc(max + 1, sizeof(uint32_t));
 	if (!buf)
 		return 0;
 	size_t buf_len	 = 0;
 	size_t msgid_len = 0;
 
 	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, (uint32_t*)L"\\n"))
 	{
 		if (!(buf_len > 1
 			    && u32_starts_with(buf + buf_len - 2,
 				    (uint32_t*)L"\\n")))
 		{
 			buf_len += 2;
 			buf[buf_len - 2] = '\\';
 			buf[buf_len - 1] = 'n';
 			buf[buf_len]	 = 0;
 		}
 	}
 #ifdef MATCH_MSGSTR_ENDING
 	else if (msgid_len > 0
 		&& u32_strstr((uint32_t*)L" .", msgid + msgid_len - 1))
 	{
 		if (!(buf_len > 0
 			    && u32_strstr((uint32_t*)L" .", buf + buf_len - 1)))
 		{
 			buf_len++;
 			buf[buf_len - 1] = msgid[msgid_len - 1];
 			buf[buf_len]	 = 0;
 		}
 	}
 	else if (buf_len > 1
 		&& u32_starts_with(buf + buf_len - 2, (uint32_t*)L"\\n"))
 	{
 		buf_len -= 2;
 		buf[buf_len] = 0;
 	}
 	else if (buf_len > 0 && u32_strstr((uint32_t*)L" .", buf + buf_len - 1))
 	{
 		buf_len--;
 		buf[buf_len] = 0;
 	}
 #endif
 
 	u32_strncpy(msgstr, buf, max);
 
 	return buf_len;
 }
 
 size_t
 u32_count_chars(const uint32_t* s, const uint32_t ch)
 {
 	size_t result	   = 0;
 	const uint32_t* ps = s;
 	while (*ps)
 	{
 		if (*ps == ch)
 			result++;
 		ps++;
 	}
 	return result;
 }
 
 size_t
 u32_count_strings(const uint32_t* haystack, const uint32_t* needle)
 {
 	size_t result		  = 0;
 	const uint32_t* phaystack = haystack;
 	size_t needle_len	  = 0;
 
 	if (!haystack || !needle)
 		return 0;
 
 	needle_len = u32_strlen(needle);
 	if (!needle_len)
 		return 0;
 
 	while (*phaystack)
 	{
 		if (u32_starts_with(phaystack, needle))
 			result++;
 		phaystack++;
 	}
 	return result;
 }
 
 size_t
 u32_encode_tabs(uint32_t* s, size_t max)
 {
 	uint32_t* buf = calloc(max + 1, sizeof(uint32_t));
 	if (!buf)
 		return 0;
 	uint32_t* pbuf = buf;
 	uint32_t* ps   = s;
 	size_t newlen  = 0;
 
 	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;
 }
 
 size_t
 u32_decode_tabs(uint32_t* s, size_t max)
 {
 	uint32_t* buf = calloc(max + 1, sizeof(uint32_t));
 	if (!buf)
 		return 0;
 	uint32_t* pbuf = buf;
 	uint32_t* ps   = s;
 	size_t newlen  = 0;
 
 	while (*ps)
 	{
 		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;
 }
 
 size_t
 u32_strlen(const uint32_t* s)
 {
 	const uint32_t* ps = s;
 	size_t len	   = 0;
 	if (!s)
 		return 0;
 	while (*ps++)
 		len++;
 	return len;
 }
 
 const uint32_t*
 u32_strstr(const uint32_t* haystack, const uint32_t* needle)
 {
 	const uint32_t* ph = haystack;
 	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;
 	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;
 	/* 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;
 	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;
 	if (!ufrom)
 		return 0;
 	u8_string_to_unicode(ufrom, from, max);
 	len = u32_strncpy(to, ufrom, max);
 	free(ufrom);
 	return len;
 }
 
 size_t
 u8_u32_strncpy(char* to, const uint32_t* from, size_t max)
 {
 	char* cfrom = calloc(max + 1, 1);
 	size_t len;
 	if (!cfrom)
 		return 0;
 	unicode_string_to_u8(cfrom, max + 1, 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 - start;
 			have_last_nonblank = 1;
 		}
 
 		ps++;
 		result++;
 	}
 
 	if (next_line)
 		*next_line = ps;
 
 	return result;
 }
 
 const int
 is_word_boundary(const char ch, const int strictly_whitespace)
 {
 	return strictly_whitespace ? strchr(" \v\t", ch) != NULL
 				   : strchr(" \v\t()[]{},.;:/\\", ch) != NULL;
 }
 
 const int
 u32_is_word_boundary(const uint32_t ch, const int strictly_whitespace)
 {
 	return strictly_whitespace
 		? u32_strchr((uint32_t*)L" \v\t", ch) != NULL
 		: u32_strchr((uint32_t*)L" \v\t()[]{},.;:/\\", ch) != NULL;
 }
 
 const int
 starts_with(const char* s, const char* with)
 {
 	while (*s && *s == *with)
 	{
 		if (*s != *with)
 			return 0;
 		s++;
 		with++;
 	}
 	return *with == 0;
 }
 
 const int
 u32_starts_with(const uint32_t* s, const uint32_t* with)
 {
 	while (*s && *s == *with)
 	{
 		if (*s != *with)
 			return 0;
 		s++;
 		with++;
 	}
 	return *with == 0;
 }
 
 const char*
 u8_basename(const char* path)
 {
 	const char* ppath;
 	if (!path)
 		return 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);
 }*/