Blame view
lib/string.c
17.4 KB
1da177e4c Linux-2.6.12-rc2 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
/* * linux/lib/string.c * * Copyright (C) 1991, 1992 Linus Torvalds */ /* * stupid library routines.. The optimized versions should generally be found * as inline code in <asm-xx/string.h> * * These are buggy as well.. * * * Fri Jun 25 1999, Ingo Oeser <ioe@informatik.tu-chemnitz.de> * - Added strsep() which will replace strtok() soon (because strsep() is * reentrant and should be faster). Use only strsep() in new code, please. * * * Sat Feb 09 2002, Jason Thomas <jason@topic.com.au>, * Matthew Hawkins <matt@mh.dropbear.id.au> * - Kissed strtok() goodbye */ #include <linux/types.h> #include <linux/string.h> #include <linux/ctype.h> |
8bc3bcc93 lib: reduce the u... |
25 26 |
#include <linux/kernel.h> #include <linux/export.h> |
50af5ead3 bug.h: add includ... |
27 |
#include <linux/bug.h> |
8bc3bcc93 lib: reduce the u... |
28 |
#include <linux/errno.h> |
1da177e4c Linux-2.6.12-rc2 |
29 |
|
cd514e727 lib/string.c: rem... |
30 |
#ifndef __HAVE_ARCH_STRNCASECMP |
1da177e4c Linux-2.6.12-rc2 |
31 |
/** |
cd514e727 lib/string.c: rem... |
32 |
* strncasecmp - Case insensitive, length-limited string comparison |
1da177e4c Linux-2.6.12-rc2 |
33 34 35 36 |
* @s1: One string * @s2: The other string * @len: the maximum number of characters to compare */ |
cd514e727 lib/string.c: rem... |
37 |
int strncasecmp(const char *s1, const char *s2, size_t len) |
1da177e4c Linux-2.6.12-rc2 |
38 39 40 |
{ /* Yes, Virginia, it had better be unsigned */ unsigned char c1, c2; |
a11d2b64e lib/string.c: sim... |
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
if (!len) return 0; do { c1 = *s1++; c2 = *s2++; if (!c1 || !c2) break; if (c1 == c2) continue; c1 = tolower(c1); c2 = tolower(c2); if (c1 != c2) break; } while (--len); |
1da177e4c Linux-2.6.12-rc2 |
56 57 |
return (int)c1 - (int)c2; } |
cd514e727 lib/string.c: rem... |
58 59 |
EXPORT_SYMBOL(strncasecmp); #endif |
1da177e4c Linux-2.6.12-rc2 |
60 |
|
ded220bd8 [STRING]: Move st... |
61 62 63 64 65 66 67 68 69 70 71 72 73 |
#ifndef __HAVE_ARCH_STRCASECMP int strcasecmp(const char *s1, const char *s2) { int c1, c2; do { c1 = tolower(*s1++); c2 = tolower(*s2++); } while (c1 == c2 && c1 != 0); return c1 - c2; } EXPORT_SYMBOL(strcasecmp); #endif |
1da177e4c Linux-2.6.12-rc2 |
74 75 76 77 78 79 |
#ifndef __HAVE_ARCH_STRCPY /** * strcpy - Copy a %NUL terminated string * @dest: Where to copy the string to * @src: Where to copy the string from */ |
0c28130b5 [PATCH] x86_64: m... |
80 |
#undef strcpy |
51a0f0f65 [PATCH] lib/strin... |
81 |
char *strcpy(char *dest, const char *src) |
1da177e4c Linux-2.6.12-rc2 |
82 83 84 85 86 87 88 89 90 91 92 93 |
{ char *tmp = dest; while ((*dest++ = *src++) != '\0') /* nothing */; return tmp; } EXPORT_SYMBOL(strcpy); #endif #ifndef __HAVE_ARCH_STRNCPY /** |
0046dd9fe lib/string.c: use... |
94 |
* strncpy - Copy a length-limited, C-string |
1da177e4c Linux-2.6.12-rc2 |
95 96 97 98 99 100 |
* @dest: Where to copy the string to * @src: Where to copy the string from * @count: The maximum number of bytes to copy * * The result is not %NUL-terminated if the source exceeds * @count bytes. |
252795264 [PATCH] documenta... |
101 102 103 104 |
* * In the case where the length of @src is less than that of * count, the remainder of @dest will be padded with %NUL. * |
1da177e4c Linux-2.6.12-rc2 |
105 |
*/ |
51a0f0f65 [PATCH] lib/strin... |
106 |
char *strncpy(char *dest, const char *src, size_t count) |
1da177e4c Linux-2.6.12-rc2 |
107 108 109 110 |
{ char *tmp = dest; while (count) { |
51a0f0f65 [PATCH] lib/strin... |
111 112 |
if ((*tmp = *src) != 0) src++; |
1da177e4c Linux-2.6.12-rc2 |
113 114 115 116 117 118 119 120 121 122 |
tmp++; count--; } return dest; } EXPORT_SYMBOL(strncpy); #endif #ifndef __HAVE_ARCH_STRLCPY /** |
0046dd9fe lib/string.c: use... |
123 |
* strlcpy - Copy a C-string into a sized buffer |
1da177e4c Linux-2.6.12-rc2 |
124 125 126 127 128 129 130 131 132 133 134 135 136 137 |
* @dest: Where to copy the string to * @src: Where to copy the string from * @size: size of destination buffer * * Compatible with *BSD: the result is always a valid * NUL-terminated string that fits in the buffer (unless, * of course, the buffer size is zero). It does not pad * out the result like strncpy() does. */ size_t strlcpy(char *dest, const char *src, size_t size) { size_t ret = strlen(src); if (size) { |
51a0f0f65 [PATCH] lib/strin... |
138 |
size_t len = (ret >= size) ? size - 1 : ret; |
1da177e4c Linux-2.6.12-rc2 |
139 140 141 142 143 144 145 146 147 148 149 150 151 152 |
memcpy(dest, src, len); dest[len] = '\0'; } return ret; } EXPORT_SYMBOL(strlcpy); #endif #ifndef __HAVE_ARCH_STRCAT /** * strcat - Append one %NUL-terminated string to another * @dest: The string to be appended to * @src: The string to append to it */ |
0c28130b5 [PATCH] x86_64: m... |
153 |
#undef strcat |
51a0f0f65 [PATCH] lib/strin... |
154 |
char *strcat(char *dest, const char *src) |
1da177e4c Linux-2.6.12-rc2 |
155 156 157 158 159 160 161 |
{ char *tmp = dest; while (*dest) dest++; while ((*dest++ = *src++) != '\0') ; |
1da177e4c Linux-2.6.12-rc2 |
162 163 164 165 166 167 168 |
return tmp; } EXPORT_SYMBOL(strcat); #endif #ifndef __HAVE_ARCH_STRNCAT /** |
0046dd9fe lib/string.c: use... |
169 |
* strncat - Append a length-limited, C-string to another |
1da177e4c Linux-2.6.12-rc2 |
170 171 172 173 |
* @dest: The string to be appended to * @src: The string to append to it * @count: The maximum numbers of bytes to copy * |
72fd4a35a [PATCH] Numerous ... |
174 |
* Note that in contrast to strncpy(), strncat() ensures the result is |
1da177e4c Linux-2.6.12-rc2 |
175 176 |
* terminated. */ |
51a0f0f65 [PATCH] lib/strin... |
177 |
char *strncat(char *dest, const char *src, size_t count) |
1da177e4c Linux-2.6.12-rc2 |
178 179 180 181 182 183 184 185 186 187 188 189 190 |
{ char *tmp = dest; if (count) { while (*dest) dest++; while ((*dest++ = *src++) != 0) { if (--count == 0) { *dest = '\0'; break; } } } |
1da177e4c Linux-2.6.12-rc2 |
191 192 193 194 195 196 197 |
return tmp; } EXPORT_SYMBOL(strncat); #endif #ifndef __HAVE_ARCH_STRLCAT /** |
0046dd9fe lib/string.c: use... |
198 |
* strlcat - Append a length-limited, C-string to another |
1da177e4c Linux-2.6.12-rc2 |
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 |
* @dest: The string to be appended to * @src: The string to append to it * @count: The size of the destination buffer. */ size_t strlcat(char *dest, const char *src, size_t count) { size_t dsize = strlen(dest); size_t len = strlen(src); size_t res = dsize + len; /* This would be a bug */ BUG_ON(dsize >= count); dest += dsize; count -= dsize; if (len >= count) len = count-1; memcpy(dest, src, len); dest[len] = 0; return res; } EXPORT_SYMBOL(strlcat); #endif #ifndef __HAVE_ARCH_STRCMP /** * strcmp - Compare two strings * @cs: One string * @ct: Another string */ |
0c28130b5 [PATCH] x86_64: m... |
229 |
#undef strcmp |
51a0f0f65 [PATCH] lib/strin... |
230 |
int strcmp(const char *cs, const char *ct) |
1da177e4c Linux-2.6.12-rc2 |
231 |
{ |
a414f01ac strcmp: fix overf... |
232 |
unsigned char c1, c2; |
1da177e4c Linux-2.6.12-rc2 |
233 234 |
while (1) { |
a414f01ac strcmp: fix overf... |
235 236 237 238 239 |
c1 = *cs++; c2 = *ct++; if (c1 != c2) return c1 < c2 ? -1 : 1; if (!c1) |
1da177e4c Linux-2.6.12-rc2 |
240 241 |
break; } |
a414f01ac strcmp: fix overf... |
242 |
return 0; |
1da177e4c Linux-2.6.12-rc2 |
243 244 245 246 247 248 249 250 251 252 253 |
} EXPORT_SYMBOL(strcmp); #endif #ifndef __HAVE_ARCH_STRNCMP /** * strncmp - Compare two length-limited strings * @cs: One string * @ct: Another string * @count: The maximum number of bytes to compare */ |
51a0f0f65 [PATCH] lib/strin... |
254 |
int strncmp(const char *cs, const char *ct, size_t count) |
1da177e4c Linux-2.6.12-rc2 |
255 |
{ |
a414f01ac strcmp: fix overf... |
256 |
unsigned char c1, c2; |
1da177e4c Linux-2.6.12-rc2 |
257 258 |
while (count) { |
a414f01ac strcmp: fix overf... |
259 260 261 262 263 |
c1 = *cs++; c2 = *ct++; if (c1 != c2) return c1 < c2 ? -1 : 1; if (!c1) |
1da177e4c Linux-2.6.12-rc2 |
264 265 266 |
break; count--; } |
a414f01ac strcmp: fix overf... |
267 |
return 0; |
1da177e4c Linux-2.6.12-rc2 |
268 269 270 271 272 273 274 275 276 277 |
} EXPORT_SYMBOL(strncmp); #endif #ifndef __HAVE_ARCH_STRCHR /** * strchr - Find the first occurrence of a character in a string * @s: The string to be searched * @c: The character to search for */ |
51a0f0f65 [PATCH] lib/strin... |
278 |
char *strchr(const char *s, int c) |
1da177e4c Linux-2.6.12-rc2 |
279 |
{ |
51a0f0f65 [PATCH] lib/strin... |
280 |
for (; *s != (char)c; ++s) |
1da177e4c Linux-2.6.12-rc2 |
281 282 |
if (*s == '\0') return NULL; |
51a0f0f65 [PATCH] lib/strin... |
283 |
return (char *)s; |
1da177e4c Linux-2.6.12-rc2 |
284 285 286 |
} EXPORT_SYMBOL(strchr); #endif |
11d200e95 lib: add glibc st... |
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 |
#ifndef __HAVE_ARCH_STRCHRNUL /** * strchrnul - Find and return a character in a string, or end of string * @s: The string to be searched * @c: The character to search for * * Returns pointer to first occurrence of 'c' in s. If c is not found, then * return a pointer to the null byte at the end of s. */ char *strchrnul(const char *s, int c) { while (*s && *s != (char)c) s++; return (char *)s; } EXPORT_SYMBOL(strchrnul); #endif |
1da177e4c Linux-2.6.12-rc2 |
304 305 306 307 308 309 |
#ifndef __HAVE_ARCH_STRRCHR /** * strrchr - Find the last occurrence of a character in a string * @s: The string to be searched * @c: The character to search for */ |
51a0f0f65 [PATCH] lib/strin... |
310 |
char *strrchr(const char *s, int c) |
1da177e4c Linux-2.6.12-rc2 |
311 |
{ |
8da53d459 lib/string.c: imp... |
312 313 314 315 316 317 |
const char *last = NULL; do { if (*s == (char)c) last = s; } while (*s++); return (char *)last; |
1da177e4c Linux-2.6.12-rc2 |
318 319 320 321 322 323 324 325 326 327 328 329 330 331 |
} EXPORT_SYMBOL(strrchr); #endif #ifndef __HAVE_ARCH_STRNCHR /** * strnchr - Find a character in a length limited string * @s: The string to be searched * @count: The number of characters to be searched * @c: The character to search for */ char *strnchr(const char *s, size_t count, int c) { for (; count-- && *s != '\0'; ++s) |
51a0f0f65 [PATCH] lib/strin... |
332 333 |
if (*s == (char)c) return (char *)s; |
1da177e4c Linux-2.6.12-rc2 |
334 335 336 337 |
return NULL; } EXPORT_SYMBOL(strnchr); #endif |
481fad483 [PATCH] strstrip(... |
338 |
/** |
a6cd13f3c lib/string.c: fix... |
339 340 |
* skip_spaces - Removes leading whitespace from @str. * @str: The string to be stripped. |
f653398c8 string: factorize... |
341 |
* |
a6cd13f3c lib/string.c: fix... |
342 |
* Returns a pointer to the first non-whitespace character in @str. |
f653398c8 string: factorize... |
343 344 345 346 347 348 349 350 351 352 |
*/ char *skip_spaces(const char *str) { while (isspace(*str)) ++str; return (char *)str; } EXPORT_SYMBOL(skip_spaces); /** |
ca54cb8c9 Subject: Re: [PAT... |
353 |
* strim - Removes leading and trailing whitespace from @s. |
481fad483 [PATCH] strstrip(... |
354 355 356 357 358 359 |
* @s: The string to be stripped. * * Note that the first trailing whitespace is replaced with a %NUL-terminator * in the given string @s. Returns a pointer to the first non-whitespace * character in @s. */ |
ca54cb8c9 Subject: Re: [PAT... |
360 |
char *strim(char *s) |
481fad483 [PATCH] strstrip(... |
361 362 363 364 365 |
{ size_t size; char *end; size = strlen(s); |
481fad483 [PATCH] strstrip(... |
366 367 368 369 |
if (!size) return s; end = s + size - 1; |
6e6d9fa6f [PATCH] strstrip ... |
370 |
while (end >= s && isspace(*end)) |
481fad483 [PATCH] strstrip(... |
371 372 |
end--; *(end + 1) = '\0'; |
66f6958e6 lib/string.c: fix... |
373 |
return skip_spaces(s); |
481fad483 [PATCH] strstrip(... |
374 |
} |
ca54cb8c9 Subject: Re: [PAT... |
375 |
EXPORT_SYMBOL(strim); |
481fad483 [PATCH] strstrip(... |
376 |
|
1da177e4c Linux-2.6.12-rc2 |
377 378 379 380 381 |
#ifndef __HAVE_ARCH_STRLEN /** * strlen - Find the length of a string * @s: The string to be sized */ |
51a0f0f65 [PATCH] lib/strin... |
382 |
size_t strlen(const char *s) |
1da177e4c Linux-2.6.12-rc2 |
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 |
{ const char *sc; for (sc = s; *sc != '\0'; ++sc) /* nothing */; return sc - s; } EXPORT_SYMBOL(strlen); #endif #ifndef __HAVE_ARCH_STRNLEN /** * strnlen - Find the length of a length-limited string * @s: The string to be sized * @count: The maximum number of bytes to search */ |
51a0f0f65 [PATCH] lib/strin... |
399 |
size_t strnlen(const char *s, size_t count) |
1da177e4c Linux-2.6.12-rc2 |
400 401 402 403 404 405 406 407 408 409 410 411 |
{ const char *sc; for (sc = s; count-- && *sc != '\0'; ++sc) /* nothing */; return sc - s; } EXPORT_SYMBOL(strnlen); #endif #ifndef __HAVE_ARCH_STRSPN /** |
72fd4a35a [PATCH] Numerous ... |
412 |
* strspn - Calculate the length of the initial substring of @s which only contain letters in @accept |
1da177e4c Linux-2.6.12-rc2 |
413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 |
* @s: The string to be searched * @accept: The string to search for */ size_t strspn(const char *s, const char *accept) { const char *p; const char *a; size_t count = 0; for (p = s; *p != '\0'; ++p) { for (a = accept; *a != '\0'; ++a) { if (*p == *a) break; } if (*a == '\0') return count; ++count; } |
1da177e4c Linux-2.6.12-rc2 |
431 432 433 434 435 |
return count; } EXPORT_SYMBOL(strspn); #endif |
8833d328c [PATCH] Clean up ... |
436 |
#ifndef __HAVE_ARCH_STRCSPN |
1da177e4c Linux-2.6.12-rc2 |
437 |
/** |
72fd4a35a [PATCH] Numerous ... |
438 |
* strcspn - Calculate the length of the initial substring of @s which does not contain letters in @reject |
1da177e4c Linux-2.6.12-rc2 |
439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 |
* @s: The string to be searched * @reject: The string to avoid */ size_t strcspn(const char *s, const char *reject) { const char *p; const char *r; size_t count = 0; for (p = s; *p != '\0'; ++p) { for (r = reject; *r != '\0'; ++r) { if (*p == *r) return count; } ++count; } |
1da177e4c Linux-2.6.12-rc2 |
455 |
return count; |
51a0f0f65 [PATCH] lib/strin... |
456 |
} |
1da177e4c Linux-2.6.12-rc2 |
457 |
EXPORT_SYMBOL(strcspn); |
8833d328c [PATCH] Clean up ... |
458 |
#endif |
1da177e4c Linux-2.6.12-rc2 |
459 460 461 462 463 464 465 |
#ifndef __HAVE_ARCH_STRPBRK /** * strpbrk - Find the first occurrence of a set of characters * @cs: The string to be searched * @ct: The characters to search for */ |
51a0f0f65 [PATCH] lib/strin... |
466 |
char *strpbrk(const char *cs, const char *ct) |
1da177e4c Linux-2.6.12-rc2 |
467 |
{ |
51a0f0f65 [PATCH] lib/strin... |
468 |
const char *sc1, *sc2; |
1da177e4c Linux-2.6.12-rc2 |
469 |
|
51a0f0f65 [PATCH] lib/strin... |
470 471 |
for (sc1 = cs; *sc1 != '\0'; ++sc1) { for (sc2 = ct; *sc2 != '\0'; ++sc2) { |
1da177e4c Linux-2.6.12-rc2 |
472 |
if (*sc1 == *sc2) |
51a0f0f65 [PATCH] lib/strin... |
473 |
return (char *)sc1; |
1da177e4c Linux-2.6.12-rc2 |
474 475 476 477 |
} } return NULL; } |
894b5779c [PATCH] No arch-s... |
478 |
EXPORT_SYMBOL(strpbrk); |
1da177e4c Linux-2.6.12-rc2 |
479 480 481 482 483 484 485 486 487 488 489 490 491 492 |
#endif #ifndef __HAVE_ARCH_STRSEP /** * strsep - Split a string into tokens * @s: The string to be searched * @ct: The characters to search for * * strsep() updates @s to point after the token, ready for the next call. * * It returns empty tokens, too, behaving exactly like the libc function * of that name. In fact, it was stolen from glibc2 and de-fancy-fied. * Same semantics, slimmer shape. ;) */ |
51a0f0f65 [PATCH] lib/strin... |
493 |
char *strsep(char **s, const char *ct) |
1da177e4c Linux-2.6.12-rc2 |
494 |
{ |
51a0f0f65 [PATCH] lib/strin... |
495 496 |
char *sbegin = *s; char *end; |
1da177e4c Linux-2.6.12-rc2 |
497 498 499 500 501 502 503 504 |
if (sbegin == NULL) return NULL; end = strpbrk(sbegin, ct); if (end) *end++ = '\0'; *s = end; |
1da177e4c Linux-2.6.12-rc2 |
505 506 |
return sbegin; } |
1da177e4c Linux-2.6.12-rc2 |
507 508 |
EXPORT_SYMBOL(strsep); #endif |
34990cf70 Add a new sysfs_s... |
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 |
/** * sysfs_streq - return true if strings are equal, modulo trailing newline * @s1: one string * @s2: another string * * This routine returns true iff two strings are equal, treating both * NUL and newline-then-NUL as equivalent string terminations. It's * geared for use with sysfs input strings, which generally terminate * with newlines but are compared against values without newlines. */ bool sysfs_streq(const char *s1, const char *s2) { while (*s1 && *s1 == *s2) { s1++; s2++; } if (*s1 == *s2) return true; if (!*s1 && *s2 == ' ' && !s2[1]) return true; if (*s1 == ' ' && !s1[1] && !*s2) return true; return false; } EXPORT_SYMBOL(sysfs_streq); |
d0f1fed29 Add a strtobool f... |
537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 |
/** * strtobool - convert common user inputs into boolean values * @s: input string * @res: result * * This routine returns 0 iff the first character is one of 'Yy1Nn0'. * Otherwise it will return -EINVAL. Value pointed to by res is * updated upon finding a match. */ int strtobool(const char *s, bool *res) { switch (s[0]) { case 'y': case 'Y': case '1': *res = true; break; case 'n': case 'N': case '0': *res = false; break; default: return -EINVAL; } return 0; } EXPORT_SYMBOL(strtobool); |
1da177e4c Linux-2.6.12-rc2 |
565 566 567 568 569 570 571 572 573 |
#ifndef __HAVE_ARCH_MEMSET /** * memset - Fill a region of memory with the given value * @s: Pointer to the start of the area. * @c: The byte to fill the area with * @count: The size of the area. * * Do not use memset() to access IO space, use memset_io() instead. */ |
51a0f0f65 [PATCH] lib/strin... |
574 |
void *memset(void *s, int c, size_t count) |
1da177e4c Linux-2.6.12-rc2 |
575 |
{ |
850b92479 [PATCH] lib/strin... |
576 |
char *xs = s; |
1da177e4c Linux-2.6.12-rc2 |
577 578 579 |
while (count--) *xs++ = c; |
1da177e4c Linux-2.6.12-rc2 |
580 581 582 583 |
return s; } EXPORT_SYMBOL(memset); #endif |
d4c5efdb9 random: add and u... |
584 585 586 587 588 589 |
/** * memzero_explicit - Fill a region of memory (e.g. sensitive * keying data) with 0s. * @s: Pointer to the start of the area. * @count: The size of the area. * |
8155330aa lib: memzero_expl... |
590 591 592 593 594 |
* Note: usually using memset() is just fine (!), but in cases * where clearing out _local_ data at the end of a scope is * necessary, memzero_explicit() should be used instead in * order to prevent the compiler from optimising away zeroing. * |
d4c5efdb9 random: add and u... |
595 596 597 598 599 600 |
* memzero_explicit() doesn't need an arch-specific version as * it just invokes the one of memset() implicitly. */ void memzero_explicit(void *s, size_t count) { memset(s, 0, count); |
7829fb09a lib: make memzero... |
601 |
barrier_data(s); |
d4c5efdb9 random: add and u... |
602 603 |
} EXPORT_SYMBOL(memzero_explicit); |
1da177e4c Linux-2.6.12-rc2 |
604 605 606 607 608 609 610 611 612 613 |
#ifndef __HAVE_ARCH_MEMCPY /** * memcpy - Copy one area of memory to another * @dest: Where to copy to * @src: Where to copy from * @count: The size of the area. * * You should not use this function to access IO space, use memcpy_toio() * or memcpy_fromio() instead. */ |
51a0f0f65 [PATCH] lib/strin... |
614 |
void *memcpy(void *dest, const void *src, size_t count) |
1da177e4c Linux-2.6.12-rc2 |
615 |
{ |
850b92479 [PATCH] lib/strin... |
616 |
char *tmp = dest; |
4c416ab71 [PATCH] Silence a... |
617 |
const char *s = src; |
1da177e4c Linux-2.6.12-rc2 |
618 619 620 |
while (count--) *tmp++ = *s++; |
1da177e4c Linux-2.6.12-rc2 |
621 622 623 624 625 626 627 628 629 630 631 632 633 634 |
return dest; } EXPORT_SYMBOL(memcpy); #endif #ifndef __HAVE_ARCH_MEMMOVE /** * memmove - Copy one area of memory to another * @dest: Where to copy to * @src: Where to copy from * @count: The size of the area. * * Unlike memcpy(), memmove() copes with overlapping areas. */ |
51a0f0f65 [PATCH] lib/strin... |
635 |
void *memmove(void *dest, const void *src, size_t count) |
1da177e4c Linux-2.6.12-rc2 |
636 |
{ |
82da2c372 [PATCH] lib/strin... |
637 638 |
char *tmp; const char *s; |
1da177e4c Linux-2.6.12-rc2 |
639 640 |
if (dest <= src) { |
850b92479 [PATCH] lib/strin... |
641 642 |
tmp = dest; s = src; |
1da177e4c Linux-2.6.12-rc2 |
643 644 |
while (count--) *tmp++ = *s++; |
51a0f0f65 [PATCH] lib/strin... |
645 |
} else { |
850b92479 [PATCH] lib/strin... |
646 647 648 649 |
tmp = dest; tmp += count; s = src; s += count; |
1da177e4c Linux-2.6.12-rc2 |
650 651 |
while (count--) *--tmp = *--s; |
51a0f0f65 [PATCH] lib/strin... |
652 |
} |
1da177e4c Linux-2.6.12-rc2 |
653 654 655 656 657 658 659 660 661 662 663 664 |
return dest; } EXPORT_SYMBOL(memmove); #endif #ifndef __HAVE_ARCH_MEMCMP /** * memcmp - Compare two areas of memory * @cs: One area of memory * @ct: Another area of memory * @count: The size of the area. */ |
0c28130b5 [PATCH] x86_64: m... |
665 |
#undef memcmp |
a7330c997 asmlinkage Make _... |
666 |
__visible int memcmp(const void *cs, const void *ct, size_t count) |
1da177e4c Linux-2.6.12-rc2 |
667 668 669 |
{ const unsigned char *su1, *su2; int res = 0; |
51a0f0f65 [PATCH] lib/strin... |
670 |
for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--) |
1da177e4c Linux-2.6.12-rc2 |
671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 |
if ((res = *su1 - *su2) != 0) break; return res; } EXPORT_SYMBOL(memcmp); #endif #ifndef __HAVE_ARCH_MEMSCAN /** * memscan - Find a character in an area of memory. * @addr: The memory area * @c: The byte to search for * @size: The size of the area. * * returns the address of the first occurrence of @c, or 1 byte past * the area if @c is not found */ |
51a0f0f65 [PATCH] lib/strin... |
688 |
void *memscan(void *addr, int c, size_t size) |
1da177e4c Linux-2.6.12-rc2 |
689 |
{ |
850b92479 [PATCH] lib/strin... |
690 |
unsigned char *p = addr; |
1da177e4c Linux-2.6.12-rc2 |
691 692 693 |
while (size) { if (*p == c) |
51a0f0f65 [PATCH] lib/strin... |
694 |
return (void *)p; |
1da177e4c Linux-2.6.12-rc2 |
695 696 697 |
p++; size--; } |
51a0f0f65 [PATCH] lib/strin... |
698 |
return (void *)p; |
1da177e4c Linux-2.6.12-rc2 |
699 700 701 702 703 704 705 706 707 708 |
} EXPORT_SYMBOL(memscan); #endif #ifndef __HAVE_ARCH_STRSTR /** * strstr - Find the first substring in a %NUL terminated string * @s1: The string to be searched * @s2: The string to search for */ |
51a0f0f65 [PATCH] lib/strin... |
709 |
char *strstr(const char *s1, const char *s2) |
1da177e4c Linux-2.6.12-rc2 |
710 |
{ |
d5f1fb533 lib: Introduce st... |
711 |
size_t l1, l2; |
1da177e4c Linux-2.6.12-rc2 |
712 713 714 |
l2 = strlen(s2); if (!l2) |
51a0f0f65 [PATCH] lib/strin... |
715 |
return (char *)s1; |
1da177e4c Linux-2.6.12-rc2 |
716 717 718 |
l1 = strlen(s1); while (l1 >= l2) { l1--; |
51a0f0f65 [PATCH] lib/strin... |
719 720 |
if (!memcmp(s1, s2, l2)) return (char *)s1; |
1da177e4c Linux-2.6.12-rc2 |
721 722 723 724 725 726 |
s1++; } return NULL; } EXPORT_SYMBOL(strstr); #endif |
d5f1fb533 lib: Introduce st... |
727 728 729 730 731 732 733 734 735 |
#ifndef __HAVE_ARCH_STRNSTR /** * strnstr - Find the first substring in a length-limited string * @s1: The string to be searched * @s2: The string to search for * @len: the maximum number of characters to search */ char *strnstr(const char *s1, const char *s2, size_t len) { |
d6a2eedfd lib/string.c: sim... |
736 |
size_t l2; |
d5f1fb533 lib: Introduce st... |
737 738 739 740 |
l2 = strlen(s2); if (!l2) return (char *)s1; |
d6a2eedfd lib/string.c: sim... |
741 742 |
while (len >= l2) { len--; |
d5f1fb533 lib: Introduce st... |
743 744 745 746 747 748 749 750 |
if (!memcmp(s1, s2, l2)) return (char *)s1; s1++; } return NULL; } EXPORT_SYMBOL(strnstr); #endif |
1da177e4c Linux-2.6.12-rc2 |
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 |
#ifndef __HAVE_ARCH_MEMCHR /** * memchr - Find a character in an area of memory. * @s: The memory area * @c: The byte to search for * @n: The size of the area. * * returns the address of the first occurrence of @c, or %NULL * if @c is not found */ void *memchr(const void *s, int c, size_t n) { const unsigned char *p = s; while (n-- != 0) { if ((unsigned char)c == *p++) { |
51a0f0f65 [PATCH] lib/strin... |
766 |
return (void *)(p - 1); |
1da177e4c Linux-2.6.12-rc2 |
767 768 769 770 771 772 |
} } return NULL; } EXPORT_SYMBOL(memchr); #endif |
798248206 lib/string.c: int... |
773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 |
static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes) { while (bytes) { if (*start != value) return (void *)start; start++; bytes--; } return NULL; } /** * memchr_inv - Find an unmatching character in an area of memory. * @start: The memory area * @c: Find a character other than c * @bytes: The size of the area. * * returns the address of the first character other than @c, or %NULL * if the whole buffer contains just @c. */ void *memchr_inv(const void *start, int c, size_t bytes) { u8 value = c; u64 value64; unsigned int words, prefix; if (bytes <= 16) return check_bytes8(start, value, bytes); |
f43804bf5 string: memchr_in... |
802 |
value64 = value; |
72d931046 Make ARCH_HAS_FAS... |
803 |
#if defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) && BITS_PER_LONG == 64 |
f43804bf5 string: memchr_in... |
804 |
value64 *= 0x0101010101010101; |
72d931046 Make ARCH_HAS_FAS... |
805 |
#elif defined(CONFIG_ARCH_HAS_FAST_MULTIPLIER) |
f43804bf5 string: memchr_in... |
806 807 808 809 810 811 812 |
value64 *= 0x01010101; value64 |= value64 << 32; #else value64 |= value64 << 8; value64 |= value64 << 16; value64 |= value64 << 32; #endif |
798248206 lib/string.c: int... |
813 |
|
f43804bf5 string: memchr_in... |
814 |
prefix = (unsigned long)start % 8; |
798248206 lib/string.c: int... |
815 |
if (prefix) { |
f43804bf5 string: memchr_in... |
816 817 818 819 |
u8 *r; prefix = 8 - prefix; r = check_bytes8(start, value, prefix); |
798248206 lib/string.c: int... |
820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 |
if (r) return r; start += prefix; bytes -= prefix; } words = bytes / 8; while (words) { if (*(u64 *)start != value64) return check_bytes8(start, value, 8); start += 8; words--; } return check_bytes8(start, value, bytes % 8); } EXPORT_SYMBOL(memchr_inv); |
94df29040 lib/string.c: int... |
838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 |
/** * strreplace - Replace all occurrences of character in string. * @s: The string to operate on. * @old: The character being replaced. * @new: The character @old is replaced with. * * Returns pointer to the nul byte at the end of @s. */ char *strreplace(char *s, char old, char new) { for (; *s; ++s) if (*s == old) *s = new; return s; } EXPORT_SYMBOL(strreplace); |