Annotation of embedaddon/libxml2/triostr.c, revision 1.1.1.1

1.1       misho       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 */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>