third_party/libxml/src/triostr.c

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