1 /*
2 * cifs_unicode: Unicode kernel case support
3 *
4 * Function:
5 * Convert a unicode character to upper or lower case using
6 * compressed tables.
7 *
8 * Copyright (c) International Business Machines Corp., 2000,2007
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
18 * the GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 *
24 *
25 * Notes:
26 * These APIs are based on the C library functions. The semantics
27 * should match the C functions but with expanded size operands.
28 *
29 * The upper/lower functions are based on a table created by mkupr.
30 * This is a compressed table of upper and lower case conversion.
31 *
32 */
33
34 #include <asm/byteorder.h>
35 #include <linux/types.h>
36 #include <linux/nls.h>
37
38 #define UNIUPR_NOLOWER /* Example to not expand lower case tables */
39
40 /* Just define what we want from uniupr.h. We don't want to define the tables
41 * in each source file.
42 */
43 #ifndef UNICASERANGE_DEFINED
44 struct UniCaseRange {
45 wchar_t start;
46 wchar_t end;
47 signed char *table;
48 };
49 #endif /* UNICASERANGE_DEFINED */
50
51 #ifndef UNIUPR_NOUPPER
52 extern signed char CifsUniUpperTable[512];
53 extern const struct UniCaseRange CifsUniUpperRange[];
54 #endif /* UNIUPR_NOUPPER */
55
56 #ifndef UNIUPR_NOLOWER
57 extern signed char UniLowerTable[512];
58 extern struct UniCaseRange UniLowerRange[];
59 #endif /* UNIUPR_NOLOWER */
60
61 #ifdef __KERNEL__
62 int cifs_strfromUCS_le(char *, const __le16 *, int, const struct nls_table *);
63 int cifs_strtoUCS(__le16 *, const char *, int, const struct nls_table *);
64 #endif
65
66 /*
67 * UniStrcat: Concatenate the second string to the first
68 *
69 * Returns:
70 * Address of the first string
71 */
72 static inline wchar_t *
73 UniStrcat(wchar_t *ucs1, const wchar_t *ucs2)
74 {
75 wchar_t *anchor = ucs1; /* save a pointer to start of ucs1 */
76
77 while (*ucs1++) ; /* To end of first string */
78 ucs1--; /* Return to the null */
79 while ((*ucs1++ = *ucs2++)) ; /* copy string 2 over */
80 return anchor;
81 }
82
83 /*
84 * UniStrchr: Find a character in a string
85 *
86 * Returns:
87 * Address of first occurrence of character in string
88 * or NULL if the character is not in the string
89 */
90 static inline wchar_t *
91 UniStrchr(const wchar_t *ucs, wchar_t uc)
92 {
93 while ((*ucs != uc) && *ucs)
94 ucs++;
95
96 if (*ucs == uc)
97 return (wchar_t *) ucs;
98 return NULL;
99 }
100
101 /*
102 * UniStrcmp: Compare two strings
103 *
104 * Returns:
105 * < 0: First string is less than second
106 * = 0: Strings are equal
107 * > 0: First string is greater than second
108 */
109 static inline int
110 UniStrcmp(const wchar_t *ucs1, const wchar_t *ucs2)
111 {
112 while ((*ucs1 == *ucs2) && *ucs1) {
113 ucs1++;
114 ucs2++;
115 }
116 return (int) *ucs1 - (int) *ucs2;
117 }
118
119 /*
120 * UniStrcpy: Copy a string
121 */
122 static inline wchar_t *
123 UniStrcpy(wchar_t *ucs1, const wchar_t *ucs2)
124 {
125 wchar_t *anchor = ucs1; /* save the start of result string */
126
127 while ((*ucs1++ = *ucs2++)) ;
128 return anchor;
129 }
130
131 /*
132 * UniStrlen: Return the length of a string (in 16 bit Unicode chars not bytes)
133 */
134 static inline size_t
135 UniStrlen(const wchar_t *ucs1)
136 {
137 int i = 0;
138
139 while (*ucs1++)
140 i++;
141 return i;
142 }
143
144 /*
145 * UniStrnlen: Return the length (in 16 bit Unicode chars not bytes) of a
146 * string (length limited)
147 */
148 static inline size_t
149 UniStrnlen(const wchar_t *ucs1, int maxlen)
150 {
151 int i = 0;
152
153 while (*ucs1++) {
154 i++;
155 if (i >= maxlen)
156 break;
157 }
158 return i;
159 }
160
161 /*
162 * UniStrncat: Concatenate length limited string
163 */
164 static inline wchar_t *
165 UniStrncat(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
166 {
167 wchar_t *anchor = ucs1; /* save pointer to string 1 */
168
169 while (*ucs1++) ;
170 ucs1--; /* point to null terminator of s1 */
171 while (n-- && (*ucs1 = *ucs2)) { /* copy s2 after s1 */
172 ucs1++;
173 ucs2++;
174 }
175 *ucs1 = 0; /* Null terminate the result */
176 return (anchor);
177 }
178
179 /*
180 * UniStrncmp: Compare length limited string
181 */
182 static inline int
183 UniStrncmp(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
184 {
185 if (!n)
186 return 0; /* Null strings are equal */
187 while ((*ucs1 == *ucs2) && *ucs1 && --n) {
188 ucs1++;
189 ucs2++;
190 }
191 return (int) *ucs1 - (int) *ucs2;
192 }
193
194 /*
195 * UniStrncmp_le: Compare length limited string - native to little-endian
196 */
197 static inline int
198 UniStrncmp_le(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
199 {
200 if (!n)
201 return 0; /* Null strings are equal */
202 while ((*ucs1 == __le16_to_cpu(*ucs2)) && *ucs1 && --n) {
203 ucs1++;
204 ucs2++;
205 }
206 return (int) *ucs1 - (int) __le16_to_cpu(*ucs2);
207 }
208
209 /*
210 * UniStrncpy: Copy length limited string with pad
211 */
212 static inline wchar_t *
213 UniStrncpy(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
214 {
215 wchar_t *anchor = ucs1;
216
217 while (n-- && *ucs2) /* Copy the strings */
218 *ucs1++ = *ucs2++;
219
220 n++;
221 while (n--) /* Pad with nulls */
222 *ucs1++ = 0;
223 return anchor;
224 }
225
226 /*
227 * UniStrncpy_le: Copy length limited string with pad to little-endian
228 */
229 static inline wchar_t *
230 UniStrncpy_le(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
231 {
232 wchar_t *anchor = ucs1;
233
234 while (n-- && *ucs2) /* Copy the strings */
235 *ucs1++ = __le16_to_cpu(*ucs2++);
236
237 n++;
238 while (n--) /* Pad with nulls */
239 *ucs1++ = 0;
240 return anchor;
241 }
242
243 /*
244 * UniStrstr: Find a string in a string
245 *
246 * Returns:
247 * Address of first match found
248 * NULL if no matching string is found
249 */
250 static inline wchar_t *
251 UniStrstr(const wchar_t *ucs1, const wchar_t *ucs2)
252 {
253 const wchar_t *anchor1 = ucs1;
254 const wchar_t *anchor2 = ucs2;
255
256 while (*ucs1) {
257 if (*ucs1 == *ucs2) {
258 /* Partial match found */
259 ucs1++;
260 ucs2++;
261 } else {
262 if (!*ucs2) /* Match found */
263 return (wchar_t *) anchor1;
264 ucs1 = ++anchor1; /* No match */
265 ucs2 = anchor2;
266 }
267 }
268
269 if (!*ucs2) /* Both end together */
270 return (wchar_t *) anchor1; /* Match found */
271 return NULL; /* No match */
272 }
273
274 #ifndef UNIUPR_NOUPPER
275 /*
276 * UniToupper: Convert a unicode character to upper case
277 */
278 static inline wchar_t
279 UniToupper(register wchar_t uc)
280 {
281 register const struct UniCaseRange *rp;
282
283 if (uc < sizeof(CifsUniUpperTable)) {
284 /* Latin characters */
285 return uc + CifsUniUpperTable[uc]; /* Use base tables */
286 } else {
287 rp = CifsUniUpperRange; /* Use range tables */
288 while (rp->start) {
289 if (uc < rp->start) /* Before start of range */
290 return uc; /* Uppercase = input */
291 if (uc <= rp->end) /* In range */
292 return uc + rp->table[uc - rp->start];
293 rp++; /* Try next range */
294 }
295 }
296 return uc; /* Past last range */
297 }
298
299 /*
300 * UniStrupr: Upper case a unicode string
301 */
302 static inline wchar_t *
303 UniStrupr(register wchar_t *upin)
304 {
305 register wchar_t *up;
306
307 up = upin;
308 while (*up) { /* For all characters */
309 *up = UniToupper(*up);
310 up++;
311 }
312 return upin; /* Return input pointer */
313 }
314 #endif /* UNIUPR_NOUPPER */
315
316 #ifndef UNIUPR_NOLOWER
317 /*
318 * UniTolower: Convert a unicode character to lower case
319 */
320 static inline wchar_t
321 UniTolower(wchar_t uc)
322 {
323 register struct UniCaseRange *rp;
324
325 if (uc < sizeof(UniLowerTable)) {
326 /* Latin characters */
327 return uc + UniLowerTable[uc]; /* Use base tables */
328 } else {
329 rp = UniLowerRange; /* Use range tables */
330 while (rp->start) {
331 if (uc < rp->start) /* Before start of range */
332 return uc; /* Uppercase = input */
333 if (uc <= rp->end) /* In range */
334 return uc + rp->table[uc - rp->start];
335 rp++; /* Try next range */
336 }
337 }
338 return uc; /* Past last range */
339 }
340
341 /*
342 * UniStrlwr: Lower case a unicode string
343 */
344 static inline wchar_t *
345 UniStrlwr(register wchar_t *upin)
346 {
347 register wchar_t *up;
348
349 up = upin;
350 while (*up) { /* For all characters */
351 *up = UniTolower(*up);
352 up++;
353 }
354 return upin; /* Return input pointer */
355 }
356
357 #endif
358
|
This page was automatically generated by the
LXR engine.
|