|
352
|
1 /* |
|
|
2 * The authors of this software are Rob Pike and Ken Thompson. |
|
|
3 * Copyright (c) 1998-2002 by Lucent Technologies. |
|
|
4 * Portions Copyright (c) 2009 The Go Authors. All rights reserved. |
|
|
5 * Permission to use, copy, modify, and distribute this software for any |
|
|
6 * purpose without fee is hereby granted, provided that this entire notice |
|
|
7 * is included in all copies of any software which is or includes a copy |
|
|
8 * or modification of this software and in all copies of the supporting |
|
|
9 * documentation for such software. |
|
|
10 * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED |
|
|
11 * WARRANTY. IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY |
|
|
12 * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY |
|
|
13 * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. |
|
|
14 */ |
|
|
15 |
|
|
16 #ifndef _UTFH_ |
|
|
17 #define _UTFH_ 1 |
|
|
18 |
|
|
19 typedef unsigned int Rune; /* Code-point values in Unicode 4.0 are 21 bits wide.*/ |
|
|
20 |
|
|
21 enum |
|
|
22 { |
|
|
23 UTFmax = 4, /* maximum bytes per rune */ |
|
|
24 Runesync = 0x80, /* cannot represent part of a UTF sequence (<) */ |
|
|
25 Runeself = 0x80, /* rune and UTF sequences are the same (<) */ |
|
|
26 Runeerror = 0xFFFD, /* decoding error in UTF */ |
|
|
27 Runemax = 0x10FFFF, /* maximum rune value */ |
|
|
28 }; |
|
|
29 |
|
|
30 #ifdef __cplusplus |
|
|
31 extern "C" { |
|
|
32 #endif |
|
|
33 |
|
|
34 /* |
|
|
35 * rune routines |
|
|
36 */ |
|
|
37 |
|
|
38 /* |
|
|
39 * These routines were written by Rob Pike and Ken Thompson |
|
|
40 * and first appeared in Plan 9. |
|
|
41 * SEE ALSO |
|
|
42 * utf (7) |
|
|
43 * tcs (1) |
|
|
44 */ |
|
|
45 |
|
|
46 // runetochar copies (encodes) one rune, pointed to by r, to at most |
|
|
47 // UTFmax bytes starting at s and returns the number of bytes generated. |
|
|
48 |
|
|
49 int runetochar(char* s, const Rune* r); |
|
|
50 |
|
|
51 |
|
|
52 // chartorune copies (decodes) at most UTFmax bytes starting at s to |
|
|
53 // one rune, pointed to by r, and returns the number of bytes consumed. |
|
|
54 // If the input is not exactly in UTF format, chartorune will set *r |
|
|
55 // to Runeerror and return 1. |
|
|
56 // |
|
|
57 // Note: There is no special case for a "null-terminated" string. A |
|
|
58 // string whose first byte has the value 0 is the UTF8 encoding of the |
|
|
59 // Unicode value 0 (i.e., ASCII NULL). A byte value of 0 is illegal |
|
|
60 // anywhere else in a UTF sequence. |
|
|
61 |
|
|
62 int chartorune(Rune* r, const char* s); |
|
|
63 |
|
|
64 |
|
|
65 // charntorune is like chartorune, except that it will access at most |
|
|
66 // n bytes of s. If the UTF sequence is incomplete within n bytes, |
|
|
67 // charntorune will set *r to Runeerror and return 0. If it is complete |
|
|
68 // but not in UTF format, it will set *r to Runeerror and return 1. |
|
|
69 // |
|
|
70 // Added 2004-09-24 by Wei-Hwa Huang |
|
|
71 |
|
|
72 int charntorune(Rune* r, const char* s, int n); |
|
|
73 |
|
|
74 // isvalidcharntorune(str, n, r, consumed) |
|
|
75 // is a convenience function that calls "*consumed = charntorune(r, str, n)" |
|
|
76 // and returns an int (logically boolean) indicating whether the first |
|
|
77 // n bytes of str was a valid and complete UTF sequence. |
|
|
78 |
|
|
79 int isvalidcharntorune(const char* str, int n, Rune* r, int* consumed); |
|
|
80 |
|
|
81 // runelen returns the number of bytes required to convert r into UTF. |
|
|
82 |
|
|
83 int runelen(Rune r); |
|
|
84 |
|
|
85 |
|
|
86 // runenlen returns the number of bytes required to convert the n |
|
|
87 // runes pointed to by r into UTF. |
|
|
88 |
|
|
89 int runenlen(const Rune* r, int n); |
|
|
90 |
|
|
91 |
|
|
92 // fullrune returns 1 if the string s of length n is long enough to be |
|
|
93 // decoded by chartorune, and 0 otherwise. This does not guarantee |
|
|
94 // that the string contains a legal UTF encoding. This routine is used |
|
|
95 // by programs that obtain input one byte at a time and need to know |
|
|
96 // when a full rune has arrived. |
|
|
97 |
|
|
98 int fullrune(const char* s, int n); |
|
|
99 |
|
|
100 // The following routines are analogous to the corresponding string |
|
|
101 // routines with "utf" substituted for "str", and "rune" substituted |
|
|
102 // for "chr". |
|
|
103 |
|
|
104 // utflen returns the number of runes that are represented by the UTF |
|
|
105 // string s. (cf. strlen) |
|
|
106 |
|
|
107 int utflen(const char* s); |
|
|
108 |
|
|
109 |
|
|
110 // utfnlen returns the number of complete runes that are represented |
|
|
111 // by the first n bytes of the UTF string s. If the last few bytes of |
|
|
112 // the string contain an incompletely coded rune, utfnlen will not |
|
|
113 // count them; in this way, it differs from utflen, which includes |
|
|
114 // every byte of the string. (cf. strnlen) |
|
|
115 |
|
|
116 int utfnlen(const char* s, long n); |
|
|
117 |
|
|
118 |
|
|
119 // utfrune returns a pointer to the first occurrence of rune r in the |
|
|
120 // UTF string s, or 0 if r does not occur in the string. The NULL |
|
|
121 // byte terminating a string is considered to be part of the string s. |
|
|
122 // (cf. strchr) |
|
|
123 |
|
|
124 /*const*/ char* utfrune(const char* s, Rune r); |
|
|
125 |
|
|
126 |
|
|
127 // utfrrune returns a pointer to the last occurrence of rune r in the |
|
|
128 // UTF string s, or 0 if r does not occur in the string. The NULL |
|
|
129 // byte terminating a string is considered to be part of the string s. |
|
|
130 // (cf. strrchr) |
|
|
131 |
|
|
132 /*const*/ char* utfrrune(const char* s, Rune r); |
|
|
133 |
|
|
134 |
|
|
135 // utfutf returns a pointer to the first occurrence of the UTF string |
|
|
136 // s2 as a UTF substring of s1, or 0 if there is none. If s2 is the |
|
|
137 // null string, utfutf returns s1. (cf. strstr) |
|
|
138 |
|
|
139 const char* utfutf(const char* s1, const char* s2); |
|
|
140 |
|
|
141 |
|
|
142 // utfecpy copies UTF sequences until a null sequence has been copied, |
|
|
143 // but writes no sequences beyond es1. If any sequences are copied, |
|
|
144 // s1 is terminated by a null sequence, and a pointer to that sequence |
|
|
145 // is returned. Otherwise, the original s1 is returned. (cf. strecpy) |
|
|
146 |
|
|
147 char* utfecpy(char *s1, char *es1, const char *s2); |
|
|
148 |
|
|
149 |
|
|
150 |
|
|
151 // These functions are rune-string analogues of the corresponding |
|
|
152 // functions in strcat (3). |
|
|
153 // |
|
|
154 // These routines first appeared in Plan 9. |
|
|
155 // SEE ALSO |
|
|
156 // memmove (3) |
|
|
157 // rune (3) |
|
|
158 // strcat (2) |
|
|
159 // |
|
|
160 // BUGS: The outcome of overlapping moves varies among implementations. |
|
|
161 |
|
|
162 Rune* runestrcat(Rune* s1, const Rune* s2); |
|
|
163 Rune* runestrncat(Rune* s1, const Rune* s2, long n); |
|
|
164 |
|
|
165 const Rune* runestrchr(const Rune* s, Rune c); |
|
|
166 |
|
|
167 int runestrcmp(const Rune* s1, const Rune* s2); |
|
|
168 int runestrncmp(const Rune* s1, const Rune* s2, long n); |
|
|
169 |
|
|
170 Rune* runestrcpy(Rune* s1, const Rune* s2); |
|
|
171 Rune* runestrncpy(Rune* s1, const Rune* s2, long n); |
|
|
172 Rune* runestrecpy(Rune* s1, Rune* es1, const Rune* s2); |
|
|
173 |
|
|
174 Rune* runestrdup(const Rune* s); |
|
|
175 |
|
|
176 const Rune* runestrrchr(const Rune* s, Rune c); |
|
|
177 long runestrlen(const Rune* s); |
|
|
178 const Rune* runestrstr(const Rune* s1, const Rune* s2); |
|
|
179 |
|
|
180 |
|
|
181 |
|
|
182 // The following routines test types and modify cases for Unicode |
|
|
183 // characters. Unicode defines some characters as letters and |
|
|
184 // specifies three cases: upper, lower, and title. Mappings among the |
|
|
185 // cases are also defined, although they are not exhaustive: some |
|
|
186 // upper case letters have no lower case mapping, and so on. Unicode |
|
|
187 // also defines several character properties, a subset of which are |
|
|
188 // checked by these routines. These routines are based on Unicode |
|
|
189 // version 3.0.0. |
|
|
190 // |
|
|
191 // NOTE: The routines are implemented in C, so the boolean functions |
|
|
192 // (e.g., isupperrune) return 0 for false and 1 for true. |
|
|
193 // |
|
|
194 // |
|
|
195 // toupperrune, tolowerrune, and totitlerune are the Unicode case |
|
|
196 // mappings. These routines return the character unchanged if it has |
|
|
197 // no defined mapping. |
|
|
198 |
|
|
199 Rune toupperrune(Rune r); |
|
|
200 Rune tolowerrune(Rune r); |
|
|
201 Rune totitlerune(Rune r); |
|
|
202 |
|
|
203 |
|
|
204 // isupperrune tests for upper case characters, including Unicode |
|
|
205 // upper case letters and targets of the toupper mapping. islowerrune |
|
|
206 // and istitlerune are defined analogously. |
|
|
207 |
|
|
208 int isupperrune(Rune r); |
|
|
209 int islowerrune(Rune r); |
|
|
210 int istitlerune(Rune r); |
|
|
211 |
|
|
212 |
|
|
213 // isalpharune tests for Unicode letters; this includes ideographs in |
|
|
214 // addition to alphabetic characters. |
|
|
215 |
|
|
216 int isalpharune(Rune r); |
|
|
217 |
|
|
218 |
|
|
219 // isdigitrune tests for digits. Non-digit numbers, such as Roman |
|
|
220 // numerals, are not included. |
|
|
221 |
|
|
222 int isdigitrune(Rune r); |
|
|
223 |
|
|
224 |
|
|
225 // isspacerune tests for whitespace characters, including "C" locale |
|
|
226 // whitespace, Unicode defined whitespace, and the "zero-width |
|
|
227 // non-break space" character. |
|
|
228 |
|
|
229 int isspacerune(Rune r); |
|
|
230 |
|
|
231 |
|
|
232 // (The comments in this file were copied from the manpage files rune.3, |
|
|
233 // isalpharune.3, and runestrcat.3. Some formatting changes were also made |
|
|
234 // to conform to Google style. /JRM 11/11/05) |
|
|
235 |
|
|
236 #ifdef __cplusplus |
|
|
237 } |
|
|
238 #endif |
|
|
239 |
|
|
240 #endif |
