comparison: ucx/cx/string.h
ucx/cx/string.h
- changeset 854
- 1c8401ece69e
- parent 852
- 83fdf679df99
- child 855
- 6740836b7a1e
equal
deleted
inserted
replaced
| 853:2ad93ebdc8d9 | 854:1c8401ece69e |
|---|---|
| 40 #include "allocator.h" | 40 #include "allocator.h" |
| 41 | 41 |
| 42 /** | 42 /** |
| 43 * The maximum length of the "needle" in cx_strstr() that can use SBO. | 43 * The maximum length of the "needle" in cx_strstr() that can use SBO. |
| 44 */ | 44 */ |
| 45 cx_attr_export | |
| 45 extern const unsigned cx_strstr_sbo_size; | 46 extern const unsigned cx_strstr_sbo_size; |
| 46 | 47 |
| 47 /** | 48 /** |
| 48 * The UCX string structure. | 49 * The UCX string structure. |
| 49 */ | 50 */ |
| 50 struct cx_mutstr_s { | 51 struct cx_mutstr_s { |
| 51 /** | 52 /** |
| 52 * A pointer to the string. | 53 * A pointer to the string. |
| 53 * @note The string is not necessarily @c NULL terminated. | 54 * @note The string is not necessarily @c NULL terminated. |
| 54 * Always use the length. | |
| 55 */ | 55 */ |
| 56 char *ptr; | 56 char *ptr; |
| 57 /** The length of the string */ | 57 /** The length of the string */ |
| 58 size_t length; | 58 size_t length; |
| 59 }; | 59 }; |
| 68 */ | 68 */ |
| 69 struct cx_string_s { | 69 struct cx_string_s { |
| 70 /** | 70 /** |
| 71 * A pointer to the immutable string. | 71 * A pointer to the immutable string. |
| 72 * @note The string is not necessarily @c NULL terminated. | 72 * @note The string is not necessarily @c NULL terminated. |
| 73 * Always use the length. | |
| 74 */ | 73 */ |
| 75 const char *ptr; | 74 const char *ptr; |
| 76 /** The length of the string */ | 75 /** The length of the string */ |
| 77 size_t length; | 76 size_t length; |
| 78 }; | 77 }; |
| 173 * @see cx_mutstrn() | 172 * @see cx_mutstrn() |
| 174 */ | 173 */ |
| 175 cx_attr_nonnull | 174 cx_attr_nonnull |
| 176 cx_attr_nodiscard | 175 cx_attr_nodiscard |
| 177 cx_attr_cstr_arg(1) | 176 cx_attr_cstr_arg(1) |
| 177 cx_attr_export | |
| 178 cxmutstr cx_mutstr(char *cstring); | 178 cxmutstr cx_mutstr(char *cstring); |
| 179 | 179 |
| 180 /** | 180 /** |
| 181 * Wraps a string that does not need to be zero-terminated. | 181 * Wraps a string that does not need to be zero-terminated. |
| 182 * | 182 * |
| 193 * | 193 * |
| 194 * @see cx_mutstr() | 194 * @see cx_mutstr() |
| 195 */ | 195 */ |
| 196 cx_attr_nodiscard | 196 cx_attr_nodiscard |
| 197 cx_attr_access_rw(1, 2) | 197 cx_attr_access_rw(1, 2) |
| 198 cx_attr_export | |
| 198 cxmutstr cx_mutstrn( | 199 cxmutstr cx_mutstrn( |
| 199 char *cstring, | 200 char *cstring, |
| 200 size_t length | 201 size_t length |
| 201 ); | 202 ); |
| 202 | 203 |
| 216 * @see cx_strn() | 217 * @see cx_strn() |
| 217 */ | 218 */ |
| 218 cx_attr_nonnull | 219 cx_attr_nonnull |
| 219 cx_attr_nodiscard | 220 cx_attr_nodiscard |
| 220 cx_attr_cstr_arg(1) | 221 cx_attr_cstr_arg(1) |
| 222 cx_attr_export | |
| 221 cxstring cx_str(const char *cstring); | 223 cxstring cx_str(const char *cstring); |
| 222 | 224 |
| 223 | 225 |
| 224 /** | 226 /** |
| 225 * Wraps a string that does not need to be zero-terminated. | 227 * Wraps a string that does not need to be zero-terminated. |
| 237 * | 239 * |
| 238 * @see cx_str() | 240 * @see cx_str() |
| 239 */ | 241 */ |
| 240 cx_attr_nodiscard | 242 cx_attr_nodiscard |
| 241 cx_attr_access_r(1, 2) | 243 cx_attr_access_r(1, 2) |
| 244 cx_attr_export | |
| 242 cxstring cx_strn( | 245 cxstring cx_strn( |
| 243 const char *cstring, | 246 const char *cstring, |
| 244 size_t length | 247 size_t length |
| 245 ); | 248 ); |
| 246 | 249 |
| 296 #endif | 299 #endif |
| 297 | 300 |
| 298 /** | 301 /** |
| 299 * Passes the pointer in this string to @c free(). | 302 * Passes the pointer in this string to @c free(). |
| 300 * | 303 * |
| 301 * The pointer in the struct is set to @c NULL and the length is set to zero. | 304 * The pointer in the struct is set to @c NULL and the length is set to zero |
| 305 * which means that this function protects you against double-free. | |
| 302 * | 306 * |
| 303 * @note There is no implementation for cxstring, because it is unlikely that | 307 * @note There is no implementation for cxstring, because it is unlikely that |
| 304 * you ever have a <code>const char*</code> you are really supposed to free. | 308 * you ever have a <code>const char*</code> you are really supposed to free. |
| 305 * If you encounter such situation, you should double-check your code. | 309 * If you encounter such situation, you should double-check your code. |
| 306 * | 310 * |
| 307 * @param str the string to free | 311 * @param str the string to free |
| 308 */ | 312 */ |
| 313 cx_attr_export | |
| 309 void cx_strfree(cxmutstr *str); | 314 void cx_strfree(cxmutstr *str); |
| 310 | 315 |
| 311 /** | 316 /** |
| 312 * Passes the pointer in this string to the allocators free function. | 317 * Passes the pointer in this string to the allocators free function. |
| 313 * | 318 * |
| 314 * The pointer in the struct is set to @c NULL and the length is set to zero. | 319 * The pointer in the struct is set to @c NULL and the length is set to zero |
| 320 * which means that this function protects you against double-free. | |
| 315 * | 321 * |
| 316 * @note There is no implementation for cxstring, because it is unlikely that | 322 * @note There is no implementation for cxstring, because it is unlikely that |
| 317 * you ever have a <code>const char*</code> you are really supposed to free. | 323 * you ever have a <code>const char*</code> you are really supposed to free. |
| 318 * If you encounter such situation, you should double-check your code. | 324 * If you encounter such situation, you should double-check your code. |
| 319 * | 325 * |
| 320 * @param alloc the allocator | 326 * @param alloc the allocator |
| 321 * @param str the string to free | 327 * @param str the string to free |
| 322 */ | 328 */ |
| 323 cx_attr_nonnull_arg(1) | 329 cx_attr_nonnull_arg(1) |
| 330 cx_attr_export | |
| 324 void cx_strfree_a( | 331 void cx_strfree_a( |
| 325 const CxAllocator *alloc, | 332 const CxAllocator *alloc, |
| 326 cxmutstr *str | 333 cxmutstr *str |
| 327 ); | 334 ); |
| 328 | 335 |
| 337 * @param count the total number of specified strings | 344 * @param count the total number of specified strings |
| 338 * @param ... all strings | 345 * @param ... all strings |
| 339 * @return the accumulated length of all strings | 346 * @return the accumulated length of all strings |
| 340 */ | 347 */ |
| 341 cx_attr_nodiscard | 348 cx_attr_nodiscard |
| 349 cx_attr_export | |
| 342 size_t cx_strlen( | 350 size_t cx_strlen( |
| 343 size_t count, | 351 size_t count, |
| 344 ... | 352 ... |
| 345 ); | 353 ); |
| 346 | 354 |
| 366 * @param ... all other UCX strings | 374 * @param ... all other UCX strings |
| 367 * @return the concatenated string | 375 * @return the concatenated string |
| 368 */ | 376 */ |
| 369 cx_attr_nodiscard | 377 cx_attr_nodiscard |
| 370 cx_attr_nonnull | 378 cx_attr_nonnull |
| 379 cx_attr_export | |
| 371 cxmutstr cx_strcat_ma( | 380 cxmutstr cx_strcat_ma( |
| 372 const CxAllocator *alloc, | 381 const CxAllocator *alloc, |
| 373 cxmutstr str, | 382 cxmutstr str, |
| 374 size_t count, | 383 size_t count, |
| 375 ... | 384 ... |
| 454 * @see cx_strsubsl() | 463 * @see cx_strsubsl() |
| 455 * @see cx_strsubs_m() | 464 * @see cx_strsubs_m() |
| 456 * @see cx_strsubsl_m() | 465 * @see cx_strsubsl_m() |
| 457 */ | 466 */ |
| 458 cx_attr_nodiscard | 467 cx_attr_nodiscard |
| 468 cx_attr_export | |
| 459 cxstring cx_strsubs( | 469 cxstring cx_strsubs( |
| 460 cxstring string, | 470 cxstring string, |
| 461 size_t start | 471 size_t start |
| 462 ); | 472 ); |
| 463 | 473 |
| 479 * @see cx_strsubs() | 489 * @see cx_strsubs() |
| 480 * @see cx_strsubs_m() | 490 * @see cx_strsubs_m() |
| 481 * @see cx_strsubsl_m() | 491 * @see cx_strsubsl_m() |
| 482 */ | 492 */ |
| 483 cx_attr_nodiscard | 493 cx_attr_nodiscard |
| 494 cx_attr_export | |
| 484 cxstring cx_strsubsl( | 495 cxstring cx_strsubsl( |
| 485 cxstring string, | 496 cxstring string, |
| 486 size_t start, | 497 size_t start, |
| 487 size_t length | 498 size_t length |
| 488 ); | 499 ); |
| 501 * @see cx_strsubsl_m() | 512 * @see cx_strsubsl_m() |
| 502 * @see cx_strsubs() | 513 * @see cx_strsubs() |
| 503 * @see cx_strsubsl() | 514 * @see cx_strsubsl() |
| 504 */ | 515 */ |
| 505 cx_attr_nodiscard | 516 cx_attr_nodiscard |
| 517 cx_attr_export | |
| 506 cxmutstr cx_strsubs_m( | 518 cxmutstr cx_strsubs_m( |
| 507 cxmutstr string, | 519 cxmutstr string, |
| 508 size_t start | 520 size_t start |
| 509 ); | 521 ); |
| 510 | 522 |
| 526 * @see cx_strsubs_m() | 538 * @see cx_strsubs_m() |
| 527 * @see cx_strsubs() | 539 * @see cx_strsubs() |
| 528 * @see cx_strsubsl() | 540 * @see cx_strsubsl() |
| 529 */ | 541 */ |
| 530 cx_attr_nodiscard | 542 cx_attr_nodiscard |
| 543 cx_attr_export | |
| 531 cxmutstr cx_strsubsl_m( | 544 cxmutstr cx_strsubsl_m( |
| 532 cxmutstr string, | 545 cxmutstr string, |
| 533 size_t start, | 546 size_t start, |
| 534 size_t length | 547 size_t length |
| 535 ); | 548 ); |
| 545 * @return a substring starting at the first location of @p chr | 558 * @return a substring starting at the first location of @p chr |
| 546 * | 559 * |
| 547 * @see cx_strchr_m() | 560 * @see cx_strchr_m() |
| 548 */ | 561 */ |
| 549 cx_attr_nodiscard | 562 cx_attr_nodiscard |
| 563 cx_attr_export | |
| 550 cxstring cx_strchr( | 564 cxstring cx_strchr( |
| 551 cxstring string, | 565 cxstring string, |
| 552 int chr | 566 int chr |
| 553 ); | 567 ); |
| 554 | 568 |
| 563 * @return a substring starting at the first location of @p chr | 577 * @return a substring starting at the first location of @p chr |
| 564 * | 578 * |
| 565 * @see cx_strchr() | 579 * @see cx_strchr() |
| 566 */ | 580 */ |
| 567 cx_attr_nodiscard | 581 cx_attr_nodiscard |
| 582 cx_attr_export | |
| 568 cxmutstr cx_strchr_m( | 583 cxmutstr cx_strchr_m( |
| 569 cxmutstr string, | 584 cxmutstr string, |
| 570 int chr | 585 int chr |
| 571 ); | 586 ); |
| 572 | 587 |
| 581 * @return a substring starting at the last location of @p chr | 596 * @return a substring starting at the last location of @p chr |
| 582 * | 597 * |
| 583 * @see cx_strrchr_m() | 598 * @see cx_strrchr_m() |
| 584 */ | 599 */ |
| 585 cx_attr_nodiscard | 600 cx_attr_nodiscard |
| 601 cx_attr_export | |
| 586 cxstring cx_strrchr( | 602 cxstring cx_strrchr( |
| 587 cxstring string, | 603 cxstring string, |
| 588 int chr | 604 int chr |
| 589 ); | 605 ); |
| 590 | 606 |
| 599 * @return a substring starting at the last location of @p chr | 615 * @return a substring starting at the last location of @p chr |
| 600 * | 616 * |
| 601 * @see cx_strrchr() | 617 * @see cx_strrchr() |
| 602 */ | 618 */ |
| 603 cx_attr_nodiscard | 619 cx_attr_nodiscard |
| 620 cx_attr_export | |
| 604 cxmutstr cx_strrchr_m( | 621 cxmutstr cx_strrchr_m( |
| 605 cxmutstr string, | 622 cxmutstr string, |
| 606 int chr | 623 int chr |
| 607 ); | 624 ); |
| 608 | 625 |
| 621 * @p needle, or an empty string, if the sequence is not | 638 * @p needle, or an empty string, if the sequence is not |
| 622 * contained | 639 * contained |
| 623 * @see cx_strstr_m() | 640 * @see cx_strstr_m() |
| 624 */ | 641 */ |
| 625 cx_attr_nodiscard | 642 cx_attr_nodiscard |
| 643 cx_attr_export | |
| 626 cxstring cx_strstr( | 644 cxstring cx_strstr( |
| 627 cxstring haystack, | 645 cxstring haystack, |
| 628 cxstring needle | 646 cxstring needle |
| 629 ); | 647 ); |
| 630 | 648 |
| 643 * @p needle, or an empty string, if the sequence is not | 661 * @p needle, or an empty string, if the sequence is not |
| 644 * contained | 662 * contained |
| 645 * @see cx_strstr() | 663 * @see cx_strstr() |
| 646 */ | 664 */ |
| 647 cx_attr_nodiscard | 665 cx_attr_nodiscard |
| 666 cx_attr_export | |
| 648 cxmutstr cx_strstr_m( | 667 cxmutstr cx_strstr_m( |
| 649 cxmutstr haystack, | 668 cxmutstr haystack, |
| 650 cxstring needle | 669 cxstring needle |
| 651 ); | 670 ); |
| 652 | 671 |
| 657 * @p string. Use cx_strdup() to get copies. | 676 * @p string. Use cx_strdup() to get copies. |
| 658 * | 677 * |
| 659 * @param string the string to split | 678 * @param string the string to split |
| 660 * @param delim the delimiter | 679 * @param delim the delimiter |
| 661 * @param limit the maximum number of split items | 680 * @param limit the maximum number of split items |
| 662 * @param output a pre-allocated array of at least @p limit length | 681 * @param output a preallocated array of at least @p limit length |
| 663 * @return the actual number of split items | 682 * @return the actual number of split items |
| 664 */ | 683 */ |
| 665 cx_attr_nodiscard | 684 cx_attr_nodiscard |
| 666 cx_attr_nonnull | 685 cx_attr_nonnull |
| 667 cx_attr_access_w(4, 3) | 686 cx_attr_access_w(4, 3) |
| 687 cx_attr_export | |
| 668 size_t cx_strsplit( | 688 size_t cx_strsplit( |
| 669 cxstring string, | 689 cxstring string, |
| 670 cxstring delim, | 690 cxstring delim, |
| 671 size_t limit, | 691 size_t limit, |
| 672 cxstring *output | 692 cxstring *output |
| 692 * @return the actual number of split items | 712 * @return the actual number of split items |
| 693 */ | 713 */ |
| 694 cx_attr_nodiscard | 714 cx_attr_nodiscard |
| 695 cx_attr_nonnull | 715 cx_attr_nonnull |
| 696 cx_attr_access_w(5) | 716 cx_attr_access_w(5) |
| 717 cx_attr_export | |
| 697 size_t cx_strsplit_a( | 718 size_t cx_strsplit_a( |
| 698 const CxAllocator *allocator, | 719 const CxAllocator *allocator, |
| 699 cxstring string, | 720 cxstring string, |
| 700 cxstring delim, | 721 cxstring delim, |
| 701 size_t limit, | 722 size_t limit, |
| 710 * @p string. Use cx_strdup() to get copies. | 731 * @p string. Use cx_strdup() to get copies. |
| 711 * | 732 * |
| 712 * @param string the string to split | 733 * @param string the string to split |
| 713 * @param delim the delimiter | 734 * @param delim the delimiter |
| 714 * @param limit the maximum number of split items | 735 * @param limit the maximum number of split items |
| 715 * @param output a pre-allocated array of at least @p limit length | 736 * @param output a preallocated array of at least @p limit length |
| 716 * @return the actual number of split items | 737 * @return the actual number of split items |
| 717 */ | 738 */ |
| 718 cx_attr_nodiscard | 739 cx_attr_nodiscard |
| 719 cx_attr_nonnull | 740 cx_attr_nonnull |
| 720 cx_attr_access_w(4, 3) | 741 cx_attr_access_w(4, 3) |
| 742 cx_attr_export | |
| 721 size_t cx_strsplit_m( | 743 size_t cx_strsplit_m( |
| 722 cxmutstr string, | 744 cxmutstr string, |
| 723 cxstring delim, | 745 cxstring delim, |
| 724 size_t limit, | 746 size_t limit, |
| 725 cxmutstr *output | 747 cxmutstr *output |
| 745 * @return the actual number of split items | 767 * @return the actual number of split items |
| 746 */ | 768 */ |
| 747 cx_attr_nodiscard | 769 cx_attr_nodiscard |
| 748 cx_attr_nonnull | 770 cx_attr_nonnull |
| 749 cx_attr_access_w(5) | 771 cx_attr_access_w(5) |
| 772 cx_attr_export | |
| 750 size_t cx_strsplit_ma( | 773 size_t cx_strsplit_ma( |
| 751 const CxAllocator *allocator, | 774 const CxAllocator *allocator, |
| 752 cxmutstr string, | 775 cxmutstr string, |
| 753 cxstring delim, | 776 cxstring delim, |
| 754 size_t limit, | 777 size_t limit, |
| 762 * @param s2 the second string | 785 * @param s2 the second string |
| 763 * @return negative if @p s1 is smaller than @p s2, positive if @p s1 is larger | 786 * @return negative if @p s1 is smaller than @p s2, positive if @p s1 is larger |
| 764 * than @p s2, zero if both strings equal | 787 * than @p s2, zero if both strings equal |
| 765 */ | 788 */ |
| 766 cx_attr_nodiscard | 789 cx_attr_nodiscard |
| 790 cx_attr_export | |
| 767 int cx_strcmp( | 791 int cx_strcmp( |
| 768 cxstring s1, | 792 cxstring s1, |
| 769 cxstring s2 | 793 cxstring s2 |
| 770 ); | 794 ); |
| 771 | 795 |
| 776 * @param s2 the second string | 800 * @param s2 the second string |
| 777 * @return negative if @p s1 is smaller than @p s2, positive if @p s1 is larger | 801 * @return negative if @p s1 is smaller than @p s2, positive if @p s1 is larger |
| 778 * than @p s2, zero if both strings equal ignoring case | 802 * than @p s2, zero if both strings equal ignoring case |
| 779 */ | 803 */ |
| 780 cx_attr_nodiscard | 804 cx_attr_nodiscard |
| 805 cx_attr_export | |
| 781 int cx_strcasecmp( | 806 int cx_strcasecmp( |
| 782 cxstring s1, | 807 cxstring s1, |
| 783 cxstring s2 | 808 cxstring s2 |
| 784 ); | 809 ); |
| 785 | 810 |
| 793 * @return negative if @p s1 is smaller than @p s2, positive if @p s1 is larger | 818 * @return negative if @p s1 is smaller than @p s2, positive if @p s1 is larger |
| 794 * than @p s2, zero if both strings equal | 819 * than @p s2, zero if both strings equal |
| 795 */ | 820 */ |
| 796 cx_attr_nodiscard | 821 cx_attr_nodiscard |
| 797 cx_attr_nonnull | 822 cx_attr_nonnull |
| 823 cx_attr_export | |
| 798 int cx_strcmp_p( | 824 int cx_strcmp_p( |
| 799 const void *s1, | 825 const void *s1, |
| 800 const void *s2 | 826 const void *s2 |
| 801 ); | 827 ); |
| 802 | 828 |
| 810 * @return negative if @p s1 is smaller than @p s2, positive if @p s1 is larger | 836 * @return negative if @p s1 is smaller than @p s2, positive if @p s1 is larger |
| 811 * than @p s2, zero if both strings equal ignoring case | 837 * than @p s2, zero if both strings equal ignoring case |
| 812 */ | 838 */ |
| 813 cx_attr_nodiscard | 839 cx_attr_nodiscard |
| 814 cx_attr_nonnull | 840 cx_attr_nonnull |
| 841 cx_attr_export | |
| 815 int cx_strcasecmp_p( | 842 int cx_strcasecmp_p( |
| 816 const void *s1, | 843 const void *s1, |
| 817 const void *s2 | 844 const void *s2 |
| 818 ); | 845 ); |
| 819 | 846 |
| 830 * @return a duplicate of the string | 857 * @return a duplicate of the string |
| 831 * @see cx_strdup() | 858 * @see cx_strdup() |
| 832 */ | 859 */ |
| 833 cx_attr_nodiscard | 860 cx_attr_nodiscard |
| 834 cx_attr_nonnull | 861 cx_attr_nonnull |
| 835 cxmutstr cx_strdup_a( | 862 cx_attr_export |
| 863 cxmutstr cx_strdup_a_( | |
| 836 const CxAllocator *allocator, | 864 const CxAllocator *allocator, |
| 837 cxstring string | 865 cxstring string |
| 838 ); | 866 ); |
| 839 | 867 |
| 840 /** | 868 /** |
| 841 * Creates a duplicate of the specified string. | 869 * Creates a duplicate of the specified string. |
| 842 * | 870 * |
| 871 * The new string will contain a copy allocated by @p allocator. | |
| 872 * | |
| 873 * @note The returned string is guaranteed to be zero-terminated. | |
| 874 * | |
| 875 * @param allocator (@c CxAllocator*) the allocator to use | |
| 876 * @param string the string to duplicate | |
| 877 * @return (@c cxmutstr) a duplicate of the string | |
| 878 * @see cx_strdup() | |
| 879 * @see cx_strfree_a() | |
| 880 */ | |
| 881 #define cx_strdup_a(allocator, string) \ | |
| 882 cx_strdup_a_((allocator), cx_strcast((string))) | |
| 883 | |
| 884 /** | |
| 885 * Creates a duplicate of the specified string. | |
| 886 * | |
| 843 * The new string will contain a copy allocated by standard | 887 * The new string will contain a copy allocated by standard |
| 844 * @c malloc(). So developers @em must pass the return value to cx_strfree(). | 888 * @c malloc(). So developers @em must pass the return value to cx_strfree(). |
| 845 * | 889 * |
| 846 * @note The returned string is guaranteed to be zero-terminated. | 890 * @note The returned string is guaranteed to be zero-terminated. |
| 847 * | 891 * |
| 848 * @param string (@c cxstring) the string to duplicate | 892 * @param string the string to duplicate |
| 849 * @return (@c cxmutstr) a duplicate of the string | 893 * @return (@c cxmutstr) a duplicate of the string |
| 850 * @see cx_strdup_a() | 894 * @see cx_strdup_a() |
| 851 */ | 895 * @see cx_strfree() |
| 852 #define cx_strdup(string) cx_strdup_a(cxDefaultAllocator, string) | 896 */ |
| 853 | 897 #define cx_strdup(string) cx_strdup_a_(cxDefaultAllocator, string) |
| 854 | |
| 855 /** | |
| 856 * Creates a duplicate of the specified string. | |
| 857 * | |
| 858 * The new string will contain a copy allocated by @p allocator. | |
| 859 * | |
| 860 * @note The returned string is guaranteed to be zero-terminated. | |
| 861 * | |
| 862 * @param allocator (@c CxAllocator*) the allocator to use | |
| 863 * @param string (@c cxmutstr) the string to duplicate | |
| 864 * @return (@c cxmutstr) a duplicate of the string | |
| 865 * @see cx_strdup_m() | |
| 866 */ | |
| 867 #define cx_strdup_ma(allocator, string) cx_strdup_a(allocator, cx_strcast(string)) | |
| 868 | |
| 869 /** | |
| 870 * Creates a duplicate of the specified string. | |
| 871 * | |
| 872 * The new string will contain a copy allocated by standard | |
| 873 * @c malloc(). So developers @em must pass the return value to cx_strfree(). | |
| 874 * | |
| 875 * @note The returned string is guaranteed to be zero-terminated. | |
| 876 * | |
| 877 * @param string (@c cxmutstr) the string to duplicate | |
| 878 * @return (@c cxmutstr) a duplicate of the string | |
| 879 * @see cx_strdup_ma() | |
| 880 */ | |
| 881 #define cx_strdup_m(string) cx_strdup_a(cxDefaultAllocator, cx_strcast(string)) | |
| 882 | 898 |
| 883 /** | 899 /** |
| 884 * Omits leading and trailing spaces. | 900 * Omits leading and trailing spaces. |
| 885 * | 901 * |
| 886 * @note the returned string references the same memory, thus you | 902 * @note the returned string references the same memory, thus you |
| 888 * | 904 * |
| 889 * @param string the string that shall be trimmed | 905 * @param string the string that shall be trimmed |
| 890 * @return the trimmed string | 906 * @return the trimmed string |
| 891 */ | 907 */ |
| 892 cx_attr_nodiscard | 908 cx_attr_nodiscard |
| 909 cx_attr_export | |
| 893 cxstring cx_strtrim(cxstring string); | 910 cxstring cx_strtrim(cxstring string); |
| 894 | 911 |
| 895 /** | 912 /** |
| 896 * Omits leading and trailing spaces. | 913 * Omits leading and trailing spaces. |
| 897 * | 914 * |
| 900 * | 917 * |
| 901 * @param string the string that shall be trimmed | 918 * @param string the string that shall be trimmed |
| 902 * @return the trimmed string | 919 * @return the trimmed string |
| 903 */ | 920 */ |
| 904 cx_attr_nodiscard | 921 cx_attr_nodiscard |
| 922 cx_attr_export | |
| 905 cxmutstr cx_strtrim_m(cxmutstr string); | 923 cxmutstr cx_strtrim_m(cxmutstr string); |
| 906 | 924 |
| 907 /** | 925 /** |
| 908 * Checks, if a string has a specific prefix. | 926 * Checks, if a string has a specific prefix. |
| 909 * | 927 * |
| 911 * @param prefix the prefix the string should have | 929 * @param prefix the prefix the string should have |
| 912 * @return @c true, if and only if the string has the specified prefix, | 930 * @return @c true, if and only if the string has the specified prefix, |
| 913 * @c false otherwise | 931 * @c false otherwise |
| 914 */ | 932 */ |
| 915 cx_attr_nodiscard | 933 cx_attr_nodiscard |
| 934 cx_attr_export | |
| 916 bool cx_strprefix( | 935 bool cx_strprefix( |
| 917 cxstring string, | 936 cxstring string, |
| 918 cxstring prefix | 937 cxstring prefix |
| 919 ); | 938 ); |
| 920 | 939 |
| 925 * @param suffix the suffix the string should have | 944 * @param suffix the suffix the string should have |
| 926 * @return @c true, if and only if the string has the specified suffix, | 945 * @return @c true, if and only if the string has the specified suffix, |
| 927 * @c false otherwise | 946 * @c false otherwise |
| 928 */ | 947 */ |
| 929 cx_attr_nodiscard | 948 cx_attr_nodiscard |
| 949 cx_attr_export | |
| 930 bool cx_strsuffix( | 950 bool cx_strsuffix( |
| 931 cxstring string, | 951 cxstring string, |
| 932 cxstring suffix | 952 cxstring suffix |
| 933 ); | 953 ); |
| 934 | 954 |
| 939 * @param prefix the prefix the string should have | 959 * @param prefix the prefix the string should have |
| 940 * @return @c true, if and only if the string has the specified prefix, | 960 * @return @c true, if and only if the string has the specified prefix, |
| 941 * @c false otherwise | 961 * @c false otherwise |
| 942 */ | 962 */ |
| 943 cx_attr_nodiscard | 963 cx_attr_nodiscard |
| 964 cx_attr_export | |
| 944 bool cx_strcaseprefix( | 965 bool cx_strcaseprefix( |
| 945 cxstring string, | 966 cxstring string, |
| 946 cxstring prefix | 967 cxstring prefix |
| 947 ); | 968 ); |
| 948 | 969 |
| 953 * @param suffix the suffix the string should have | 974 * @param suffix the suffix the string should have |
| 954 * @return @c true, if and only if the string has the specified suffix, | 975 * @return @c true, if and only if the string has the specified suffix, |
| 955 * @c false otherwise | 976 * @c false otherwise |
| 956 */ | 977 */ |
| 957 cx_attr_nodiscard | 978 cx_attr_nodiscard |
| 979 cx_attr_export | |
| 958 bool cx_strcasesuffix( | 980 bool cx_strcasesuffix( |
| 959 cxstring string, | 981 cxstring string, |
| 960 cxstring suffix | 982 cxstring suffix |
| 961 ); | 983 ); |
| 962 | 984 |
| 963 /** | 985 /** |
| 964 * Converts the string to lower case. | 986 * Replaces a string with another string. |
| 965 * | 987 * |
| 966 * The change is made in-place. If you want a copy, use cx_strdup(), first. | |
| 967 * | |
| 968 * @param string the string to modify | |
| 969 * @see cx_strdup() | |
| 970 */ | |
| 971 void cx_strlower(cxmutstr string); | |
| 972 | |
| 973 /** | |
| 974 * Converts the string to upper case. | |
| 975 * | |
| 976 * The change is made in-place. If you want a copy, use cx_strdup(), first. | |
| 977 * | |
| 978 * @param string the string to modify | |
| 979 * @see cx_strdup() | |
| 980 */ | |
| 981 void cx_strupper(cxmutstr string); | |
| 982 | |
| 983 /** | |
| 984 * Replaces a pattern in a string with another string. | |
| 985 * | |
| 986 * The pattern is taken literally and is no regular expression. | |
| 987 * Replaces at most @p replmax occurrences. | 988 * Replaces at most @p replmax occurrences. |
| 988 * | 989 * |
| 989 * The returned string will be allocated by @p allocator and is guaranteed | 990 * The returned string will be allocated by @p allocator and is guaranteed |
| 990 * to be zero-terminated. | 991 * to be zero-terminated. |
| 991 * | 992 * |
| 992 * If allocation fails, or the input string is empty, | 993 * If allocation fails, or the input string is empty, |
| 993 * the returned string will be empty. | 994 * the returned string will be empty. |
| 994 * | 995 * |
| 995 * @param allocator the allocator to use | 996 * @param allocator the allocator to use |
| 996 * @param str the string where replacements should be applied | 997 * @param str the string where replacements should be applied |
| 997 * @param pattern the pattern to search for | 998 * @param search the string to search for |
| 998 * @param replacement the replacement string | 999 * @param replacement the replacement string |
| 999 * @param replmax maximum number of replacements | 1000 * @param replmax maximum number of replacements |
| 1000 * @return the resulting string after applying the replacements | 1001 * @return the resulting string after applying the replacements |
| 1001 */ | 1002 */ |
| 1002 cx_attr_nodiscard | 1003 cx_attr_nodiscard |
| 1003 cx_attr_nonnull | 1004 cx_attr_nonnull |
| 1005 cx_attr_export | |
| 1004 cxmutstr cx_strreplacen_a( | 1006 cxmutstr cx_strreplacen_a( |
| 1005 const CxAllocator *allocator, | 1007 const CxAllocator *allocator, |
| 1006 cxstring str, | 1008 cxstring str, |
| 1007 cxstring pattern, | 1009 cxstring search, |
| 1008 cxstring replacement, | 1010 cxstring replacement, |
| 1009 size_t replmax | 1011 size_t replmax |
| 1010 ); | 1012 ); |
| 1011 | 1013 |
| 1012 /** | 1014 /** |
| 1013 * Replaces a pattern in a string with another string. | 1015 * Replaces a string with another string. |
| 1014 * | 1016 * |
| 1015 * The pattern is taken literally and is no regular expression. | |
| 1016 * Replaces at most @p replmax occurrences. | 1017 * Replaces at most @p replmax occurrences. |
| 1017 * | 1018 * |
| 1018 * The returned string will be allocated by @c malloc() and is guaranteed | 1019 * The returned string will be allocated by @c malloc() and is guaranteed |
| 1019 * to be zero-terminated. | 1020 * to be zero-terminated. |
| 1020 * | 1021 * |
| 1021 * If allocation fails, or the input string is empty, | 1022 * If allocation fails, or the input string is empty, |
| 1022 * the returned string will be empty. | 1023 * the returned string will be empty. |
| 1023 * | 1024 * |
| 1024 * @param str (@c cxstring) the string where replacements should be applied | 1025 * @param str (@c cxstring) the string where replacements should be applied |
| 1025 * @param pattern (@c cxstring) the pattern to search for | 1026 * @param search (@c cxstring) the string to search for |
| 1026 * @param replacement (@c cxstring) the replacement string | 1027 * @param replacement (@c cxstring) the replacement string |
| 1027 * @param replmax (@c size_t) maximum number of replacements | 1028 * @param replmax (@c size_t) maximum number of replacements |
| 1028 * @return (@c cxmutstr) the resulting string after applying the replacements | 1029 * @return (@c cxmutstr) the resulting string after applying the replacements |
| 1029 */ | 1030 */ |
| 1030 #define cx_strreplacen(str, pattern, replacement, replmax) \ | 1031 #define cx_strreplacen(str, search, replacement, replmax) \ |
| 1031 cx_strreplacen_a(cxDefaultAllocator, str, pattern, replacement, replmax) | 1032 cx_strreplacen_a(cxDefaultAllocator, str, search, replacement, replmax) |
| 1032 | 1033 |
| 1033 /** | 1034 /** |
| 1034 * Replaces a pattern in a string with another string. | 1035 * Replaces a string with another string. |
| 1035 * | |
| 1036 * The pattern is taken literally and is no regular expression. | |
| 1037 * | 1036 * |
| 1038 * The returned string will be allocated by @p allocator and is guaranteed | 1037 * The returned string will be allocated by @p allocator and is guaranteed |
| 1039 * to be zero-terminated. | 1038 * to be zero-terminated. |
| 1040 * | 1039 * |
| 1041 * If allocation fails, or the input string is empty, | 1040 * If allocation fails, or the input string is empty, |
| 1042 * the returned string will be empty. | 1041 * the returned string will be empty. |
| 1043 * | 1042 * |
| 1044 * @param allocator (@c CxAllocator*) the allocator to use | 1043 * @param allocator (@c CxAllocator*) the allocator to use |
| 1045 * @param str (@c cxstring) the string where replacements should be applied | 1044 * @param str (@c cxstring) the string where replacements should be applied |
| 1046 * @param pattern (@c cxstring) the pattern to search for | 1045 * @param search (@c cxstring) the string to search for |
| 1047 * @param replacement (@c cxstring) the replacement string | 1046 * @param replacement (@c cxstring) the replacement string |
| 1048 * @return (@c cxmutstr) the resulting string after applying the replacements | 1047 * @return (@c cxmutstr) the resulting string after applying the replacements |
| 1049 */ | 1048 */ |
| 1050 #define cx_strreplace_a(allocator, str, pattern, replacement) \ | 1049 #define cx_strreplace_a(allocator, str, search, replacement) \ |
| 1051 cx_strreplacen_a(allocator, str, pattern, replacement, SIZE_MAX) | 1050 cx_strreplacen_a(allocator, str, search, replacement, SIZE_MAX) |
| 1052 | 1051 |
| 1053 /** | 1052 /** |
| 1054 * Replaces a pattern in a string with another string. | 1053 * Replaces a string with another string. |
| 1055 * | |
| 1056 * The pattern is taken literally and is no regular expression. | |
| 1057 * Replaces at most @p replmax occurrences. | |
| 1058 * | 1054 * |
| 1059 * The returned string will be allocated by @c malloc() and is guaranteed | 1055 * The returned string will be allocated by @c malloc() and is guaranteed |
| 1060 * to be zero-terminated. | 1056 * to be zero-terminated. |
| 1061 * | 1057 * |
| 1062 * If allocation fails, or the input string is empty, | 1058 * If allocation fails, or the input string is empty, |
| 1063 * the returned string will be empty. | 1059 * the returned string will be empty. |
| 1064 * | 1060 * |
| 1065 * @param str (@c cxstring) the string where replacements should be applied | 1061 * @param str (@c cxstring) the string where replacements should be applied |
| 1066 * @param pattern (@c cxstring) the pattern to search for | 1062 * @param search (@c cxstring) the string to search for |
| 1067 * @param replacement (@c cxstring) the replacement string | 1063 * @param replacement (@c cxstring) the replacement string |
| 1068 * @return (@c cxmutstr) the resulting string after applying the replacements | 1064 * @return (@c cxmutstr) the resulting string after applying the replacements |
| 1069 */ | 1065 */ |
| 1070 #define cx_strreplace(str, pattern, replacement) \ | 1066 #define cx_strreplace(str, search, replacement) \ |
| 1071 cx_strreplacen_a(cxDefaultAllocator, str, pattern, replacement, SIZE_MAX) | 1067 cx_strreplacen_a(cxDefaultAllocator, str, search, replacement, SIZE_MAX) |
| 1072 | 1068 |
| 1073 /** | 1069 /** |
| 1074 * Creates a string tokenization context. | 1070 * Creates a string tokenization context. |
| 1075 * | 1071 * |
| 1076 * @param str the string to tokenize | 1072 * @param str the string to tokenize |
| 1077 * @param delim the delimiter (must not be empty) | 1073 * @param delim the delimiter (must not be empty) |
| 1078 * @param limit the maximum number of tokens that shall be returned | 1074 * @param limit the maximum number of tokens that shall be returned |
| 1079 * @return a new string tokenization context | 1075 * @return a new string tokenization context |
| 1080 */ | 1076 */ |
| 1081 cx_attr_nodiscard | 1077 cx_attr_nodiscard |
| 1082 CxStrtokCtx cx_strtok( | 1078 cx_attr_export |
| 1079 CxStrtokCtx cx_strtok_( | |
| 1083 cxstring str, | 1080 cxstring str, |
| 1084 cxstring delim, | 1081 cxstring delim, |
| 1085 size_t limit | 1082 size_t limit |
| 1086 ); | 1083 ); |
| 1087 | 1084 |
| 1088 /** | 1085 /** |
| 1089 * Creates a string tokenization context for a mutable string. | 1086 * Creates a string tokenization context. |
| 1090 * | 1087 * |
| 1091 * @param str the string to tokenize | 1088 * @param str the string to tokenize |
| 1092 * @param delim the delimiter (must not be empty) | 1089 * @param delim the delimiter string (must not be empty) |
| 1093 * @param limit the maximum number of tokens that shall be returned | 1090 * @param limit (@c size_t) the maximum number of tokens that shall be returned |
| 1094 * @return a new string tokenization context | 1091 * @return (@c CxStrtokCtx) a new string tokenization context |
| 1095 */ | 1092 */ |
| 1096 cx_attr_nodiscard | 1093 #define cx_strtok(str, delim, limit) \ |
| 1097 CxStrtokCtx cx_strtok_m( | 1094 cx_strtok_(cx_strcast((str)), cx_strcast((delim)), (limit)) |
| 1098 cxmutstr str, | |
| 1099 cxstring delim, | |
| 1100 size_t limit | |
| 1101 ); | |
| 1102 | 1095 |
| 1103 /** | 1096 /** |
| 1104 * Returns the next token. | 1097 * Returns the next token. |
| 1105 * | 1098 * |
| 1106 * The token will point to the source string. | 1099 * The token will point to the source string. |
| 1111 * has been reached | 1104 * has been reached |
| 1112 */ | 1105 */ |
| 1113 cx_attr_nonnull | 1106 cx_attr_nonnull |
| 1114 cx_attr_nodiscard | 1107 cx_attr_nodiscard |
| 1115 cx_attr_access_w(2) | 1108 cx_attr_access_w(2) |
| 1109 cx_attr_export | |
| 1116 bool cx_strtok_next( | 1110 bool cx_strtok_next( |
| 1117 CxStrtokCtx *ctx, | 1111 CxStrtokCtx *ctx, |
| 1118 cxstring *token | 1112 cxstring *token |
| 1119 ); | 1113 ); |
| 1120 | 1114 |
| 1121 /** | 1115 /** |
| 1122 * Returns the next token of a mutable string. | 1116 * Returns the next token of a mutable string. |
| 1123 * | 1117 * |
| 1124 * The token will point to the source string. | 1118 * The token will point to the source string. |
| 1119 * | |
| 1120 * @attention | |
| 1125 * If the context was not initialized over a mutable string, modifying | 1121 * If the context was not initialized over a mutable string, modifying |
| 1126 * the data of the returned token is undefined behavior. | 1122 * the data of the returned token is undefined behavior. |
| 1127 * | 1123 * |
| 1128 * @param ctx the tokenization context | 1124 * @param ctx the tokenization context |
| 1129 * @param token a pointer to memory where the next token shall be stored | 1125 * @param token a pointer to memory where the next token shall be stored |
| 1131 * has been reached | 1127 * has been reached |
| 1132 */ | 1128 */ |
| 1133 cx_attr_nonnull | 1129 cx_attr_nonnull |
| 1134 cx_attr_nodiscard | 1130 cx_attr_nodiscard |
| 1135 cx_attr_access_w(2) | 1131 cx_attr_access_w(2) |
| 1132 cx_attr_export | |
| 1136 bool cx_strtok_next_m( | 1133 bool cx_strtok_next_m( |
| 1137 CxStrtokCtx *ctx, | 1134 CxStrtokCtx *ctx, |
| 1138 cxmutstr *token | 1135 cxmutstr *token |
| 1139 ); | 1136 ); |
| 1140 | 1137 |
| 1145 * @param delim array of more delimiters | 1142 * @param delim array of more delimiters |
| 1146 * @param count number of elements in the array | 1143 * @param count number of elements in the array |
| 1147 */ | 1144 */ |
| 1148 cx_attr_nonnull | 1145 cx_attr_nonnull |
| 1149 cx_attr_access_r(2, 3) | 1146 cx_attr_access_r(2, 3) |
| 1147 cx_attr_export | |
| 1150 void cx_strtok_delim( | 1148 void cx_strtok_delim( |
| 1151 CxStrtokCtx *ctx, | 1149 CxStrtokCtx *ctx, |
| 1152 const cxstring *delim, | 1150 const cxstring *delim, |
| 1153 size_t count | 1151 size_t count |
| 1154 ); | 1152 ); |
| 1156 /* ------------------------------------------------------------------------- * | 1154 /* ------------------------------------------------------------------------- * |
| 1157 * string to number conversion functions * | 1155 * string to number conversion functions * |
| 1158 * ------------------------------------------------------------------------- */ | 1156 * ------------------------------------------------------------------------- */ |
| 1159 | 1157 |
| 1160 /** | 1158 /** |
| 1161 * @copydoc cx_strtouz_lc() | |
| 1162 */ | |
| 1163 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1164 int cx_strtos_lc(cxstring str, short *output, int base, const char *groupsep); | |
| 1165 /** | |
| 1166 * @copydoc cx_strtouz_lc() | |
| 1167 */ | |
| 1168 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1169 int cx_strtoi_lc(cxstring str, int *output, int base, const char *groupsep); | |
| 1170 /** | |
| 1171 * @copydoc cx_strtouz_lc() | |
| 1172 */ | |
| 1173 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1174 int cx_strtol_lc(cxstring str, long *output, int base, const char *groupsep); | |
| 1175 /** | |
| 1176 * @copydoc cx_strtouz_lc() | |
| 1177 */ | |
| 1178 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1179 int cx_strtoll_lc(cxstring str, long long *output, int base, const char *groupsep); | |
| 1180 /** | |
| 1181 * @copydoc cx_strtouz_lc() | |
| 1182 */ | |
| 1183 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1184 int cx_strtoi8_lc(cxstring str, int8_t *output, int base, const char *groupsep); | |
| 1185 /** | |
| 1186 * @copydoc cx_strtouz_lc() | |
| 1187 */ | |
| 1188 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1189 int cx_strtoi16_lc(cxstring str, int16_t *output, int base, const char *groupsep); | |
| 1190 /** | |
| 1191 * @copydoc cx_strtouz_lc() | |
| 1192 */ | |
| 1193 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1194 int cx_strtoi32_lc(cxstring str, int32_t *output, int base, const char *groupsep); | |
| 1195 /** | |
| 1196 * @copydoc cx_strtouz_lc() | |
| 1197 */ | |
| 1198 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1199 int cx_strtoi64_lc(cxstring str, int64_t *output, int base, const char *groupsep); | |
| 1200 /** | |
| 1201 * @copydoc cx_strtouz_lc() | |
| 1202 */ | |
| 1203 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1204 int cx_strtoz_lc(cxstring str, ssize_t *output, int base, const char *groupsep); | |
| 1205 /** | |
| 1206 * @copydoc cx_strtouz_lc() | |
| 1207 */ | |
| 1208 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1209 int cx_strtous_lc(cxstring str, unsigned short *output, int base, const char *groupsep); | |
| 1210 /** | |
| 1211 * @copydoc cx_strtouz_lc() | |
| 1212 */ | |
| 1213 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1214 int cx_strtou_lc(cxstring str, unsigned int *output, int base, const char *groupsep); | |
| 1215 /** | |
| 1216 * @copydoc cx_strtouz_lc() | |
| 1217 */ | |
| 1218 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1219 int cx_strtoul_lc(cxstring str, unsigned long *output, int base, const char *groupsep); | |
| 1220 /** | |
| 1221 * @copydoc cx_strtouz_lc() | |
| 1222 */ | |
| 1223 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1224 int cx_strtoull_lc(cxstring str, unsigned long long *output, int base, const char *groupsep); | |
| 1225 /** | |
| 1226 * @copydoc cx_strtouz_lc() | |
| 1227 */ | |
| 1228 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1229 int cx_strtou8_lc(cxstring str, uint8_t *output, int base, const char *groupsep); | |
| 1230 /** | |
| 1231 * @copydoc cx_strtouz_lc() | |
| 1232 */ | |
| 1233 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1234 int cx_strtou16_lc(cxstring str, uint16_t *output, int base, const char *groupsep); | |
| 1235 /** | |
| 1236 * @copydoc cx_strtouz_lc() | |
| 1237 */ | |
| 1238 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1239 int cx_strtou32_lc(cxstring str, uint32_t *output, int base, const char *groupsep); | |
| 1240 /** | |
| 1241 * @copydoc cx_strtouz_lc() | |
| 1242 */ | |
| 1243 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1244 int cx_strtou64_lc(cxstring str, uint64_t *output, int base, const char *groupsep); | |
| 1245 | |
| 1246 /** | |
| 1247 * Converts a string to a number. | 1159 * Converts a string to a number. |
| 1248 * | 1160 * |
| 1249 * The function returns non-zero when conversion is not possible. | 1161 * The function returns non-zero when conversion is not possible. |
| 1250 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | 1162 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. |
| 1251 * It sets errno to ERANGE when the target datatype is too small. | 1163 * It sets errno to ERANGE when the target datatype is too small. |
| 1255 * @param base 2, 8, 10, or 16 | 1167 * @param base 2, 8, 10, or 16 |
| 1256 * @param groupsep each character in this string is treated as group separator and ignored during conversion | 1168 * @param groupsep each character in this string is treated as group separator and ignored during conversion |
| 1257 * @retval zero success | 1169 * @retval zero success |
| 1258 * @retval non-zero conversion was not possible | 1170 * @retval non-zero conversion was not possible |
| 1259 */ | 1171 */ |
| 1260 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | 1172 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export |
| 1261 int cx_strtouz_lc(cxstring str, size_t *output, int base, const char *groupsep); | 1173 int cx_strtos_lc_(cxstring str, short *output, int base, const char *groupsep); |
| 1174 | |
| 1175 /** | |
| 1176 * Converts a string to a number. | |
| 1177 * | |
| 1178 * The function returns non-zero when conversion is not possible. | |
| 1179 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1180 * It sets errno to ERANGE when the target datatype is too small. | |
| 1181 * | |
| 1182 * @param str the string to convert | |
| 1183 * @param output a pointer to the integer variable where the result shall be stored | |
| 1184 * @param base 2, 8, 10, or 16 | |
| 1185 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1186 * @retval zero success | |
| 1187 * @retval non-zero conversion was not possible | |
| 1188 */ | |
| 1189 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1190 int cx_strtoi_lc_(cxstring str, int *output, int base, const char *groupsep); | |
| 1191 | |
| 1192 /** | |
| 1193 * Converts a string to a number. | |
| 1194 * | |
| 1195 * The function returns non-zero when conversion is not possible. | |
| 1196 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1197 * It sets errno to ERANGE when the target datatype is too small. | |
| 1198 * | |
| 1199 * @param str the string to convert | |
| 1200 * @param output a pointer to the integer variable where the result shall be stored | |
| 1201 * @param base 2, 8, 10, or 16 | |
| 1202 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1203 * @retval zero success | |
| 1204 * @retval non-zero conversion was not possible | |
| 1205 */ | |
| 1206 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1207 int cx_strtol_lc_(cxstring str, long *output, int base, const char *groupsep); | |
| 1208 | |
| 1209 /** | |
| 1210 * Converts a string to a number. | |
| 1211 * | |
| 1212 * The function returns non-zero when conversion is not possible. | |
| 1213 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1214 * It sets errno to ERANGE when the target datatype is too small. | |
| 1215 * | |
| 1216 * @param str the string to convert | |
| 1217 * @param output a pointer to the integer variable where the result shall be stored | |
| 1218 * @param base 2, 8, 10, or 16 | |
| 1219 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1220 * @retval zero success | |
| 1221 * @retval non-zero conversion was not possible | |
| 1222 */ | |
| 1223 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1224 int cx_strtoll_lc_(cxstring str, long long *output, int base, const char *groupsep); | |
| 1225 | |
| 1226 /** | |
| 1227 * Converts a string to a number. | |
| 1228 * | |
| 1229 * The function returns non-zero when conversion is not possible. | |
| 1230 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1231 * It sets errno to ERANGE when the target datatype is too small. | |
| 1232 * | |
| 1233 * @param str the string to convert | |
| 1234 * @param output a pointer to the integer variable where the result shall be stored | |
| 1235 * @param base 2, 8, 10, or 16 | |
| 1236 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1237 * @retval zero success | |
| 1238 * @retval non-zero conversion was not possible | |
| 1239 */ | |
| 1240 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1241 int cx_strtoi8_lc_(cxstring str, int8_t *output, int base, const char *groupsep); | |
| 1242 | |
| 1243 /** | |
| 1244 * Converts a string to a number. | |
| 1245 * | |
| 1246 * The function returns non-zero when conversion is not possible. | |
| 1247 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1248 * It sets errno to ERANGE when the target datatype is too small. | |
| 1249 * | |
| 1250 * @param str the string to convert | |
| 1251 * @param output a pointer to the integer variable where the result shall be stored | |
| 1252 * @param base 2, 8, 10, or 16 | |
| 1253 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1254 * @retval zero success | |
| 1255 * @retval non-zero conversion was not possible | |
| 1256 */ | |
| 1257 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1258 int cx_strtoi16_lc_(cxstring str, int16_t *output, int base, const char *groupsep); | |
| 1259 | |
| 1260 /** | |
| 1261 * Converts a string to a number. | |
| 1262 * | |
| 1263 * The function returns non-zero when conversion is not possible. | |
| 1264 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1265 * It sets errno to ERANGE when the target datatype is too small. | |
| 1266 * | |
| 1267 * @param str the string to convert | |
| 1268 * @param output a pointer to the integer variable where the result shall be stored | |
| 1269 * @param base 2, 8, 10, or 16 | |
| 1270 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1271 * @retval zero success | |
| 1272 * @retval non-zero conversion was not possible | |
| 1273 */ | |
| 1274 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1275 int cx_strtoi32_lc_(cxstring str, int32_t *output, int base, const char *groupsep); | |
| 1276 | |
| 1277 /** | |
| 1278 * Converts a string to a number. | |
| 1279 * | |
| 1280 * The function returns non-zero when conversion is not possible. | |
| 1281 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1282 * It sets errno to ERANGE when the target datatype is too small. | |
| 1283 * | |
| 1284 * @param str the string to convert | |
| 1285 * @param output a pointer to the integer variable where the result shall be stored | |
| 1286 * @param base 2, 8, 10, or 16 | |
| 1287 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1288 * @retval zero success | |
| 1289 * @retval non-zero conversion was not possible | |
| 1290 */ | |
| 1291 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1292 int cx_strtoi64_lc_(cxstring str, int64_t *output, int base, const char *groupsep); | |
| 1293 | |
| 1294 /** | |
| 1295 * Converts a string to a number. | |
| 1296 * | |
| 1297 * The function returns non-zero when conversion is not possible. | |
| 1298 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1299 * It sets errno to ERANGE when the target datatype is too small. | |
| 1300 * | |
| 1301 * @param str the string to convert | |
| 1302 * @param output a pointer to the integer variable where the result shall be stored | |
| 1303 * @param base 2, 8, 10, or 16 | |
| 1304 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1305 * @retval zero success | |
| 1306 * @retval non-zero conversion was not possible | |
| 1307 */ | |
| 1308 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1309 int cx_strtous_lc_(cxstring str, unsigned short *output, int base, const char *groupsep); | |
| 1310 | |
| 1311 /** | |
| 1312 * Converts a string to a number. | |
| 1313 * | |
| 1314 * The function returns non-zero when conversion is not possible. | |
| 1315 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1316 * It sets errno to ERANGE when the target datatype is too small. | |
| 1317 * | |
| 1318 * @param str the string to convert | |
| 1319 * @param output a pointer to the integer variable where the result shall be stored | |
| 1320 * @param base 2, 8, 10, or 16 | |
| 1321 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1322 * @retval zero success | |
| 1323 * @retval non-zero conversion was not possible | |
| 1324 */ | |
| 1325 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1326 int cx_strtou_lc_(cxstring str, unsigned int *output, int base, const char *groupsep); | |
| 1327 | |
| 1328 /** | |
| 1329 * Converts a string to a number. | |
| 1330 * | |
| 1331 * The function returns non-zero when conversion is not possible. | |
| 1332 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1333 * It sets errno to ERANGE when the target datatype is too small. | |
| 1334 * | |
| 1335 * @param str the string to convert | |
| 1336 * @param output a pointer to the integer variable where the result shall be stored | |
| 1337 * @param base 2, 8, 10, or 16 | |
| 1338 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1339 * @retval zero success | |
| 1340 * @retval non-zero conversion was not possible | |
| 1341 */ | |
| 1342 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1343 int cx_strtoul_lc_(cxstring str, unsigned long *output, int base, const char *groupsep); | |
| 1344 | |
| 1345 /** | |
| 1346 * Converts a string to a number. | |
| 1347 * | |
| 1348 * The function returns non-zero when conversion is not possible. | |
| 1349 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1350 * It sets errno to ERANGE when the target datatype is too small. | |
| 1351 * | |
| 1352 * @param str the string to convert | |
| 1353 * @param output a pointer to the integer variable where the result shall be stored | |
| 1354 * @param base 2, 8, 10, or 16 | |
| 1355 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1356 * @retval zero success | |
| 1357 * @retval non-zero conversion was not possible | |
| 1358 */ | |
| 1359 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1360 int cx_strtoull_lc_(cxstring str, unsigned long long *output, int base, const char *groupsep); | |
| 1361 | |
| 1362 /** | |
| 1363 * Converts a string to a number. | |
| 1364 * | |
| 1365 * The function returns non-zero when conversion is not possible. | |
| 1366 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1367 * It sets errno to ERANGE when the target datatype is too small. | |
| 1368 * | |
| 1369 * @param str the string to convert | |
| 1370 * @param output a pointer to the integer variable where the result shall be stored | |
| 1371 * @param base 2, 8, 10, or 16 | |
| 1372 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1373 * @retval zero success | |
| 1374 * @retval non-zero conversion was not possible | |
| 1375 */ | |
| 1376 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1377 int cx_strtou8_lc_(cxstring str, uint8_t *output, int base, const char *groupsep); | |
| 1378 | |
| 1379 /** | |
| 1380 * Converts a string to a number. | |
| 1381 * | |
| 1382 * The function returns non-zero when conversion is not possible. | |
| 1383 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1384 * It sets errno to ERANGE when the target datatype is too small. | |
| 1385 * | |
| 1386 * @param str the string to convert | |
| 1387 * @param output a pointer to the integer variable where the result shall be stored | |
| 1388 * @param base 2, 8, 10, or 16 | |
| 1389 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1390 * @retval zero success | |
| 1391 * @retval non-zero conversion was not possible | |
| 1392 */ | |
| 1393 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1394 int cx_strtou16_lc_(cxstring str, uint16_t *output, int base, const char *groupsep); | |
| 1395 | |
| 1396 /** | |
| 1397 * Converts a string to a number. | |
| 1398 * | |
| 1399 * The function returns non-zero when conversion is not possible. | |
| 1400 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1401 * It sets errno to ERANGE when the target datatype is too small. | |
| 1402 * | |
| 1403 * @param str the string to convert | |
| 1404 * @param output a pointer to the integer variable where the result shall be stored | |
| 1405 * @param base 2, 8, 10, or 16 | |
| 1406 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1407 * @retval zero success | |
| 1408 * @retval non-zero conversion was not possible | |
| 1409 */ | |
| 1410 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1411 int cx_strtou32_lc_(cxstring str, uint32_t *output, int base, const char *groupsep); | |
| 1412 | |
| 1413 /** | |
| 1414 * Converts a string to a number. | |
| 1415 * | |
| 1416 * The function returns non-zero when conversion is not possible. | |
| 1417 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1418 * It sets errno to ERANGE when the target datatype is too small. | |
| 1419 * | |
| 1420 * @param str the string to convert | |
| 1421 * @param output a pointer to the integer variable where the result shall be stored | |
| 1422 * @param base 2, 8, 10, or 16 | |
| 1423 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1424 * @retval zero success | |
| 1425 * @retval non-zero conversion was not possible | |
| 1426 */ | |
| 1427 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1428 int cx_strtou64_lc_(cxstring str, uint64_t *output, int base, const char *groupsep); | |
| 1429 | |
| 1430 /** | |
| 1431 * Converts a string to a number. | |
| 1432 * | |
| 1433 * The function returns non-zero when conversion is not possible. | |
| 1434 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1435 * It sets errno to ERANGE when the target datatype is too small. | |
| 1436 * | |
| 1437 * @param str the string to convert | |
| 1438 * @param output a pointer to the integer variable where the result shall be stored | |
| 1439 * @param base 2, 8, 10, or 16 | |
| 1440 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1441 * @retval zero success | |
| 1442 * @retval non-zero conversion was not possible | |
| 1443 */ | |
| 1444 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1445 int cx_strtoz_lc_(cxstring str, size_t *output, int base, const char *groupsep); | |
| 1446 | |
| 1447 /** | |
| 1448 * Converts a string to a single precision floating point number. | |
| 1449 * | |
| 1450 * The function returns non-zero when conversion is not possible. | |
| 1451 * In that case the function sets errno to EINVAL when the reason is an invalid character. | |
| 1452 * It sets errno to ERANGE when the necessary representation would exceed the limits defined in libc's float.h. | |
| 1453 * | |
| 1454 * @param str the string to convert | |
| 1455 * @param output a pointer to the float variable where the result shall be stored | |
| 1456 * @param decsep the decimal separator | |
| 1457 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1458 * @retval zero success | |
| 1459 * @retval non-zero conversion was not possible | |
| 1460 */ | |
| 1461 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1462 int cx_strtof_lc_(cxstring str, float *output, char decsep, const char *groupsep); | |
| 1463 | |
| 1464 /** | |
| 1465 * Converts a string to a double precision floating point number. | |
| 1466 * | |
| 1467 * The function returns non-zero when conversion is not possible. | |
| 1468 * In that case the function sets errno to EINVAL when the reason is an invalid character. | |
| 1469 * It sets errno to ERANGE when the necessary representation would exceed the limits defined in libc's float.h. | |
| 1470 * | |
| 1471 * @param str the string to convert | |
| 1472 * @param output a pointer to the float variable where the result shall be stored | |
| 1473 * @param decsep the decimal separator | |
| 1474 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1475 * @retval zero success | |
| 1476 * @retval non-zero conversion was not possible | |
| 1477 */ | |
| 1478 cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export | |
| 1479 int cx_strtod_lc_(cxstring str, double *output, char decsep, const char *groupsep); | |
| 1480 | |
| 1481 /** | |
| 1482 * Converts a string to a number. | |
| 1483 * | |
| 1484 * The function returns non-zero when conversion is not possible. | |
| 1485 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1486 * It sets errno to ERANGE when the target datatype is too small. | |
| 1487 * | |
| 1488 * @param str the string to convert | |
| 1489 * @param output a pointer to the integer variable where the result shall be stored | |
| 1490 * @param base 2, 8, 10, or 16 | |
| 1491 * @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion | |
| 1492 * @retval zero success | |
| 1493 * @retval non-zero conversion was not possible | |
| 1494 */ | |
| 1495 #define cx_strtos_lc(str, output, base, groupsep) cx_strtos_lc_(cx_strcast(str), output, base, groupsep) | |
| 1496 | |
| 1497 /** | |
| 1498 * Converts a string to a number. | |
| 1499 * | |
| 1500 * The function returns non-zero when conversion is not possible. | |
| 1501 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1502 * It sets errno to ERANGE when the target datatype is too small. | |
| 1503 * | |
| 1504 * @param str the string to convert | |
| 1505 * @param output a pointer to the integer variable where the result shall be stored | |
| 1506 * @param base 2, 8, 10, or 16 | |
| 1507 * @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion | |
| 1508 * @retval zero success | |
| 1509 * @retval non-zero conversion was not possible | |
| 1510 */ | |
| 1511 #define cx_strtoi_lc(str, output, base, groupsep) cx_strtoi_lc_(cx_strcast(str), output, base, groupsep) | |
| 1512 | |
| 1513 /** | |
| 1514 * Converts a string to a number. | |
| 1515 * | |
| 1516 * The function returns non-zero when conversion is not possible. | |
| 1517 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1518 * It sets errno to ERANGE when the target datatype is too small. | |
| 1519 * | |
| 1520 * @param str the string to convert | |
| 1521 * @param output a pointer to the integer variable where the result shall be stored | |
| 1522 * @param base 2, 8, 10, or 16 | |
| 1523 * @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion | |
| 1524 * @retval zero success | |
| 1525 * @retval non-zero conversion was not possible | |
| 1526 */ | |
| 1527 #define cx_strtol_lc(str, output, base, groupsep) cx_strtol_lc_(cx_strcast(str), output, base, groupsep) | |
| 1528 | |
| 1529 /** | |
| 1530 * Converts a string to a number. | |
| 1531 * | |
| 1532 * The function returns non-zero when conversion is not possible. | |
| 1533 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1534 * It sets errno to ERANGE when the target datatype is too small. | |
| 1535 * | |
| 1536 * @param str the string to convert | |
| 1537 * @param output a pointer to the integer variable where the result shall be stored | |
| 1538 * @param base 2, 8, 10, or 16 | |
| 1539 * @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion | |
| 1540 * @retval zero success | |
| 1541 * @retval non-zero conversion was not possible | |
| 1542 */ | |
| 1543 #define cx_strtoll_lc(str, output, base, groupsep) cx_strtoll_lc_(cx_strcast(str), output, base, groupsep) | |
| 1544 | |
| 1545 /** | |
| 1546 * Converts a string to a number. | |
| 1547 * | |
| 1548 * The function returns non-zero when conversion is not possible. | |
| 1549 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1550 * It sets errno to ERANGE when the target datatype is too small. | |
| 1551 * | |
| 1552 * @param str the string to convert | |
| 1553 * @param output a pointer to the integer variable where the result shall be stored | |
| 1554 * @param base 2, 8, 10, or 16 | |
| 1555 * @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion | |
| 1556 * @retval zero success | |
| 1557 * @retval non-zero conversion was not possible | |
| 1558 */ | |
| 1559 #define cx_strtoi8_lc(str, output, base, groupsep) cx_strtoi8_lc_(cx_strcast(str), output, base, groupsep) | |
| 1560 | |
| 1561 /** | |
| 1562 * Converts a string to a number. | |
| 1563 * | |
| 1564 * The function returns non-zero when conversion is not possible. | |
| 1565 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1566 * It sets errno to ERANGE when the target datatype is too small. | |
| 1567 * | |
| 1568 * @param str the string to convert | |
| 1569 * @param output a pointer to the integer variable where the result shall be stored | |
| 1570 * @param base 2, 8, 10, or 16 | |
| 1571 * @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion | |
| 1572 * @retval zero success | |
| 1573 * @retval non-zero conversion was not possible | |
| 1574 */ | |
| 1575 #define cx_strtoi16_lc(str, output, base, groupsep) cx_strtoi16_lc_(cx_strcast(str), output, base, groupsep) | |
| 1576 | |
| 1577 /** | |
| 1578 * Converts a string to a number. | |
| 1579 * | |
| 1580 * The function returns non-zero when conversion is not possible. | |
| 1581 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1582 * It sets errno to ERANGE when the target datatype is too small. | |
| 1583 * | |
| 1584 * @param str the string to convert | |
| 1585 * @param output a pointer to the integer variable where the result shall be stored | |
| 1586 * @param base 2, 8, 10, or 16 | |
| 1587 * @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion | |
| 1588 * @retval zero success | |
| 1589 * @retval non-zero conversion was not possible | |
| 1590 */ | |
| 1591 #define cx_strtoi32_lc(str, output, base, groupsep) cx_strtoi32_lc_(cx_strcast(str), output, base, groupsep) | |
| 1592 | |
| 1593 /** | |
| 1594 * Converts a string to a number. | |
| 1595 * | |
| 1596 * The function returns non-zero when conversion is not possible. | |
| 1597 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1598 * It sets errno to ERANGE when the target datatype is too small. | |
| 1599 * | |
| 1600 * @param str the string to convert | |
| 1601 * @param output a pointer to the integer variable where the result shall be stored | |
| 1602 * @param base 2, 8, 10, or 16 | |
| 1603 * @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion | |
| 1604 * @retval zero success | |
| 1605 * @retval non-zero conversion was not possible | |
| 1606 */ | |
| 1607 #define cx_strtoi64_lc(str, output, base, groupsep) cx_strtoi64_lc_(cx_strcast(str), output, base, groupsep) | |
| 1608 | |
| 1609 /** | |
| 1610 * Converts a string to a number. | |
| 1611 * | |
| 1612 * The function returns non-zero when conversion is not possible. | |
| 1613 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1614 * It sets errno to ERANGE when the target datatype is too small. | |
| 1615 * | |
| 1616 * @param str the string to convert | |
| 1617 * @param output a pointer to the integer variable where the result shall be stored | |
| 1618 * @param base 2, 8, 10, or 16 | |
| 1619 * @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion | |
| 1620 * @retval zero success | |
| 1621 * @retval non-zero conversion was not possible | |
| 1622 */ | |
| 1623 #define cx_strtous_lc(str, output, base, groupsep) cx_strtous_lc_(cx_strcast(str), output, base, groupsep) | |
| 1624 | |
| 1625 /** | |
| 1626 * Converts a string to a number. | |
| 1627 * | |
| 1628 * The function returns non-zero when conversion is not possible. | |
| 1629 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1630 * It sets errno to ERANGE when the target datatype is too small. | |
| 1631 * | |
| 1632 * @param str the string to convert | |
| 1633 * @param output a pointer to the integer variable where the result shall be stored | |
| 1634 * @param base 2, 8, 10, or 16 | |
| 1635 * @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion | |
| 1636 * @retval zero success | |
| 1637 * @retval non-zero conversion was not possible | |
| 1638 */ | |
| 1639 #define cx_strtou_lc(str, output, base, groupsep) cx_strtou_lc_(cx_strcast(str), output, base, groupsep) | |
| 1640 | |
| 1641 /** | |
| 1642 * Converts a string to a number. | |
| 1643 * | |
| 1644 * The function returns non-zero when conversion is not possible. | |
| 1645 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1646 * It sets errno to ERANGE when the target datatype is too small. | |
| 1647 * | |
| 1648 * @param str the string to convert | |
| 1649 * @param output a pointer to the integer variable where the result shall be stored | |
| 1650 * @param base 2, 8, 10, or 16 | |
| 1651 * @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion | |
| 1652 * @retval zero success | |
| 1653 * @retval non-zero conversion was not possible | |
| 1654 */ | |
| 1655 #define cx_strtoul_lc(str, output, base, groupsep) cx_strtoul_lc_(cx_strcast(str), output, base, groupsep) | |
| 1656 | |
| 1657 /** | |
| 1658 * Converts a string to a number. | |
| 1659 * | |
| 1660 * The function returns non-zero when conversion is not possible. | |
| 1661 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1662 * It sets errno to ERANGE when the target datatype is too small. | |
| 1663 * | |
| 1664 * @param str the string to convert | |
| 1665 * @param output a pointer to the integer variable where the result shall be stored | |
| 1666 * @param base 2, 8, 10, or 16 | |
| 1667 * @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion | |
| 1668 * @retval zero success | |
| 1669 * @retval non-zero conversion was not possible | |
| 1670 */ | |
| 1671 #define cx_strtoull_lc(str, output, base, groupsep) cx_strtoull_lc_(cx_strcast(str), output, base, groupsep) | |
| 1672 | |
| 1673 /** | |
| 1674 * Converts a string to a number. | |
| 1675 * | |
| 1676 * The function returns non-zero when conversion is not possible. | |
| 1677 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1678 * It sets errno to ERANGE when the target datatype is too small. | |
| 1679 * | |
| 1680 * @param str the string to convert | |
| 1681 * @param output a pointer to the integer variable where the result shall be stored | |
| 1682 * @param base 2, 8, 10, or 16 | |
| 1683 * @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion | |
| 1684 * @retval zero success | |
| 1685 * @retval non-zero conversion was not possible | |
| 1686 */ | |
| 1687 #define cx_strtou8_lc(str, output, base, groupsep) cx_strtou8_lc_(cx_strcast(str), output, base, groupsep) | |
| 1688 | |
| 1689 /** | |
| 1690 * Converts a string to a number. | |
| 1691 * | |
| 1692 * The function returns non-zero when conversion is not possible. | |
| 1693 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1694 * It sets errno to ERANGE when the target datatype is too small. | |
| 1695 * | |
| 1696 * @param str the string to convert | |
| 1697 * @param output a pointer to the integer variable where the result shall be stored | |
| 1698 * @param base 2, 8, 10, or 16 | |
| 1699 * @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion | |
| 1700 * @retval zero success | |
| 1701 * @retval non-zero conversion was not possible | |
| 1702 */ | |
| 1703 #define cx_strtou16_lc(str, output, base, groupsep) cx_strtou16_lc_(cx_strcast(str), output, base, groupsep) | |
| 1704 | |
| 1705 /** | |
| 1706 * Converts a string to a number. | |
| 1707 * | |
| 1708 * The function returns non-zero when conversion is not possible. | |
| 1709 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1710 * It sets errno to ERANGE when the target datatype is too small. | |
| 1711 * | |
| 1712 * @param str the string to convert | |
| 1713 * @param output a pointer to the integer variable where the result shall be stored | |
| 1714 * @param base 2, 8, 10, or 16 | |
| 1715 * @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion | |
| 1716 * @retval zero success | |
| 1717 * @retval non-zero conversion was not possible | |
| 1718 */ | |
| 1719 #define cx_strtou32_lc(str, output, base, groupsep) cx_strtou32_lc_(cx_strcast(str), output, base, groupsep) | |
| 1720 | |
| 1721 /** | |
| 1722 * Converts a string to a number. | |
| 1723 * | |
| 1724 * The function returns non-zero when conversion is not possible. | |
| 1725 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1726 * It sets errno to ERANGE when the target datatype is too small. | |
| 1727 * | |
| 1728 * @param str the string to convert | |
| 1729 * @param output a pointer to the integer variable where the result shall be stored | |
| 1730 * @param base 2, 8, 10, or 16 | |
| 1731 * @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion | |
| 1732 * @retval zero success | |
| 1733 * @retval non-zero conversion was not possible | |
| 1734 */ | |
| 1735 #define cx_strtou64_lc(str, output, base, groupsep) cx_strtou64_lc_(cx_strcast(str), output, base, groupsep) | |
| 1736 | |
| 1737 /** | |
| 1738 * Converts a string to a number. | |
| 1739 * | |
| 1740 * The function returns non-zero when conversion is not possible. | |
| 1741 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1742 * It sets errno to ERANGE when the target datatype is too small. | |
| 1743 * | |
| 1744 * @param str the string to convert | |
| 1745 * @param output a pointer to the integer variable where the result shall be stored | |
| 1746 * @param base 2, 8, 10, or 16 | |
| 1747 * @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion | |
| 1748 * @retval zero success | |
| 1749 * @retval non-zero conversion was not possible | |
| 1750 */ | |
| 1751 #define cx_strtoz_lc(str, output, base, groupsep) cx_strtoz_lc_(cx_strcast(str), output, base, groupsep) | |
| 1752 | |
| 1753 /** | |
| 1754 * Converts a string to a number. | |
| 1755 * | |
| 1756 * The function returns non-zero when conversion is not possible. | |
| 1757 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1758 * It sets errno to ERANGE when the target datatype is too small. | |
| 1759 * | |
| 1760 * The comma character is treated as group separator and ignored during parsing. | |
| 1761 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()). | |
| 1762 * | |
| 1763 * @param str the string to convert | |
| 1764 * @param output a pointer to the integer variable where the result shall be stored | |
| 1765 * @param base 2, 8, 10, or 16 | |
| 1766 * @retval zero success | |
| 1767 * @retval non-zero conversion was not possible | |
| 1768 */ | |
| 1769 #define cx_strtos(str, output, base) cx_strtos_lc_(cx_strcast(str), output, base, ",") | |
| 1770 | |
| 1771 /** | |
| 1772 * Converts a string to a number. | |
| 1773 * | |
| 1774 * The function returns non-zero when conversion is not possible. | |
| 1775 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1776 * It sets errno to ERANGE when the target datatype is too small. | |
| 1777 * | |
| 1778 * The comma character is treated as group separator and ignored during parsing. | |
| 1779 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()). | |
| 1780 * | |
| 1781 * @param str the string to convert | |
| 1782 * @param output a pointer to the integer variable where the result shall be stored | |
| 1783 * @param base 2, 8, 10, or 16 | |
| 1784 * @retval zero success | |
| 1785 * @retval non-zero conversion was not possible | |
| 1786 */ | |
| 1787 #define cx_strtoi(str, output, base) cx_strtoi_lc_(cx_strcast(str), output, base, ",") | |
| 1788 | |
| 1789 /** | |
| 1790 * Converts a string to a number. | |
| 1791 * | |
| 1792 * The function returns non-zero when conversion is not possible. | |
| 1793 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1794 * It sets errno to ERANGE when the target datatype is too small. | |
| 1795 * | |
| 1796 * The comma character is treated as group separator and ignored during parsing. | |
| 1797 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()). | |
| 1798 * | |
| 1799 * @param str the string to convert | |
| 1800 * @param output a pointer to the integer variable where the result shall be stored | |
| 1801 * @param base 2, 8, 10, or 16 | |
| 1802 * @retval zero success | |
| 1803 * @retval non-zero conversion was not possible | |
| 1804 */ | |
| 1805 #define cx_strtol(str, output, base) cx_strtol_lc_(cx_strcast(str), output, base, ",") | |
| 1806 | |
| 1807 /** | |
| 1808 * Converts a string to a number. | |
| 1809 * | |
| 1810 * The function returns non-zero when conversion is not possible. | |
| 1811 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1812 * It sets errno to ERANGE when the target datatype is too small. | |
| 1813 * | |
| 1814 * The comma character is treated as group separator and ignored during parsing. | |
| 1815 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()). | |
| 1816 * | |
| 1817 * @param str the string to convert | |
| 1818 * @param output a pointer to the integer variable where the result shall be stored | |
| 1819 * @param base 2, 8, 10, or 16 | |
| 1820 * @retval zero success | |
| 1821 * @retval non-zero conversion was not possible | |
| 1822 */ | |
| 1823 #define cx_strtoll(str, output, base) cx_strtoll_lc_(cx_strcast(str), output, base, ",") | |
| 1824 | |
| 1825 /** | |
| 1826 * Converts a string to a number. | |
| 1827 * | |
| 1828 * The function returns non-zero when conversion is not possible. | |
| 1829 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1830 * It sets errno to ERANGE when the target datatype is too small. | |
| 1831 * | |
| 1832 * The comma character is treated as group separator and ignored during parsing. | |
| 1833 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()). | |
| 1834 * | |
| 1835 * @param str the string to convert | |
| 1836 * @param output a pointer to the integer variable where the result shall be stored | |
| 1837 * @param base 2, 8, 10, or 16 | |
| 1838 * @retval zero success | |
| 1839 * @retval non-zero conversion was not possible | |
| 1840 */ | |
| 1841 #define cx_strtoi8(str, output, base) cx_strtoi8_lc_(cx_strcast(str), output, base, ",") | |
| 1842 | |
| 1843 /** | |
| 1844 * Converts a string to a number. | |
| 1845 * | |
| 1846 * The function returns non-zero when conversion is not possible. | |
| 1847 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1848 * It sets errno to ERANGE when the target datatype is too small. | |
| 1849 * | |
| 1850 * The comma character is treated as group separator and ignored during parsing. | |
| 1851 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()). | |
| 1852 * | |
| 1853 * @param str the string to convert | |
| 1854 * @param output a pointer to the integer variable where the result shall be stored | |
| 1855 * @param base 2, 8, 10, or 16 | |
| 1856 * @retval zero success | |
| 1857 * @retval non-zero conversion was not possible | |
| 1858 */ | |
| 1859 #define cx_strtoi16(str, output, base) cx_strtoi16_lc_(cx_strcast(str), output, base, ",") | |
| 1860 | |
| 1861 /** | |
| 1862 * Converts a string to a number. | |
| 1863 * | |
| 1864 * The function returns non-zero when conversion is not possible. | |
| 1865 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1866 * It sets errno to ERANGE when the target datatype is too small. | |
| 1867 * | |
| 1868 * The comma character is treated as group separator and ignored during parsing. | |
| 1869 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()). | |
| 1870 * | |
| 1871 * @param str the string to convert | |
| 1872 * @param output a pointer to the integer variable where the result shall be stored | |
| 1873 * @param base 2, 8, 10, or 16 | |
| 1874 * @retval zero success | |
| 1875 * @retval non-zero conversion was not possible | |
| 1876 */ | |
| 1877 #define cx_strtoi32(str, output, base) cx_strtoi32_lc_(cx_strcast(str), output, base, ",") | |
| 1878 | |
| 1879 /** | |
| 1880 * Converts a string to a number. | |
| 1881 * | |
| 1882 * The function returns non-zero when conversion is not possible. | |
| 1883 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1884 * It sets errno to ERANGE when the target datatype is too small. | |
| 1885 * | |
| 1886 * The comma character is treated as group separator and ignored during parsing. | |
| 1887 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()). | |
| 1888 * | |
| 1889 * @param str the string to convert | |
| 1890 * @param output a pointer to the integer variable where the result shall be stored | |
| 1891 * @param base 2, 8, 10, or 16 | |
| 1892 * @retval zero success | |
| 1893 * @retval non-zero conversion was not possible | |
| 1894 */ | |
| 1895 #define cx_strtoi64(str, output, base) cx_strtoi64_lc_(cx_strcast(str), output, base, ",") | |
| 1896 | |
| 1897 /** | |
| 1898 * Converts a string to a number. | |
| 1899 * | |
| 1900 * The function returns non-zero when conversion is not possible. | |
| 1901 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1902 * It sets errno to ERANGE when the target datatype is too small. | |
| 1903 * | |
| 1904 * The comma character is treated as group separator and ignored during parsing. | |
| 1905 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()). | |
| 1906 * | |
| 1907 * @param str the string to convert | |
| 1908 * @param output a pointer to the integer variable where the result shall be stored | |
| 1909 * @param base 2, 8, 10, or 16 | |
| 1910 * @retval zero success | |
| 1911 * @retval non-zero conversion was not possible | |
| 1912 */ | |
| 1913 #define cx_strtoz(str, output, base) cx_strtoz_lc_(cx_strcast(str), output, base, ",") | |
| 1914 | |
| 1915 /** | |
| 1916 * Converts a string to a number. | |
| 1917 * | |
| 1918 * The function returns non-zero when conversion is not possible. | |
| 1919 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1920 * It sets errno to ERANGE when the target datatype is too small. | |
| 1921 * | |
| 1922 * The comma character is treated as group separator and ignored during parsing. | |
| 1923 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()). | |
| 1924 * | |
| 1925 * @param str the string to convert | |
| 1926 * @param output a pointer to the integer variable where the result shall be stored | |
| 1927 * @param base 2, 8, 10, or 16 | |
| 1928 * @retval zero success | |
| 1929 * @retval non-zero conversion was not possible | |
| 1930 */ | |
| 1931 #define cx_strtous(str, output, base) cx_strtous_lc_(cx_strcast(str), output, base, ",") | |
| 1932 | |
| 1933 /** | |
| 1934 * Converts a string to a number. | |
| 1935 * | |
| 1936 * The function returns non-zero when conversion is not possible. | |
| 1937 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1938 * It sets errno to ERANGE when the target datatype is too small. | |
| 1939 * | |
| 1940 * The comma character is treated as group separator and ignored during parsing. | |
| 1941 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()). | |
| 1942 * | |
| 1943 * @param str the string to convert | |
| 1944 * @param output a pointer to the integer variable where the result shall be stored | |
| 1945 * @param base 2, 8, 10, or 16 | |
| 1946 * @retval zero success | |
| 1947 * @retval non-zero conversion was not possible | |
| 1948 */ | |
| 1949 #define cx_strtou(str, output, base) cx_strtou_lc_(cx_strcast(str), output, base, ",") | |
| 1950 | |
| 1951 /** | |
| 1952 * Converts a string to a number. | |
| 1953 * | |
| 1954 * The function returns non-zero when conversion is not possible. | |
| 1955 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1956 * It sets errno to ERANGE when the target datatype is too small. | |
| 1957 * | |
| 1958 * The comma character is treated as group separator and ignored during parsing. | |
| 1959 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()). | |
| 1960 * | |
| 1961 * @param str the string to convert | |
| 1962 * @param output a pointer to the integer variable where the result shall be stored | |
| 1963 * @param base 2, 8, 10, or 16 | |
| 1964 * @retval zero success | |
| 1965 * @retval non-zero conversion was not possible | |
| 1966 */ | |
| 1967 #define cx_strtoul(str, output, base) cx_strtoul_lc_(cx_strcast(str), output, base, ",") | |
| 1968 | |
| 1969 /** | |
| 1970 * Converts a string to a number. | |
| 1971 * | |
| 1972 * The function returns non-zero when conversion is not possible. | |
| 1973 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1974 * It sets errno to ERANGE when the target datatype is too small. | |
| 1975 * | |
| 1976 * The comma character is treated as group separator and ignored during parsing. | |
| 1977 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()). | |
| 1978 * | |
| 1979 * @param str the string to convert | |
| 1980 * @param output a pointer to the integer variable where the result shall be stored | |
| 1981 * @param base 2, 8, 10, or 16 | |
| 1982 * @retval zero success | |
| 1983 * @retval non-zero conversion was not possible | |
| 1984 */ | |
| 1985 #define cx_strtoull(str, output, base) cx_strtoull_lc_(cx_strcast(str), output, base, ",") | |
| 1986 | |
| 1987 /** | |
| 1988 * Converts a string to a number. | |
| 1989 * | |
| 1990 * The function returns non-zero when conversion is not possible. | |
| 1991 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1992 * It sets errno to ERANGE when the target datatype is too small. | |
| 1993 * | |
| 1994 * The comma character is treated as group separator and ignored during parsing. | |
| 1995 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()). | |
| 1996 * | |
| 1997 * @param str the string to convert | |
| 1998 * @param output a pointer to the integer variable where the result shall be stored | |
| 1999 * @param base 2, 8, 10, or 16 | |
| 2000 * @retval zero success | |
| 2001 * @retval non-zero conversion was not possible | |
| 2002 */ | |
| 2003 #define cx_strtou8(str, output, base) cx_strtou8_lc_(cx_strcast(str), output, base, ",") | |
| 2004 | |
| 2005 /** | |
| 2006 * Converts a string to a number. | |
| 2007 * | |
| 2008 * The function returns non-zero when conversion is not possible. | |
| 2009 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 2010 * It sets errno to ERANGE when the target datatype is too small. | |
| 2011 * | |
| 2012 * The comma character is treated as group separator and ignored during parsing. | |
| 2013 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()). | |
| 2014 * | |
| 2015 * @param str the string to convert | |
| 2016 * @param output a pointer to the integer variable where the result shall be stored | |
| 2017 * @param base 2, 8, 10, or 16 | |
| 2018 * @retval zero success | |
| 2019 * @retval non-zero conversion was not possible | |
| 2020 */ | |
| 2021 #define cx_strtou16(str, output, base) cx_strtou16_lc_(cx_strcast(str), output, base, ",") | |
| 2022 | |
| 2023 /** | |
| 2024 * Converts a string to a number. | |
| 2025 * | |
| 2026 * The function returns non-zero when conversion is not possible. | |
| 2027 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 2028 * It sets errno to ERANGE when the target datatype is too small. | |
| 2029 * | |
| 2030 * The comma character is treated as group separator and ignored during parsing. | |
| 2031 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()). | |
| 2032 * | |
| 2033 * @param str the string to convert | |
| 2034 * @param output a pointer to the integer variable where the result shall be stored | |
| 2035 * @param base 2, 8, 10, or 16 | |
| 2036 * @retval zero success | |
| 2037 * @retval non-zero conversion was not possible | |
| 2038 */ | |
| 2039 #define cx_strtou32(str, output, base) cx_strtou32_lc_(cx_strcast(str), output, base, ",") | |
| 2040 | |
| 2041 /** | |
| 2042 * Converts a string to a number. | |
| 2043 * | |
| 2044 * The function returns non-zero when conversion is not possible. | |
| 2045 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 2046 * It sets errno to ERANGE when the target datatype is too small. | |
| 2047 * | |
| 2048 * The comma character is treated as group separator and ignored during parsing. | |
| 2049 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()). | |
| 2050 * | |
| 2051 * @param str the string to convert | |
| 2052 * @param output a pointer to the integer variable where the result shall be stored | |
| 2053 * @param base 2, 8, 10, or 16 | |
| 2054 * @retval zero success | |
| 2055 * @retval non-zero conversion was not possible | |
| 2056 */ | |
| 2057 #define cx_strtou64(str, output, base) cx_strtou64_lc_(cx_strcast(str), output, base, ",") | |
| 2058 | |
| 2059 /** | |
| 2060 * Converts a string to a single precision floating point number. | |
| 2061 * | |
| 2062 * The function returns non-zero when conversion is not possible. | |
| 2063 * In that case the function sets errno to EINVAL when the reason is an invalid character. | |
| 2064 * It sets errno to ERANGE when the necessary representation would exceed the limits defined in libc's float.h. | |
| 2065 * | |
| 2066 * @param str the string to convert | |
| 2067 * @param output a pointer to the float variable where the result shall be stored | |
| 2068 * @param decsep the decimal separator | |
| 2069 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 2070 * @retval zero success | |
| 2071 * @retval non-zero conversion was not possible | |
| 2072 */ | |
| 2073 #define cx_strtof_lc(str, output, decsep, groupsep) cx_strtof_lc_(cx_strcast(str), output, decsep, groupsep) | |
| 2074 | |
| 2075 /** | |
| 2076 * Converts a string to a double precision floating point number. | |
| 2077 * | |
| 2078 * The function returns non-zero when conversion is not possible. | |
| 2079 * In that case the function sets errno to EINVAL when the reason is an invalid character. | |
| 2080 * | |
| 2081 * @param str the string to convert | |
| 2082 * @param output a pointer to the double variable where the result shall be stored | |
| 2083 * @param decsep the decimal separator | |
| 2084 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 2085 * @retval zero success | |
| 2086 * @retval non-zero conversion was not possible | |
| 2087 */ | |
| 2088 #define cx_strtod_lc(str, output, decsep, groupsep) cx_strtod_lc_(cx_strcast(str), output, decsep, groupsep) | |
| 1262 | 2089 |
| 1263 /** | 2090 /** |
| 1264 * Converts a string to a single precision floating point number. | 2091 * Converts a string to a single precision floating point number. |
| 1265 * | 2092 * |
| 1266 * The function returns non-zero when conversion is not possible. | 2093 * The function returns non-zero when conversion is not possible. |
| 1271 * The comma character is treated as group separator and ignored during parsing. | 2098 * The comma character is treated as group separator and ignored during parsing. |
| 1272 * If you want to choose a different format, use cx_strtof_lc(). | 2099 * If you want to choose a different format, use cx_strtof_lc(). |
| 1273 * | 2100 * |
| 1274 * @param str the string to convert | 2101 * @param str the string to convert |
| 1275 * @param output a pointer to the float variable where the result shall be stored | 2102 * @param output a pointer to the float variable where the result shall be stored |
| 1276 * @param decsep the decimal separator | 2103 * @retval zero success |
| 1277 * @param groupsep each character in this string is treated as group separator and ignored during conversion | 2104 * @retval non-zero conversion was not possible |
| 1278 * @retval zero success | 2105 */ |
| 1279 * @retval non-zero conversion was not possible | 2106 #define cx_strtof(str, output) cx_strtof_lc_(cx_strcast(str), output, '.', ",") |
| 1280 */ | |
| 1281 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1282 int cx_strtof_lc(cxstring str, float *output, char decsep, const char *groupsep); | |
| 1283 | 2107 |
| 1284 /** | 2108 /** |
| 1285 * Converts a string to a double precision floating point number. | 2109 * Converts a string to a double precision floating point number. |
| 1286 * | 2110 * |
| 1287 * The function returns non-zero when conversion is not possible. | 2111 * The function returns non-zero when conversion is not possible. |
| 1288 * In that case the function sets errno to EINVAL when the reason is an invalid character. | 2112 * In that case the function sets errno to EINVAL when the reason is an invalid character. |
| 1289 * It sets errno to ERANGE when the necessary representation would exceed the limits defined in libc's float.h. | |
| 1290 * | 2113 * |
| 1291 * The decimal separator is assumed to be a dot character. | 2114 * The decimal separator is assumed to be a dot character. |
| 1292 * The comma character is treated as group separator and ignored during parsing. | 2115 * The comma character is treated as group separator and ignored during parsing. |
| 1293 * If you want to choose a different format, use cx_strtof_lc(). | 2116 * If you want to choose a different format, use cx_strtof_lc(). |
| 1294 * | 2117 * |
| 1295 * @param str the string to convert | 2118 * @param str the string to convert |
| 1296 * @param output a pointer to the float variable where the result shall be stored | |
| 1297 * @param decsep the decimal separator | |
| 1298 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1299 * @retval zero success | |
| 1300 * @retval non-zero conversion was not possible | |
| 1301 */ | |
| 1302 cx_attr_access_w(2) cx_attr_nonnull_arg(2) | |
| 1303 int cx_strtod_lc(cxstring str, double *output, char decsep, const char *groupsep); | |
| 1304 | |
| 1305 #ifndef CX_STR_IMPLEMENTATION | |
| 1306 /** | |
| 1307 * @copydoc cx_strtouz_lc() | |
| 1308 */ | |
| 1309 #define cx_strtos_lc(str, output, base, groupsep) cx_strtos_lc(cx_strcast(str), output, base, groupsep) | |
| 1310 /** | |
| 1311 * @copydoc cx_strtouz_lc() | |
| 1312 */ | |
| 1313 #define cx_strtoi_lc(str, output, base, groupsep) cx_strtoi_lc(cx_strcast(str), output, base, groupsep) | |
| 1314 /** | |
| 1315 * @copydoc cx_strtouz_lc() | |
| 1316 */ | |
| 1317 #define cx_strtol_lc(str, output, base, groupsep) cx_strtol_lc(cx_strcast(str), output, base, groupsep) | |
| 1318 /** | |
| 1319 * @copydoc cx_strtouz_lc() | |
| 1320 */ | |
| 1321 #define cx_strtoll_lc(str, output, base, groupsep) cx_strtoll_lc(cx_strcast(str), output, base, groupsep) | |
| 1322 /** | |
| 1323 * @copydoc cx_strtouz_lc() | |
| 1324 */ | |
| 1325 #define cx_strtoi8_lc(str, output, base, groupsep) cx_strtoi8_lc(cx_strcast(str), output, base, groupsep) | |
| 1326 /** | |
| 1327 * @copydoc cx_strtouz_lc() | |
| 1328 */ | |
| 1329 #define cx_strtoi16_lc(str, output, base, groupsep) cx_strtoi16_lc(cx_strcast(str), output, base, groupsep) | |
| 1330 /** | |
| 1331 * @copydoc cx_strtouz_lc() | |
| 1332 */ | |
| 1333 #define cx_strtoi32_lc(str, output, base, groupsep) cx_strtoi32_lc(cx_strcast(str), output, base, groupsep) | |
| 1334 /** | |
| 1335 * @copydoc cx_strtouz_lc() | |
| 1336 */ | |
| 1337 #define cx_strtoi64_lc(str, output, base, groupsep) cx_strtoi64_lc(cx_strcast(str), output, base, groupsep) | |
| 1338 /** | |
| 1339 * @copydoc cx_strtouz_lc() | |
| 1340 */ | |
| 1341 #define cx_strtoz_lc(str, output, base, groupsep) cx_strtoz_lc(cx_strcast(str), output, base, groupsep) | |
| 1342 /** | |
| 1343 * @copydoc cx_strtouz_lc() | |
| 1344 */ | |
| 1345 #define cx_strtous_lc(str, output, base, groupsep) cx_strtous_lc(cx_strcast(str), output, base, groupsep) | |
| 1346 /** | |
| 1347 * @copydoc cx_strtouz_lc() | |
| 1348 */ | |
| 1349 #define cx_strtou_lc(str, output, base, groupsep) cx_strtou_lc(cx_strcast(str), output, base, groupsep) | |
| 1350 /** | |
| 1351 * @copydoc cx_strtouz_lc() | |
| 1352 */ | |
| 1353 #define cx_strtoul_lc(str, output, base, groupsep) cx_strtoul_lc(cx_strcast(str), output, base, groupsep) | |
| 1354 /** | |
| 1355 * @copydoc cx_strtouz_lc() | |
| 1356 */ | |
| 1357 #define cx_strtoull_lc(str, output, base, groupsep) cx_strtoull_lc(cx_strcast(str), output, base, groupsep) | |
| 1358 /** | |
| 1359 * @copydoc cx_strtouz_lc() | |
| 1360 */ | |
| 1361 #define cx_strtou8_lc(str, output, base, groupsep) cx_strtou8_lc(cx_strcast(str), output, base, groupsep) | |
| 1362 /** | |
| 1363 * @copydoc cx_strtouz_lc() | |
| 1364 */ | |
| 1365 #define cx_strtou16_lc(str, output, base, groupsep) cx_strtou16_lc(cx_strcast(str), output, base, groupsep) | |
| 1366 /** | |
| 1367 * @copydoc cx_strtouz_lc() | |
| 1368 */ | |
| 1369 #define cx_strtou32_lc(str, output, base, groupsep) cx_strtou32_lc(cx_strcast(str), output, base, groupsep) | |
| 1370 /** | |
| 1371 * @copydoc cx_strtouz_lc() | |
| 1372 */ | |
| 1373 #define cx_strtou64_lc(str, output, base, groupsep) cx_strtou64_lc(cx_strcast(str), output, base, groupsep) | |
| 1374 /** | |
| 1375 * Converts a string to a number. | |
| 1376 * | |
| 1377 * The function returns non-zero when conversion is not possible. | |
| 1378 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1379 * It sets errno to ERANGE when the target datatype is too small. | |
| 1380 * | |
| 1381 * @param str the string to convert | |
| 1382 * @param output a pointer to the integer variable where the result shall be stored | |
| 1383 * @param base 2, 8, 10, or 16 | |
| 1384 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1385 * @retval zero success | |
| 1386 * @retval non-zero conversion was not possible | |
| 1387 */ | |
| 1388 #define cx_strtouz_lc(str, output, base, groupsep) cx_strtouz_lc(cx_strcast(str), output, base, groupsep) | |
| 1389 | |
| 1390 /** | |
| 1391 * @copydoc cx_strtouz() | |
| 1392 */ | |
| 1393 #define cx_strtos(str, output, base) cx_strtos_lc(str, output, base, ",") | |
| 1394 /** | |
| 1395 * @copydoc cx_strtouz() | |
| 1396 */ | |
| 1397 #define cx_strtoi(str, output, base) cx_strtoi_lc(str, output, base, ",") | |
| 1398 /** | |
| 1399 * @copydoc cx_strtouz() | |
| 1400 */ | |
| 1401 #define cx_strtol(str, output, base) cx_strtol_lc(str, output, base, ",") | |
| 1402 /** | |
| 1403 * @copydoc cx_strtouz() | |
| 1404 */ | |
| 1405 #define cx_strtoll(str, output, base) cx_strtoll_lc(str, output, base, ",") | |
| 1406 /** | |
| 1407 * @copydoc cx_strtouz() | |
| 1408 */ | |
| 1409 #define cx_strtoi8(str, output, base) cx_strtoi8_lc(str, output, base, ",") | |
| 1410 /** | |
| 1411 * @copydoc cx_strtouz() | |
| 1412 */ | |
| 1413 #define cx_strtoi16(str, output, base) cx_strtoi16_lc(str, output, base, ",") | |
| 1414 /** | |
| 1415 * @copydoc cx_strtouz() | |
| 1416 */ | |
| 1417 #define cx_strtoi32(str, output, base) cx_strtoi32_lc(str, output, base, ",") | |
| 1418 /** | |
| 1419 * @copydoc cx_strtouz() | |
| 1420 */ | |
| 1421 #define cx_strtoi64(str, output, base) cx_strtoi64_lc(str, output, base, ",") | |
| 1422 /** | |
| 1423 * @copydoc cx_strtouz() | |
| 1424 */ | |
| 1425 #define cx_strtoz(str, output, base) cx_strtoz_lc(str, output, base, ",") | |
| 1426 /** | |
| 1427 * @copydoc cx_strtouz() | |
| 1428 */ | |
| 1429 #define cx_strtous(str, output, base) cx_strtous_lc(str, output, base, ",") | |
| 1430 /** | |
| 1431 * @copydoc cx_strtouz() | |
| 1432 */ | |
| 1433 #define cx_strtou(str, output, base) cx_strtou_lc(str, output, base, ",") | |
| 1434 /** | |
| 1435 * @copydoc cx_strtouz() | |
| 1436 */ | |
| 1437 #define cx_strtoul(str, output, base) cx_strtoul_lc(str, output, base, ",") | |
| 1438 /** | |
| 1439 * @copydoc cx_strtouz() | |
| 1440 */ | |
| 1441 #define cx_strtoull(str, output, base) cx_strtoull_lc(str, output, base, ",") | |
| 1442 /** | |
| 1443 * @copydoc cx_strtouz() | |
| 1444 */ | |
| 1445 #define cx_strtou8(str, output, base) cx_strtou8_lc(str, output, base, ",") | |
| 1446 /** | |
| 1447 * @copydoc cx_strtouz() | |
| 1448 */ | |
| 1449 #define cx_strtou16(str, output, base) cx_strtou16_lc(str, output, base, ",") | |
| 1450 /** | |
| 1451 * @copydoc cx_strtouz() | |
| 1452 */ | |
| 1453 #define cx_strtou32(str, output, base) cx_strtou32_lc(str, output, base, ",") | |
| 1454 /** | |
| 1455 * @copydoc cx_strtouz() | |
| 1456 */ | |
| 1457 #define cx_strtou64(str, output, base) cx_strtou64_lc(str, output, base, ",") | |
| 1458 /** | |
| 1459 * Converts a string to a number. | |
| 1460 * | |
| 1461 * The function returns non-zero when conversion is not possible. | |
| 1462 * In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base. | |
| 1463 * It sets errno to ERANGE when the target datatype is too small. | |
| 1464 * | |
| 1465 * The comma character is treated as group separator and ignored during parsing. | |
| 1466 * If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtouz_lc()). | |
| 1467 * | |
| 1468 * @param str the string to convert | |
| 1469 * @param output a pointer to the integer variable where the result shall be stored | |
| 1470 * @param base 2, 8, 10, or 16 | |
| 1471 * @retval zero success | |
| 1472 * @retval non-zero conversion was not possible | |
| 1473 */ | |
| 1474 #define cx_strtouz(str, output, base) cx_strtouz_lc(str, output, base, ",") | |
| 1475 | |
| 1476 /** | |
| 1477 * Converts a string to a single precision floating point number. | |
| 1478 * | |
| 1479 * The function returns non-zero when conversion is not possible. | |
| 1480 * In that case the function sets errno to EINVAL when the reason is an invalid character. | |
| 1481 * It sets errno to ERANGE when the necessary representation would exceed the limits defined in libc's float.h. | |
| 1482 * | |
| 1483 * The decimal separator is assumed to be a dot character. | |
| 1484 * The comma character is treated as group separator and ignored during parsing. | |
| 1485 * If you want to choose a different format, use cx_strtof_lc(). | |
| 1486 * | |
| 1487 * @param str the string to convert | |
| 1488 * @param output a pointer to the float variable where the result shall be stored | |
| 1489 * @param decsep the decimal separator | |
| 1490 * @param groupsep each character in this string is treated as group separator and ignored during conversion | |
| 1491 * @retval zero success | |
| 1492 * @retval non-zero conversion was not possible | |
| 1493 */ | |
| 1494 #define cx_strtof_lc(str, output, decsep, groupsep) cx_strtof_lc(cx_strcast(str), output, decsep, groupsep) | |
| 1495 /** | |
| 1496 * Converts a string to a double precision floating point number. | |
| 1497 * | |
| 1498 * The function returns non-zero when conversion is not possible. | |
| 1499 * In that case the function sets errno to EINVAL when the reason is an invalid character. | |
| 1500 * | |
| 1501 * The decimal separator is assumed to be a dot character. | |
| 1502 * The comma character is treated as group separator and ignored during parsing. | |
| 1503 * If you want to choose a different format, use cx_strtof_lc(). | |
| 1504 * | |
| 1505 * @param str the string to convert | |
| 1506 * @param output a pointer to the double variable where the result shall be stored | 2119 * @param output a pointer to the double variable where the result shall be stored |
| 1507 * @param decsep the decimal separator | 2120 * @retval zero success |
| 1508 * @param groupsep each character in this string is treated as group separator and ignored during conversion | 2121 * @retval non-zero conversion was not possible |
| 1509 * @retval zero success | 2122 */ |
| 1510 * @retval non-zero conversion was not possible | 2123 #define cx_strtod(str, output) cx_strtod_lc_(cx_strcast(str), output, '.', ",") |
| 1511 */ | |
| 1512 #define cx_strtod_lc(str, output, decsep, groupsep) cx_strtod_lc(cx_strcast(str), output, decsep, groupsep) | |
| 1513 | |
| 1514 /** | |
| 1515 * Converts a string to a single precision floating point number. | |
| 1516 * | |
| 1517 * The function returns non-zero when conversion is not possible. | |
| 1518 * In that case the function sets errno to EINVAL when the reason is an invalid character. | |
| 1519 * It sets errno to ERANGE when the necessary representation would exceed the limits defined in libc's float.h. | |
| 1520 * | |
| 1521 * The decimal separator is assumed to be a dot character. | |
| 1522 * The comma character is treated as group separator and ignored during parsing. | |
| 1523 * If you want to choose a different format, use cx_strtof_lc(). | |
| 1524 * | |
| 1525 * @param str the string to convert | |
| 1526 * @param output a pointer to the float variable where the result shall be stored | |
| 1527 * @retval zero success | |
| 1528 * @retval non-zero conversion was not possible | |
| 1529 */ | |
| 1530 #define cx_strtof(str, output) cx_strtof_lc(str, output, '.', ",") | |
| 1531 /** | |
| 1532 * Converts a string to a double precision floating point number. | |
| 1533 * | |
| 1534 * The function returns non-zero when conversion is not possible. | |
| 1535 * In that case the function sets errno to EINVAL when the reason is an invalid character. | |
| 1536 * | |
| 1537 * The decimal separator is assumed to be a dot character. | |
| 1538 * The comma character is treated as group separator and ignored during parsing. | |
| 1539 * If you want to choose a different format, use cx_strtof_lc(). | |
| 1540 * | |
| 1541 * @param str the string to convert | |
| 1542 * @param output a pointer to the double variable where the result shall be stored | |
| 1543 * @retval zero success | |
| 1544 * @retval non-zero conversion was not possible | |
| 1545 */ | |
| 1546 #define cx_strtod(str, output) cx_strtod_lc(str, output, '.', ",") | |
| 1547 | |
| 1548 #endif | |
| 1549 | 2124 |
| 1550 #ifdef __cplusplus | 2125 #ifdef __cplusplus |
| 1551 } // extern "C" | 2126 } // extern "C" |
| 1552 #endif | 2127 #endif |
| 1553 | 2128 |
