Annotation of embedaddon/libxml2/triostr.c, revision 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>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to triostr.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2