Changeset abf09311 in mainline
- Timestamp:
- 2010-04-17T01:12:35Z (14 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- 46416ab
- Parents:
- d7f8796c
- Files:
-
- 3 edited
Legend:
- Unmodified
- Added
- Removed
-
kernel/generic/include/str.h
rd7f8796c rabf09311 89 89 extern void wstr_to_str(char *dest, size_t size, const wchar_t *src); 90 90 91 extern char *str_dup(const char *src); 92 extern char *str_ndup(const char *src, size_t n); 93 91 94 extern char *str_chr(const char *str, wchar_t ch); 92 95 -
kernel/generic/src/lib/str.c
rd7f8796c rabf09311 537 537 * null-terminated and containing only complete characters. 538 538 * 539 * @param dest 539 * @param dest Destination buffer. 540 540 * @param count Size of the destination buffer (must be > 0). 541 541 * @param src Source string. 542 * 542 543 */ 543 544 void str_cpy(char *dest, size_t size, const char *src) 544 545 { 545 wchar_t ch;546 size_t src_off;547 size_t dest_off;548 549 546 /* There must be space for a null terminator in the buffer. */ 550 547 ASSERT(size > 0); 551 548 552 src_off = 0; 553 dest_off = 0; 554 549 size_t src_off = 0; 550 size_t dest_off = 0; 551 552 wchar_t ch; 555 553 while ((ch = str_decode(src, &src_off, STR_NO_LIMIT)) != 0) { 556 554 if (chr_encode(ch, dest, &dest_off, size - 1) != EOK) 557 555 break; 558 556 } 559 557 560 558 dest[dest_off] = '\0'; 561 559 } … … 571 569 * have to be null-terminated. 572 570 * 573 * @param dest 571 * @param dest Destination buffer. 574 572 * @param count Size of the destination buffer (must be > 0). 575 573 * @param src Source string. 576 * @param n Maximum number of bytes to read from @a src. 574 * @param n Maximum number of bytes to read from @a src. 575 * 577 576 */ 578 577 void str_ncpy(char *dest, size_t size, const char *src, size_t n) 579 578 { 580 wchar_t ch;581 size_t src_off;582 size_t dest_off;583 584 579 /* There must be space for a null terminator in the buffer. */ 585 580 ASSERT(size > 0); 586 581 587 src_off = 0; 588 dest_off = 0; 589 582 size_t src_off = 0; 583 size_t dest_off = 0; 584 585 wchar_t ch; 590 586 while ((ch = str_decode(src, &src_off, n)) != 0) { 591 587 if (chr_encode(ch, dest, &dest_off, size - 1) != EOK) 592 588 break; 593 589 } 594 590 595 591 dest[dest_off] = '\0'; 592 } 593 594 /** Duplicate string. 595 * 596 * Allocate a new string and copy characters from the source 597 * string into it. The duplicate string is allocated via sleeping 598 * malloc(), thus this function can sleep in no memory conditions. 599 * 600 * The allocation cannot fail and the return value is always 601 * a valid pointer. The duplicate string is always a well-formed 602 * null-terminated UTF-8 string, but it can differ from the source 603 * string on the byte level. 604 * 605 * @param src Source string. 606 * 607 * @return Duplicate string. 608 * 609 */ 610 char *str_dup(const char *src) 611 { 612 size_t size = str_size(src) + 1; 613 char *dest = malloc(size, 0); 614 ASSERT(dest); 615 616 str_cpy(dest, size, src); 617 return dest; 618 } 619 620 /** Duplicate string with size limit. 621 * 622 * Allocate a new string and copy up to @max_size bytes from the source 623 * string into it. The duplicate string is allocated via sleeping 624 * malloc(), thus this function can sleep in no memory conditions. 625 * No more than @max_size + 1 bytes is allocated, but if the size 626 * occupied by the source string is smaller than @max_size + 1, 627 * less is allocated. 628 * 629 * The allocation cannot fail and the return value is always 630 * a valid pointer. The duplicate string is always a well-formed 631 * null-terminated UTF-8 string, but it can differ from the source 632 * string on the byte level. 633 * 634 * @param src Source string. 635 * @param n Maximum number of bytes to duplicate. 636 * 637 * @return Duplicate string. 638 * 639 */ 640 char *str_ndup(const char *src, size_t n) 641 { 642 size_t size = str_size(src); 643 if (size > n) 644 size = n; 645 646 char *dest = malloc(size + 1, 0); 647 ASSERT(dest); 648 649 str_ncpy(dest, size + 1, src, size); 650 return dest; 596 651 } 597 652 -
uspace/lib/c/generic/str.c
rd7f8796c rabf09311 471 471 * null-terminated and containing only complete characters. 472 472 * 473 * @param dest 473 * @param dest Destination buffer. 474 474 * @param count Size of the destination buffer (must be > 0). 475 475 * @param src Source string. … … 477 477 void str_cpy(char *dest, size_t size, const char *src) 478 478 { 479 wchar_t ch;480 size_t src_off;481 size_t dest_off;482 483 479 /* There must be space for a null terminator in the buffer. */ 484 480 assert(size > 0); 485 481 486 src_off = 0; 487 dest_off = 0; 488 482 size_t src_off = 0; 483 size_t dest_off = 0; 484 485 wchar_t ch; 489 486 while ((ch = str_decode(src, &src_off, STR_NO_LIMIT)) != 0) { 490 487 if (chr_encode(ch, dest, &dest_off, size - 1) != EOK) 491 488 break; 492 489 } 493 490 494 491 dest[dest_off] = '\0'; 495 492 } … … 505 502 * have to be null-terminated. 506 503 * 507 * @param dest 504 * @param dest Destination buffer. 508 505 * @param count Size of the destination buffer (must be > 0). 509 506 * @param src Source string. 510 * @param n 507 * @param n Maximum number of bytes to read from @a src. 511 508 */ 512 509 void str_ncpy(char *dest, size_t size, const char *src, size_t n) 513 510 { 514 wchar_t ch;515 size_t src_off;516 size_t dest_off;517 518 511 /* There must be space for a null terminator in the buffer. */ 519 512 assert(size > 0); 520 513 521 src_off = 0; 522 dest_off = 0; 523 514 size_t src_off = 0; 515 size_t dest_off = 0; 516 517 wchar_t ch; 524 518 while ((ch = str_decode(src, &src_off, n)) != 0) { 525 519 if (chr_encode(ch, dest, &dest_off, size - 1) != EOK) 526 520 break; 527 521 } 528 522 529 523 dest[dest_off] = '\0'; 530 524 } … … 896 890 } 897 891 892 /** Duplicate string. 893 * 894 * Allocate a new string and copy characters from the source 895 * string into it. The duplicate string is allocated via sleeping 896 * malloc(), thus this function can sleep in no memory conditions. 897 * 898 * The allocation cannot fail and the return value is always 899 * a valid pointer. The duplicate string is always a well-formed 900 * null-terminated UTF-8 string, but it can differ from the source 901 * string on the byte level. 902 * 903 * @param src Source string. 904 * 905 * @return Duplicate string. 906 * 907 */ 898 908 char *str_dup(const char *src) 899 909 { 900 size_t size = str_size(src); 901 void *dest = malloc(size + 1); 902 910 size_t size = str_size(src) + 1; 911 char *dest = (char *) malloc(size); 903 912 if (dest == NULL) 904 913 return (char *) NULL; 905 914 906 return (char *) memcpy(dest, src, size + 1); 907 } 908 909 char *str_ndup(const char *src, size_t max_size) 915 str_cpy(dest, size, src); 916 return dest; 917 } 918 919 /** Duplicate string with size limit. 920 * 921 * Allocate a new string and copy up to @max_size bytes from the source 922 * string into it. The duplicate string is allocated via sleeping 923 * malloc(), thus this function can sleep in no memory conditions. 924 * No more than @max_size + 1 bytes is allocated, but if the size 925 * occupied by the source string is smaller than @max_size + 1, 926 * less is allocated. 927 * 928 * The allocation cannot fail and the return value is always 929 * a valid pointer. The duplicate string is always a well-formed 930 * null-terminated UTF-8 string, but it can differ from the source 931 * string on the byte level. 932 * 933 * @param src Source string. 934 * @param n Maximum number of bytes to duplicate. 935 * 936 * @return Duplicate string. 937 * 938 */ 939 char *str_ndup(const char *src, size_t n) 910 940 { 911 941 size_t size = str_size(src); 912 if (size > max_size)913 size = max_size;942 if (size > n) 943 size = n; 914 944 915 945 char *dest = (char *) malloc(size + 1); 916 917 946 if (dest == NULL) 918 947 return (char *) NULL; 919 948 920 memcpy(dest, src, size); 921 dest[size] = 0; 949 str_ncpy(dest, size + 1, src, size); 922 950 return dest; 923 951 }
Note:
See TracChangeset
for help on using the changeset viewer.