Eric Lee / smarc-ti-linux-kernel

Download as
Browse Code ยป

Commit 4c416ab71164dc8d3f800a942fb18c4e67f67897

Authored by Jan-Benedict Glaw
Committed by Linus Torvalds
1 parent b04eb6aa08

[PATCH] Silence a const vs non-const warning 

lib/string.c: In function 'memcpy':
lib/string.c:470: warning: initialization discards qualifiers from pointer =
target type

Signed-off-by: Jan-Benedict Glaw <jbglaw@lug-owl.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

Showing 1 changed file with 1 additions and 1 deletions Inline Diff

1 /* 1 /*
2 * linux/lib/string.c 2 * linux/lib/string.c
3 * 3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds 4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */ 5 */
6 6
7 /* 7 /*
8 * stupid library routines.. The optimized versions should generally be found 8 * stupid library routines.. The optimized versions should generally be found
9 * as inline code in <asm-xx/string.h> 9 * as inline code in <asm-xx/string.h>
10 * 10 *
11 * These are buggy as well.. 11 * These are buggy as well..
12 * 12 *
13 * * Fri Jun 25 1999, Ingo Oeser <ioe@informatik.tu-chemnitz.de> 13 * * Fri Jun 25 1999, Ingo Oeser <ioe@informatik.tu-chemnitz.de>
14 * - Added strsep() which will replace strtok() soon (because strsep() is 14 * - Added strsep() which will replace strtok() soon (because strsep() is
15 * reentrant and should be faster). Use only strsep() in new code, please. 15 * reentrant and should be faster). Use only strsep() in new code, please.
16 * 16 *
17 * * Sat Feb 09 2002, Jason Thomas <jason@topic.com.au>, 17 * * Sat Feb 09 2002, Jason Thomas <jason@topic.com.au>,
18 * Matthew Hawkins <matt@mh.dropbear.id.au> 18 * Matthew Hawkins <matt@mh.dropbear.id.au>
19 * - Kissed strtok() goodbye 19 * - Kissed strtok() goodbye
20 */ 20 */
21 21
22 #include <linux/types.h> 22 #include <linux/types.h>
23 #include <linux/string.h> 23 #include <linux/string.h>
24 #include <linux/ctype.h> 24 #include <linux/ctype.h>
25 #include <linux/module.h> 25 #include <linux/module.h>
26 26
27 #ifndef __HAVE_ARCH_STRNICMP 27 #ifndef __HAVE_ARCH_STRNICMP
28 /** 28 /**
29 * strnicmp - Case insensitive, length-limited string comparison 29 * strnicmp - Case insensitive, length-limited string comparison
30 * @s1: One string 30 * @s1: One string
31 * @s2: The other string 31 * @s2: The other string
32 * @len: the maximum number of characters to compare 32 * @len: the maximum number of characters to compare
33 */ 33 */
34 int strnicmp(const char *s1, const char *s2, size_t len) 34 int strnicmp(const char *s1, const char *s2, size_t len)
35 { 35 {
36 /* Yes, Virginia, it had better be unsigned */ 36 /* Yes, Virginia, it had better be unsigned */
37 unsigned char c1, c2; 37 unsigned char c1, c2;
38 38
39 c1 = c2 = 0; 39 c1 = c2 = 0;
40 if (len) { 40 if (len) {
41 do { 41 do {
42 c1 = *s1; 42 c1 = *s1;
43 c2 = *s2; 43 c2 = *s2;
44 s1++; 44 s1++;
45 s2++; 45 s2++;
46 if (!c1) 46 if (!c1)
47 break; 47 break;
48 if (!c2) 48 if (!c2)
49 break; 49 break;
50 if (c1 == c2) 50 if (c1 == c2)
51 continue; 51 continue;
52 c1 = tolower(c1); 52 c1 = tolower(c1);
53 c2 = tolower(c2); 53 c2 = tolower(c2);
54 if (c1 != c2) 54 if (c1 != c2)
55 break; 55 break;
56 } while (--len); 56 } while (--len);
57 } 57 }
58 return (int)c1 - (int)c2; 58 return (int)c1 - (int)c2;
59 } 59 }
60 EXPORT_SYMBOL(strnicmp); 60 EXPORT_SYMBOL(strnicmp);
61 #endif 61 #endif
62 62
63 #ifndef __HAVE_ARCH_STRCPY 63 #ifndef __HAVE_ARCH_STRCPY
64 /** 64 /**
65 * strcpy - Copy a %NUL terminated string 65 * strcpy - Copy a %NUL terminated string
66 * @dest: Where to copy the string to 66 * @dest: Where to copy the string to
67 * @src: Where to copy the string from 67 * @src: Where to copy the string from
68 */ 68 */
69 #undef strcpy 69 #undef strcpy
70 char *strcpy(char *dest, const char *src) 70 char *strcpy(char *dest, const char *src)
71 { 71 {
72 char *tmp = dest; 72 char *tmp = dest;
73 73
74 while ((*dest++ = *src++) != '\0') 74 while ((*dest++ = *src++) != '\0')
75 /* nothing */; 75 /* nothing */;
76 return tmp; 76 return tmp;
77 } 77 }
78 EXPORT_SYMBOL(strcpy); 78 EXPORT_SYMBOL(strcpy);
79 #endif 79 #endif
80 80
81 #ifndef __HAVE_ARCH_STRNCPY 81 #ifndef __HAVE_ARCH_STRNCPY
82 /** 82 /**
83 * strncpy - Copy a length-limited, %NUL-terminated string 83 * strncpy - Copy a length-limited, %NUL-terminated string
84 * @dest: Where to copy the string to 84 * @dest: Where to copy the string to
85 * @src: Where to copy the string from 85 * @src: Where to copy the string from
86 * @count: The maximum number of bytes to copy 86 * @count: The maximum number of bytes to copy
87 * 87 *
88 * The result is not %NUL-terminated if the source exceeds 88 * The result is not %NUL-terminated if the source exceeds
89 * @count bytes. 89 * @count bytes.
90 * 90 *
91 * In the case where the length of @src is less than that of 91 * In the case where the length of @src is less than that of
92 * count, the remainder of @dest will be padded with %NUL. 92 * count, the remainder of @dest will be padded with %NUL.
93 * 93 *
94 */ 94 */
95 char *strncpy(char *dest, const char *src, size_t count) 95 char *strncpy(char *dest, const char *src, size_t count)
96 { 96 {
97 char *tmp = dest; 97 char *tmp = dest;
98 98
99 while (count) { 99 while (count) {
100 if ((*tmp = *src) != 0) 100 if ((*tmp = *src) != 0)
101 src++; 101 src++;
102 tmp++; 102 tmp++;
103 count--; 103 count--;
104 } 104 }
105 return dest; 105 return dest;
106 } 106 }
107 EXPORT_SYMBOL(strncpy); 107 EXPORT_SYMBOL(strncpy);
108 #endif 108 #endif
109 109
110 #ifndef __HAVE_ARCH_STRLCPY 110 #ifndef __HAVE_ARCH_STRLCPY
111 /** 111 /**
112 * strlcpy - Copy a %NUL terminated string into a sized buffer 112 * strlcpy - Copy a %NUL terminated string into a sized buffer
113 * @dest: Where to copy the string to 113 * @dest: Where to copy the string to
114 * @src: Where to copy the string from 114 * @src: Where to copy the string from
115 * @size: size of destination buffer 115 * @size: size of destination buffer
116 * 116 *
117 * Compatible with *BSD: the result is always a valid 117 * Compatible with *BSD: the result is always a valid
118 * NUL-terminated string that fits in the buffer (unless, 118 * NUL-terminated string that fits in the buffer (unless,
119 * of course, the buffer size is zero). It does not pad 119 * of course, the buffer size is zero). It does not pad
120 * out the result like strncpy() does. 120 * out the result like strncpy() does.
121 */ 121 */
122 size_t strlcpy(char *dest, const char *src, size_t size) 122 size_t strlcpy(char *dest, const char *src, size_t size)
123 { 123 {
124 size_t ret = strlen(src); 124 size_t ret = strlen(src);
125 125
126 if (size) { 126 if (size) {
127 size_t len = (ret >= size) ? size - 1 : ret; 127 size_t len = (ret >= size) ? size - 1 : ret;
128 memcpy(dest, src, len); 128 memcpy(dest, src, len);
129 dest[len] = '\0'; 129 dest[len] = '\0';
130 } 130 }
131 return ret; 131 return ret;
132 } 132 }
133 EXPORT_SYMBOL(strlcpy); 133 EXPORT_SYMBOL(strlcpy);
134 #endif 134 #endif
135 135
136 #ifndef __HAVE_ARCH_STRCAT 136 #ifndef __HAVE_ARCH_STRCAT
137 /** 137 /**
138 * strcat - Append one %NUL-terminated string to another 138 * strcat - Append one %NUL-terminated string to another
139 * @dest: The string to be appended to 139 * @dest: The string to be appended to
140 * @src: The string to append to it 140 * @src: The string to append to it
141 */ 141 */
142 #undef strcat 142 #undef strcat
143 char *strcat(char *dest, const char *src) 143 char *strcat(char *dest, const char *src)
144 { 144 {
145 char *tmp = dest; 145 char *tmp = dest;
146 146
147 while (*dest) 147 while (*dest)
148 dest++; 148 dest++;
149 while ((*dest++ = *src++) != '\0') 149 while ((*dest++ = *src++) != '\0')
150 ; 150 ;
151 return tmp; 151 return tmp;
152 } 152 }
153 EXPORT_SYMBOL(strcat); 153 EXPORT_SYMBOL(strcat);
154 #endif 154 #endif
155 155
156 #ifndef __HAVE_ARCH_STRNCAT 156 #ifndef __HAVE_ARCH_STRNCAT
157 /** 157 /**
158 * strncat - Append a length-limited, %NUL-terminated string to another 158 * strncat - Append a length-limited, %NUL-terminated string to another
159 * @dest: The string to be appended to 159 * @dest: The string to be appended to
160 * @src: The string to append to it 160 * @src: The string to append to it
161 * @count: The maximum numbers of bytes to copy 161 * @count: The maximum numbers of bytes to copy
162 * 162 *
163 * Note that in contrast to strncpy, strncat ensures the result is 163 * Note that in contrast to strncpy, strncat ensures the result is
164 * terminated. 164 * terminated.
165 */ 165 */
166 char *strncat(char *dest, const char *src, size_t count) 166 char *strncat(char *dest, const char *src, size_t count)
167 { 167 {
168 char *tmp = dest; 168 char *tmp = dest;
169 169
170 if (count) { 170 if (count) {
171 while (*dest) 171 while (*dest)
172 dest++; 172 dest++;
173 while ((*dest++ = *src++) != 0) { 173 while ((*dest++ = *src++) != 0) {
174 if (--count == 0) { 174 if (--count == 0) {
175 *dest = '\0'; 175 *dest = '\0';
176 break; 176 break;
177 } 177 }
178 } 178 }
179 } 179 }
180 return tmp; 180 return tmp;
181 } 181 }
182 EXPORT_SYMBOL(strncat); 182 EXPORT_SYMBOL(strncat);
183 #endif 183 #endif
184 184
185 #ifndef __HAVE_ARCH_STRLCAT 185 #ifndef __HAVE_ARCH_STRLCAT
186 /** 186 /**
187 * strlcat - Append a length-limited, %NUL-terminated string to another 187 * strlcat - Append a length-limited, %NUL-terminated string to another
188 * @dest: The string to be appended to 188 * @dest: The string to be appended to
189 * @src: The string to append to it 189 * @src: The string to append to it
190 * @count: The size of the destination buffer. 190 * @count: The size of the destination buffer.
191 */ 191 */
192 size_t strlcat(char *dest, const char *src, size_t count) 192 size_t strlcat(char *dest, const char *src, size_t count)
193 { 193 {
194 size_t dsize = strlen(dest); 194 size_t dsize = strlen(dest);
195 size_t len = strlen(src); 195 size_t len = strlen(src);
196 size_t res = dsize + len; 196 size_t res = dsize + len;
197 197
198 /* This would be a bug */ 198 /* This would be a bug */
199 BUG_ON(dsize >= count); 199 BUG_ON(dsize >= count);
200 200
201 dest += dsize; 201 dest += dsize;
202 count -= dsize; 202 count -= dsize;
203 if (len >= count) 203 if (len >= count)
204 len = count-1; 204 len = count-1;
205 memcpy(dest, src, len); 205 memcpy(dest, src, len);
206 dest[len] = 0; 206 dest[len] = 0;
207 return res; 207 return res;
208 } 208 }
209 EXPORT_SYMBOL(strlcat); 209 EXPORT_SYMBOL(strlcat);
210 #endif 210 #endif
211 211
212 #ifndef __HAVE_ARCH_STRCMP 212 #ifndef __HAVE_ARCH_STRCMP
213 /** 213 /**
214 * strcmp - Compare two strings 214 * strcmp - Compare two strings
215 * @cs: One string 215 * @cs: One string
216 * @ct: Another string 216 * @ct: Another string
217 */ 217 */
218 #undef strcmp 218 #undef strcmp
219 int strcmp(const char *cs, const char *ct) 219 int strcmp(const char *cs, const char *ct)
220 { 220 {
221 signed char __res; 221 signed char __res;
222 222
223 while (1) { 223 while (1) {
224 if ((__res = *cs - *ct++) != 0 || !*cs++) 224 if ((__res = *cs - *ct++) != 0 || !*cs++)
225 break; 225 break;
226 } 226 }
227 return __res; 227 return __res;
228 } 228 }
229 EXPORT_SYMBOL(strcmp); 229 EXPORT_SYMBOL(strcmp);
230 #endif 230 #endif
231 231
232 #ifndef __HAVE_ARCH_STRNCMP 232 #ifndef __HAVE_ARCH_STRNCMP
233 /** 233 /**
234 * strncmp - Compare two length-limited strings 234 * strncmp - Compare two length-limited strings
235 * @cs: One string 235 * @cs: One string
236 * @ct: Another string 236 * @ct: Another string
237 * @count: The maximum number of bytes to compare 237 * @count: The maximum number of bytes to compare
238 */ 238 */
239 int strncmp(const char *cs, const char *ct, size_t count) 239 int strncmp(const char *cs, const char *ct, size_t count)
240 { 240 {
241 signed char __res = 0; 241 signed char __res = 0;
242 242
243 while (count) { 243 while (count) {
244 if ((__res = *cs - *ct++) != 0 || !*cs++) 244 if ((__res = *cs - *ct++) != 0 || !*cs++)
245 break; 245 break;
246 count--; 246 count--;
247 } 247 }
248 return __res; 248 return __res;
249 } 249 }
250 EXPORT_SYMBOL(strncmp); 250 EXPORT_SYMBOL(strncmp);
251 #endif 251 #endif
252 252
253 #ifndef __HAVE_ARCH_STRCHR 253 #ifndef __HAVE_ARCH_STRCHR
254 /** 254 /**
255 * strchr - Find the first occurrence of a character in a string 255 * strchr - Find the first occurrence of a character in a string
256 * @s: The string to be searched 256 * @s: The string to be searched
257 * @c: The character to search for 257 * @c: The character to search for
258 */ 258 */
259 char *strchr(const char *s, int c) 259 char *strchr(const char *s, int c)
260 { 260 {
261 for (; *s != (char)c; ++s) 261 for (; *s != (char)c; ++s)
262 if (*s == '\0') 262 if (*s == '\0')
263 return NULL; 263 return NULL;
264 return (char *)s; 264 return (char *)s;
265 } 265 }
266 EXPORT_SYMBOL(strchr); 266 EXPORT_SYMBOL(strchr);
267 #endif 267 #endif
268 268
269 #ifndef __HAVE_ARCH_STRRCHR 269 #ifndef __HAVE_ARCH_STRRCHR
270 /** 270 /**
271 * strrchr - Find the last occurrence of a character in a string 271 * strrchr - Find the last occurrence of a character in a string
272 * @s: The string to be searched 272 * @s: The string to be searched
273 * @c: The character to search for 273 * @c: The character to search for
274 */ 274 */
275 char *strrchr(const char *s, int c) 275 char *strrchr(const char *s, int c)
276 { 276 {
277 const char *p = s + strlen(s); 277 const char *p = s + strlen(s);
278 do { 278 do {
279 if (*p == (char)c) 279 if (*p == (char)c)
280 return (char *)p; 280 return (char *)p;
281 } while (--p >= s); 281 } while (--p >= s);
282 return NULL; 282 return NULL;
283 } 283 }
284 EXPORT_SYMBOL(strrchr); 284 EXPORT_SYMBOL(strrchr);
285 #endif 285 #endif
286 286
287 #ifndef __HAVE_ARCH_STRNCHR 287 #ifndef __HAVE_ARCH_STRNCHR
288 /** 288 /**
289 * strnchr - Find a character in a length limited string 289 * strnchr - Find a character in a length limited string
290 * @s: The string to be searched 290 * @s: The string to be searched
291 * @count: The number of characters to be searched 291 * @count: The number of characters to be searched
292 * @c: The character to search for 292 * @c: The character to search for
293 */ 293 */
294 char *strnchr(const char *s, size_t count, int c) 294 char *strnchr(const char *s, size_t count, int c)
295 { 295 {
296 for (; count-- && *s != '\0'; ++s) 296 for (; count-- && *s != '\0'; ++s)
297 if (*s == (char)c) 297 if (*s == (char)c)
298 return (char *)s; 298 return (char *)s;
299 return NULL; 299 return NULL;
300 } 300 }
301 EXPORT_SYMBOL(strnchr); 301 EXPORT_SYMBOL(strnchr);
302 #endif 302 #endif
303 303
304 #ifndef __HAVE_ARCH_STRLEN 304 #ifndef __HAVE_ARCH_STRLEN
305 /** 305 /**
306 * strlen - Find the length of a string 306 * strlen - Find the length of a string
307 * @s: The string to be sized 307 * @s: The string to be sized
308 */ 308 */
309 size_t strlen(const char *s) 309 size_t strlen(const char *s)
310 { 310 {
311 const char *sc; 311 const char *sc;
312 312
313 for (sc = s; *sc != '\0'; ++sc) 313 for (sc = s; *sc != '\0'; ++sc)
314 /* nothing */; 314 /* nothing */;
315 return sc - s; 315 return sc - s;
316 } 316 }
317 EXPORT_SYMBOL(strlen); 317 EXPORT_SYMBOL(strlen);
318 #endif 318 #endif
319 319
320 #ifndef __HAVE_ARCH_STRNLEN 320 #ifndef __HAVE_ARCH_STRNLEN
321 /** 321 /**
322 * strnlen - Find the length of a length-limited string 322 * strnlen - Find the length of a length-limited string
323 * @s: The string to be sized 323 * @s: The string to be sized
324 * @count: The maximum number of bytes to search 324 * @count: The maximum number of bytes to search
325 */ 325 */
326 size_t strnlen(const char *s, size_t count) 326 size_t strnlen(const char *s, size_t count)
327 { 327 {
328 const char *sc; 328 const char *sc;
329 329
330 for (sc = s; count-- && *sc != '\0'; ++sc) 330 for (sc = s; count-- && *sc != '\0'; ++sc)
331 /* nothing */; 331 /* nothing */;
332 return sc - s; 332 return sc - s;
333 } 333 }
334 EXPORT_SYMBOL(strnlen); 334 EXPORT_SYMBOL(strnlen);
335 #endif 335 #endif
336 336
337 #ifndef __HAVE_ARCH_STRSPN 337 #ifndef __HAVE_ARCH_STRSPN
338 /** 338 /**
339 * strspn - Calculate the length of the initial substring of @s which only 339 * strspn - Calculate the length of the initial substring of @s which only
340 * contain letters in @accept 340 * contain letters in @accept
341 * @s: The string to be searched 341 * @s: The string to be searched
342 * @accept: The string to search for 342 * @accept: The string to search for
343 */ 343 */
344 size_t strspn(const char *s, const char *accept) 344 size_t strspn(const char *s, const char *accept)
345 { 345 {
346 const char *p; 346 const char *p;
347 const char *a; 347 const char *a;
348 size_t count = 0; 348 size_t count = 0;
349 349
350 for (p = s; *p != '\0'; ++p) { 350 for (p = s; *p != '\0'; ++p) {
351 for (a = accept; *a != '\0'; ++a) { 351 for (a = accept; *a != '\0'; ++a) {
352 if (*p == *a) 352 if (*p == *a)
353 break; 353 break;
354 } 354 }
355 if (*a == '\0') 355 if (*a == '\0')
356 return count; 356 return count;
357 ++count; 357 ++count;
358 } 358 }
359 return count; 359 return count;
360 } 360 }
361 361
362 EXPORT_SYMBOL(strspn); 362 EXPORT_SYMBOL(strspn);
363 #endif 363 #endif
364 364
365 #ifndef __HAVE_ARCH_STRCSPN 365 #ifndef __HAVE_ARCH_STRCSPN
366 /** 366 /**
367 * strcspn - Calculate the length of the initial substring of @s which does 367 * strcspn - Calculate the length of the initial substring of @s which does
368 * not contain letters in @reject 368 * not contain letters in @reject
369 * @s: The string to be searched 369 * @s: The string to be searched
370 * @reject: The string to avoid 370 * @reject: The string to avoid
371 */ 371 */
372 size_t strcspn(const char *s, const char *reject) 372 size_t strcspn(const char *s, const char *reject)
373 { 373 {
374 const char *p; 374 const char *p;
375 const char *r; 375 const char *r;
376 size_t count = 0; 376 size_t count = 0;
377 377
378 for (p = s; *p != '\0'; ++p) { 378 for (p = s; *p != '\0'; ++p) {
379 for (r = reject; *r != '\0'; ++r) { 379 for (r = reject; *r != '\0'; ++r) {
380 if (*p == *r) 380 if (*p == *r)
381 return count; 381 return count;
382 } 382 }
383 ++count; 383 ++count;
384 } 384 }
385 return count; 385 return count;
386 } 386 }
387 EXPORT_SYMBOL(strcspn); 387 EXPORT_SYMBOL(strcspn);
388 #endif 388 #endif
389 389
390 #ifndef __HAVE_ARCH_STRPBRK 390 #ifndef __HAVE_ARCH_STRPBRK
391 /** 391 /**
392 * strpbrk - Find the first occurrence of a set of characters 392 * strpbrk - Find the first occurrence of a set of characters
393 * @cs: The string to be searched 393 * @cs: The string to be searched
394 * @ct: The characters to search for 394 * @ct: The characters to search for
395 */ 395 */
396 char *strpbrk(const char *cs, const char *ct) 396 char *strpbrk(const char *cs, const char *ct)
397 { 397 {
398 const char *sc1, *sc2; 398 const char *sc1, *sc2;
399 399
400 for (sc1 = cs; *sc1 != '\0'; ++sc1) { 400 for (sc1 = cs; *sc1 != '\0'; ++sc1) {
401 for (sc2 = ct; *sc2 != '\0'; ++sc2) { 401 for (sc2 = ct; *sc2 != '\0'; ++sc2) {
402 if (*sc1 == *sc2) 402 if (*sc1 == *sc2)
403 return (char *)sc1; 403 return (char *)sc1;
404 } 404 }
405 } 405 }
406 return NULL; 406 return NULL;
407 } 407 }
408 EXPORT_SYMBOL(strpbrk); 408 EXPORT_SYMBOL(strpbrk);
409 #endif 409 #endif
410 410
411 #ifndef __HAVE_ARCH_STRSEP 411 #ifndef __HAVE_ARCH_STRSEP
412 /** 412 /**
413 * strsep - Split a string into tokens 413 * strsep - Split a string into tokens
414 * @s: The string to be searched 414 * @s: The string to be searched
415 * @ct: The characters to search for 415 * @ct: The characters to search for
416 * 416 *
417 * strsep() updates @s to point after the token, ready for the next call. 417 * strsep() updates @s to point after the token, ready for the next call.
418 * 418 *
419 * It returns empty tokens, too, behaving exactly like the libc function 419 * It returns empty tokens, too, behaving exactly like the libc function
420 * of that name. In fact, it was stolen from glibc2 and de-fancy-fied. 420 * of that name. In fact, it was stolen from glibc2 and de-fancy-fied.
421 * Same semantics, slimmer shape. ;) 421 * Same semantics, slimmer shape. ;)
422 */ 422 */
423 char *strsep(char **s, const char *ct) 423 char *strsep(char **s, const char *ct)
424 { 424 {
425 char *sbegin = *s; 425 char *sbegin = *s;
426 char *end; 426 char *end;
427 427
428 if (sbegin == NULL) 428 if (sbegin == NULL)
429 return NULL; 429 return NULL;
430 430
431 end = strpbrk(sbegin, ct); 431 end = strpbrk(sbegin, ct);
432 if (end) 432 if (end)
433 *end++ = '\0'; 433 *end++ = '\0';
434 *s = end; 434 *s = end;
435 return sbegin; 435 return sbegin;
436 } 436 }
437 EXPORT_SYMBOL(strsep); 437 EXPORT_SYMBOL(strsep);
438 #endif 438 #endif
439 439
440 #ifndef __HAVE_ARCH_MEMSET 440 #ifndef __HAVE_ARCH_MEMSET
441 /** 441 /**
442 * memset - Fill a region of memory with the given value 442 * memset - Fill a region of memory with the given value
443 * @s: Pointer to the start of the area. 443 * @s: Pointer to the start of the area.
444 * @c: The byte to fill the area with 444 * @c: The byte to fill the area with
445 * @count: The size of the area. 445 * @count: The size of the area.
446 * 446 *
447 * Do not use memset() to access IO space, use memset_io() instead. 447 * Do not use memset() to access IO space, use memset_io() instead.
448 */ 448 */
449 void *memset(void *s, int c, size_t count) 449 void *memset(void *s, int c, size_t count)
450 { 450 {
451 char *xs = s; 451 char *xs = s;
452 452
453 while (count--) 453 while (count--)
454 *xs++ = c; 454 *xs++ = c;
455 return s; 455 return s;
456 } 456 }
457 EXPORT_SYMBOL(memset); 457 EXPORT_SYMBOL(memset);
458 #endif 458 #endif
459 459
460 #ifndef __HAVE_ARCH_MEMCPY 460 #ifndef __HAVE_ARCH_MEMCPY
461 /** 461 /**
462 * memcpy - Copy one area of memory to another 462 * memcpy - Copy one area of memory to another
463 * @dest: Where to copy to 463 * @dest: Where to copy to
464 * @src: Where to copy from 464 * @src: Where to copy from
465 * @count: The size of the area. 465 * @count: The size of the area.
466 * 466 *
467 * You should not use this function to access IO space, use memcpy_toio() 467 * You should not use this function to access IO space, use memcpy_toio()
468 * or memcpy_fromio() instead. 468 * or memcpy_fromio() instead.
469 */ 469 */
470 void *memcpy(void *dest, const void *src, size_t count) 470 void *memcpy(void *dest, const void *src, size_t count)
471 { 471 {
472 char *tmp = dest; 472 char *tmp = dest;
473 char *s = src; 473 const char *s = src;
474 474
475 while (count--) 475 while (count--)
476 *tmp++ = *s++; 476 *tmp++ = *s++;
477 return dest; 477 return dest;
478 } 478 }
479 EXPORT_SYMBOL(memcpy); 479 EXPORT_SYMBOL(memcpy);
480 #endif 480 #endif
481 481
482 #ifndef __HAVE_ARCH_MEMMOVE 482 #ifndef __HAVE_ARCH_MEMMOVE
483 /** 483 /**
484 * memmove - Copy one area of memory to another 484 * memmove - Copy one area of memory to another
485 * @dest: Where to copy to 485 * @dest: Where to copy to
486 * @src: Where to copy from 486 * @src: Where to copy from
487 * @count: The size of the area. 487 * @count: The size of the area.
488 * 488 *
489 * Unlike memcpy(), memmove() copes with overlapping areas. 489 * Unlike memcpy(), memmove() copes with overlapping areas.
490 */ 490 */
491 void *memmove(void *dest, const void *src, size_t count) 491 void *memmove(void *dest, const void *src, size_t count)
492 { 492 {
493 char *tmp; 493 char *tmp;
494 const char *s; 494 const char *s;
495 495
496 if (dest <= src) { 496 if (dest <= src) {
497 tmp = dest; 497 tmp = dest;
498 s = src; 498 s = src;
499 while (count--) 499 while (count--)
500 *tmp++ = *s++; 500 *tmp++ = *s++;
501 } else { 501 } else {
502 tmp = dest; 502 tmp = dest;
503 tmp += count; 503 tmp += count;
504 s = src; 504 s = src;
505 s += count; 505 s += count;
506 while (count--) 506 while (count--)
507 *--tmp = *--s; 507 *--tmp = *--s;
508 } 508 }
509 return dest; 509 return dest;
510 } 510 }
511 EXPORT_SYMBOL(memmove); 511 EXPORT_SYMBOL(memmove);
512 #endif 512 #endif
513 513
514 #ifndef __HAVE_ARCH_MEMCMP 514 #ifndef __HAVE_ARCH_MEMCMP
515 /** 515 /**
516 * memcmp - Compare two areas of memory 516 * memcmp - Compare two areas of memory
517 * @cs: One area of memory 517 * @cs: One area of memory
518 * @ct: Another area of memory 518 * @ct: Another area of memory
519 * @count: The size of the area. 519 * @count: The size of the area.
520 */ 520 */
521 #undef memcmp 521 #undef memcmp
522 int memcmp(const void *cs, const void *ct, size_t count) 522 int memcmp(const void *cs, const void *ct, size_t count)
523 { 523 {
524 const unsigned char *su1, *su2; 524 const unsigned char *su1, *su2;
525 int res = 0; 525 int res = 0;
526 526
527 for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--) 527 for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
528 if ((res = *su1 - *su2) != 0) 528 if ((res = *su1 - *su2) != 0)
529 break; 529 break;
530 return res; 530 return res;
531 } 531 }
532 EXPORT_SYMBOL(memcmp); 532 EXPORT_SYMBOL(memcmp);
533 #endif 533 #endif
534 534
535 #ifndef __HAVE_ARCH_MEMSCAN 535 #ifndef __HAVE_ARCH_MEMSCAN
536 /** 536 /**
537 * memscan - Find a character in an area of memory. 537 * memscan - Find a character in an area of memory.
538 * @addr: The memory area 538 * @addr: The memory area
539 * @c: The byte to search for 539 * @c: The byte to search for
540 * @size: The size of the area. 540 * @size: The size of the area.
541 * 541 *
542 * returns the address of the first occurrence of @c, or 1 byte past 542 * returns the address of the first occurrence of @c, or 1 byte past
543 * the area if @c is not found 543 * the area if @c is not found
544 */ 544 */
545 void *memscan(void *addr, int c, size_t size) 545 void *memscan(void *addr, int c, size_t size)
546 { 546 {
547 unsigned char *p = addr; 547 unsigned char *p = addr;
548 548
549 while (size) { 549 while (size) {
550 if (*p == c) 550 if (*p == c)
551 return (void *)p; 551 return (void *)p;
552 p++; 552 p++;
553 size--; 553 size--;
554 } 554 }
555 return (void *)p; 555 return (void *)p;
556 } 556 }
557 EXPORT_SYMBOL(memscan); 557 EXPORT_SYMBOL(memscan);
558 #endif 558 #endif
559 559
560 #ifndef __HAVE_ARCH_STRSTR 560 #ifndef __HAVE_ARCH_STRSTR
561 /** 561 /**
562 * strstr - Find the first substring in a %NUL terminated string 562 * strstr - Find the first substring in a %NUL terminated string
563 * @s1: The string to be searched 563 * @s1: The string to be searched
564 * @s2: The string to search for 564 * @s2: The string to search for
565 */ 565 */
566 char *strstr(const char *s1, const char *s2) 566 char *strstr(const char *s1, const char *s2)
567 { 567 {
568 int l1, l2; 568 int l1, l2;
569 569
570 l2 = strlen(s2); 570 l2 = strlen(s2);
571 if (!l2) 571 if (!l2)
572 return (char *)s1; 572 return (char *)s1;
573 l1 = strlen(s1); 573 l1 = strlen(s1);
574 while (l1 >= l2) { 574 while (l1 >= l2) {
575 l1--; 575 l1--;
576 if (!memcmp(s1, s2, l2)) 576 if (!memcmp(s1, s2, l2))
577 return (char *)s1; 577 return (char *)s1;
578 s1++; 578 s1++;
579 } 579 }
580 return NULL; 580 return NULL;
581 } 581 }
582 EXPORT_SYMBOL(strstr); 582 EXPORT_SYMBOL(strstr);
583 #endif 583 #endif
584 584
585 #ifndef __HAVE_ARCH_MEMCHR 585 #ifndef __HAVE_ARCH_MEMCHR
586 /** 586 /**
587 * memchr - Find a character in an area of memory. 587 * memchr - Find a character in an area of memory.
588 * @s: The memory area 588 * @s: The memory area
589 * @c: The byte to search for 589 * @c: The byte to search for
590 * @n: The size of the area. 590 * @n: The size of the area.
591 * 591 *
592 * returns the address of the first occurrence of @c, or %NULL 592 * returns the address of the first occurrence of @c, or %NULL
593 * if @c is not found 593 * if @c is not found
594 */ 594 */
595 void *memchr(const void *s, int c, size_t n) 595 void *memchr(const void *s, int c, size_t n)
596 { 596 {
597 const unsigned char *p = s; 597 const unsigned char *p = s;
598 while (n-- != 0) { 598 while (n-- != 0) {
599 if ((unsigned char)c == *p++) { 599 if ((unsigned char)c == *p++) {
600 return (void *)(p - 1); 600 return (void *)(p - 1);
601 } 601 }
602 } 602 }
603 return NULL; 603 return NULL;
604 } 604 }
605 EXPORT_SYMBOL(memchr); 605 EXPORT_SYMBOL(memchr);
606 #endif 606 #endif
607 607