unicode.c

/* Unicode module, utf8 encoding */

#include "unicode.h"

#ifdef UNICODE_DEBUG
#include <stdio.h>
#define UNI_DEBUG(x) do { printf x; puts("\n"); } while (0)
#else
#define UNI_DEBUG(x)
#endif

#define INVALID_TAIL(c) ((c & 0xc0) != 0x80)

/* utf8_decode_len - Returns the number of chars needed to
 * fully decode an utf8 encoded string starting with [ch].
 * -1 is returned in case of error.
 */
int
utf8_decode_len(unsigned char ch)
{
	if (ch < 0x80)
		return 1;
	else if (ch < 0xc0)
		return -1;
	else if (ch < 0xe0)
		return 2;
	else if (ch < 0xf0)
		return 3;
	else if (ch < 0xf8)
		return 4;
	else
		return -1;
}

/* utf8_rune_len - Returns the number of bytes needed to
 * encode a given Rune.
 *
 * -1 is returned in case of error.
 */
int
utf8_rune_len(Rune ucs)
{
	if (ucs < 0x80)
		return 1;
	else if (ucs < 0x800)
		return 2;
	else if (ucs < 0x10000)
		return 3;
	else if (ucs < 0x110000)
		return 4;
	else
		return -1;
}

/* utf8_rune_nlen - Returns the number of chars needed to
 * encode a given string of Rune of length [len].
 */
int
utf8_rune_nlen(const Rune * ucs, int len)
{
	int count = 0, i;

	for (i = 0; i < len; i++)
		count += utf8_rune_len(ucs[i]);
	return count;
}

/* utf8_encode_rune - Encodes a given Rune using the utf8
 * encoding scheme in a the string [s], writing, at most
 * [len] chars. If [len] is not enough to fully encode the
 * Rune, return 0.
 */
int
utf8_encode_rune(Rune ucs, unsigned char *s, int len)
{
	if (ucs < 0x80) {
		if (len < 1)
			return 0;
		s[0] = (unsigned char)ucs;
		return 1;
	} else if (ucs < 0x800) {
		if (len < 2)
			return 0;
		s[0] = (unsigned char)0xc0 | (ucs >> 6);
		s[1] = (unsigned char)0x80 | (ucs & 0x3f);
		return 2;
	} else if (ucs < 0x10000) {
		if (len < 3)
			return 0;
		s[0] = (unsigned char)0xe0 | (ucs >> 12);
		s[1] = (unsigned char)0x80 | ((ucs >> 6) & 0x3f);
		s[2] = (unsigned char)0x80 | (ucs & 0x3f);
		return 3;
	} else if (ucs < 0x110000) {
		if (len < 4)
			return 0;
		s[0] = (unsigned char)0xf0 | (ucs >> 18);
		s[1] = (unsigned char)0x80 | ((ucs >> 12) & 0x3f);
		s[2] = (unsigned char)0x80 | ((ucs >> 6) & 0x3f);
		s[3] = (unsigned char)0x80 | (ucs & 0x3f);
		return 4;
	} else {
		UNI_DEBUG(("utf8_encode_rune: invalid rune supplied"));
		return -1;
	}
}

/* utf8_decode_rune - Decodes one Rune from a utf8 encoded
 * string containing at least [len] chars. Returns the
 * number of chars processed int [str].
 *
 * If not enough data is present to decode 0 is returned.
 */
int
utf8_decode_rune(Rune *r, const unsigned char *str, int len)
{
	unsigned char c;
	int read, n;
	Rune ucs;

	if (len < 1)
		return 0;

	c = *str++;

	if (c < 0x80) {
		*r = c;
		return 1;
	}
	else if (c < 0xc0) {
		goto fail;
	}
	else if (c < 0xe0) {
		read = 2;
		ucs = c & 0x1f;
	}
	else if (c < 0xf0) {
		read = 3;
		ucs = c & 0xf;
	}
	else if (c < 0xf8) {
		read = 4;
		ucs = c & 0x7;
	}
	else {
		goto fail;
	}

	if (len < read)
		return 0;

	for (n=0; n<read-1; n++) {
		c = *str++;
		if (INVALID_TAIL(c))
			goto fail;
		ucs <<= 6;
		ucs |= c & 0x3f;
	}

	if (read == utf8_rune_len(ucs)) {
		*r = ucs;
		return read;
	}

fail:
	*r = WRONGRUNE;
	return 1;

}

