1 /************************************************************************* 2 * 3 * $Id$ 4 * 5 * Copyright (C) 2001 Bjorn Reese and Daniel Stenberg. 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED 12 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF 13 * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND 14 * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER. 15 * 16 ************************************************************************/ 17 18 /************************************************************************* 19 * Include files 20 */ 21 22 #include <assert.h> 23 #include <stdlib.h> 24 #include <string.h> 25 #include <ctype.h> 26 #include <math.h> 27 #include "triodef.h" 28 #include "triostr.h" 29 30 /************************************************************************* 31 * Definitions 32 */ 33 34 #if !defined(TRIO_STRING_PUBLIC) 35 # define TRIO_STRING_PUBLIC TRIO_PUBLIC 36 #endif 37 #if !defined(TRIO_STRING_PRIVATE) 38 # define TRIO_STRING_PRIVATE TRIO_PRIVATE 39 #endif 40 41 #if !defined(NULL) 42 # define NULL 0 43 #endif 44 #if !defined(NIL) 45 # define NIL ((char)0) 46 #endif 47 #if !defined(FALSE) 48 # define FALSE (1 == 0) 49 # define TRUE (! FALSE) 50 #endif 51 #if !defined(BOOLEAN_T) 52 # define BOOLEAN_T int 53 #endif 54 55 #if defined(TRIO_COMPILER_SUPPORTS_C99) 56 # define USE_STRTOD 57 # define USE_STRTOF 58 #elif defined(TRIO_COMPILER_MSVC) 59 # define USE_STRTOD 60 #endif 61 62 #if defined(TRIO_PLATFORM_UNIX) 63 # define USE_STRCASECMP 64 # define USE_STRNCASECMP 65 # if defined(TRIO_PLATFORM_SUNOS) 66 # define USE_SYS_ERRLIST 67 # else 68 # define USE_STRERROR 69 # endif 70 # if defined(TRIO_PLATFORM_QNX) 71 # define strcasecmp(x,y) stricmp(x,y) 72 # define strncasecmp(x,y,n) strnicmp(x,y,n) 73 # endif 74 #elif defined(TRIO_PLATFORM_WIN32) 75 # define USE_STRCASECMP 76 # if defined(_WIN32_WCE) 77 # define strcasecmp(x,y) _stricmp(x,y) 78 # else 79 # define strcasecmp(x,y) strcmpi(x,y) 80 # endif 81 #endif 82 83 #if !(defined(TRIO_PLATFORM_SUNOS)) 84 # define USE_TOLOWER 85 # define USE_TOUPPER 86 #endif 87 88 /************************************************************************* 89 * Structures 90 */ 91 92 struct _trio_string_t 93 { 94 char *content; 95 size_t length; 96 size_t allocated; 97 }; 98 99 /************************************************************************* 100 * Constants 101 */ 102 103 #if !defined(TRIO_MINIMAL) 104 static TRIO_CONST char rcsid[] = "@(#)$Id$"; 105 #endif 106 107 /************************************************************************* 108 * Static String Functions 109 */ 110 111 #if defined(TRIO_DOCUMENTATION) 112 # include "doc/doc_static.h" 113 #endif 114 /** @addtogroup StaticStrings 115 @{ 116 */ 117 118 /** 119 Create new string. 120 121 @param size Size of new string. 122 @return Pointer to string, or NULL if allocation failed. 123 */ 124 TRIO_STRING_PUBLIC char * 125 trio_create 126 TRIO_ARGS1((size), 127 size_t size) 128 { 129 return (char *)TRIO_MALLOC(size); 130 } 131 132 133 /** 134 Destroy string. 135 136 @param string String to be freed. 137 */ 138 TRIO_STRING_PUBLIC void 139 trio_destroy 140 TRIO_ARGS1((string), 141 char *string) 142 { 143 if (string) 144 { 145 TRIO_FREE(string); 146 } 147 } 148 149 150 /** 151 Count the number of characters in a string. 152 153 @param string String to measure. 154 @return Number of characters in @string. 155 */ 156 TRIO_STRING_PUBLIC size_t 157 trio_length 158 TRIO_ARGS1((string), 159 TRIO_CONST char *string) 160 { 161 return strlen(string); 162 } 163 164 165 #if !defined(TRIO_MINIMAL) 166 /** 167 Append @p source at the end of @p target. 168 169 @param target Target string. 170 @param source Source string. 171 @return Boolean value indicating success or failure. 172 173 @pre @p target must point to a memory chunk with sufficient room to 174 contain the @p target string and @p source string. 175 @pre No boundary checking is performed, so insufficient memory will 176 result in a buffer overrun. 177 @post @p target will be zero terminated. 178 */ 179 TRIO_STRING_PUBLIC int 180 trio_append 181 TRIO_ARGS2((target, source), 182 char *target, 183 TRIO_CONST char *source) 184 { 185 assert(target); 186 assert(source); 187 188 return (strcat(target, source) != NULL); 189 } 190 #endif /* !defined(TRIO_MINIMAL) */ 191 192 #if !defined(TRIO_MINIMAL) 193 /** 194 Append at most @p max characters from @p source to @p target. 195 196 @param target Target string. 197 @param max Maximum number of characters to append. 198 @param source Source string. 199 @return Boolean value indicating success or failure. 200 201 @pre @p target must point to a memory chuck with sufficient room to 202 contain the @p target string and the @p source string (at most @p max 203 characters). 204 @pre No boundary checking is performed, so insufficient memory will 205 result in a buffer overrun. 206 @post @p target will be zero terminated. 207 */ 208 TRIO_STRING_PUBLIC int 209 trio_append_max 210 TRIO_ARGS3((target, max, source), 211 char *target, 212 size_t max, 213 TRIO_CONST char *source) 214 { 215 size_t length; 216 217 assert(target); 218 assert(source); 219 220 length = trio_length(target); 221 222 if (max > length) 223 { 224 strncat(target, source, max - length - 1); 225 } 226 return TRUE; 227 } 228 #endif /* !defined(TRIO_MINIMAL) */ 229 230 231 #if !defined(TRIO_MINIMAL) 232 /** 233 Determine if a string contains a substring. 234 235 @param string String to be searched. 236 @param substring String to be found. 237 @return Boolean value indicating success or failure. 238 */ 239 TRIO_STRING_PUBLIC int 240 trio_contains 241 TRIO_ARGS2((string, substring), 242 TRIO_CONST char *string, 243 TRIO_CONST char *substring) 244 { 245 assert(string); 246 assert(substring); 247 248 return (0 != strstr(string, substring)); 249 } 250 #endif /* !defined(TRIO_MINIMAL) */ 251 252 253 #if !defined(TRIO_MINIMAL) 254 /** 255 Copy @p source to @p target. 256 257 @param target Target string. 258 @param source Source string. 259 @return Boolean value indicating success or failure. 260 261 @pre @p target must point to a memory chunk with sufficient room to 262 contain the @p source string. 263 @pre No boundary checking is performed, so insufficient memory will 264 result in a buffer overrun. 265 @post @p target will be zero terminated. 266 */ 267 TRIO_STRING_PUBLIC int 268 trio_copy 269 TRIO_ARGS2((target, source), 270 char *target, 271 TRIO_CONST char *source) 272 { 273 assert(target); 274 assert(source); 275 276 (void)strcpy(target, source); 277 return TRUE; 278 } 279 #endif /* !defined(TRIO_MINIMAL) */ 280 281 282 /** 283 Copy at most @p max characters from @p source to @p target. 284 285 @param target Target string. 286 @param max Maximum number of characters to append. 287 @param source Source string. 288 @return Boolean value indicating success or failure. 289 290 @pre @p target must point to a memory chunk with sufficient room to 291 contain the @p source string (at most @p max characters). 292 @pre No boundary checking is performed, so insufficient memory will 293 result in a buffer overrun. 294 @post @p target will be zero terminated. 295 */ 296 TRIO_STRING_PUBLIC int 297 trio_copy_max 298 TRIO_ARGS3((target, max, source), 299 char *target, 300 size_t max, 301 TRIO_CONST char *source) 302 { 303 assert(target); 304 assert(source); 305 assert(max > 0); /* Includes != 0 */ 306 307 (void)strncpy(target, source, max - 1); 308 target[max - 1] = (char)0; 309 return TRUE; 310 } 311 312 313 /* 314 * TrioDuplicateMax 315 */ 316 TRIO_STRING_PRIVATE char * 317 TrioDuplicateMax 318 TRIO_ARGS2((source, size), 319 TRIO_CONST char *source, 320 size_t size) 321 { 322 char *target; 323 324 assert(source); 325 326 /* Make room for string plus a terminating zero */ 327 size++; 328 target = trio_create(size); 329 if (target) 330 { 331 trio_copy_max(target, size, source); 332 } 333 return target; 334 } 335 336 337 /** 338 Duplicate @p source. 339 340 @param source Source string. 341 @return A copy of the @p source string. 342 343 @post @p target will be zero terminated. 344 */ 345 TRIO_STRING_PUBLIC char * 346 trio_duplicate 347 TRIO_ARGS1((source), 348 TRIO_CONST char *source) 349 { 350 return TrioDuplicateMax(source, trio_length(source)); 351 } 352 353 354 #if !defined(TRIO_MINIMAL) 355 /** 356 Duplicate at most @p max characters of @p source. 357 358 @param source Source string. 359 @param max Maximum number of characters to duplicate. 360 @return A copy of the @p source string. 361 362 @post @p target will be zero terminated. 363 */ 364 TRIO_STRING_PUBLIC char * 365 trio_duplicate_max TRIO_ARGS2((source, max), 366 TRIO_CONST char *source, 367 size_t max) 368 { 369 size_t length; 370 371 assert(source); 372 assert(max > 0); 373 374 length = trio_length(source); 375 if (length > max) 376 { 377 length = max; 378 } 379 return TrioDuplicateMax(source, length); 380 } 381 #endif /* !defined(TRIO_MINIMAL) */ 382 383 384 /** 385 Compare if two strings are equal. 386 387 @param first First string. 388 @param second Second string. 389 @return Boolean indicating whether the two strings are equal or not. 390 391 Case-insensitive comparison. 392 */ 393 TRIO_STRING_PUBLIC int 394 trio_equal 395 TRIO_ARGS2((first, second), 396 TRIO_CONST char *first, 397 TRIO_CONST char *second) 398 { 399 assert(first); 400 assert(second); 401 402 if ((first != NULL) && (second != NULL)) 403 { 404 #if defined(USE_STRCASECMP) 405 return (0 == strcasecmp(first, second)); 406 #else 407 while ((*first != NIL) && (*second != NIL)) 408 { 409 if (trio_to_upper(*first) != trio_to_upper(*second)) 410 { 411 break; 412 } 413 first++; 414 second++; 415 } 416 return ((*first == NIL) && (*second == NIL)); 417 #endif 418 } 419 return FALSE; 420 } 421 422 423 /** 424 Compare if two strings are equal. 425 426 @param first First string. 427 @param second Second string. 428 @return Boolean indicating whether the two strings are equal or not. 429 430 Case-sensitive comparison. 431 */ 432 TRIO_STRING_PUBLIC int 433 trio_equal_case 434 TRIO_ARGS2((first, second), 435 TRIO_CONST char *first, 436 TRIO_CONST char *second) 437 { 438 assert(first); 439 assert(second); 440 441 if ((first != NULL) && (second != NULL)) 442 { 443 return (0 == strcmp(first, second)); 444 } 445 return FALSE; 446 } 447 448 449 #if !defined(TRIO_MINIMAL) 450 /** 451 Compare if two strings up until the first @p max characters are equal. 452 453 @param first First string. 454 @param max Maximum number of characters to compare. 455 @param second Second string. 456 @return Boolean indicating whether the two strings are equal or not. 457 458 Case-sensitive comparison. 459 */ 460 TRIO_STRING_PUBLIC int 461 trio_equal_case_max 462 TRIO_ARGS3((first, max, second), 463 TRIO_CONST char *first, 464 size_t max, 465 TRIO_CONST char *second) 466 { 467 assert(first); 468 assert(second); 469 470 if ((first != NULL) && (second != NULL)) 471 { 472 return (0 == strncmp(first, second, max)); 473 } 474 return FALSE; 475 } 476 #endif /* !defined(TRIO_MINIMAL) */ 477 478 479 /** 480 Compare if two strings are equal. 481 482 @param first First string. 483 @param second Second string. 484 @return Boolean indicating whether the two strings are equal or not. 485 486 Collating characters are considered equal. 487 */ 488 TRIO_STRING_PUBLIC int 489 trio_equal_locale 490 TRIO_ARGS2((first, second), 491 TRIO_CONST char *first, 492 TRIO_CONST char *second) 493 { 494 assert(first); 495 assert(second); 496 497 #if defined(LC_COLLATE) 498 return (strcoll(first, second) == 0); 499 #else 500 return trio_equal(first, second); 501 #endif 502 } 503 504 505 /** 506 Compare if two strings up until the first @p max characters are equal. 507 508 @param first First string. 509 @param max Maximum number of characters to compare. 510 @param second Second string. 511 @return Boolean indicating whether the two strings are equal or not. 512 513 Case-insensitive comparison. 514 */ 515 TRIO_STRING_PUBLIC int 516 trio_equal_max 517 TRIO_ARGS3((first, max, second), 518 TRIO_CONST char *first, 519 size_t max, 520 TRIO_CONST char *second) 521 { 522 assert(first); 523 assert(second); 524 525 if ((first != NULL) && (second != NULL)) 526 { 527 #if defined(USE_STRNCASECMP) 528 return (0 == strncasecmp(first, second, max)); 529 #else 530 /* Not adequately tested yet */ 531 size_t cnt = 0; 532 while ((*first != NIL) && (*second != NIL) && (cnt <= max)) 533 { 534 if (trio_to_upper(*first) != trio_to_upper(*second)) 535 { 536 break; 537 } 538 first++; 539 second++; 540 cnt++; 541 } 542 return ((cnt == max) || ((*first == NIL) && (*second == NIL))); 543 #endif 544 } 545 return FALSE; 546 } 547 548 549 /** 550 Provide a textual description of an error code (errno). 551 552 @param error_number Error number. 553 @return Textual description of @p error_number. 554 */ 555 TRIO_STRING_PUBLIC TRIO_CONST char * 556 trio_error 557 TRIO_ARGS1((error_number), 558 int error_number) 559 { 560 #if defined(USE_STRERROR) 561 562 return strerror(error_number); 563 564 #elif defined(USE_SYS_ERRLIST) 565 566 extern char *sys_errlist[]; 567 extern int sys_nerr; 568 569 return ((error_number < 0) || (error_number >= sys_nerr)) 570 ? "unknown" 571 : sys_errlist[error_number]; 572 573 #else 574 575 return "unknown"; 576 577 #endif 578 } 579 580 581 #if !defined(TRIO_MINIMAL) && !defined(_WIN32_WCE) 582 /** 583 Format the date/time according to @p format. 584 585 @param target Target string. 586 @param max Maximum number of characters to format. 587 @param format Formatting string. 588 @param datetime Date/time structure. 589 @return Number of formatted characters. 590 591 The formatting string accepts the same specifiers as the standard C 592 function strftime. 593 */ 594 TRIO_STRING_PUBLIC size_t 595 trio_format_date_max 596 TRIO_ARGS4((target, max, format, datetime), 597 char *target, 598 size_t max, 599 TRIO_CONST char *format, 600 TRIO_CONST struct tm *datetime) 601 { 602 assert(target); 603 assert(format); 604 assert(datetime); 605 assert(max > 0); 606 607 return strftime(target, max, format, datetime); 608 } 609 #endif /* !defined(TRIO_MINIMAL) */ 610 611 612 #if !defined(TRIO_MINIMAL) 613 /** 614 Calculate a hash value for a string. 615 616 @param string String to be calculated on. 617 @param type Hash function. 618 @return Calculated hash value. 619 620 @p type can be one of the following 621 @li @c TRIO_HASH_PLAIN Plain hash function. 622 */ 623 TRIO_STRING_PUBLIC unsigned long 624 trio_hash 625 TRIO_ARGS2((string, type), 626 TRIO_CONST char *string, 627 int type) 628 { 629 unsigned long value = 0L; 630 char ch; 631 632 assert(string); 633 634 switch (type) 635 { 636 case TRIO_HASH_PLAIN: 637 while ( (ch = *string++) != NIL ) 638 { 639 value *= 31; 640 value += (unsigned long)ch; 641 } 642 break; 643 default: 644 assert(FALSE); 645 break; 646 } 647 return value; 648 } 649 #endif /* !defined(TRIO_MINIMAL) */ 650 651 652 #if !defined(TRIO_MINIMAL) 653 /** 654 Find first occurrence of a character in a string. 655 656 @param string String to be searched. 657 @param character Character to be found. 658 @param A pointer to the found character, or NULL if character was not found. 659 */ 660 TRIO_STRING_PUBLIC char * 661 trio_index 662 TRIO_ARGS2((string, character), 663 TRIO_CONST char *string, 664 int character) 665 { 666 assert(string); 667 668 return strchr(string, character); 669 } 670 #endif /* !defined(TRIO_MINIMAL) */ 671 672 673 #if !defined(TRIO_MINIMAL) 674 /** 675 Find last occurrence of a character in a string. 676 677 @param string String to be searched. 678 @param character Character to be found. 679 @param A pointer to the found character, or NULL if character was not found. 680 */ 681 TRIO_STRING_PUBLIC char * 682 trio_index_last 683 TRIO_ARGS2((string, character), 684 TRIO_CONST char *string, 685 int character) 686 { 687 assert(string); 688 689 return strchr(string, character); 690 } 691 #endif /* !defined(TRIO_MINIMAL) */ 692 693 694 #if !defined(TRIO_MINIMAL) 695 /** 696 Convert the alphabetic letters in the string to lower-case. 697 698 @param target String to be converted. 699 @return Number of processed characters (converted or not). 700 */ 701 TRIO_STRING_PUBLIC int 702 trio_lower 703 TRIO_ARGS1((target), 704 char *target) 705 { 706 assert(target); 707 708 return trio_span_function(target, target, trio_to_lower); 709 } 710 #endif /* !defined(TRIO_MINIMAL) */ 711 712 713 #if !defined(TRIO_MINIMAL) 714 /** 715 Compare two strings using wildcards. 716 717 @param string String to be searched. 718 @param pattern Pattern, including wildcards, to search for. 719 @return Boolean value indicating success or failure. 720 721 Case-insensitive comparison. 722 723 The following wildcards can be used 724 @li @c * Match any number of characters. 725 @li @c ? Match a single character. 726 */ 727 TRIO_STRING_PUBLIC int 728 trio_match 729 TRIO_ARGS2((string, pattern), 730 TRIO_CONST char *string, 731 TRIO_CONST char *pattern) 732 { 733 assert(string); 734 assert(pattern); 735 736 for (; ('*' != *pattern); ++pattern, ++string) 737 { 738 if (NIL == *string) 739 { 740 return (NIL == *pattern); 741 } 742 if ((trio_to_upper((int)*string) != trio_to_upper((int)*pattern)) 743 && ('?' != *pattern)) 744 { 745 return FALSE; 746 } 747 } 748 /* two-line patch to prevent *too* much recursiveness: */ 749 while ('*' == pattern[1]) 750 pattern++; 751 752 do 753 { 754 if ( trio_match(string, &pattern[1]) ) 755 { 756 return TRUE; 757 } 758 } 759 while (*string++); 760 761 return FALSE; 762 } 763 #endif /* !defined(TRIO_MINIMAL) */ 764 765 766 #if !defined(TRIO_MINIMAL) 767 /** 768 Compare two strings using wildcards. 769 770 @param string String to be searched. 771 @param pattern Pattern, including wildcards, to search for. 772 @return Boolean value indicating success or failure. 773 774 Case-sensitive comparison. 775 776 The following wildcards can be used 777 @li @c * Match any number of characters. 778 @li @c ? Match a single character. 779 */ 780 TRIO_STRING_PUBLIC int 781 trio_match_case 782 TRIO_ARGS2((string, pattern), 783 TRIO_CONST char *string, 784 TRIO_CONST char *pattern) 785 { 786 assert(string); 787 assert(pattern); 788 789 for (; ('*' != *pattern); ++pattern, ++string) 790 { 791 if (NIL == *string) 792 { 793 return (NIL == *pattern); 794 } 795 if ((*string != *pattern) 796 && ('?' != *pattern)) 797 { 798 return FALSE; 799 } 800 } 801 /* two-line patch to prevent *too* much recursiveness: */ 802 while ('*' == pattern[1]) 803 pattern++; 804 805 do 806 { 807 if ( trio_match_case(string, &pattern[1]) ) 808 { 809 return TRUE; 810 } 811 } 812 while (*string++); 813 814 return FALSE; 815 } 816 #endif /* !defined(TRIO_MINIMAL) */ 817 818 819 #if !defined(TRIO_MINIMAL) 820 /** 821 Execute a function on each character in string. 822 823 @param target Target string. 824 @param source Source string. 825 @param Function Function to be executed. 826 @return Number of processed characters. 827 */ 828 TRIO_STRING_PUBLIC size_t 829 trio_span_function 830 TRIO_ARGS3((target, source, Function), 831 char *target, 832 TRIO_CONST char *source, 833 int (*Function) TRIO_PROTO((int))) 834 { 835 size_t count = 0; 836 837 assert(target); 838 assert(source); 839 assert(Function); 840 841 while (*source != NIL) 842 { 843 *target++ = Function(*source++); 844 count++; 845 } 846 return count; 847 } 848 #endif /* !defined(TRIO_MINIMAL) */ 849 850 851 #if !defined(TRIO_MINIMAL) 852 /** 853 Search for a substring in a string. 854 855 @param string String to be searched. 856 @param substring String to be found. 857 @return Pointer to first occurrence of @p substring in @p string, or NULL 858 if no match was found. 859 */ 860 TRIO_STRING_PUBLIC char * 861 trio_substring 862 TRIO_ARGS2((string, substring), 863 TRIO_CONST char *string, 864 TRIO_CONST char *substring) 865 { 866 assert(string); 867 assert(substring); 868 869 return strstr(string, substring); 870 } 871 #endif /* !defined(TRIO_MINIMAL) */ 872 873 874 #if !defined(TRIO_MINIMAL) 875 /** 876 Search for a substring in the first @p max characters of a string. 877 878 @param string String to be searched. 879 @param max Maximum characters to be searched. 880 @param substring String to be found. 881 @return Pointer to first occurrence of @p substring in @p string, or NULL 882 if no match was found. 883 */ 884 TRIO_STRING_PUBLIC char * 885 trio_substring_max 886 TRIO_ARGS3((string, max, substring), 887 TRIO_CONST char *string, 888 size_t max, 889 TRIO_CONST char *substring) 890 { 891 size_t count; 892 size_t size; 893 char *result = NULL; 894 895 assert(string); 896 assert(substring); 897 898 size = trio_length(substring); 899 if (size <= max) 900 { 901 for (count = 0; count <= max - size; count++) 902 { 903 if (trio_equal_max(substring, size, &string[count])) 904 { 905 result = (char *)&string[count]; 906 break; 907 } 908 } 909 } 910 return result; 911 } 912 #endif /* !defined(TRIO_MINIMAL) */ 913 914 915 #if !defined(TRIO_MINIMAL) 916 /** 917 Tokenize string. 918 919 @param string String to be tokenized. 920 @param tokens String containing list of delimiting characters. 921 @return Start of new token. 922 923 @warning @p string will be destroyed. 924 */ 925 TRIO_STRING_PUBLIC char * 926 trio_tokenize 927 TRIO_ARGS2((string, delimiters), 928 char *string, 929 TRIO_CONST char *delimiters) 930 { 931 assert(delimiters); 932 933 return strtok(string, delimiters); 934 } 935 #endif /* !defined(TRIO_MINIMAL) */ 936 937 938 /** 939 Convert string to floating-point number. 940 941 @param source String to be converted. 942 @param endp Pointer to end of the converted string. 943 @return A floating-point number. 944 945 The following Extended Backus-Naur form is used 946 @verbatim 947 double ::= [ <sign> ] 948 ( <number> | 949 <number> <decimal_point> <number> | 950 <decimal_point> <number> ) 951 [ <exponential> [ <sign> ] <number> ] 952 number ::= 1*( <digit> ) 953 digit ::= ( '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' ) 954 exponential ::= ( 'e' | 'E' ) 955 sign ::= ( '-' | '+' ) 956 decimal_point ::= '.' 957 @endverbatim 958 */ 959 /* FIXME: Add EBNF for hex-floats */ 960 TRIO_STRING_PUBLIC trio_long_double_t 961 trio_to_long_double 962 TRIO_ARGS2((source, endp), 963 TRIO_CONST char *source, 964 char **endp) 965 { 966 #if defined(USE_STRTOLD) 967 return strtold(source, endp); 968 #else 969 int isNegative = FALSE; 970 int isExponentNegative = FALSE; 971 trio_long_double_t integer = 0.0; 972 trio_long_double_t fraction = 0.0; 973 unsigned long exponent = 0; 974 trio_long_double_t base; 975 trio_long_double_t fracdiv = 1.0; 976 trio_long_double_t value = 0.0; 977 978 /* First try hex-floats */ 979 if ((source[0] == '0') && ((source[1] == 'x') || (source[1] == 'X'))) 980 { 981 base = 16.0; 982 source += 2; 983 while (isxdigit((int)*source)) 984 { 985 integer *= base; 986 integer += (isdigit((int)*source) 987 ? (*source - '0') 988 : 10 + (trio_to_upper((int)*source) - 'A')); 989 source++; 990 } 991 if (*source == '.') 992 { 993 source++; 994 while (isxdigit((int)*source)) 995 { 996 fracdiv /= base; 997 fraction += fracdiv * (isdigit((int)*source) 998 ? (*source - '0') 999 : 10 + (trio_to_upper((int)*source) - 'A')); 1000 source++; 1001 } 1002 if ((*source == 'p') || (*source == 'P')) 1003 { 1004 source++; 1005 if ((*source == '+') || (*source == '-')) 1006 { 1007 isExponentNegative = (*source == '-'); 1008 source++; 1009 } 1010 while (isdigit((int)*source)) 1011 { 1012 exponent *= 10; 1013 exponent += (*source - '0'); 1014 source++; 1015 } 1016 } 1017 } 1018 /* For later use with exponent */ 1019 base = 2.0; 1020 } 1021 else /* Then try normal decimal floats */ 1022 { 1023 base = 10.0; 1024 isNegative = (*source == '-'); 1025 /* Skip sign */ 1026 if ((*source == '+') || (*source == '-')) 1027 source++; 1028 1029 /* Integer part */ 1030 while (isdigit((int)*source)) 1031 { 1032 integer *= base; 1033 integer += (*source - '0'); 1034 source++; 1035 } 1036 1037 if (*source == '.') 1038 { 1039 source++; /* skip decimal point */ 1040 while (isdigit((int)*source)) 1041 { 1042 fracdiv /= base; 1043 fraction += (*source - '0') * fracdiv; 1044 source++; 1045 } 1046 } 1047 if ((*source == 'e') 1048 || (*source == 'E') 1049 #if TRIO_MICROSOFT 1050 || (*source == 'd') 1051 || (*source == 'D') 1052 #endif 1053 ) 1054 { 1055 source++; /* Skip exponential indicator */ 1056 isExponentNegative = (*source == '-'); 1057 if ((*source == '+') || (*source == '-')) 1058 source++; 1059 while (isdigit((int)*source)) 1060 { 1061 exponent *= (int)base; 1062 exponent += (*source - '0'); 1063 source++; 1064 } 1065 } 1066 } 1067 1068 value = integer + fraction; 1069 if (exponent != 0) 1070 { 1071 if (isExponentNegative) 1072 value /= pow(base, (double)exponent); 1073 else 1074 value *= pow(base, (double)exponent); 1075 } 1076 if (isNegative) 1077 value = -value; 1078 1079 if (endp) 1080 *endp = (char *)source; 1081 return value; 1082 #endif 1083 } 1084 1085 1086 /** 1087 Convert string to floating-point number. 1088 1089 @param source String to be converted. 1090 @param endp Pointer to end of the converted string. 1091 @return A floating-point number. 1092 1093 See @ref trio_to_long_double. 1094 */ 1095 TRIO_STRING_PUBLIC double 1096 trio_to_double 1097 TRIO_ARGS2((source, endp), 1098 TRIO_CONST char *source, 1099 char **endp) 1100 { 1101 #if defined(USE_STRTOD) 1102 return strtod(source, endp); 1103 #else 1104 return (double)trio_to_long_double(source, endp); 1105 #endif 1106 } 1107 1108 #if !defined(TRIO_MINIMAL) 1109 /** 1110 Convert string to floating-point number. 1111 1112 @param source String to be converted. 1113 @param endp Pointer to end of the converted string. 1114 @return A floating-point number. 1115 1116 See @ref trio_to_long_double. 1117 */ 1118 TRIO_STRING_PUBLIC float 1119 trio_to_float 1120 TRIO_ARGS2((source, endp), 1121 TRIO_CONST char *source, 1122 char **endp) 1123 { 1124 #if defined(USE_STRTOF) 1125 return strtof(source, endp); 1126 #else 1127 return (float)trio_to_long_double(source, endp); 1128 #endif 1129 } 1130 #endif /* !defined(TRIO_MINIMAL) */ 1131 1132 1133 /** 1134 Convert string to signed integer. 1135 1136 @param string String to be converted. 1137 @param endp Pointer to end of converted string. 1138 @param base Radix number of number. 1139 */ 1140 TRIO_STRING_PUBLIC long 1141 trio_to_long 1142 TRIO_ARGS3((string, endp, base), 1143 TRIO_CONST char *string, 1144 char **endp, 1145 int base) 1146 { 1147 assert(string); 1148 assert((base >= 2) && (base <= 36)); 1149 1150 return strtol(string, endp, base); 1151 } 1152 1153 1154 #if !defined(TRIO_MINIMAL) 1155 /** 1156 Convert one alphabetic letter to lower-case. 1157 1158 @param source The letter to be converted. 1159 @return The converted letter. 1160 */ 1161 TRIO_STRING_PUBLIC int 1162 trio_to_lower 1163 TRIO_ARGS1((source), 1164 int source) 1165 { 1166 #if defined(USE_TOLOWER) 1167 1168 return tolower(source); 1169 1170 #else 1171 1172 /* Does not handle locales or non-contiguous alphabetic characters */ 1173 return ((source >= (int)'A') && (source <= (int)'Z')) 1174 ? source - 'A' + 'a' 1175 : source; 1176 1177 #endif 1178 } 1179 #endif /* !defined(TRIO_MINIMAL) */ 1180 1181 #if !defined(TRIO_MINIMAL) 1182 /** 1183 Convert string to unsigned integer. 1184 1185 @param string String to be converted. 1186 @param endp Pointer to end of converted string. 1187 @param base Radix number of number. 1188 */ 1189 TRIO_STRING_PUBLIC unsigned long 1190 trio_to_unsigned_long 1191 TRIO_ARGS3((string, endp, base), 1192 TRIO_CONST char *string, 1193 char **endp, 1194 int base) 1195 { 1196 assert(string); 1197 assert((base >= 2) && (base <= 36)); 1198 1199 return strtoul(string, endp, base); 1200 } 1201 #endif /* !defined(TRIO_MINIMAL) */ 1202 1203 1204 /** 1205 Convert one alphabetic letter to upper-case. 1206 1207 @param source The letter to be converted. 1208 @return The converted letter. 1209 */ 1210 TRIO_STRING_PUBLIC int 1211 trio_to_upper 1212 TRIO_ARGS1((source), 1213 int source) 1214 { 1215 #if defined(USE_TOUPPER) 1216 1217 return toupper(source); 1218 1219 #else 1220 1221 /* Does not handle locales or non-contiguous alphabetic characters */ 1222 return ((source >= (int)'a') && (source <= (int)'z')) 1223 ? source - 'a' + 'A' 1224 : source; 1225 1226 #endif 1227 } 1228 1229 #if !defined(TRIO_MINIMAL) 1230 /** 1231 Convert the alphabetic letters in the string to upper-case. 1232 1233 @param target The string to be converted. 1234 @return The number of processed characters (converted or not). 1235 */ 1236 TRIO_STRING_PUBLIC int 1237 trio_upper 1238 TRIO_ARGS1((target), 1239 char *target) 1240 { 1241 assert(target); 1242 1243 return trio_span_function(target, target, trio_to_upper); 1244 } 1245 #endif /* !defined(TRIO_MINIMAL) */ 1246 1247 1248 /** @} End of StaticStrings */ 1249 1250 1251 /************************************************************************* 1252 * Dynamic String Functions 1253 */ 1254 1255 #if defined(TRIO_DOCUMENTATION) 1256 # include "doc/doc_dynamic.h" 1257 #endif 1258 /** @addtogroup DynamicStrings 1259 @{ 1260 */ 1261 1262 /* 1263 * TrioStringAlloc 1264 */ 1265 TRIO_STRING_PRIVATE trio_string_t * 1266 TrioStringAlloc(TRIO_NOARGS) 1267 { 1268 trio_string_t *self; 1269 1270 self = (trio_string_t *)TRIO_MALLOC(sizeof(trio_string_t)); 1271 if (self) 1272 { 1273 self->content = NULL; 1274 self->length = 0; 1275 self->allocated = 0; 1276 } 1277 return self; 1278 } 1279 1280 1281 /* 1282 * TrioStringGrow 1283 * 1284 * The size of the string will be increased by 'delta' characters. If 1285 * 'delta' is zero, the size will be doubled. 1286 */ 1287 TRIO_STRING_PRIVATE BOOLEAN_T 1288 TrioStringGrow 1289 TRIO_ARGS2((self, delta), 1290 trio_string_t *self, 1291 size_t delta) 1292 { 1293 BOOLEAN_T status = FALSE; 1294 char *new_content; 1295 size_t new_size; 1296 1297 new_size = (delta == 0) 1298 ? ( (self->allocated == 0) ? 1 : self->allocated * 2 ) 1299 : self->allocated + delta; 1300 1301 new_content = (char *)TRIO_REALLOC(self->content, new_size); 1302 if (new_content) 1303 { 1304 self->content = new_content; 1305 self->allocated = new_size; 1306 status = TRUE; 1307 } 1308 return status; 1309 } 1310 1311 1312 #if !defined(TRIO_MINIMAL) 1313 /* 1314 * TrioStringGrowTo 1315 * 1316 * The size of the string will be increased to 'length' plus one characters. 1317 * If 'length' is less than the original size, the original size will be 1318 * used (that is, the size of the string is never decreased). 1319 */ 1320 TRIO_STRING_PRIVATE BOOLEAN_T 1321 TrioStringGrowTo 1322 TRIO_ARGS2((self, length), 1323 trio_string_t *self, 1324 size_t length) 1325 { 1326 length++; /* Room for terminating zero */ 1327 return (self->allocated < length) 1328 ? TrioStringGrow(self, length - self->allocated) 1329 : TRUE; 1330 } 1331 #endif /* !defined(TRIO_MINIMAL) */ 1332 1333 1334 #if !defined(TRIO_MINIMAL) 1335 /** 1336 Create a new dynamic string. 1337 1338 @param initial_size Initial size of the buffer. 1339 @return Newly allocated dynamic string, or NULL if memory allocation failed. 1340 */ 1341 TRIO_STRING_PUBLIC trio_string_t * 1342 trio_string_create 1343 TRIO_ARGS1((initial_size), 1344 int initial_size) 1345 { 1346 trio_string_t *self; 1347 1348 self = TrioStringAlloc(); 1349 if (self) 1350 { 1351 if (TrioStringGrow(self, 1352 (size_t)((initial_size > 0) ? initial_size : 1))) 1353 { 1354 self->content[0] = (char)0; 1355 self->allocated = initial_size; 1356 } 1357 else 1358 { 1359 trio_string_destroy(self); 1360 self = NULL; 1361 } 1362 } 1363 return self; 1364 } 1365 #endif /* !defined(TRIO_MINIMAL) */ 1366 1367 1368 /** 1369 Deallocate the dynamic string and its contents. 1370 1371 @param self Dynamic string 1372 */ 1373 TRIO_STRING_PUBLIC void 1374 trio_string_destroy 1375 TRIO_ARGS1((self), 1376 trio_string_t *self) 1377 { 1378 assert(self); 1379 1380 if (self) 1381 { 1382 trio_destroy(self->content); 1383 TRIO_FREE(self); 1384 } 1385 } 1386 1387 1388 #if !defined(TRIO_MINIMAL) 1389 /** 1390 Get a pointer to the content. 1391 1392 @param self Dynamic string. 1393 @param offset Offset into content. 1394 @return Pointer to the content. 1395 1396 @p Offset can be zero, positive, or negative. If @p offset is zero, 1397 then the start of the content will be returned. If @p offset is positive, 1398 then a pointer to @p offset number of characters from the beginning of the 1399 content is returned. If @p offset is negative, then a pointer to @p offset 1400 number of characters from the ending of the string, starting at the 1401 terminating zero, is returned. 1402 */ 1403 TRIO_STRING_PUBLIC char * 1404 trio_string_get 1405 TRIO_ARGS2((self, offset), 1406 trio_string_t *self, 1407 int offset) 1408 { 1409 char *result = NULL; 1410 1411 assert(self); 1412 1413 if (self->content != NULL) 1414 { 1415 if (self->length == 0) 1416 { 1417 (void)trio_string_length(self); 1418 } 1419 if (offset >= 0) 1420 { 1421 if (offset > (int)self->length) 1422 { 1423 offset = self->length; 1424 } 1425 } 1426 else 1427 { 1428 offset += self->length + 1; 1429 if (offset < 0) 1430 { 1431 offset = 0; 1432 } 1433 } 1434 result = &(self->content[offset]); 1435 } 1436 return result; 1437 } 1438 #endif /* !defined(TRIO_MINIMAL) */ 1439 1440 1441 /** 1442 Extract the content. 1443 1444 @param self Dynamic String 1445 @return Content of dynamic string. 1446 1447 The content is removed from the dynamic string. This enables destruction 1448 of the dynamic string without deallocation of the content. 1449 */ 1450 TRIO_STRING_PUBLIC char * 1451 trio_string_extract 1452 TRIO_ARGS1((self), 1453 trio_string_t *self) 1454 { 1455 char *result; 1456 1457 assert(self); 1458 1459 result = self->content; 1460 /* FIXME: Allocate new empty buffer? */ 1461 self->content = NULL; 1462 self->length = self->allocated = 0; 1463 return result; 1464 } 1465 1466 1467 #if !defined(TRIO_MINIMAL) 1468 /** 1469 Set the content of the dynamic string. 1470 1471 @param self Dynamic String 1472 @param buffer The new content. 1473 1474 Sets the content of the dynamic string to a copy @p buffer. 1475 An existing content will be deallocated first, if necessary. 1476 1477 @remark 1478 This function will make a copy of @p buffer. 1479 You are responsible for deallocating @p buffer yourself. 1480 */ 1481 TRIO_STRING_PUBLIC void 1482 trio_xstring_set 1483 TRIO_ARGS2((self, buffer), 1484 trio_string_t *self, 1485 char *buffer) 1486 { 1487 assert(self); 1488 1489 trio_destroy(self->content); 1490 self->content = trio_duplicate(buffer); 1491 } 1492 #endif /* !defined(TRIO_MINIMAL) */ 1493 1494 1495 /* 1496 * trio_string_size 1497 */ 1498 TRIO_STRING_PUBLIC int 1499 trio_string_size 1500 TRIO_ARGS1((self), 1501 trio_string_t *self) 1502 { 1503 assert(self); 1504 1505 return self->allocated; 1506 } 1507 1508 1509 /* 1510 * trio_string_terminate 1511 */ 1512 TRIO_STRING_PUBLIC void 1513 trio_string_terminate 1514 TRIO_ARGS1((self), 1515 trio_string_t *self) 1516 { 1517 trio_xstring_append_char(self, 0); 1518 } 1519 1520 1521 #if !defined(TRIO_MINIMAL) 1522 /** 1523 Append the second string to the first. 1524 1525 @param self Dynamic string to be modified. 1526 @param other Dynamic string to copy from. 1527 @return Boolean value indicating success or failure. 1528 */ 1529 TRIO_STRING_PUBLIC int 1530 trio_string_append 1531 TRIO_ARGS2((self, other), 1532 trio_string_t *self, 1533 trio_string_t *other) 1534 { 1535 size_t length; 1536 1537 assert(self); 1538 assert(other); 1539 1540 length = self->length + other->length; 1541 if (!TrioStringGrowTo(self, length)) 1542 goto error; 1543 trio_copy(&self->content[self->length], other->content); 1544 self->length = length; 1545 return TRUE; 1546 1547 error: 1548 return FALSE; 1549 } 1550 #endif /* !defined(TRIO_MINIMAL) */ 1551 1552 1553 #if !defined(TRIO_MINIMAL) 1554 /* 1555 * trio_xstring_append 1556 */ 1557 TRIO_STRING_PUBLIC int 1558 trio_xstring_append 1559 TRIO_ARGS2((self, other), 1560 trio_string_t *self, 1561 TRIO_CONST char *other) 1562 { 1563 size_t length; 1564 1565 assert(self); 1566 assert(other); 1567 1568 length = self->length + trio_length(other); 1569 if (!TrioStringGrowTo(self, length)) 1570 goto error; 1571 trio_copy(&self->content[self->length], other); 1572 self->length = length; 1573 return TRUE; 1574 1575 error: 1576 return FALSE; 1577 } 1578 #endif /* !defined(TRIO_MINIMAL) */ 1579 1580 1581 /* 1582 * trio_xstring_append_char 1583 */ 1584 TRIO_STRING_PUBLIC int 1585 trio_xstring_append_char 1586 TRIO_ARGS2((self, character), 1587 trio_string_t *self, 1588 char character) 1589 { 1590 assert(self); 1591 1592 if ((int)self->length >= trio_string_size(self)) 1593 { 1594 if (!TrioStringGrow(self, 0)) 1595 goto error; 1596 } 1597 self->content[self->length] = character; 1598 self->length++; 1599 return TRUE; 1600 1601 error: 1602 return FALSE; 1603 } 1604 1605 1606 #if !defined(TRIO_MINIMAL) 1607 /** 1608 Search for the first occurrence of second parameter in the first. 1609 1610 @param self Dynamic string to be modified. 1611 @param other Dynamic string to copy from. 1612 @return Boolean value indicating success or failure. 1613 */ 1614 TRIO_STRING_PUBLIC int 1615 trio_string_contains 1616 TRIO_ARGS2((self, other), 1617 trio_string_t *self, 1618 trio_string_t *other) 1619 { 1620 assert(self); 1621 assert(other); 1622 1623 return trio_contains(self->content, other->content); 1624 } 1625 #endif /* !defined(TRIO_MINIMAL) */ 1626 1627 1628 #if !defined(TRIO_MINIMAL) 1629 /* 1630 * trio_xstring_contains 1631 */ 1632 TRIO_STRING_PUBLIC int 1633 trio_xstring_contains 1634 TRIO_ARGS2((self, other), 1635 trio_string_t *self, 1636 TRIO_CONST char *other) 1637 { 1638 assert(self); 1639 assert(other); 1640 1641 return trio_contains(self->content, other); 1642 } 1643 #endif /* !defined(TRIO_MINIMAL) */ 1644 1645 1646 #if !defined(TRIO_MINIMAL) 1647 /* 1648 * trio_string_copy 1649 */ 1650 TRIO_STRING_PUBLIC int 1651 trio_string_copy 1652 TRIO_ARGS2((self, other), 1653 trio_string_t *self, 1654 trio_string_t *other) 1655 { 1656 assert(self); 1657 assert(other); 1658 1659 self->length = 0; 1660 return trio_string_append(self, other); 1661 } 1662 #endif /* !defined(TRIO_MINIMAL) */ 1663 1664 1665 #if !defined(TRIO_MINIMAL) 1666 /* 1667 * trio_xstring_copy 1668 */ 1669 TRIO_STRING_PUBLIC int 1670 trio_xstring_copy 1671 TRIO_ARGS2((self, other), 1672 trio_string_t *self, 1673 TRIO_CONST char *other) 1674 { 1675 assert(self); 1676 assert(other); 1677 1678 self->length = 0; 1679 return trio_xstring_append(self, other); 1680 } 1681 #endif /* !defined(TRIO_MINIMAL) */ 1682 1683 1684 #if !defined(TRIO_MINIMAL) 1685 /* 1686 * trio_string_duplicate 1687 */ 1688 TRIO_STRING_PUBLIC trio_string_t * 1689 trio_string_duplicate 1690 TRIO_ARGS1((other), 1691 trio_string_t *other) 1692 { 1693 trio_string_t *self; 1694 1695 assert(other); 1696 1697 self = TrioStringAlloc(); 1698 if (self) 1699 { 1700 self->content = TrioDuplicateMax(other->content, other->length); 1701 if (self->content) 1702 { 1703 self->length = other->length; 1704 self->allocated = self->length + 1; 1705 } 1706 else 1707 { 1708 self->length = self->allocated = 0; 1709 } 1710 } 1711 return self; 1712 } 1713 #endif /* !defined(TRIO_MINIMAL) */ 1714 1715 1716 /* 1717 * trio_xstring_duplicate 1718 */ 1719 TRIO_STRING_PUBLIC trio_string_t * 1720 trio_xstring_duplicate 1721 TRIO_ARGS1((other), 1722 TRIO_CONST char *other) 1723 { 1724 trio_string_t *self; 1725 1726 assert(other); 1727 1728 self = TrioStringAlloc(); 1729 if (self) 1730 { 1731 self->content = TrioDuplicateMax(other, trio_length(other)); 1732 if (self->content) 1733 { 1734 self->length = trio_length(self->content); 1735 self->allocated = self->length + 1; 1736 } 1737 else 1738 { 1739 self->length = self->allocated = 0; 1740 } 1741 } 1742 return self; 1743 } 1744 1745 1746 #if !defined(TRIO_MINIMAL) 1747 /* 1748 * trio_string_equal 1749 */ 1750 TRIO_STRING_PUBLIC int 1751 trio_string_equal 1752 TRIO_ARGS2((self, other), 1753 trio_string_t *self, 1754 trio_string_t *other) 1755 { 1756 assert(self); 1757 assert(other); 1758 1759 return trio_equal(self->content, other->content); 1760 } 1761 #endif /* !defined(TRIO_MINIMAL) */ 1762 1763 1764 #if !defined(TRIO_MINIMAL) 1765 /* 1766 * trio_xstring_equal 1767 */ 1768 TRIO_STRING_PUBLIC int 1769 trio_xstring_equal 1770 TRIO_ARGS2((self, other), 1771 trio_string_t *self, 1772 TRIO_CONST char *other) 1773 { 1774 assert(self); 1775 assert(other); 1776 1777 return trio_equal(self->content, other); 1778 } 1779 #endif /* !defined(TRIO_MINIMAL) */ 1780 1781 1782 #if !defined(TRIO_MINIMAL) 1783 /* 1784 * trio_string_equal_max 1785 */ 1786 TRIO_STRING_PUBLIC int 1787 trio_string_equal_max 1788 TRIO_ARGS3((self, max, other), 1789 trio_string_t *self, 1790 size_t max, 1791 trio_string_t *other) 1792 { 1793 assert(self); 1794 assert(other); 1795 1796 return trio_equal_max(self->content, max, other->content); 1797 } 1798 #endif /* !defined(TRIO_MINIMAL) */ 1799 1800 1801 #if !defined(TRIO_MINIMAL) 1802 /* 1803 * trio_xstring_equal_max 1804 */ 1805 TRIO_STRING_PUBLIC int 1806 trio_xstring_equal_max 1807 TRIO_ARGS3((self, max, other), 1808 trio_string_t *self, 1809 size_t max, 1810 TRIO_CONST char *other) 1811 { 1812 assert(self); 1813 assert(other); 1814 1815 return trio_equal_max(self->content, max, other); 1816 } 1817 #endif /* !defined(TRIO_MINIMAL) */ 1818 1819 1820 #if !defined(TRIO_MINIMAL) 1821 /* 1822 * trio_string_equal_case 1823 */ 1824 TRIO_STRING_PUBLIC int 1825 trio_string_equal_case 1826 TRIO_ARGS2((self, other), 1827 trio_string_t *self, 1828 trio_string_t *other) 1829 { 1830 assert(self); 1831 assert(other); 1832 1833 return trio_equal_case(self->content, other->content); 1834 } 1835 #endif /* !defined(TRIO_MINIMAL) */ 1836 1837 1838 #if !defined(TRIO_MINIMAL) 1839 /* 1840 * trio_xstring_equal_case 1841 */ 1842 TRIO_STRING_PUBLIC int 1843 trio_xstring_equal_case 1844 TRIO_ARGS2((self, other), 1845 trio_string_t *self, 1846 TRIO_CONST char *other) 1847 { 1848 assert(self); 1849 assert(other); 1850 1851 return trio_equal_case(self->content, other); 1852 } 1853 #endif /* !defined(TRIO_MINIMAL) */ 1854 1855 1856 #if !defined(TRIO_MINIMAL) 1857 /* 1858 * trio_string_equal_case_max 1859 */ 1860 TRIO_STRING_PUBLIC int 1861 trio_string_equal_case_max 1862 TRIO_ARGS3((self, max, other), 1863 trio_string_t *self, 1864 size_t max, 1865 trio_string_t *other) 1866 { 1867 assert(self); 1868 assert(other); 1869 1870 return trio_equal_case_max(self->content, max, other->content); 1871 } 1872 #endif /* !defined(TRIO_MINIMAL) */ 1873 1874 1875 #if !defined(TRIO_MINIMAL) 1876 /* 1877 * trio_xstring_equal_case_max 1878 */ 1879 TRIO_STRING_PUBLIC int 1880 trio_xstring_equal_case_max 1881 TRIO_ARGS3((self, max, other), 1882 trio_string_t *self, 1883 size_t max, 1884 TRIO_CONST char *other) 1885 { 1886 assert(self); 1887 assert(other); 1888 1889 return trio_equal_case_max(self->content, max, other); 1890 } 1891 #endif /* !defined(TRIO_MINIMAL) */ 1892 1893 1894 #if !defined(TRIO_MINIMAL) && !defined(_WIN32_WCE) 1895 /* 1896 * trio_string_format_data_max 1897 */ 1898 TRIO_STRING_PUBLIC size_t 1899 trio_string_format_date_max 1900 TRIO_ARGS4((self, max, format, datetime), 1901 trio_string_t *self, 1902 size_t max, 1903 TRIO_CONST char *format, 1904 TRIO_CONST struct tm *datetime) 1905 { 1906 assert(self); 1907 1908 return trio_format_date_max(self->content, max, format, datetime); 1909 } 1910 #endif /* !defined(TRIO_MINIMAL) */ 1911 1912 1913 #if !defined(TRIO_MINIMAL) 1914 /* 1915 * trio_string_index 1916 */ 1917 TRIO_STRING_PUBLIC char * 1918 trio_string_index 1919 TRIO_ARGS2((self, character), 1920 trio_string_t *self, 1921 int character) 1922 { 1923 assert(self); 1924 1925 return trio_index(self->content, character); 1926 } 1927 #endif /* !defined(TRIO_MINIMAL) */ 1928 1929 1930 #if !defined(TRIO_MINIMAL) 1931 /* 1932 * trio_string_index_last 1933 */ 1934 TRIO_STRING_PUBLIC char * 1935 trio_string_index_last 1936 TRIO_ARGS2((self, character), 1937 trio_string_t *self, 1938 int character) 1939 { 1940 assert(self); 1941 1942 return trio_index_last(self->content, character); 1943 } 1944 #endif /* !defined(TRIO_MINIMAL) */ 1945 1946 1947 #if !defined(TRIO_MINIMAL) 1948 /* 1949 * trio_string_length 1950 */ 1951 TRIO_STRING_PUBLIC int 1952 trio_string_length 1953 TRIO_ARGS1((self), 1954 trio_string_t *self) 1955 { 1956 assert(self); 1957 1958 if (self->length == 0) 1959 { 1960 self->length = trio_length(self->content); 1961 } 1962 return self->length; 1963 } 1964 #endif /* !defined(TRIO_MINIMAL) */ 1965 1966 1967 #if !defined(TRIO_MINIMAL) 1968 /* 1969 * trio_string_lower 1970 */ 1971 TRIO_STRING_PUBLIC int 1972 trio_string_lower 1973 TRIO_ARGS1((self), 1974 trio_string_t *self) 1975 { 1976 assert(self); 1977 1978 return trio_lower(self->content); 1979 } 1980 #endif /* !defined(TRIO_MINIMAL) */ 1981 1982 1983 #if !defined(TRIO_MINIMAL) 1984 /* 1985 * trio_string_match 1986 */ 1987 TRIO_STRING_PUBLIC int 1988 trio_string_match 1989 TRIO_ARGS2((self, other), 1990 trio_string_t *self, 1991 trio_string_t *other) 1992 { 1993 assert(self); 1994 assert(other); 1995 1996 return trio_match(self->content, other->content); 1997 } 1998 #endif /* !defined(TRIO_MINIMAL) */ 1999 2000 2001 #if !defined(TRIO_MINIMAL) 2002 /* 2003 * trio_xstring_match 2004 */ 2005 TRIO_STRING_PUBLIC int 2006 trio_xstring_match 2007 TRIO_ARGS2((self, other), 2008 trio_string_t *self, 2009 TRIO_CONST char *other) 2010 { 2011 assert(self); 2012 assert(other); 2013 2014 return trio_match(self->content, other); 2015 } 2016 #endif /* !defined(TRIO_MINIMAL) */ 2017 2018 2019 #if !defined(TRIO_MINIMAL) 2020 /* 2021 * trio_string_match_case 2022 */ 2023 TRIO_STRING_PUBLIC int 2024 trio_string_match_case 2025 TRIO_ARGS2((self, other), 2026 trio_string_t *self, 2027 trio_string_t *other) 2028 { 2029 assert(self); 2030 assert(other); 2031 2032 return trio_match_case(self->content, other->content); 2033 } 2034 #endif /* !defined(TRIO_MINIMAL) */ 2035 2036 2037 #if !defined(TRIO_MINIMAL) 2038 /* 2039 * trio_xstring_match_case 2040 */ 2041 TRIO_STRING_PUBLIC int 2042 trio_xstring_match_case 2043 TRIO_ARGS2((self, other), 2044 trio_string_t *self, 2045 TRIO_CONST char *other) 2046 { 2047 assert(self); 2048 assert(other); 2049 2050 return trio_match_case(self->content, other); 2051 } 2052 #endif /* !defined(TRIO_MINIMAL) */ 2053 2054 2055 #if !defined(TRIO_MINIMAL) 2056 /* 2057 * trio_string_substring 2058 */ 2059 TRIO_STRING_PUBLIC char * 2060 trio_string_substring 2061 TRIO_ARGS2((self, other), 2062 trio_string_t *self, 2063 trio_string_t *other) 2064 { 2065 assert(self); 2066 assert(other); 2067 2068 return trio_substring(self->content, other->content); 2069 } 2070 #endif /* !defined(TRIO_MINIMAL) */ 2071 2072 2073 #if !defined(TRIO_MINIMAL) 2074 /* 2075 * trio_xstring_substring 2076 */ 2077 TRIO_STRING_PUBLIC char * 2078 trio_xstring_substring 2079 TRIO_ARGS2((self, other), 2080 trio_string_t *self, 2081 TRIO_CONST char *other) 2082 { 2083 assert(self); 2084 assert(other); 2085 2086 return trio_substring(self->content, other); 2087 } 2088 #endif /* !defined(TRIO_MINIMAL) */ 2089 2090 2091 #if !defined(TRIO_MINIMAL) 2092 /* 2093 * trio_string_upper 2094 */ 2095 TRIO_STRING_PUBLIC int 2096 trio_string_upper 2097 TRIO_ARGS1((self), 2098 trio_string_t *self) 2099 { 2100 assert(self); 2101 2102 return trio_upper(self->content); 2103 } 2104 #endif /* !defined(TRIO_MINIMAL) */ 2105 2106 /** @} End of DynamicStrings */ 2107
