1/*
2 * The authors of this software are Rob Pike and Ken Thompson.
3 *              Copyright (c) 2002 by Lucent Technologies.
4 * Permission to use, copy, modify, and distribute this software for any
5 * purpose without fee is hereby granted, provided that this entire notice
6 * is included in all copies of any software which is or includes a copy
7 * or modification of this software and in all copies of the supporting
8 * documentation for such software.
9 * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
10 * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
11 * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
12 * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
13 */
14#include <stdarg.h>
15#include <string.h>
16#include "util/utf.h"
17
18namespace re2 {
19
20enum
21{
22	Bit1	= 7,
23	Bitx	= 6,
24	Bit2	= 5,
25	Bit3	= 4,
26	Bit4	= 3,
27	Bit5	= 2,
28
29	T1	= ((1<<(Bit1+1))-1) ^ 0xFF,	/* 0000 0000 */
30	Tx	= ((1<<(Bitx+1))-1) ^ 0xFF,	/* 1000 0000 */
31	T2	= ((1<<(Bit2+1))-1) ^ 0xFF,	/* 1100 0000 */
32	T3	= ((1<<(Bit3+1))-1) ^ 0xFF,	/* 1110 0000 */
33	T4	= ((1<<(Bit4+1))-1) ^ 0xFF,	/* 1111 0000 */
34	T5	= ((1<<(Bit5+1))-1) ^ 0xFF,	/* 1111 1000 */
35
36	Rune1	= (1<<(Bit1+0*Bitx))-1,		/* 0000 0000 0111 1111 */
37	Rune2	= (1<<(Bit2+1*Bitx))-1,		/* 0000 0111 1111 1111 */
38	Rune3	= (1<<(Bit3+2*Bitx))-1,		/* 1111 1111 1111 1111 */
39	Rune4	= (1<<(Bit4+3*Bitx))-1,
40                                        /* 0001 1111 1111 1111 1111 1111 */
41
42	Maskx	= (1<<Bitx)-1,			/* 0011 1111 */
43	Testx	= Maskx ^ 0xFF,			/* 1100 0000 */
44
45	Bad	= Runeerror,
46};
47
48int
49chartorune(Rune *rune, const char *str)
50{
51	int c, c1, c2, c3;
52	long l;
53
54	/*
55	 * one character sequence
56	 *	00000-0007F => T1
57	 */
58	c = *(unsigned char*)str;
59	if(c < Tx) {
60		*rune = c;
61		return 1;
62	}
63
64	/*
65	 * two character sequence
66	 *	0080-07FF => T2 Tx
67	 */
68	c1 = *(unsigned char*)(str+1) ^ Tx;
69	if(c1 & Testx)
70		goto bad;
71	if(c < T3) {
72		if(c < T2)
73			goto bad;
74		l = ((c << Bitx) | c1) & Rune2;
75		if(l <= Rune1)
76			goto bad;
77		*rune = l;
78		return 2;
79	}
80
81	/*
82	 * three character sequence
83	 *	0800-FFFF => T3 Tx Tx
84	 */
85	c2 = *(unsigned char*)(str+2) ^ Tx;
86	if(c2 & Testx)
87		goto bad;
88	if(c < T4) {
89		l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3;
90		if(l <= Rune2)
91			goto bad;
92		*rune = l;
93		return 3;
94	}
95
96	/*
97	 * four character sequence (21-bit value)
98	 *	10000-1FFFFF => T4 Tx Tx Tx
99	 */
100	c3 = *(unsigned char*)(str+3) ^ Tx;
101	if (c3 & Testx)
102		goto bad;
103	if (c < T5) {
104		l = ((((((c << Bitx) | c1) << Bitx) | c2) << Bitx) | c3) & Rune4;
105		if (l <= Rune3)
106			goto bad;
107		*rune = l;
108		return 4;
109	}
110
111	/*
112	 * Support for 5-byte or longer UTF-8 would go here, but
113	 * since we don't have that, we'll just fall through to bad.
114	 */
115
116	/*
117	 * bad decoding
118	 */
119bad:
120	*rune = Bad;
121	return 1;
122}
123
124int
125runetochar(char *str, const Rune *rune)
126{
127	/* Runes are signed, so convert to unsigned for range check. */
128	unsigned long c;
129
130	/*
131	 * one character sequence
132	 *	00000-0007F => 00-7F
133	 */
134	c = *rune;
135	if(c <= Rune1) {
136		str[0] = c;
137		return 1;
138	}
139
140	/*
141	 * two character sequence
142	 *	0080-07FF => T2 Tx
143	 */
144	if(c <= Rune2) {
145		str[0] = T2 | (c >> 1*Bitx);
146		str[1] = Tx | (c & Maskx);
147		return 2;
148	}
149
150	/*
151	 * If the Rune is out of range, convert it to the error rune.
152	 * Do this test here because the error rune encodes to three bytes.
153	 * Doing it earlier would duplicate work, since an out of range
154	 * Rune wouldn't have fit in one or two bytes.
155	 */
156	if (c > Runemax)
157		c = Runeerror;
158
159	/*
160	 * three character sequence
161	 *	0800-FFFF => T3 Tx Tx
162	 */
163	if (c <= Rune3) {
164		str[0] = T3 |  (c >> 2*Bitx);
165		str[1] = Tx | ((c >> 1*Bitx) & Maskx);
166		str[2] = Tx |  (c & Maskx);
167		return 3;
168	}
169
170	/*
171	 * four character sequence (21-bit value)
172	 *     10000-1FFFFF => T4 Tx Tx Tx
173	 */
174	str[0] = T4 | (c >> 3*Bitx);
175	str[1] = Tx | ((c >> 2*Bitx) & Maskx);
176	str[2] = Tx | ((c >> 1*Bitx) & Maskx);
177	str[3] = Tx | (c & Maskx);
178	return 4;
179}
180
181int
182runelen(Rune rune)
183{
184	char str[10];
185
186	return runetochar(str, &rune);
187}
188
189int
190fullrune(const char *str, int n)
191{
192	if (n > 0) {
193		int c = *(unsigned char*)str;
194		if (c < Tx)
195			return 1;
196		if (n > 1) {
197			if (c < T3)
198				return 1;
199			if (n > 2) {
200				if (c < T4 || n > 3)
201					return 1;
202			}
203		}
204	}
205	return 0;
206}
207
208
209int
210utflen(const char *s)
211{
212	int c;
213	long n;
214	Rune rune;
215
216	n = 0;
217	for(;;) {
218		c = *(unsigned char*)s;
219		if(c < Runeself) {
220			if(c == 0)
221				return n;
222			s++;
223		} else
224			s += chartorune(&rune, s);
225		n++;
226	}
227	return 0;
228}
229
230char*
231utfrune(const char *s, Rune c)
232{
233	long c1;
234	Rune r;
235	int n;
236
237	if(c < Runesync)		/* not part of utf sequence */
238		return strchr((char*)s, c);
239
240	for(;;) {
241		c1 = *(unsigned char*)s;
242		if(c1 < Runeself) {	/* one byte rune */
243			if(c1 == 0)
244				return 0;
245			if(c1 == c)
246				return (char*)s;
247			s++;
248			continue;
249		}
250		n = chartorune(&r, s);
251		if(r == c)
252			return (char*)s;
253		s += n;
254	}
255	return 0;
256}
257
258}  // namespace re2
259