[thirdparty/git.git] / utf8.c

#include "git-compat-util.h"
#include "utf8.h"

/* This code is originally from http://www.cl.cam.ac.uk/~mgk25/ucs/ */

struct interval {
  int first;
  int last;
};

/* auxiliary function for binary search in interval table */
static int bisearch(ucs_char_t 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;
}

/* The following two functions define the column width of an ISO 10646
 * character as follows:
 *
 *    - The null character (U+0000) has a column width of 0.
 *
 *    - Other C0/C1 control characters and DEL will lead to a return
 *      value of -1.
 *
 *    - Non-spacing and enclosing combining characters (general
 *      category code Mn or Me in the Unicode database) have a
 *      column width of 0.
 *
 *    - SOFT HYPHEN (U+00AD) has a column width of 1.
 *
 *    - Other format characters (general category code Cf in the Unicode
 *      database) and ZERO WIDTH SPACE (U+200B) have a column width of 0.
 *
 *    - Hangul Jamo medial vowels and final consonants (U+1160-U+11FF)
 *      have a column width of 0.
 *
 *    - Spacing characters in the East Asian Wide (W) or East Asian
 *      Full-width (F) category as defined in Unicode Technical
 *      Report #11 have a column width of 2.
 *
 *    - All remaining characters (including all printable
 *      ISO 8859-1 and WGL4 characters, Unicode control characters,
 *      etc.) have a column width of 1.
 *
 * This implementation assumes that ucs_char_t characters are encoded
 * in ISO 10646.
 */