/* Char width determination */

struct interval {
	Rune first;
	Rune last;
};

static int
bisearch(Rune ucs, const struct interval *table, int max)
{
	int min = 0;
	int mid;

	if (ucs < table[0].first || ucs > table[max].last)
		return 0;
	while (max >= min) {
		mid = (min + max) / 2;
		if (ucs > table[mid].last)
			min = mid + 1;
		else if (ucs < table[mid].first)
			max = mid - 1;
		else
			return 1;
	}
	return 0;
}


/* unicode_rune_width - Credit goes to Markus Kuhn for this function,
 * latest version: http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
 */
int
unicode_rune_width(Rune ucs)
{
	static const struct interval comb[] = {
		{0x0300, 0x036f}, {0x0483, 0x0486}, {0x0488, 0x0489},
		{0x0591, 0x05bd}, {0x05bf, 0x05bf}, {0x05c1, 0x05c2},
		{0x05c4, 0x05c5}, {0x05c7, 0x05c7}, {0x0600, 0x0603},
		{0x0610, 0x0615}, {0x064b, 0x065e}, {0x0670, 0x0670},
		{0x06d6, 0x06e4}, {0x06e7, 0x06e8}, {0x06ea, 0x06ed},
		{0x070f, 0x070f}, {0x0711, 0x0711}, {0x0730, 0x074a},
		{0x07a6, 0x07b0}, {0x07eb, 0x07f3}, {0x0901, 0x0902},
		{0x093c, 0x093c}, {0x0941, 0x0948}, {0x094d, 0x094d},
		{0x0951, 0x0954}, {0x0962, 0x0963}, {0x0981, 0x0981},
		{0x09bc, 0x09bc}, {0x09c1, 0x09c4}, {0x09cd, 0x09cd},
		{0x09e2, 0x09e3}, {0x0a01, 0x0a02}, {0x0a3c, 0x0a3c},
		{0x0a41, 0x0a42}, {0x0a47, 0x0a48}, {0x0a4b, 0x0a4d},
		{0x0a70, 0x0a71}, {0x0a81, 0x0a82}, {0x0abc, 0x0abc},
		{0x0ac1, 0x0ac5}, {0x0ac7, 0x0ac8}, {0x0acd, 0x0acd},
		{0x0ae2, 0x0ae3}, {0x0b01, 0x0b01}, {0x0b3c, 0x0b3c},
		{0x0b3f, 0x0b3f}, {0x0b41, 0x0b43}, {0x0b4d, 0x0b4d},
		{0x0b56, 0x0b56}, {0x0b82, 0x0b82}, {0x0bc0, 0x0bc0},
		{0x0bcd, 0x0bcd}, {0x0c3e, 0x0c40}, {0x0c46, 0x0c48},
		{0x0c4a, 0x0c4d}, {0x0c55, 0x0c56}, {0x0cbc, 0x0cbc},
		{0x0cbf, 0x0cbf}, {0x0cc6, 0x0cc6}, {0x0ccc, 0x0ccd},
		{0x0ce2, 0x0ce3}, {0x0d41, 0x0d43}, {0x0d4d, 0x0d4d},
		{0x0dca, 0x0dca}, {0x0dd2, 0x0dd4}, {0x0dd6, 0x0dd6},
		{0x0e31, 0x0e31}, {0x0e34, 0x0e3a}, {0x0e47, 0x0e4e},
		{0x0eb1, 0x0eb1}, {0x0eb4, 0x0eb9}, {0x0ebb, 0x0ebc},
		{0x0ec8, 0x0ecd}, {0x0f18, 0x0f19}, {0x0f35, 0x0f35},
		{0x0f37, 0x0f37}, {0x0f39, 0x0f39}, {0x0f71, 0x0f7e},
		{0x0f80, 0x0f84}, {0x0f86, 0x0f87}, {0x0f90, 0x0f97},
		{0x0f99, 0x0fbc}, {0x0fc6, 0x0fc6}, {0x102d, 0x1030},
		{0x1032, 0x1032}, {0x1036, 0x1037}, {0x1039, 0x1039},
		{0x1058, 0x1059}, {0x1160, 0x11ff}, {0x135f, 0x135f},
		{0x1712, 0x1714}, {0x1732, 0x1734}, {0x1752, 0x1753},
		{0x1772, 0x1773}, {0x17b4, 0x17b5}, {0x17b7, 0x17bd},
		{0x17c6, 0x17c6}, {0x17c9, 0x17d3}, {0x17dd, 0x17dd},
		{0x180b, 0x180d}, {0x18a9, 0x18a9}, {0x1920, 0x1922},
		{0x1927, 0x1928}, {0x1932, 0x1932}, {0x1939, 0x193b},
		{0x1a17, 0x1a18}, {0x1b00, 0x1b03}, {0x1b34, 0x1b34},
		{0x1b36, 0x1b3a}, {0x1b3c, 0x1b3c}, {0x1b42, 0x1b42},
		{0x1b6b, 0x1b73}, {0x1dc0, 0x1dca}, {0x1dfe, 0x1dff},
		{0x200b, 0x200f}, {0x202a, 0x202e}, {0x2060, 0x2063},
		{0x206a, 0x206f}, {0x20d0, 0x20ef}, {0x302a, 0x302f},
		{0x3099, 0x309a}, {0xa806, 0xa806}, {0xa80b, 0xa80b},
		{0xa825, 0xa826}, {0xfb1e, 0xfb1e}, {0xfe00, 0xfe0f},
		{0xfe20, 0xfe23}, {0xfeff, 0xfeff}, {0xfff9, 0xfffb},
		{0x10a01, 0x10a03}, {0x10a05, 0x10a06}, {0x10a0c, 0x10a0f},
		{0x10a38, 0x10a3a}, {0x10a3f, 0x10a3f}, {0x1d167, 0x1d169},
		{0x1d173, 0x1d182}, {0x1d185, 0x1d18b}, {0x1d1aa, 0x1d1ad},
		{0x1d242, 0x1d244}, {0xe0001, 0xe0001}, {0xe0020, 0xe007f},
		{0xe0100, 0xe01ef}
	};

	if (ucs == 0)
		return 0;
	if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))
		return -1;

	if (bisearch(ucs, comb, sizeof comb / sizeof comb[0] - 1))
		return 0;

	return 1 +
		(ucs >= 0x1100
		&& (ucs <= 0x115f ||                                    /* Hangul Jamo init. consonants */
		    ucs == 0x2329 || ucs == 0x232a ||
		   (ucs >= 0x2e80 && ucs <= 0xa4cf && ucs != 0x303f) || /* CJK ... Yi */
		   (ucs >= 0xac00 && ucs <= 0xd7a3) ||                  /* Hangul Syllables */
		   (ucs >= 0xf900 && ucs <= 0xfaff) ||                  /* CJK Compatibility Ideographs */
		   (ucs >= 0xfe10 && ucs <= 0xfe19) ||                  /* Vertical forms */
		   (ucs >= 0xfe30 && ucs <= 0xfe6f) ||                  /* CJK Compatibility Forms */
		   (ucs >= 0xff00 && ucs <= 0xff60) ||                  /* Fullwidth Forms */
		   (ucs >= 0xffe0 && ucs <= 0xffe6) ||
		   (ucs >= 0x20000 && ucs <= 0x2fffd) ||
		   (ucs >= 0x30000 && ucs <= 0x3fffd)));
}