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>
![[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