| /* |
| * The authors of this software are Rob Pike and Ken Thompson. |
| * Copyright (c) 2002 by Lucent Technologies. |
| * Portions Copyright (c) 2009 The Go Authors. All rights reserved. |
| * Permission to use, copy, modify, and distribute this software for any |
| * purpose without fee is hereby granted, provided that this entire notice |
| * is included in all copies of any software which is or includes a copy |
| * or modification of this software and in all copies of the supporting |
| * documentation for such software. |
| * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED |
| * WARRANTY. IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY |
| * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY |
| * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. |
| */ |
| #include "utf.h" |
| #include "utfdef.h" |
| |
| enum |
| { |
| Bit1 = 7, |
| Bitx = 6, |
| Bit2 = 5, |
| Bit3 = 4, |
| Bit4 = 3, |
| Bit5 = 2, |
| |
| T1 = ((1<<(Bit1+1))-1) ^ 0xFF, /* 0000 0000 */ |
| Tx = ((1<<(Bitx+1))-1) ^ 0xFF, /* 1000 0000 */ |
| T2 = ((1<<(Bit2+1))-1) ^ 0xFF, /* 1100 0000 */ |
| T3 = ((1<<(Bit3+1))-1) ^ 0xFF, /* 1110 0000 */ |
| T4 = ((1<<(Bit4+1))-1) ^ 0xFF, /* 1111 0000 */ |
| T5 = ((1<<(Bit5+1))-1) ^ 0xFF, /* 1111 1000 */ |
| |
| Rune1 = (1<<(Bit1+0*Bitx))-1, /* 0000 0000 0111 1111 */ |
| Rune2 = (1<<(Bit2+1*Bitx))-1, /* 0000 0111 1111 1111 */ |
| Rune3 = (1<<(Bit3+2*Bitx))-1, /* 1111 1111 1111 1111 */ |
| Rune4 = (1<<(Bit4+3*Bitx))-1, /* 0001 1111 1111 1111 1111 1111 */ |
| |
| Maskx = (1<<Bitx)-1, /* 0011 1111 */ |
| Testx = Maskx ^ 0xFF, /* 1100 0000 */ |
| |
| SurrogateMin = 0xD800, |
| SurrogateMax = 0xDFFF, |
| |
| Bad = Runeerror, |
| }; |
| |
| /* |
| * Modified by Wei-Hwa Huang, Google Inc., on 2004-09-24 |
| * This is a slower but "safe" version of the old chartorune |
| * that works on strings that are not necessarily null-terminated. |
| * |
| * If you know for sure that your string is null-terminated, |
| * chartorune will be a bit faster. |
| * |
| * It is guaranteed not to attempt to access "length" |
| * past the incoming pointer. This is to avoid |
| * possible access violations. If the string appears to be |
| * well-formed but incomplete (i.e., to get the whole Rune |
| * we'd need to read past str+length) then we'll set the Rune |
| * to Bad and return 0. |
| * |
| * Note that if we have decoding problems for other |
| * reasons, we return 1 instead of 0. |
| */ |
| int |
| charntorune(Rune *rune, const char *str, int length) |
| { |
| int c, c1, c2, c3; |
| long l; |
| |
| /* When we're not allowed to read anything */ |
| if(length <= 0) { |
| goto badlen; |
| } |
| |
| /* |
| * one character sequence (7-bit value) |
| * 00000-0007F => T1 |
| */ |
| c = *(uchar*)str; |
| if(c < Tx) { |
| *rune = (Rune)c; |
| return 1; |
| } |
| |
| // If we can't read more than one character we must stop |
| if(length <= 1) { |
| goto badlen; |
| } |
| |
| /* |
| * two character sequence (11-bit value) |
| * 0080-07FF => T2 Tx |
| */ |
| c1 = *(uchar*)(str+1) ^ Tx; |
| if(c1 & Testx) |
| goto bad; |
| if(c < T3) { |
| if(c < T2) |
| goto bad; |
| l = ((c << Bitx) | c1) & Rune2; |
| if(l <= Rune1) |
| goto bad; |
| *rune = (Rune)l; |
| return 2; |
| } |
| |
| // If we can't read more than two characters we must stop |
| if(length <= 2) { |
| goto badlen; |
| } |
| |
| /* |
| * three character sequence (16-bit value) |
| * 0800-FFFF => T3 Tx Tx |
| */ |
| c2 = *(uchar*)(str+2) ^ Tx; |
| if(c2 & Testx) |
| goto bad; |
| if(c < T4) { |
| l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3; |
| if(l <= Rune2) |
| goto bad; |
| if (SurrogateMin <= l && l <= SurrogateMax) |
| goto bad; |
| *rune = (Rune)l; |
| return 3; |
| } |
| |
| if (length <= 3) |
| goto badlen; |
| |
| /* |
| * four character sequence (21-bit value) |
| * 10000-1FFFFF => T4 Tx Tx Tx |
| */ |
| c3 = *(uchar*)(str+3) ^ Tx; |
| if (c3 & Testx) |
| goto bad; |
| if (c < T5) { |
| l = ((((((c << Bitx) | c1) << Bitx) | c2) << Bitx) | c3) & Rune4; |
| if (l <= Rune3 || l > Runemax) |
| goto bad; |
| *rune = (Rune)l; |
| return 4; |
| } |
| |
| // Support for 5-byte or longer UTF-8 would go here, but |
| // since we don't have that, we'll just fall through to bad. |
| |
| /* |
| * bad decoding |
| */ |
| bad: |
| *rune = Bad; |
| return 1; |
| badlen: |
| *rune = Bad; |
| return 0; |
| |
| } |
| |
| |
| /* |
| * This is the older "unsafe" version, which works fine on |
| * null-terminated strings. |
| */ |
| int |
| chartorune(Rune *rune, const char *str) |
| { |
| int c, c1, c2, c3; |
| long l; |
| |
| /* |
| * one character sequence |
| * 00000-0007F => T1 |
| */ |
| c = *(uchar*)str; |
| if(c < Tx) { |
| *rune = (Rune)c; |
| return 1; |
| } |
| |
| /* |
| * two character sequence |
| * 0080-07FF => T2 Tx |
| */ |
| c1 = *(uchar*)(str+1) ^ Tx; |
| if(c1 & Testx) |
| goto bad; |
| if(c < T3) { |
| if(c < T2) |
| goto bad; |
| l = ((c << Bitx) | c1) & Rune2; |
| if(l <= Rune1) |
| goto bad; |
| *rune = (Rune)l; |
| return 2; |
| } |
| |
| /* |
| * three character sequence |
| * 0800-FFFF => T3 Tx Tx |
| */ |
| c2 = *(uchar*)(str+2) ^ Tx; |
| if(c2 & Testx) |
| goto bad; |
| if(c < T4) { |
| l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3; |
| if(l <= Rune2) |
| goto bad; |
| if (SurrogateMin <= l && l <= SurrogateMax) |
| goto bad; |
| *rune = (Rune)l; |
| return 3; |
| } |
| |
| /* |
| * four character sequence (21-bit value) |
| * 10000-1FFFFF => T4 Tx Tx Tx |
| */ |
| c3 = *(uchar*)(str+3) ^ Tx; |
| if (c3 & Testx) |
| goto bad; |
| if (c < T5) { |
| l = ((((((c << Bitx) | c1) << Bitx) | c2) << Bitx) | c3) & Rune4; |
| if (l <= Rune3 || l > Runemax) |
| goto bad; |
| *rune = (Rune)l; |
| return 4; |
| } |
| |
| /* |
| * Support for 5-byte or longer UTF-8 would go here, but |
| * since we don't have that, we'll just fall through to bad. |
| */ |
| |
| /* |
| * bad decoding |
| */ |
| bad: |
| *rune = Bad; |
| return 1; |
| } |
| |
| int |
| isvalidcharntorune(const char* str, int length, Rune* rune, int* consumed) |
| { |
| *consumed = charntorune(rune, str, length); |
| return *rune != Runeerror || *consumed == 3; |
| } |
| |
| int |
| runetochar(char *str, const Rune *rune) |
| { |
| /* Runes are signed, so convert to unsigned for range check. */ |
| unsigned long c; |
| |
| /* |
| * one character sequence |
| * 00000-0007F => 00-7F |
| */ |
| c = *rune; |
| if(c <= Rune1) { |
| str[0] = (char)c; |
| return 1; |
| } |
| |
| /* |
| * two character sequence |
| * 0080-07FF => T2 Tx |
| */ |
| if(c <= Rune2) { |
| str[0] = (char)(T2 | (c >> 1*Bitx)); |
| str[1] = (char)(Tx | (c & Maskx)); |
| return 2; |
| } |
| |
| /* |
| * If the Rune is out of range or a surrogate half, convert it to the error rune. |
| * Do this test here because the error rune encodes to three bytes. |
| * Doing it earlier would duplicate work, since an out of range |
| * Rune wouldn't have fit in one or two bytes. |
| */ |
| if (c > Runemax) |
| c = Runeerror; |
| if (SurrogateMin <= c && c <= SurrogateMax) |
| c = Runeerror; |
| |
| /* |
| * three character sequence |
| * 0800-FFFF => T3 Tx Tx |
| */ |
| if (c <= Rune3) { |
| str[0] = (char)(T3 | (c >> 2*Bitx)); |
| str[1] = (char)(Tx | ((c >> 1*Bitx) & Maskx)); |
| str[2] = (char)(Tx | (c & Maskx)); |
| return 3; |
| } |
| |
| /* |
| * four character sequence (21-bit value) |
| * 10000-1FFFFF => T4 Tx Tx Tx |
| */ |
| str[0] = (char)(T4 | (c >> 3*Bitx)); |
| str[1] = (char)(Tx | ((c >> 2*Bitx) & Maskx)); |
| str[2] = (char)(Tx | ((c >> 1*Bitx) & Maskx)); |
| str[3] = (char)(Tx | (c & Maskx)); |
| return 4; |
| } |
| |
| int |
| runelen(Rune rune) |
| { |
| char str[10]; |
| |
| return runetochar(str, &rune); |
| } |
| |
| int |
| runenlen(const Rune *r, int nrune) |
| { |
| int nb, c; |
| |
| nb = 0; |
| while(nrune--) { |
| c = (int)*r++; |
| if (c <= Rune1) |
| nb++; |
| else if (c <= Rune2) |
| nb += 2; |
| else if (c <= Rune3) |
| nb += 3; |
| else /* assert(c <= Rune4) */ |
| nb += 4; |
| } |
| return nb; |
| } |
| |
| int |
| fullrune(const char *str, int n) |
| { |
| if (n > 0) { |
| int c = *(uchar*)str; |
| if (c < Tx) |
| return 1; |
| if (n > 1) { |
| if (c < T3) |
| return 1; |
| if (n > 2) { |
| if (c < T4 || n > 3) |
| return 1; |
| } |
| } |
| } |
| return 0; |
| } |