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