Subversion Repositories planix.SVN

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 - 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 "utf.h"
17 
#include "utfdef.h"
18 
 
19 
enum
20 
{
21 
	Bit1	= 7,
22 
	Bitx	= 6,
23 
	Bit2	= 5,
24 
	Bit3	= 4,
25 
	Bit4	= 3,
26 
	Bit5	= 2,
27 
 
28 
	T1	= ((1<<(Bit1+1))-1) ^ 0xFF,	/* 0000 0000 */
29 
	Tx	= ((1<<(Bitx+1))-1) ^ 0xFF,	/* 1000 0000 */
30 
	T2	= ((1<<(Bit2+1))-1) ^ 0xFF,	/* 1100 0000 */
31 
	T3	= ((1<<(Bit3+1))-1) ^ 0xFF,	/* 1110 0000 */
32 
	T4	= ((1<<(Bit4+1))-1) ^ 0xFF,	/* 1111 0000 */
33 
	T5	= ((1<<(Bit5+1))-1) ^ 0xFF,	/* 1111 1000 */
34 
 
35 
	Rune1	= (1<<(Bit1+0*Bitx))-1,		/* 0000 0000 0000 0000 0111 1111 */
36 
	Rune2	= (1<<(Bit2+1*Bitx))-1,		/* 0000 0000 0000 0111 1111 1111 */
37 
	Rune3	= (1<<(Bit3+2*Bitx))-1,		/* 0000 0000 1111 1111 1111 1111 */
38 
	Rune4	= (1<<(Bit4+3*Bitx))-1,		/* 0001 1111 1111 1111 1111 1111 */
39 
 
40 
	Maskx	= (1<<Bitx)-1,			/* 0011 1111 */
41 
	Testx	= Maskx ^ 0xFF,			/* 1100 0000 */
42 
 
43 
	SurrogateMin	= 0xD800,
44 
	SurrogateMax	= 0xDFFF,
45 
 
46 
	Bad	= Runeerror,
47 
};
48 
 
49 
int
50 
chartorune(Rune *rune, char *str)
51 
{
52 
	int c, c1, c2, c3;
53 
	long l;
54 
 
55 
	/*
56 
	 * one character sequence
57 
	 *	00000-0007F => T1
58 
	 */
59 
	c = *(uchar*)str;
60 
	if(c < Tx) {
61 
		*rune = c;
62 
		return 1;
63 
	}
64 
 
65 
	/*
66 
	 * two character sequence
67 
	 *	00080-007FF => T2 Tx
68 
	 */
69 
	c1 = *(uchar*)(str+1) ^ Tx;
70 
	if(c1 & Testx)
71 
		goto bad;
72 
	if(c < T3) {
73 
		if(c < T2)
74 
			goto bad;
75 
		l = ((c << Bitx) | c1) & Rune2;
76 
		if(l <= Rune1)
77 
			goto bad;
78 
		*rune = l;
79 
		return 2;
80 
	}
81 
 
82 
	/*
83 
	 * three character sequence
84 
	 *	00800-0FFFF => T3 Tx Tx
85 
	 */
86 
	c2 = *(uchar*)(str+2) ^ Tx;
87 
 
88 
	if(c2 & Testx)
89 
		goto bad;
90 
	if(c < T4) {
91 
		l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3;
92 
		if(l <= Rune2)
93 
			goto bad;
94 
		if (SurrogateMin <= l && l <= SurrogateMax)
95 
			goto bad;
96 
		*rune = l;
97 
		return 3;
98 
	}
99 
 
100 
	/*
101 
	 * four character sequence
102 
	 *	10000-10FFFF => T4 Tx Tx Tx
103 
	 */
104 
	if(UTFmax >= 4) {
105 
		c3 = *(uchar*)(str+3) ^ Tx;
106 
		if(c3 & Testx)
107 
			goto bad;
108 
		if(c < T5) {
109 
			l = ((((((c << Bitx) | c1) << Bitx) | c2) << Bitx) | c3) & Rune4;
110 
			if(l <= Rune3)
111 
				goto bad;
112 
			if(l > Runemax)
113 
				goto bad;
114 
			*rune = l;
115 
			return 4;
116 
		}
117 
	}
118 
 
119 
	/*
120 
	 * bad decoding
121 
	 */
122 
bad:
123 
	*rune = Bad;
124 
	return 1;
125 
}
126 
 
127 
int
128 
runetochar(char *str, Rune *rune)
129 
{
130 
	long c;
131 
 
132 
	/*
133 
	 * one character sequence
134 
	 *	00000-0007F => 00-7F
135 
	 */
136 
	c = *rune;
137 
	if(c <= Rune1) {
138 
		str[0] = c;
139 
		return 1;
140 
	}
141 
 
142 
	/*
143 
	 * two character sequence
144 
	 *	0080-07FF => T2 Tx
145 
	 */
146 
	if(c <= Rune2) {
147 
		str[0] = T2 | (c >> 1*Bitx);
148 
		str[1] = Tx | (c & Maskx);
149 
		return 2;
150 
	}
151 
	/*
152 
	 * If the Rune is out of range or a surrogate half, convert it to the error rune.
153 
	 * Do this test here because the error rune encodes to three bytes.
154 
	 * Doing it earlier would duplicate work, since an out of range
155 
	 * Rune wouldn't have fit in one or two bytes.
156 
	 */
157 
	if (c > Runemax)
158 
		c = Runeerror;
159 
	if (SurrogateMin <= c && c <= SurrogateMax)
160 
		c = Runeerror;
161 
 
162 
	/*
163 
	 * three character sequence
164 
	 *	0800-FFFF => T3 Tx Tx
165 
	 */
166 
	if (c <= Rune3) {
167 
		str[0] = T3 |  (c >> 2*Bitx);
168 
		str[1] = Tx | ((c >> 1*Bitx) & Maskx);
169 
		str[2] = Tx |  (c & Maskx);
170 
		return 3;
171 
	}
172 
 
173 
	/*
174 
	 * four character sequence (21-bit value)
175 
	 *     10000-1FFFFF => T4 Tx Tx Tx
176 
	 */
177 
	str[0] = T4 | (c >> 3*Bitx);
178 
	str[1] = Tx | ((c >> 2*Bitx) & Maskx);
179 
	str[2] = Tx | ((c >> 1*Bitx) & Maskx);
180 
	str[3] = Tx | (c & Maskx);
181 
	return 4;
182 
}
183 
 
184 
int
185 
runelen(long c)
186 
{
187 
	Rune rune;
188 
	char str[10];
189 
 
190 
	rune = c;
191 
	return runetochar(str, &rune);
192 
}
193 
 
194 
int
195 
runenlen(Rune *r, int nrune)
196 
{
197 
	int nb, c;
198 
 
199 
	nb = 0;
200 
	while(nrune--) {
201 
		c = *r++;
202 
		if(c <= Rune1)
203 
			nb++;
204 
		else if(c <= Rune2)
205 
			nb += 2;
206 
		else if(c <= Rune3)
207 
 			nb += 3;
208 
		else
209 
			nb += 4;
210 
	}
211 
	return nb;
212 
}
213 
 
214 
int
215 
fullrune(char *str, int n)
216 
{
217 
	int c;
218 
	if(n <= 0)
219 
		return 0;
220 
	c = *(uchar*)str;
221 
	if(c < Tx)
222 
		return 1;
223 
	if(c < T3)
224 
		return n >= 2;
225 
	if(c < T4)
226 
		return n >= 3;
227 
	return n >= 4;
228 
}