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