static int git_wcwidth(ucs_char_t ch)
{
	/*
	 * Sorted list of non-overlapping intervals of non-spacing characters,
	 * generated by
	 *   "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c".
	 */
	static const struct interval combining[] = {
		{ 0x0300, 0x0357 }, { 0x035D, 0x036F }, { 0x0483, 0x0486 },
		{ 0x0488, 0x0489 }, { 0x0591, 0x05A1 }, { 0x05A3, 0x05B9 },
		{ 0x05BB, 0x05BD }, { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 },
		{ 0x05C4, 0x05C4 }, { 0x0600, 0x0603 }, { 0x0610, 0x0615 },
		{ 0x064B, 0x0658 }, { 0x0670, 0x0670 }, { 0x06D6, 0x06E4 },
		{ 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED }, { 0x070F, 0x070F },
		{ 0x0711, 0x0711 }, { 0x0730, 0x074A }, { 0x07A6, 0x07B0 },
		{ 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 }, { 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 }, { 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 }, { 0x200B, 0x200F },
		{ 0x202A, 0x202E }, { 0x2060, 0x2063 }, { 0x206A, 0x206F },
		{ 0x20D0, 0x20EA }, { 0x302A, 0x302F }, { 0x3099, 0x309A },
		{ 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F }, { 0xFE20, 0xFE23 },
		{ 0xFEFF, 0xFEFF }, { 0xFFF9, 0xFFFB }, { 0x1D167, 0x1D169 },
		{ 0x1D173, 0x1D182 }, { 0x1D185, 0x1D18B },
		{ 0x1D1AA, 0x1D1AD }, { 0xE0001, 0xE0001 },
		{ 0xE0020, 0xE007F }, { 0xE0100, 0xE01EF }
	};

	/* test for 8-bit control characters */
	if (ch == 0)
		return 0;
	if (ch < 32 || (ch >= 0x7f && ch < 0xa0))
		return -1;

	/* binary search in table of non-spacing characters */
	if (bisearch(ch, combining, sizeof(combining)
				/ sizeof(struct interval) - 1))
		return 0;

	/*
	 * If we arrive here, ch is neither a combining nor a C0/C1
	 * control character.
	 */

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

/*
 * Pick one ucs character starting from the location *start points at,
 * and return it, while updating the *start pointer to point at the
 * end of that character.
 *
 * If the string was not a valid UTF-8, *start pointer is set to NULL
 * and the return value is undefined.
 */
ucs_char_t pick_one_utf8_char(const char **start)
{
	unsigned char *s = (unsigned char *)*start;
	ucs_char_t ch;

	if (*s < 0x80) {
		/* 0xxxxxxx */
		ch = *s;
		*start += 1;
	} else if ((s[0] & 0xe0) == 0xc0) {
		/* 110XXXXx 10xxxxxx */
		if ((s[1] & 0xc0) != 0x80 ||
				/* overlong? */
				(s[0] & 0xfe) == 0xc0)
			goto invalid;
		ch = ((s[0] & 0x1f) << 6) | (s[1] & 0x3f);
		*start += 2;
	} else if ((s[0] & 0xf0) == 0xe0) {
		/* 1110XXXX 10Xxxxxx 10xxxxxx */
		if ((s[1] & 0xc0) != 0x80 ||
				(s[2] & 0xc0) != 0x80 ||
				/* overlong? */
				(s[0] == 0xe0 && (s[1] & 0xe0) == 0x80) ||
				/* surrogate? */
				(s[0] == 0xed && (s[1] & 0xe0) == 0xa0) ||
				/* U+FFFE or U+FFFF? */
				(s[0] == 0xef && s[1] == 0xbf &&
				 (s[2] & 0xfe) == 0xbe))
			goto invalid;
		ch = ((s[0] & 0x0f) << 12) |
			((s[1] & 0x3f) << 6) | (s[2] & 0x3f);
		*start += 3;
	} else if ((s[0] & 0xf8) == 0xf0) {
		/* 11110XXX 10XXxxxx 10xxxxxx 10xxxxxx */
		if ((s[1] & 0xc0) != 0x80 ||
				(s[2] & 0xc0) != 0x80 ||
				(s[3] & 0xc0) != 0x80 ||
				/* overlong? */
				(s[0] == 0xf0 && (s[1] & 0xf0) == 0x80) ||
				/* > U+10FFFF? */
				(s[0] == 0xf4 && s[1] > 0x8f) || s[0] > 0xf4)
			goto invalid;
		ch = ((s[0] & 0x07) << 18) | ((s[1] & 0x3f) << 12) |
			((s[2] & 0x3f) << 6) | (s[3] & 0x3f);
		*start += 4;
	} else {
invalid:
		*start = NULL;
		return 0;
	}

	return ch;
}

/*
 * This function returns the number of columns occupied by the character
 * pointed to by the variable start. The pointer is updated to point at
 * the next character.  If it was not valid UTF-8, the pointer is set to
 * NULL.
 */
int utf8_width(const char **start)
{
	ucs_char_t ch = pick_one_utf8_char(start);
	if (!*start)
		return 0;
	return git_wcwidth(ch);
}

int is_utf8(const char *text)
{
	while (*text) {
		if (*text == '\n' || *text == '\t' || *text == '\r') {
			text++;
			continue;
		}
		utf8_width(&text);
		if (!text)
			return 0;
	}
	return 1;
}

static void print_spaces(int count)
{
	static const char s[] = "                    ";
	while (count >= sizeof(s)) {
		fwrite(s, sizeof(s) - 1, 1, stdout);
		count -= sizeof(s) - 1;
	}
	fwrite(s, count, 1, stdout);
}

/*
 * Wrap the text, if necessary. The variable indent is the indent for the
 * first line, indent2 is the indent for all other lines.
 * If indent is negative, assume that already -indent columns have been
 * consumed (and no extra indent is necessary for the first line).
 */
int print_wrapped_text(const char *text, int indent, int indent2, int width)
{
	int w = indent, assume_utf8 = is_utf8(text);
	const char *bol = text, *space = NULL;

	if (indent < 0) {
		w = -indent;
		space = text;
	}

	for (;;) {
		char c = *text;
		if (!c || isspace(c)) {
			if (w < width || !space) {
				const char *start = bol;
				if (space)
					start = space;
				else
					print_spaces(indent);
				fwrite(start, text - start, 1, stdout);
				if (!c)
					return w;
				else if (c == '\t')
					w |= 0x07;
				space = text;
				w++;
				text++;
			}
			else {
				putchar('\n');
				text = bol = space + isspace(*space);
				space = NULL;
				w = indent = indent2;
			}
			continue;
		}
		if (assume_utf8)
			w += utf8_width(&text);
		else {
			w++;
			text++;
		}
	}
}

int is_encoding_utf8(const char *name)
{
	if (!name)
		return 1;
	if (!strcasecmp(name, "utf-8") || !strcasecmp(name, "utf8"))
		return 1;
	return 0;
}

/*
 * Given a buffer and its encoding, return it re-encoded
 * with iconv.  If the conversion fails, returns NULL.
 */
#ifndef NO_ICONV
#ifdef OLD_ICONV
	typedef const char * iconv_ibp;
#else
	typedef char * iconv_ibp;
#endif
char *reencode_string(const char *in, const char *out_encoding, const char *in_encoding)
{
	iconv_t conv;
	size_t insz, outsz, outalloc;
	char *out, *outpos;
	iconv_ibp cp;

	if (!in_encoding)
		return NULL;
	conv = iconv_open(out_encoding, in_encoding);
	if (conv == (iconv_t) -1)
		return NULL;
	insz = strlen(in);
	outsz = insz;
	outalloc = outsz + 1; /* for terminating NUL */
	out = xmalloc(outalloc);
	outpos = out;
	cp = (iconv_ibp)in;

	while (1) {
		size_t cnt = iconv(conv, &cp, &insz, &outpos, &outsz);

		if (cnt == -1) {
			size_t sofar;
			if (errno != E2BIG) {
				free(out);
				iconv_close(conv);
				return NULL;
			}
			/* insz has remaining number of bytes.
			 * since we started outsz the same as insz,
			 * it is likely that insz is not enough for
			 * converting the rest.
			 */
			sofar = outpos - out;
			outalloc = sofar + insz * 2 + 32;
			out = xrealloc(out, outalloc);
			outpos = out + sofar;
			outsz = outalloc - sofar - 1;
		}
		else {
			*outpos = '\0';
			break;
		}
	}
	iconv_close(conv);
	return out;
}
#endif
Commit	Line	Data
9e832665 JS	1	#include "git-compat-util.h"
	2	#include "utf8.h"
	3
	4	/* This code is originally from http://www.cl.cam.ac.uk/~mgk25/ucs/ */
	5
	6	struct interval {
	7	int first;
	8	int last;
	9	};
	10
	11	/* auxiliary function for binary search in interval table */
f3fa1838 JH	12	static int bisearch(ucs_char_t ucs, const struct interval *table, int max)
f3fa1838 JH	13	{
9e832665 JS	14	int min = 0;
	15	int mid;
	16
	17	if (ucs < table[0].first \|\| ucs > table[max].last)
	18	return 0;
	19	while (max >= min) {
	20	mid = (min + max) / 2;
	21	if (ucs > table[mid].last)
	22	min = mid + 1;
	23	else if (ucs < table[mid].first)
	24	max = mid - 1;
	25	else
	26	return 1;
	27	}
	28
	29	return 0;
	30	}
	31
	32	/* The following two functions define the column width of an ISO 10646
	33	* character as follows:
	34	*
	35	* - The null character (U+0000) has a column width of 0.
	36	*
	37	* - Other C0/C1 control characters and DEL will lead to a return
	38	* value of -1.
	39	*
	40	* - Non-spacing and enclosing combining characters (general
	41	* category code Mn or Me in the Unicode database) have a
	42	* column width of 0.
	43	*
	44	* - SOFT HYPHEN (U+00AD) has a column width of 1.
	45	*
	46	* - Other format characters (general category code Cf in the Unicode
	47	* database) and ZERO WIDTH SPACE (U+200B) have a column width of 0.
	48	*
	49	* - Hangul Jamo medial vowels and final consonants (U+1160-U+11FF)
	50	* have a column width of 0.
	51	*
	52	* - Spacing characters in the East Asian Wide (W) or East Asian
	53	* Full-width (F) category as defined in Unicode Technical
	54	* Report #11 have a column width of 2.
	55	*
	56	* - All remaining characters (including all printable
	57	* ISO 8859-1 and WGL4 characters, Unicode control characters,
	58	* etc.) have a column width of 1.
	59	*
28321145	60	* This implementation assumes that ucs_char_t characters are encoded
9e832665 JS	61	* in ISO 10646.
	62	*/
	63
b51be13c	64	static int git_wcwidth(ucs_char_t ch)
9e832665 JS	65	{
	66	/*
	67	* Sorted list of non-overlapping intervals of non-spacing characters,
	68	* generated by
	69	* "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c".
	70	*/
	71	static const struct interval combining[] = {
	72	{ 0x0300, 0x0357 }, { 0x035D, 0x036F }, { 0x0483, 0x0486 },
	73	{ 0x0488, 0x0489 }, { 0x0591, 0x05A1 }, { 0x05A3, 0x05B9 },
	74	{ 0x05BB, 0x05BD }, { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 },
	75	{ 0x05C4, 0x05C4 }, { 0x0600, 0x0603 }, { 0x0610, 0x0615 },
	76	{ 0x064B, 0x0658 }, { 0x0670, 0x0670 }, { 0x06D6, 0x06E4 },
	77	{ 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED }, { 0x070F, 0x070F },
	78	{ 0x0711, 0x0711 }, { 0x0730, 0x074A }, { 0x07A6, 0x07B0 },
	79	{ 0x0901, 0x0902 }, { 0x093C, 0x093C }, { 0x0941, 0x0948 },
	80	{ 0x094D, 0x094D }, { 0x0951, 0x0954 }, { 0x0962, 0x0963 },
	81	{ 0x0981, 0x0981 }, { 0x09BC, 0x09BC }, { 0x09C1, 0x09C4 },
	82	{ 0x09CD, 0x09CD }, { 0x09E2, 0x09E3 }, { 0x0A01, 0x0A02 },
	83	{ 0x0A3C, 0x0A3C }, { 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 },
	84	{ 0x0A4B, 0x0A4D }, { 0x0A70, 0x0A71 }, { 0x0A81, 0x0A82 },
	85	{ 0x0ABC, 0x0ABC }, { 0x0AC1, 0x0AC5 }, { 0x0AC7, 0x0AC8 },
	86	{ 0x0ACD, 0x0ACD }, { 0x0AE2, 0x0AE3 }, { 0x0B01, 0x0B01 },
	87	{ 0x0B3C, 0x0B3C }, { 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B43 },
	88	{ 0x0B4D, 0x0B4D }, { 0x0B56, 0x0B56 }, { 0x0B82, 0x0B82 },
	89	{ 0x0BC0, 0x0BC0 }, { 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 },
	90	{ 0x0C46, 0x0C48 }, { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 },
	91	{ 0x0CBC, 0x0CBC }, { 0x0CBF, 0x0CBF }, { 0x0CC6, 0x0CC6 },
	92	{ 0x0CCC, 0x0CCD }, { 0x0D41, 0x0D43 }, { 0x0D4D, 0x0D4D },
	93	{ 0x0DCA, 0x0DCA }, { 0x0DD2, 0x0DD4 }, { 0x0DD6, 0x0DD6 },
	94	{ 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A }, { 0x0E47, 0x0E4E },
	95	{ 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EB9 }, { 0x0EBB, 0x0EBC },
	96	{ 0x0EC8, 0x0ECD }, { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 },
	97	{ 0x0F37, 0x0F37 }, { 0x0F39, 0x0F39 }, { 0x0F71, 0x0F7E },
	98	{ 0x0F80, 0x0F84 }, { 0x0F86, 0x0F87 }, { 0x0F90, 0x0F97 },
	99	{ 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 }, { 0x102D, 0x1030 },
	100	{ 0x1032, 0x1032 }, { 0x1036, 0x1037 }, { 0x1039, 0x1039 },
	101	{ 0x1058, 0x1059 }, { 0x1160, 0x11FF }, { 0x1712, 0x1714 },
	102	{ 0x1732, 0x1734 }, { 0x1752, 0x1753 }, { 0x1772, 0x1773 },
	103	{ 0x17B4, 0x17B5 }, { 0x17B7, 0x17BD }, { 0x17C6, 0x17C6 },
	104	{ 0x17C9, 0x17D3 }, { 0x17DD, 0x17DD }, { 0x180B, 0x180D },
	105	{ 0x18A9, 0x18A9 }, { 0x1920, 0x1922 }, { 0x1927, 0x1928 },
	106	{ 0x1932, 0x1932 }, { 0x1939, 0x193B }, { 0x200B, 0x200F },
	107	{ 0x202A, 0x202E }, { 0x2060, 0x2063 }, { 0x206A, 0x206F },
	108	{ 0x20D0, 0x20EA }, { 0x302A, 0x302F }, { 0x3099, 0x309A },
	109	{ 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F }, { 0xFE20, 0xFE23 },
	110	{ 0xFEFF, 0xFEFF }, { 0xFFF9, 0xFFFB }, { 0x1D167, 0x1D169 },
	111	{ 0x1D173, 0x1D182 }, { 0x1D185, 0x1D18B },
	112	{ 0x1D1AA, 0x1D1AD }, { 0xE0001, 0xE0001 },
	113	{ 0xE0020, 0xE007F }, { 0xE0100, 0xE01EF }
	114	};
	115
	116	/* test for 8-bit control characters */
	117	if (ch == 0)
	118	return 0;
	119	if (ch < 32 \|\| (ch >= 0x7f && ch < 0xa0))
	120	return -1;
	121
	122	/* binary search in table of non-spacing characters */
	123	if (bisearch(ch, combining, sizeof(combining)
	124	/ sizeof(struct interval) - 1))
	125	return 0;
	126
	127	/*
	128	* If we arrive here, ch is neither a combining nor a C0/C1
129	* control character.
130	*/
131
132	return 1 +
133	(ch >= 0x1100 &&
134	/* Hangul Jamo init. consonants */
135	(ch <= 0x115f \|\|
136	ch == 0x2329 \|\| ch == 0x232a \|\|
137	/* CJK ... Yi */
138	(ch >= 0x2e80 && ch <= 0xa4cf &&
139	ch != 0x303f) \|\|
140	/* Hangul Syllables */
141	(ch >= 0xac00 && ch <= 0xd7a3) \|\|
142	/* CJK Compatibility Ideographs */
143	(ch >= 0xf900 && ch <= 0xfaff) \|\|
144	/* CJK Compatibility Forms */
145	(ch >= 0xfe30 && ch <= 0xfe6f) \|\|
146	/* Fullwidth Forms */
147	(ch >= 0xff00 && ch <= 0xff60) \|\|
148	(ch >= 0xffe0 && ch <= 0xffe6) \|\|
149	(ch >= 0x20000 && ch <= 0x2fffd) \|\|
150	(ch >= 0x30000 && ch <= 0x3fffd)));
151	}
152
153	/*
396ccf1f JH	154	* Pick one ucs character starting from the location *start points at,
	155	* and return it, while updating the *start pointer to point at the
	156	* end of that character.
	157	*
	158	* If the string was not a valid UTF-8, *start pointer is set to NULL
	159	* and the return value is undefined.
9e832665	160	*/
396ccf1f	161	ucs_char_t pick_one_utf8_char(const char **start)
9e832665 JS	162	{
9e832665 JS	163	unsigned char s = (unsigned char )*start;
28321145	164	ucs_char_t ch;
9e832665 JS	165
	166	if (*s < 0x80) {
	167	/* 0xxxxxxx */
	168	ch = *s;
	169	*start += 1;
	170	} else if ((s[0] & 0xe0) == 0xc0) {
	171	/* 110XXXXx 10xxxxxx */
	172	if ((s[1] & 0xc0) != 0x80 \|\|
	173	/* overlong? */
	174	(s[0] & 0xfe) == 0xc0)
	175	goto invalid;
	176	ch = ((s[0] & 0x1f) << 6) \| (s[1] & 0x3f);
	177	*start += 2;
	178	} else if ((s[0] & 0xf0) == 0xe0) {
	179	/* 1110XXXX 10Xxxxxx 10xxxxxx */
	180	if ((s[1] & 0xc0) != 0x80 \|\|
	181	(s[2] & 0xc0) != 0x80 \|\|
	182	/* overlong? */
	183	(s[0] == 0xe0 && (s[1] & 0xe0) == 0x80) \|\|
	184	/* surrogate? */
	185	(s[0] == 0xed && (s[1] & 0xe0) == 0xa0) \|\|
	186	/* U+FFFE or U+FFFF? */
	187	(s[0] == 0xef && s[1] == 0xbf &&
	188	(s[2] & 0xfe) == 0xbe))
	189	goto invalid;
	190	ch = ((s[0] & 0x0f) << 12) \|
	191	((s[1] & 0x3f) << 6) \| (s[2] & 0x3f);
	192	*start += 3;
	193	} else if ((s[0] & 0xf8) == 0xf0) {
	194	/* 11110XXX 10XXxxxx 10xxxxxx 10xxxxxx */
	195	if ((s[1] & 0xc0) != 0x80 \|\|
	196	(s[2] & 0xc0) != 0x80 \|\|
	197	(s[3] & 0xc0) != 0x80 \|\|
	198	/* overlong? */
	199	(s[0] == 0xf0 && (s[1] & 0xf0) == 0x80) \|\|
	200	/* > U+10FFFF? */
	201	(s[0] == 0xf4 && s[1] > 0x8f) \|\| s[0] > 0xf4)
	202	goto invalid;
	203	ch = ((s[0] & 0x07) << 18) \| ((s[1] & 0x3f) << 12) \|
	204	((s[2] & 0x3f) << 6) \| (s[3] & 0x3f);
	205	*start += 4;
	206	} else {
	207	invalid:
	208	*start = NULL;
	209	return 0;
	210	}
	211
396ccf1f JH	212	return ch;
	213	}
	214
	215	/*
	216	* This function returns the number of columns occupied by the character
	217	* pointed to by the variable start. The pointer is updated to point at
	218	* the next character. If it was not valid UTF-8, the pointer is set to
	219	* NULL.
	220	*/
	221	int utf8_width(const char **start)
	222	{
	223	ucs_char_t ch = pick_one_utf8_char(start);
	224	if (!*start)
	225	return 0;
b51be13c	226	return git_wcwidth(ch);
9e832665 JS	227	}
	228
	229	int is_utf8(const char *text)
	230	{
	231	while (*text) {
	232	if (text == '\n' \|\| text == '\t' \|\| *text == '\r') {
	233	text++;
	234	continue;
	235	}
	236	utf8_width(&text);
	237	if (!text)
	238	return 0;
	239	}
	240	return 1;
	241	}
	242
	243	static void print_spaces(int count)
	244	{
	245	static const char s[] = " ";
	246	while (count >= sizeof(s)) {
	247	fwrite(s, sizeof(s) - 1, 1, stdout);
	248	count -= sizeof(s) - 1;
	249	}
	250	fwrite(s, count, 1, stdout);
	251	}
	252
	253	/*
	254	* Wrap the text, if necessary. The variable indent is the indent for the
	255	* first line, indent2 is the indent for all other lines.
094e03b0 JS	256	* If indent is negative, assume that already -indent columns have been
094e03b0 JS	257	* consumed (and no extra indent is necessary for the first line).
9e832665	258	*/
094e03b0	259	int print_wrapped_text(const char *text, int indent, int indent2, int width)
9e832665 JS	260	{
	261	int w = indent, assume_utf8 = is_utf8(text);
	262	const char bol = text, space = NULL;
	263
094e03b0 JS	264	if (indent < 0) {
	265	w = -indent;
	266	space = text;
	267	}
	268
9e832665 JS	269	for (;;) {
	270	char c = *text;
	271	if (!c \|\| isspace(c)) {
	272	if (w < width \|\| !space) {
	273	const char *start = bol;
	274	if (space)
	275	start = space;
	276	else
	277	print_spaces(indent);
	278	fwrite(start, text - start, 1, stdout);
094e03b0 JS	279	if (!c)
	280	return w;
	281	else if (c == '\t')
9e832665 JS	282	w \|= 0x07;
	283	space = text;
	284	w++;
	285	text++;
	286	}
	287	else {
	288	putchar('\n');
62273826	289	text = bol = space + isspace(*space);
9e832665 JS	290	space = NULL;
	291	w = indent = indent2;
	292	}
	293	continue;
	294	}
	295	if (assume_utf8)
	296	w += utf8_width(&text);
	297	else {
	298	w++;
	299	text++;
	300	}
	301	}
	302	}
b45974a6	303
677cfed5 JH	304	int is_encoding_utf8(const char *name)
	305	{
	306	if (!name)
	307	return 1;
	308	if (!strcasecmp(name, "utf-8") \|\| !strcasecmp(name, "utf8"))
	309	return 1;
	310	return 0;
	311	}
	312
b45974a6 JH	313	/*
	314	* Given a buffer and its encoding, return it re-encoded
	315	* with iconv. If the conversion fails, returns NULL.
	316	*/
	317	#ifndef NO_ICONV
fd547a97 RJ	318	#ifdef OLD_ICONV
	319	typedef const char * iconv_ibp;
	320	#else
	321	typedef char * iconv_ibp;
	322	#endif
b45974a6 JH	323	char reencode_string(const char in, const char out_encoding, const char in_encoding)
	324	{
	325	iconv_t conv;
	326	size_t insz, outsz, outalloc;
fd547a97 RJ	327	char out, outpos;
fd547a97 RJ	328	iconv_ibp cp;
b45974a6 JH	329
	330	if (!in_encoding)
	331	return NULL;
	332	conv = iconv_open(out_encoding, in_encoding);
	333	if (conv == (iconv_t) -1)
	334	return NULL;
	335	insz = strlen(in);
	336	outsz = insz;
	337	outalloc = outsz + 1; /* for terminating NUL */
	338	out = xmalloc(outalloc);
	339	outpos = out;
fd547a97	340	cp = (iconv_ibp)in;
b45974a6 JH	341
	342	while (1) {
	343	size_t cnt = iconv(conv, &cp, &insz, &outpos, &outsz);
	344
	345	if (cnt == -1) {
	346	size_t sofar;
	347	if (errno != E2BIG) {
	348	free(out);
	349	iconv_close(conv);
	350	return NULL;
	351	}
	352	/* insz has remaining number of bytes.
	353	* since we started outsz the same as insz,
	354	* it is likely that insz is not enough for
	355	* converting the rest.
	356	*/
	357	sofar = outpos - out;
	358	outalloc = sofar + insz * 2 + 32;
	359	out = xrealloc(out, outalloc);
	360	outpos = out + sofar;
	361	outsz = outalloc - sofar - 1;
	362	}
	363	else {
	364	*outpos = '\0';
	365	break;
	366	}
	367	}
	368	iconv_close(conv);
	369	return out;
	370	}
	371	#endif