utils/libhack/multibyte.c

/*      $NetBSD: multibyte.c,v 1.8 2019/07/28 10:21:18 martin Exp $      */

/*
 * Ignore all multibyte sequences, removes all the citrus code.
 * Probably only used by vfprintf() when parsing the format string.
 * And possibly from libcurses if compiled with HAVE_WCHAR.
 */

#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <wctype.h>
#include <ctype.h>

size_t
mbrtowc(wchar_t *wc, const char *str, size_t max_sz, mbstate_t *ps)
{
	if (str == NULL)
		return 0;

	if (wc != NULL)
		*wc = (unsigned char)*str;

	return *str == '\0' ? 0 : 1;
}

size_t
mbrtowc_l(wchar_t *wc, const char *str, size_t max_sz, mbstate_t *ps, locale_t loc)
{
	return mbrtowc(wc, str, max_sz, ps);
}

size_t
wcrtomb(char *str, wchar_t wc, mbstate_t *ps)
{
    *str = wc & 0xFF;
    return 1;
}


size_t
wcrtomb_l(char *str, wchar_t wc, mbstate_t *ps, locale_t loc)
{
	return wcrtomb(str, wc, ps);
}

int
wctob(wint_t x)
{
	return x;
}

int
wctob_l(wint_t x, locale_t loc)
{
	return x;
}

wint_t
btowc(int x)
{
	return x;
}

wint_t
btowc_l(int x, locale_t loc)
{
	return x;
}

size_t
mbrlen(const char * __restrict p, size_t l, mbstate_t * __restrict v)
{
	size_t i;
	for (i = 0; i < l; i++)
		if (p[i] == '\0')
			return i;
	return l;
}


size_t
mbrlen_l(const char * __restrict p, size_t l, mbstate_t * __restrict v,
    locale_t loc)
{
	return mbrlen(p, l, v);
}

int
mbsinit(const mbstate_t *s)
{
	return 0;
}

size_t
mbsrtowcs(wchar_t * __restrict pwcs, const char ** __restrict s, size_t n,
    mbstate_t * __restrict ps)
{
	const char *p;
	wchar_t *d;
	size_t count;

	for (p = *s, d = pwcs, count = 0;
		count <= n;
		count++, d++, p++)
	{
		if (mbrtowc(d, p, 1, ps) == 0)
			break;
	}
	return count;
}


size_t
mbsrtowcs_l(wchar_t * __restrict pwcs, const char ** __restrict s, size_t n,
    mbstate_t * __restrict ps, locale_t loc)
{
	return mbsrtowcs(pwcs, s, n, ps);
}

size_t
wcsrtombs(char * __restrict s, const wchar_t ** __restrict pwcs, size_t n,
    mbstate_t * __restrict ps)
{
	char *d;
	const wchar_t *p;
	size_t count;

	for (p = *pwcs, d = s, count = 0;
		count <= n && *p != 0;
		count++, d++, p++)
	{
		wcrtomb(d, *p, ps);
	}
	*d = 0;
	return count;
}

size_t
wcsrtombs_l(char * __restrict s, const wchar_t ** __restrict pwcs, size_t n,
    mbstate_t * __restrict ps, locale_t loc)
{
	return wcsrtombs(s, pwcs, n, ps);
}

size_t
_mb_cur_max_l(locale_t loc)
{
	return MB_CUR_MAX;
}

wint_t
fgetwc(FILE *stream)
{
	return fgetc(stream);
}

wint_t
fputwc(wchar_t wc, FILE *stream)
{
	return fputc(wc & 0xFF, stream);
}

wint_t __fputwc_unlock(wchar_t wc, FILE *stream);
wint_t
__fputwc_unlock(wchar_t wc, FILE *stream)
{
	return __sputc(wc & 0xFF, stream);
}

#define	MAPSINGLE(CT)	\
	int	\
	isw##CT(wint_t wc)	\
	{	\
		return is##CT(wc & 0xFF);	\
	}

MAPSINGLE(alnum)
MAPSINGLE(alpha)
MAPSINGLE(blank)
MAPSINGLE(cntrl)
MAPSINGLE(digit)
MAPSINGLE(graph)
MAPSINGLE(lower)
MAPSINGLE(print)
MAPSINGLE(punct)
MAPSINGLE(space)
MAPSINGLE(upper)
MAPSINGLE(xdigit)

int
iswspace_l(wint_t wc, locale_t loc)
{
	return iswspace(wc);
}

struct wct_entry_hack {
	const char *name;
	int (*predicate)(wint_t);
};

#define	WCTENTRY(T)	{ .name= #T , .predicate= isw##T },
static const struct wct_entry_hack my_wcts[] = {
	{ .name = NULL },
	WCTENTRY(alnum)
	WCTENTRY(alpha)
	WCTENTRY(blank)
	WCTENTRY(cntrl)
	WCTENTRY(digit)
	WCTENTRY(graph)
	WCTENTRY(lower)
	WCTENTRY(print)
	WCTENTRY(punct)
	WCTENTRY(space)
	WCTENTRY(upper)
	WCTENTRY(xdigit)
};

wctype_t
wctype(const char *charclass)
{

	for (size_t i = 1; i < __arraycount(my_wcts); i++)
		if (strcmp(charclass, my_wcts[i].name) == 0)
			return (wctype_t)i;

	return (wctype_t)0;
}

int
iswctype(wint_t wc, wctype_t charclass)
{
	size_t ndx = (size_t)charclass;

	if (ndx < 1 || ndx >= __arraycount(my_wcts))
		return 0;

	return my_wcts[ndx].predicate(wc);
}

size_t
wcslen(const wchar_t *s)
{
	size_t l;

	if (s == NULL)
		return 0;

	while (*s) {
		s++;
		l++;
	}

	return l;
}

int
wcswidth(const wchar_t *pwcs, size_t n)
{
	int cols;

	if (pwcs == NULL)
		return 0;

	if (*pwcs == 0)
		return 0;

	for (cols = 0; *pwcs && n > 0; cols++)
		if (!isprint(*pwcs & 0xFF))
			return -1;
	return cols;
}

int
wcwidth(wchar_t wc)
{
	if (wc == 0)
		return 0;
	if (!isprint(wc & 0xFF))
		return -1;
	return 1;
}

wchar_t *
wmemchr(const wchar_t *s, wchar_t c, size_t n)
{

	if (s == NULL)
		return NULL;
	while (*s != 0 && *s != c)
		s++;
	if (*s != 0)
		return __UNCONST(s);
	return NULL;
}

wchar_t *
wmemcpy(wchar_t * restrict s1, const wchar_t * restrict s2, size_t n)
{
	wchar_t *p;

	for (p = s1; n > 0; n--)
		*p++ = *s2++;

	return s1;
}

wint_t
towlower(wint_t wc)
{
	return tolower(wc & 0xFF);
}

wint_t
towupper(wint_t wc)
{
	return toupper(wc & 0xFF);
}