4 * Copyright (C) 1991, 1992 Linus Torvalds
8 * stupid library routines.. The optimized versions should generally be found
9 * as inline code in <asm-xx/string.h>
11 * These are buggy as well..
13 * * Fri Jun 25 1999, Ingo Oeser <ioe@informatik.tu-chemnitz.de>
14 * - Added strsep() which will replace strtok() soon (because strsep() is
15 * reentrant and should be faster). Use only strsep() in new code, please.
19 #include <linux/types.h>
20 #include <linux/string.h>
21 #include <linux/ctype.h>
26 * strncasecmp - Case insensitive, length-limited string comparison
28 * @s2: The other string
29 * @len: the maximum number of characters to compare
31 int strncasecmp(const char *s1, const char *s2, size_t len)
33 /* Yes, Virginia, it had better be unsigned */
53 return (int)c1 - (int)c2;
57 * strcasecmp - Case insensitive string comparison
59 * @s2: The other string
61 int strcasecmp(const char *s1, const char *s2)
63 return strncasecmp(s1, s2, -1U);
68 #ifndef __HAVE_ARCH_STRCPY
70 * strcpy - Copy a %NUL terminated string
71 * @dest: Where to copy the string to
72 * @src: Where to copy the string from
74 char * strcpy(char * dest,const char *src)
78 while ((*dest++ = *src++) != '\0')
84 #ifndef __HAVE_ARCH_STRNCPY
86 * strncpy - Copy a length-limited, %NUL-terminated string
87 * @dest: Where to copy the string to
88 * @src: Where to copy the string from
89 * @count: The maximum number of bytes to copy
91 * Note that unlike userspace strncpy, this does not %NUL-pad the buffer.
92 * However, the result is not %NUL-terminated if the source exceeds
95 char * strncpy(char * dest,const char *src,size_t count)
99 while (count-- && (*dest++ = *src++) != '\0')
106 #ifndef __HAVE_ARCH_STRLCPY
108 * strlcpy - Copy a C-string into a sized buffer
109 * @dest: Where to copy the string to
110 * @src: Where to copy the string from
111 * @size: size of destination buffer
113 * Compatible with *BSD: the result is always a valid
114 * NUL-terminated string that fits in the buffer (unless,
115 * of course, the buffer size is zero). It does not pad
116 * out the result like strncpy() does.
118 * Return: the number of bytes copied
120 size_t strlcpy(char *dest, const char *src, size_t size)
123 size_t srclen = strlen(src);
124 size_t len = (srclen >= size) ? size - 1 : srclen;
126 memcpy(dest, src, len);
135 #ifndef __HAVE_ARCH_STRCAT
137 * strcat - Append one %NUL-terminated string to another
138 * @dest: The string to be appended to
139 * @src: The string to append to it
141 char * strcat(char * dest, const char * src)
147 while ((*dest++ = *src++) != '\0')
154 #ifndef __HAVE_ARCH_STRNCAT
156 * strncat - Append a length-limited, %NUL-terminated string to another
157 * @dest: The string to be appended to
158 * @src: The string to append to it
159 * @count: The maximum numbers of bytes to copy
161 * Note that in contrast to strncpy, strncat ensures the result is
164 char * strncat(char *dest, const char *src, size_t count)
171 while ((*dest++ = *src++)) {
183 #ifndef __HAVE_ARCH_STRLCAT
185 * strlcat - Append a length-limited, %NUL-terminated string to another
186 * @dest: The string to be appended to
187 * @src: The string to append to it
188 * @size: The size of @dest
190 * Compatible with *BSD: the result is always a valid NUL-terminated string that
191 * fits in the buffer (unless, of course, the buffer size is zero). It does not
192 * write past @size like strncat() does.
194 size_t strlcat(char *dest, const char *src, size_t size)
196 size_t len = strnlen(dest, size);
198 return len + strlcpy(dest + len, src, size - len);
202 #ifndef __HAVE_ARCH_STRCMP
204 * strcmp - Compare two strings
206 * @ct: Another string
208 int strcmp(const char * cs,const char * ct)
210 register signed char __res;
213 if ((__res = *cs - *ct++) != 0 || !*cs++)
221 #ifndef __HAVE_ARCH_STRNCMP
223 * strncmp - Compare two length-limited strings
225 * @ct: Another string
226 * @count: The maximum number of bytes to compare
228 int strncmp(const char * cs,const char * ct,size_t count)
230 register signed char __res = 0;
233 if ((__res = *cs - *ct++) != 0 || !*cs++)
242 #ifndef __HAVE_ARCH_STRCHR
244 * strchr - Find the first occurrence of a character in a string
245 * @s: The string to be searched
246 * @c: The character to search for
248 char * strchr(const char * s, int c)
250 for(; *s != (char) c; ++s)
257 const char *strchrnul(const char *s, int c)
259 for (; *s != (char)c; ++s)
265 #ifndef __HAVE_ARCH_STRRCHR
267 * strrchr - Find the last occurrence of a character in a string
268 * @s: The string to be searched
269 * @c: The character to search for
271 char * strrchr(const char * s, int c)
273 const char *p = s + strlen(s);
282 #ifndef __HAVE_ARCH_STRLEN
284 * strlen - Find the length of a string
285 * @s: The string to be sized
287 size_t strlen(const char * s)
291 for (sc = s; *sc != '\0'; ++sc)
297 #ifndef __HAVE_ARCH_STRNLEN
299 * strnlen - Find the length of a length-limited string
300 * @s: The string to be sized
301 * @count: The maximum number of bytes to search
303 size_t strnlen(const char * s, size_t count)
307 for (sc = s; count-- && *sc != '\0'; ++sc)
313 #ifndef __HAVE_ARCH_STRCSPN
315 * strcspn - Calculate the length of the initial substring of @s which does
316 * not contain letters in @reject
317 * @s: The string to be searched
318 * @reject: The string to avoid
320 size_t strcspn(const char *s, const char *reject)
326 for (p = s; *p != '\0'; ++p) {
327 for (r = reject; *r != '\0'; ++r) {
337 #ifndef __HAVE_ARCH_STRDUP
338 char * strdup(const char *s)
343 ((new = malloc (strlen(s) + 1)) == NULL) ) {
351 char * strndup(const char *s, size_t n)
364 new = malloc(len + 1);
368 strncpy(new, s, len);
375 #ifndef __HAVE_ARCH_STRSPN
377 * strspn - Calculate the length of the initial substring of @s which only
378 * contain letters in @accept
379 * @s: The string to be searched
380 * @accept: The string to search for
382 size_t strspn(const char *s, const char *accept)
388 for (p = s; *p != '\0'; ++p) {
389 for (a = accept; *a != '\0'; ++a) {
402 #ifndef __HAVE_ARCH_STRPBRK
404 * strpbrk - Find the first occurrence of a set of characters
405 * @cs: The string to be searched
406 * @ct: The characters to search for
408 char * strpbrk(const char * cs,const char * ct)
410 const char *sc1,*sc2;
412 for( sc1 = cs; *sc1 != '\0'; ++sc1) {
413 for( sc2 = ct; *sc2 != '\0'; ++sc2) {
422 #ifndef __HAVE_ARCH_STRTOK
424 * strtok - Split a string into tokens
425 * @s: The string to be searched
426 * @ct: The characters to search for
428 * WARNING: strtok is deprecated, use strsep instead.
430 char * strtok(char * s,const char * ct)
434 sbegin = s ? s : ___strtok;
438 sbegin += strspn(sbegin,ct);
439 if (*sbegin == '\0') {
443 send = strpbrk( sbegin, ct);
444 if (send && *send != '\0')
451 #ifndef __HAVE_ARCH_STRSEP
453 * strsep - Split a string into tokens
454 * @s: The string to be searched
455 * @ct: The characters to search for
457 * strsep() updates @s to point after the token, ready for the next call.
459 * It returns empty tokens, too, behaving exactly like the libc function
460 * of that name. In fact, it was stolen from glibc2 and de-fancy-fied.
461 * Same semantics, slimmer shape. ;)
463 char * strsep(char **s, const char *ct)
465 char *sbegin = *s, *end;
470 end = strpbrk(sbegin, ct);
479 #ifndef __HAVE_ARCH_STRSWAB
481 * strswab - swap adjacent even and odd bytes in %NUL-terminated string
482 * s: address of the string
484 * returns the address of the swapped string or NULL on error. If
485 * string length is odd, last byte is untouched.
487 char *strswab(const char *s)
491 if ((NULL == s) || ('\0' == *s)) {
495 for (p=(char *)s, q=p+1; (*p != '\0') && (*q != '\0'); p+=2, q+=2) {
507 #ifndef __HAVE_ARCH_MEMSET
509 * memset - Fill a region of memory with the given value
510 * @s: Pointer to the start of the area.
511 * @c: The byte to fill the area with
512 * @count: The size of the area.
514 * Do not use memset() to access IO space, use memset_io() instead.
516 void * memset(void * s,int c,size_t count)
518 unsigned long *sl = (unsigned long *) s;
521 #if !CONFIG_IS_ENABLED(TINY_MEMSET)
522 unsigned long cl = 0;
525 /* do it one word at a time (32 bits or 64 bits) while possible */
526 if ( ((ulong)s & (sizeof(*sl) - 1)) == 0) {
527 for (i = 0; i < sizeof(*sl); i++) {
531 while (count >= sizeof(*sl)) {
533 count -= sizeof(*sl);
536 #endif /* fill 8 bits at a time */
545 #ifndef __HAVE_ARCH_MEMCPY
547 * memcpy - Copy one area of memory to another
548 * @dest: Where to copy to
549 * @src: Where to copy from
550 * @count: The size of the area.
552 * You should not use this function to access IO space, use memcpy_toio()
553 * or memcpy_fromio() instead.
555 void * memcpy(void *dest, const void *src, size_t count)
557 unsigned long *dl = (unsigned long *)dest, *sl = (unsigned long *)src;
563 /* while all data is aligned (common case), copy a word at a time */
564 if ( (((ulong)dest | (ulong)src) & (sizeof(*dl) - 1)) == 0) {
565 while (count >= sizeof(*dl)) {
567 count -= sizeof(*dl);
570 /* copy the reset one byte at a time */
580 #ifndef __HAVE_ARCH_MEMMOVE
582 * memmove - Copy one area of memory to another
583 * @dest: Where to copy to
584 * @src: Where to copy from
585 * @count: The size of the area.
587 * Unlike memcpy(), memmove() copes with overlapping areas.
589 void * memmove(void * dest,const void *src,size_t count)
593 if (dest <= src || (src + count) <= dest) {
595 * Use the fast memcpy implementation (ARCH optimized or lib/string.c) when it is possible:
596 * - when dest is before src (assuming that memcpy is doing forward-copying)
597 * - when destination don't overlap the source buffer (src + count <= dest)
599 * WARNING: the first optimisation cause an issue, when __HAVE_ARCH_MEMCPY is defined,
600 * __HAVE_ARCH_MEMMOVE is not defined and if the memcpy ARCH-specific
601 * implementation is not doing a forward-copying.
603 * No issue today because memcpy is doing a forward-copying in lib/string.c and for ARM32
604 * architecture; no other arches use __HAVE_ARCH_MEMCPY without __HAVE_ARCH_MEMMOVE.
606 memcpy(dest, src, count);
608 tmp = (char *) dest + count;
609 s = (char *) src + count;
618 #ifndef __HAVE_ARCH_MEMCMP
620 * memcmp - Compare two areas of memory
621 * @cs: One area of memory
622 * @ct: Another area of memory
623 * @count: The size of the area.
625 int memcmp(const void * cs,const void * ct,size_t count)
627 const unsigned char *su1, *su2;
630 for( su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
631 if ((res = *su1 - *su2) != 0)
637 #ifndef __HAVE_ARCH_MEMSCAN
639 * memscan - Find a character in an area of memory.
640 * @addr: The memory area
641 * @c: The byte to search for
642 * @size: The size of the area.
644 * returns the address of the first occurrence of @c, or 1 byte past
645 * the area if @c is not found
647 void * memscan(void * addr, int c, size_t size)
649 unsigned char * p = (unsigned char *) addr;
661 #ifndef __HAVE_ARCH_STRSTR
663 * strstr - Find the first substring in a %NUL terminated string
664 * @s1: The string to be searched
665 * @s2: The string to search for
667 char * strstr(const char * s1,const char * s2)
677 if (!memcmp(s1,s2,l2))
685 #ifndef __HAVE_ARCH_MEMCHR
687 * memchr - Find a character in an area of memory.
688 * @s: The memory area
689 * @c: The byte to search for
690 * @n: The size of the area.
692 * returns the address of the first occurrence of @c, or %NULL
695 void *memchr(const void *s, int c, size_t n)
697 const unsigned char *p = s;
699 if ((unsigned char)c == *p++) {
700 return (void *)(p-1);
707 #ifndef __HAVE_ARCH_MEMCHR_INV
708 static void *check_bytes8(const u8 *start, u8 value, unsigned int bytes)
712 return (void *)start;
719 * memchr_inv - Find an unmatching character in an area of memory.
720 * @start: The memory area
721 * @c: Find a character other than c
722 * @bytes: The size of the area.
724 * returns the address of the first character other than @c, or %NULL
725 * if the whole buffer contains just @c.
727 void *memchr_inv(const void *start, int c, size_t bytes)
731 unsigned int words, prefix;
734 return check_bytes8(start, value, bytes);
737 value64 |= value64 << 8;
738 value64 |= value64 << 16;
739 value64 |= value64 << 32;
741 prefix = (unsigned long)start % 8;
746 r = check_bytes8(start, value, prefix);
756 if (*(u64 *)start != value64)
757 return check_bytes8(start, value, 8);
762 return check_bytes8(start, value, bytes % 8);