Upgraded to trio baseline 1.6
diff --git a/ChangeLog b/ChangeLog
index c055fb8..e0a7a23 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,9 @@
+Sat Jan 19 16:36:21 CET 2002 Bjorn Reese <breese@users.sourceforge.net>
+
+ * trio.h trio.c triodef.h triop.h trionan.h trionan.c Makefile.am:
+ Upgraded to trio baseline 1.6
+ * strio.h strio.c: Replaced by triostr.h and triostr.c
+
Fri Jan 18 17:22:50 CET 2002 Daniel Veillard <daniel@veillard.com>
* globals.c xmlIO.c xmlcatalog.c: removed the last occurences
diff --git a/Makefile.am b/Makefile.am
index 0b6d011..1b726b8 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -21,7 +21,7 @@
parser.c tree.c hash.c list.c xmlIO.c xmlmemory.c uri.c \
valid.c xlink.c HTMLparser.c HTMLtree.c debugXML.c xpath.c \
xpointer.c xinclude.c nanohttp.c nanoftp.c DOCBparser.c \
- catalog.c globals.c threads.c strio.c trio.c
+ catalog.c globals.c threads.c triostr.c trio.c
else
libxml2_la_SOURCES = SAX.c entities.c encoding.c error.c parserInternals.c \
@@ -568,7 +568,7 @@
libxml.m4 \
example/Makefile.am example/gjobread.c example/gjobs.xml \
$(man_MANS) libxml-2.0.pc.in \
- trionan.c trionan.h strio.c strio.h trio.c trio.h \
+ trionan.c trionan.h triostr.c triostr.h trio.c trio.h \
triop.h triodef.h libxml.h \
testThreadsWin32.c
diff --git a/strio.c b/strio.c
deleted file mode 100644
index 58a9a26..0000000
--- a/strio.c
+++ /dev/null
@@ -1,581 +0,0 @@
-/*************************************************************************
- *
- * $Id$
- *
- * Copyright (C) 1998 Bjorn Reese and Daniel Stenberg.
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
- * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
- * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
- *
- ************************************************************************/
-
-/*
- * TODO
- * - StrToLongDouble
- */
-
-static const char rcsid[] = "@(#)$Id$";
-
-#if defined(unix) || defined(__xlC__) || defined(__QNX__) || defined(__CYGWIN__)
-# define PLATFORM_UNIX
-#elif defined(WIN32) || defined(_WIN32)
-# define PLATFORM_WIN32
-#elif defined(AMIGA) && defined(__GNUC__)
-# define PLATFORM_UNIX
-#endif
-
-#if defined(__STDC__) && (__STDC_VERSION__ >= 199901L)
-# define TRIO_C99
-#endif
-
-#include "strio.h"
-#include <string.h>
-#include <locale.h>
-#include <ctype.h>
-#include <stdarg.h>
-#include <time.h>
-#include <math.h>
-#ifndef DEBUG
-# define NDEBUG
-#endif
-#include <assert.h>
-
-#ifndef NULL
-# define NULL 0
-#endif
-#define NIL ((char)0)
-#ifndef FALSE
-# define FALSE (1 == 0)
-# define TRUE (! FALSE)
-#endif
-
-#define VALID(x) (NULL != (x))
-#define INVALID(x) (NULL == (x))
-
-#if defined(PLATFORM_UNIX)
-# define USE_STRCASECMP
-# define USE_STRNCASECMP
-# define USE_STRERROR
-# if defined(__QNX__)
-# define strcasecmp(x,y) stricmp(x,y)
-# define strncasecmp(x,y,n) strnicmp(x,y,n)
-# endif
-#elif defined(PLATFORM_WIN32)
-# define USE_STRCASECMP
-# define strcasecmp(x,y) strcmpi(x,y)
-#endif
-
-/*************************************************************************
- * StrAppendMax
- */
-char *StrAppendMax(char *target, size_t max, const char *source)
-{
- assert(VALID(target));
- assert(VALID(source));
- assert(max > 0);
-
- max -= StrLength(target) + 1;
- return (max > 0) ? strncat(target, source, max) : target;
-}
-
-/*************************************************************************
- * StrCopyMax
- */
-char *StrCopyMax(char *target, size_t max, const char *source)
-{
- assert(VALID(target));
- assert(VALID(source));
- assert(max > 0); /* Includes != 0 */
-
- target = strncpy(target, source, max - 1);
- target[max - 1] = (char)0;
- return target;
-}
-
-/*************************************************************************
- * StrDuplicate
- */
-char *StrDuplicate(const char *source)
-{
- char *target;
-
- assert(VALID(source));
-
- target = StrAlloc(StrLength(source) + 1);
- if (target)
- {
- StrCopy(target, source);
- }
- return target;
-}
-
-/*************************************************************************
- * StrDuplicateMax
- */
-char *StrDuplicateMax(const char *source, size_t max)
-{
- char *target;
- size_t len;
-
- assert(VALID(source));
- assert(max > 0);
-
- /* Make room for string plus a terminating zero */
- len = StrLength(source) + 1;
- if (len > max)
- {
- len = max;
- }
- target = StrAlloc(len);
- if (target)
- {
- StrCopyMax(target, len, source);
- }
- return target;
-}
-
-/*************************************************************************
- * StrEqual
- */
-int StrEqual(const char *first, const char *second)
-{
- assert(VALID(first));
- assert(VALID(second));
-
- if (VALID(first) && VALID(second))
- {
-#if defined(USE_STRCASECMP)
- return (0 == strcasecmp(first, second));
-#else
- while ((*first != NIL) && (*second != NIL))
- {
- if (toupper(*first) != toupper(*second))
- {
- break;
- }
- first++;
- second++;
- }
- return ((*first == NIL) && (*second == NIL));
-#endif
- }
- return FALSE;
-}
-
-/*************************************************************************
- * StrEqualCase
- */
-int StrEqualCase(const char *first, const char *second)
-{
- assert(VALID(first));
- assert(VALID(second));
-
- if (VALID(first) && VALID(second))
- {
- return (0 == strcmp(first, second));
- }
- return FALSE;
-}
-
-/*************************************************************************
- * StrEqualCaseMax
- */
-int StrEqualCaseMax(const char *first, size_t max, const char *second)
-{
- assert(VALID(first));
- assert(VALID(second));
-
- if (VALID(first) && VALID(second))
- {
- return (0 == strncmp(first, second, max));
- }
- return FALSE;
-}
-
-/*************************************************************************
- * StrEqualLocale
- */
-int StrEqualLocale(const char *first, const char *second)
-{
- assert(VALID(first));
- assert(VALID(second));
-
-#if defined(LC_COLLATE)
- return (strcoll(first, second) == 0);
-#else
- return StrEqual(first, second);
-#endif
-}
-
-/*************************************************************************
- * StrEqualMax
- */
-int StrEqualMax(const char *first, size_t max, const char *second)
-{
- assert(VALID(first));
- assert(VALID(second));
-
- if (VALID(first) && VALID(second))
- {
-#if defined(USE_STRNCASECMP)
- return (0 == strncasecmp(first, second, max));
-#else
- /* Not adequately tested yet */
- size_t cnt = 0;
- while ((*first != NIL) && (*second != NIL) && (cnt <= max))
- {
- if (toupper(*first) != toupper(*second))
- {
- break;
- }
- first++;
- second++;
- cnt++;
- }
- return ((cnt == max) || ((*first == NIL) && (*second == NIL)));
-#endif
- }
- return FALSE;
-}
-
-/*************************************************************************
- * StrError
- */
-const char *StrError(int errorNumber)
-{
-#if defined(USE_STRERROR)
- return strerror(errorNumber);
-#else
- return "unknown";
-#endif
-}
-
-/*************************************************************************
- * StrFormatDate
- */
-size_t StrFormatDateMax(char *target,
- size_t max,
- const char *format,
- const struct tm *datetime)
-{
- assert(VALID(target));
- assert(VALID(format));
- assert(VALID(datetime));
- assert(max > 0);
-
- return strftime(target, max, format, datetime);
-}
-
-/*************************************************************************
- * StrHash
- */
-unsigned long StrHash(const char *string, int type)
-{
- unsigned long value = 0L;
- char ch;
-
- assert(VALID(string));
-
- switch (type)
- {
- case STRIO_HASH_PLAIN:
- while ( (ch = *string++) != NIL )
- {
- value *= 31;
- value += (unsigned long)ch;
- }
- break;
- default:
- assert(FALSE);
- break;
- }
- return value;
-}
-
-/*************************************************************************
- * StrMatch
- */
-int StrMatch(char *string, char *pattern)
-{
- assert(VALID(string));
- assert(VALID(pattern));
-
- for (; ('*' != *pattern); ++pattern, ++string)
- {
- if (NIL == *string)
- {
- return (NIL == *pattern);
- }
- if ((toupper((int)*string) != toupper((int)*pattern))
- && ('?' != *pattern))
- {
- return FALSE;
- }
- }
- /* two-line patch to prevent *too* much recursiveness: */
- while ('*' == pattern[1])
- pattern++;
-
- do
- {
- if ( StrMatch(string, &pattern[1]) )
- {
- return TRUE;
- }
- }
- while (*string++);
-
- return FALSE;
-}
-
-/*************************************************************************
- * StrMatchCase
- */
-int StrMatchCase(char *string, char *pattern)
-{
- assert(VALID(string));
- assert(VALID(pattern));
-
- for (; ('*' != *pattern); ++pattern, ++string)
- {
- if (NIL == *string)
- {
- return (NIL == *pattern);
- }
- if ((*string != *pattern)
- && ('?' != *pattern))
- {
- return FALSE;
- }
- }
- /* two-line patch to prevent *too* much recursiveness: */
- while ('*' == pattern[1])
- pattern++;
-
- do
- {
- if ( StrMatchCase(string, &pattern[1]) )
- {
- return TRUE;
- }
- }
- while (*string++);
-
- return FALSE;
-}
-
-/*************************************************************************
- * StrSpanFunction
- *
- * Untested
- */
-size_t StrSpanFunction(char *source, int (*Function)(int))
-{
- size_t count = 0;
-
- assert(VALID(source));
- assert(VALID(Function));
-
- while (*source != NIL)
- {
- if (Function(*source))
- break; /* while */
- source++;
- count++;
- }
- return count;
-}
-
-/*************************************************************************
- * StrSubstringMax
- */
-char *StrSubstringMax(const char *string, size_t max, const char *find)
-{
- size_t count;
- size_t size;
- char *result = NULL;
-
- assert(VALID(string));
- assert(VALID(find));
-
- size = StrLength(find);
- if (size <= max)
- {
- for (count = 0; count <= max - size; count++)
- {
- if (StrEqualMax(find, size, &string[count]))
- {
- result = (char *)&string[count];
- break;
- }
- }
- }
- return result;
-}
-
-/*************************************************************************
- * StrToDouble
- *
- * double ::= [ <sign> ]
- * ( <number> |
- * <number> <decimal_point> <number> |
- * <decimal_point> <number> )
- * [ <exponential> [ <sign> ] <number> ]
- * number ::= 1*( <digit> )
- * digit ::= ( '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' )
- * exponential ::= ( 'e' | 'E' )
- * sign ::= ( '-' | '+' )
- * decimal_point ::= '.'
- */
-double StrToDouble(const char *source, const char **endp)
-{
-#if defined(TRIO_C99)
- return strtod(source, endp);
-#else
- /* Preliminary code */
- int isNegative = FALSE;
- int isExponentNegative = FALSE;
- unsigned long integer = 0;
- unsigned long fraction = 0;
- unsigned long fracdiv = 1;
- unsigned long exponent = 0;
- double value = 0.0;
-
- /* First try hex-floats */
- if ((source[0] == '0') && ((source[1] == 'x') || (source[1] == 'X')))
- {
- source += 2;
- while (isxdigit((int)*source))
- {
- integer *= 16;
- integer += (isdigit((int)*source)
- ? (*source - '0')
- : 10 + (toupper((int)*source) - 'A'));
- source++;
- }
- if (*source == '.')
- {
- source++;
- while (isxdigit((int)*source))
- {
- fraction *= 16;
- fraction += (isdigit((int)*source)
- ? (*source - '0')
- : 10 + (toupper((int)*source) - 'A'));
- fracdiv *= 16;
- source++;
- }
- if ((*source == 'p') || (*source == 'P'))
- {
- source++;
- if ((*source == '+') || (*source == '-'))
- {
- isExponentNegative = (*source == '-');
- source++;
- }
- while (isdigit((int)*source))
- {
- exponent *= 10;
- exponent += (*source - '0');
- source++;
- }
- }
- }
- }
- else /* Then try normal decimal floats */
- {
- isNegative = (*source == '-');
- /* Skip sign */
- if ((*source == '+') || (*source == '-'))
- source++;
-
- /* Integer part */
- while (isdigit((int)*source))
- {
- integer *= 10;
- integer += (*source - '0');
- source++;
- }
-
- if (*source == '.')
- {
- source++; /* skip decimal point */
- while (isdigit((int)*source))
- {
- fraction *= 10;
- fraction += (*source - '0');
- fracdiv *= 10;
- source++;
- }
- }
- if ((*source == 'e') || (*source == 'E'))
- {
- source++; /* Skip exponential indicator */
- isExponentNegative = (*source == '-');
- if ((*source == '+') || (*source == '-'))
- source++;
- while (isdigit((int)*source))
- {
- exponent *= 10;
- exponent += (*source - '0');
- source++;
- }
- }
- }
-
- value = (double)integer;
- if (fraction != 0)
- {
- value += (double)fraction / (double)fracdiv;
- }
- if (exponent != 0)
- {
- if (isExponentNegative)
- value /= pow((double)10, (double)exponent);
- else
- value *= pow((double)10, (double)exponent);
- }
- if (isNegative)
- value = -value;
-
- if (endp)
- *endp = source;
- return value;
-#endif
-}
-
-/*************************************************************************
- * StrToFloat
- */
-float StrToFloat(const char *source, const char **endp)
-{
-#if defined(TRIO_C99)
- return strtof(source, endp);
-#else
- return (float)StrToDouble(source, endp);
-#endif
-}
-
-/*************************************************************************
- * StrToUpper
- */
-int StrToUpper(char *target)
-{
- int i = 0;
-
- assert(VALID(target));
-
- while (NIL != *target)
- {
- *target = toupper((int)*target);
- target++;
- i++;
- }
- return i;
-}
diff --git a/strio.h b/strio.h
deleted file mode 100644
index 68845a3..0000000
--- a/strio.h
+++ /dev/null
@@ -1,227 +0,0 @@
-/*************************************************************************
- *
- * $Id$
- *
- * Copyright (C) 1998 Bjorn Reese and Daniel Stenberg.
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
- * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
- * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
- *
- ************************************************************************/
-
-#ifndef TRIO_STRIO_H
-#define TRIO_STRIO_H
-
-#if !(defined(DEBUG) || defined(NDEBUG))
-# define NDEBUG
-#endif
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-
-#ifndef STRIO_MALLOC
-# define STRIO_MALLOC(n) malloc(n)
-#endif
-#ifndef STRIO_FREE
-# define STRIO_FREE(x) free(x)
-#endif
-
-/*
- * StrAppend(target, source)
- * StrAppendMax(target, maxsize, source)
- *
- * Append 'source' to 'target'
- *
- * target = StrAlloc(size)
- *
- * Allocate a new string
- *
- * StrContains(target, substring)
- *
- * Find out if the string 'substring' is
- * contained in the string 'target'
- *
- * StrCopy(target, source)
- * StrCopyMax(target, maxsize, source)
- *
- * Copy 'source' to 'target'
- *
- * target = StrDuplicate(source)
- * target = StrDuplicateMax(source, maxsize)
- *
- * Allocate and copy 'source' to 'target'
- *
- * StrEqual(first, second)
- * StrEqualMax(first, maxsize, second)
- *
- * Compare if 'first' is equal to 'second'.
- * Case-independent.
- *
- * StrEqualCase(first, second)
- * StrEqualCaseMax(first, maxsize, second)
- *
- * Compare if 'first' is equal to 'second'
- * Case-dependent. Please note that the use of the
- * word 'case' has the opposite meaning as that of
- * strcasecmp().
- *
- * StrFormat(target, format, ...)
- * StrFormatMax(target, maxsize, format, ...)
- *
- * Build 'target' according to 'format' and succesive
- * arguments. This is equal to the sprintf() and
- * snprintf() functions.
- *
- * StrFormatDate(target, format, ...)
- *
- * StrFree(target)
- *
- * De-allocates a string
- *
- * StrHash(string, type)
- *
- * Calculates the hash value of 'string' based on the
- * 'type'.
- *
- * StrIndex(target, character)
- * StrIndexLast(target, character)
- *
- * Find the first/last occurrence of 'character' in
- * 'target'
- *
- * StrLength(target)
- *
- * Return the length of 'target'
- *
- * StrMatch(string, pattern)
- * StrMatchCase(string, pattern)
- *
- * Find 'pattern' within 'string'. 'pattern' may contain
- * wildcards such as * (asterics) and ? (question mark)
- * which matches zero or more characters and exactly
- * on character respectively
- *
- * StrScan(source, format, ...)
- *
- * Equal to sscanf()
- *
- * StrSubstring(target, substring)
- *
- * Find the first occurrence of the string 'substring'
- * within the string 'target'
- *
- * StrTokenize(target, list)
- *
- * Split 'target' into the first token delimited by
- * one of the characters in 'list'. If 'target' is
- * NULL then next token will be returned.
- *
- * StrToUpper(target)
- *
- * Convert all lower case characters in 'target' into
- * upper case characters.
- */
-
-enum {
- STRIO_HASH_NONE = 0,
- STRIO_HASH_PLAIN,
- STRIO_HASH_TWOSIGNED
-};
-
-#if !defined(DEBUG) || defined(__DECC)
-#define StrAlloc(n) (char *)STRIO_MALLOC(n)
-#define StrAppend(x,y) strcat((x), (y))
-#define StrContains(x,y) (0 != strstr((x), (y)))
-#define StrCopy(x,y) strcpy((x), (y))
-#define StrIndex(x,y) strchr((x), (y))
-#define StrIndexLast(x,y) strrchr((x), (y))
-#define StrFree(x) STRIO_FREE(x)
-#define StrLength(x) strlen((x))
-#define StrSubstring(x,y) strstr((x), (y))
-#define StrTokenize(x,y) strtok((x), (y))
-#define StrToLong(x,y,n) strtol((x), (y), (n))
-#define StrToUnsignedLong(x,y,n) strtoul((x), (y), (n))
-#else /* DEBUG */
- /*
- * To be able to use these macros everywhere, including in
- * if() sentences, the assertions are put first in a comma
- * seperated list.
- *
- * Unfortunately the DECC compiler does not seem to like this
- * so it will use the un-asserted functions above for the
- * debugging case too.
- */
-#define StrAlloc(n) \
- (assert((n) > 0),\
- (char *)STRIO_MALLOC(n))
-#define StrAppend(x,y) \
- (assert((x) != NULL),\
- assert((y) != NULL),\
- strcat((x), (y)))
-#define StrContains(x,y) \
- (assert((x) != NULL),\
- assert((y) != NULL),\
- (0 != strstr((x), (y))))
-#define StrCopy(x,y) \
- (assert((x) != NULL),\
- assert((y) != NULL),\
- strcpy((x), (y)))
-#define StrIndex(x,c) \
- (assert((x) != NULL),\
- strchr((x), (c)))
-#define StrIndexLast(x,c) \
- (assert((x) != NULL),\
- strrchr((x), (c)))
-#define StrFree(x) \
- (assert((x) != NULL),\
- STRIO_FREE(x))
-#define StrLength(x) \
- (assert((x) != NULL),\
- strlen((x)))
-#define StrSubstring(x,y) \
- (assert((x) != NULL),\
- assert((y) != NULL),\
- strstr((x), (y)))
-#define StrTokenize(x,y) \
- (assert((y) != NULL),\
- strtok((x), (y)))
-#define StrToLong(x,y,n) \
- (assert((x) != NULL),\
- assert((y) != NULL),\
- assert((n) >= 2 && (n) <= 36),\
- strtol((x), (y), (n)))
-#define StrToUnsignedLong(x,y,n) \
- (assert((x) != NULL),\
- assert((y) != NULL),\
- assert((n) >= 2 && (n) <= 36),\
- strtoul((x), (y), (n)))
-#endif /* DEBUG */
-
-char *StrAppendMax(char *target, size_t max, const char *source);
-char *StrCopyMax(char *target, size_t max, const char *source);
-char *StrDuplicate(const char *source);
-char *StrDuplicateMax(const char *source, size_t max);
-int StrEqual(const char *first, const char *second);
-int StrEqualCase(const char *first, const char *second);
-int StrEqualCaseMax(const char *first, size_t max, const char *second);
-int StrEqualLocale(const char *first, const char *second);
-int StrEqualMax(const char *first, size_t max, const char *second);
-const char *StrError(int);
-size_t StrFormatDateMax(char *target, size_t max, const char *format, const struct tm *datetime);
-unsigned long StrHash(const char *string, int type);
-int StrMatch(char *string, char *pattern);
-int StrMatchCase(char *string, char *pattern);
-size_t StrSpanFunction(char *source, int (*Function)(int));
-char *StrSubstringMax(const char *string, size_t max, const char *find);
-float StrToFloat(const char *source, const char **target);
-double StrToDouble(const char *source, const char **target);
-int StrToUpper(char *target);
-
-#endif /* TRIO_STRIO_H */
diff --git a/trio.c b/trio.c
index 76d46ba..1a844bc 100644
--- a/trio.c
+++ b/trio.c
@@ -41,16 +41,14 @@
* - Scanning of collating symbols.
*/
-static const char rcsid[] = "@(#)$Id$";
-
/*************************************************************************
* Trio include files
*/
#include "triodef.h"
#include "trio.h"
#include "triop.h"
+#include "triostr.h"
#include "trionan.h"
-#include "strio.h"
/*
* Encode the error code and the position. This is decoded
@@ -110,17 +108,20 @@
/*************************************************************************
* Platform specific definitions
*/
-#if defined(PLATFORM_UNIX)
+#if defined(TRIO_PLATFORM_UNIX)
# include <unistd.h>
# include <signal.h>
# include <locale.h>
# define USE_LOCALE
-#endif /* PLATFORM_UNIX */
-#if defined(PLATFORM_WIN32)
+#endif /* TRIO_PLATFORM_UNIX */
+#if defined(TRIO_PLATFORM_VMS)
+# include <unistd.h>
+#endif
+#if defined(TRIO_PLATFORM_WIN32)
# include <io.h>
# define read _read
# define write _write
-#endif /* PLATFORM_WIN32 */
+#endif /* TRIO_PLATFORM_WIN32 */
#define TRIO_MSVC_VERSION_5 1100
@@ -131,6 +132,7 @@
# else
typedef char wchar_t;
typedef int wint_t;
+# define WCONST(x) L ## x
# define WEOF EOF
# define iswalnum(x) isalnum(x)
# define iswalpha(x) isalpha(x)
@@ -155,9 +157,9 @@
/* Support for long long */
#ifndef __cplusplus
# if !defined(USE_LONGLONG)
-# if defined(__GNUC__) && !defined(__STRICT_ANSI__)
+# if defined(TRIO_COMPILER_GCC) && !defined(__STRICT_ANSI__)
# define USE_LONGLONG
-# elif defined(__SUNPRO_C)
+# elif defined(TRIO_COMPILER_SUNPRO)
# define USE_LONGLONG
# elif defined(_LONG_LONG) || defined(_LONGLONG)
# define USE_LONGLONG
@@ -169,7 +171,7 @@
#if defined(USE_LONGLONG)
typedef signed long long int trio_longlong_t;
typedef unsigned long long int trio_ulonglong_t;
-#elif defined(_MSC_VER)
+#elif defined(TRIO_COMPILER_MSVC)
# if (_MSC_VER >= TRIO_MSVC_VERSION_5)
typedef signed __int64 trio_longlong_t;
typedef unsigned __int64 trio_ulonglong_t;
@@ -199,7 +201,7 @@
typedef int16_t trio_int16_t;
typedef int32_t trio_int32_t;
typedef int64_t trio_int64_t;
-#elif defined(_MSC_VER) && (_MSC_VER >= TRIO_MSVC_5)
+#elif defined(TRIO_COMPILER_MSVC) && (_MSC_VER >= TRIO_MSVC_VERSION_5)
typedef trio_longlong_t trio_intmax_t;
typedef trio_ulonglong_t trio_uintmax_t;
typedef __int8 trio_int8_t;
@@ -319,7 +321,7 @@
/* Maximal number of allowed parameters */
MAX_PARAMETERS = 64,
/* Maximal number of characters in class */
- MAX_CHARACTER_CLASS = UCHAR_MAX,
+ MAX_CHARACTER_CLASS = UCHAR_MAX + 1,
/* Maximal string lengths for user-defined specifiers */
MAX_USER_NAME = 64,
@@ -328,7 +330,10 @@
/* Maximal length of locale separator strings */
MAX_LOCALE_SEPARATOR_LENGTH = MB_LEN_MAX,
/* Maximal number of integers in grouping */
- MAX_LOCALE_GROUPS = 64
+ MAX_LOCALE_GROUPS = 64,
+
+ /* Initial size of asprintf buffer */
+ DYNAMIC_START_SIZE = 32
};
#define NO_GROUPING ((int)CHAR_MAX)
@@ -359,6 +364,7 @@
/* Character class expressions */
#define CLASS_ALNUM ":alnum:"
#define CLASS_ALPHA ":alpha:"
+#define CLASS_BLANK ":blank:"
#define CLASS_CNTRL ":cntrl:"
#define CLASS_DIGIT ":digit:"
#define CLASS_GRAPH ":graph:"
@@ -571,13 +577,21 @@
/* Parameters */
typedef struct {
+ /* An indication of which entry in the data union is used */
int type;
+ /* The flags */
unsigned long flags;
+ /* The width qualifier */
int width;
+ /* The precision qualifier */
int precision;
+ /* The base qualifier */
int base;
+ /* The size for the variable size qualifier */
int varsize;
+ /* The marker of the end of the specifier */
int indexAfterSpecifier;
+ /* The data from the argument list */
union {
char *string;
#if TRIO_WIDECHAR
@@ -597,50 +611,77 @@
/* For the user-defined specifier */
char user_name[MAX_USER_NAME];
char user_data[MAX_USER_DATA];
-} parameter_T;
+} trio_parameter_t;
/* General trio "class" */
-typedef struct _trio_T {
- void *location;
- void (*OutStream)(struct _trio_T *, int);
- void (*InStream)(struct _trio_T *, int *);
+typedef struct _trio_class_t {
/*
- * The number of characters that would have been written/read if
- * there had been sufficient space.
+ * The function to write characters to a stream.
+ */
+ void (*OutStream)(struct _trio_class_t *, int);
+ /*
+ * The function to read characters from a stream.
+ */
+ void (*InStream)(struct _trio_class_t *, int *);
+ /*
+ * The current location in the stream.
+ */
+ void *location;
+ /*
+ * The character currently being processed.
+ */
+ int current;
+ /*
+ * The number of characters that would have been written/read
+ * if there had been sufficient space.
*/
int processed;
/*
* The number of characters that are actually written/read.
- * Processed and committed with only differ for the *nprintf
+ * Processed and committed will only differ for the *nprintf
* and *nscanf functions.
*/
int committed;
+ /*
+ * The upper limit of characters that may be written/read.
+ */
int max;
- int current;
-} trio_T;
+ /*
+ * The last output error that was detected.
+ */
+ int error;
+} trio_class_t;
/* References (for user-defined callbacks) */
-typedef struct _reference_T {
- trio_T *data;
- parameter_T *parameter;
-} reference_T;
+typedef struct _trio_reference_t {
+ trio_class_t *data;
+ trio_parameter_t *parameter;
+} trio_reference_t;
/* Registered entries (for user-defined callbacks) */
-typedef struct _userdef_T {
- struct _userdef_T *next;
+typedef struct _trio_userdef_t {
+ struct _trio_userdef_t *next;
trio_callback_t callback;
char *name;
-} userdef_T;
+} trio_userdef_t;
/*************************************************************************
* Internal variables
*/
-#if defined(PLATFORM_UNIX)
-extern int errno;
+static TRIO_CONST char rcsid[] = "@(#)$Id$";
+
+/*
+ * Need this to workaround a parser bug in HP C/iX compiler that fails
+ * to resolves macro definitions that includes type 'long double',
+ * e.g: va_arg(arg_ptr, long double)
+ */
+#if defined(TRIO_PLATFORM_MPEIX)
+static TRIO_CONST long double ___dummy_long_double = 0;
#endif
-static const char null[] = "(nil)";
+
+static TRIO_CONST char internalNullString[] = "(nil)";
#if defined(USE_LOCALE)
static struct lconv *internalLocaleValues = NULL;
@@ -654,8 +695,8 @@
static char internalThousandSeparator[MAX_LOCALE_SEPARATOR_LENGTH + 1] = ",";
static char internalGrouping[MAX_LOCALE_GROUPS] = { (char)NO_GROUPING };
-static const char internalDigitsLower[] = "0123456789abcdefghijklmnopqrstuvwxyz";
-static const char internalDigitsUpper[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+static TRIO_CONST char internalDigitsLower[] = "0123456789abcdefghijklmnopqrstuvwxyz";
+static TRIO_CONST char internalDigitsUpper[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
static BOOLEAN_T internalDigitsUnconverted = TRUE;
static int internalDigitArray[128];
#if TRIO_EXTENSION
@@ -663,15 +704,16 @@
static char internalCollationArray[MAX_CHARACTER_CLASS][MAX_CHARACTER_CLASS];
#endif
-static volatile trio_callback_t internalEnterCriticalRegion = NULL;
-static volatile trio_callback_t internalLeaveCriticalRegion = NULL;
-static userdef_T *internalUserDef = NULL;
+static TRIO_VOLATILE trio_callback_t internalEnterCriticalRegion = NULL;
+static TRIO_VOLATILE trio_callback_t internalLeaveCriticalRegion = NULL;
+static trio_userdef_t *internalUserDef = NULL;
/*************************************************************************
- * trio_strerror [public]
+ * trio_strerror
*/
-const char *trio_strerror(int errorcode)
+TRIO_PUBLIC TRIO_CONST char *
+trio_strerror(int errorcode)
{
/* Textual versions of the error codes */
switch (TRIO_ERROR_CODE(errorcode))
@@ -696,14 +738,14 @@
}
/*************************************************************************
- * TrioIsQualifier [private]
+ * TrioIsQualifier
*
* Description:
* Remember to add all new qualifiers to this function.
* QUALIFIER_POSITION must not be added.
*/
-static BOOLEAN_T
-TrioIsQualifier(const char ch)
+TRIO_PRIVATE BOOLEAN_T
+TrioIsQualifier(TRIO_CONST char ch)
{
/* QUALIFIER_POSITION is not included */
switch (ch)
@@ -760,10 +802,10 @@
}
/*************************************************************************
- * TrioSetLocale [private]
+ * TrioSetLocale
*/
#if defined(USE_LOCALE)
-static void
+TRIO_PUBLIC void
TrioSetLocale(void)
{
internalLocaleValues = (struct lconv *)localeconv();
@@ -772,42 +814,42 @@
if ((internalLocaleValues->decimal_point) &&
(internalLocaleValues->decimal_point[0] != NIL))
{
- StrCopyMax(internalDecimalPoint,
- sizeof(internalDecimalPoint),
- internalLocaleValues->decimal_point);
+ trio_copy_max(internalDecimalPoint,
+ sizeof(internalDecimalPoint),
+ internalLocaleValues->decimal_point);
}
if ((internalLocaleValues->thousands_sep) &&
(internalLocaleValues->thousands_sep[0] != NIL))
{
- StrCopyMax(internalThousandSeparator,
- sizeof(internalThousandSeparator),
- internalLocaleValues->thousands_sep);
+ trio_copy_max(internalThousandSeparator,
+ sizeof(internalThousandSeparator),
+ internalLocaleValues->thousands_sep);
}
if ((internalLocaleValues->grouping) &&
(internalLocaleValues->grouping[0] != NIL))
{
- StrCopyMax(internalGrouping,
- sizeof(internalGrouping),
- internalLocaleValues->grouping);
+ trio_copy_max(internalGrouping,
+ sizeof(internalGrouping),
+ internalLocaleValues->grouping);
}
}
}
#endif /* defined(USE_LOCALE) */
/*************************************************************************
- * TrioGetPosition [private]
+ * TrioGetPosition
*
* Get the %n$ position.
*/
-static int
-TrioGetPosition(const char *format,
+TRIO_PRIVATE int
+TrioGetPosition(TRIO_CONST char *format,
int *indexPointer)
{
char *tmpformat;
int number = 0;
int index = *indexPointer;
- number = (int)StrToLong(&format[index], &tmpformat, BASE_DECIMAL);
+ number = (int)trio_to_long(&format[index], &tmpformat, BASE_DECIMAL);
index = (int)(tmpformat - format);
if ((number != 0) && (QUALIFIER_POSITION == format[index++]))
{
@@ -822,15 +864,15 @@
}
/*************************************************************************
- * TrioFindNamespace [private]
+ * TrioFindNamespace
*
* Find registered user-defined specifier.
- * The prev argument is used for optimization only.
+ * The prev argument is used for optimisation only.
*/
-static userdef_T *
-TrioFindNamespace(const char *name, userdef_T **prev)
+TRIO_PRIVATE trio_userdef_t *
+TrioFindNamespace(TRIO_CONST char *name, trio_userdef_t **prev)
{
- userdef_T *def;
+ trio_userdef_t *def;
if (internalEnterCriticalRegion)
(void)internalEnterCriticalRegion(NULL);
@@ -838,7 +880,7 @@
for (def = internalUserDef; def; def = def->next)
{
/* Case-sensitive string comparison */
- if (StrEqualCase(def->name, name))
+ if (trio_equal_case(def->name, name))
break;
if (prev)
@@ -852,17 +894,17 @@
}
/*************************************************************************
- * TrioPreprocess [private]
+ * TrioParse
*
* Description:
* Parse the format string
*/
-static int
-TrioPreprocess(int type,
- const char *format,
- parameter_T *parameters,
- va_list arglist,
- void **argarray)
+TRIO_PRIVATE int
+TrioParse(int type,
+ TRIO_CONST char *format,
+ trio_parameter_t *parameters,
+ va_list arglist,
+ void **argarray)
{
#if TRIO_ERRORS
/* Count the number of times a parameter is referenced */
@@ -890,7 +932,9 @@
int pos = 0;
/* Various variables */
char ch;
+#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
int charlen;
+#endif
int i = -1;
int num;
char *tmpformat;
@@ -1020,7 +1064,9 @@
}
else
{
- precision = StrToLong(&format[index], &tmpformat, BASE_DECIMAL);
+ precision = trio_to_long(&format[index],
+ &tmpformat,
+ BASE_DECIMAL);
index = (int)(tmpformat - format);
}
}
@@ -1059,7 +1105,9 @@
}
else
{
- base = StrToLong(&format[index], &tmpformat, BASE_DECIMAL);
+ base = trio_to_long(&format[index],
+ &tmpformat,
+ BASE_DECIMAL);
if (base > MAX_BASE)
return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
index = (int)(tmpformat - format);
@@ -1120,7 +1168,9 @@
/* &format[index - 1] is used to "rewind" the read
* character from format
*/
- width = StrToLong(&format[index - 1], &tmpformat, BASE_DECIMAL);
+ width = trio_to_long(&format[index - 1],
+ &tmpformat,
+ BASE_DECIMAL);
index = (int)(tmpformat - format);
break;
@@ -1278,6 +1328,7 @@
usedEntries[width] += 1;
#endif
parameters[pos].type = FORMAT_PARAMETER;
+ parameters[pos].flags = 0;
indices[width] = pos;
width = pos++;
}
@@ -1287,6 +1338,7 @@
usedEntries[precision] += 1;
#endif
parameters[pos].type = FORMAT_PARAMETER;
+ parameters[pos].flags = 0;
indices[precision] = pos;
precision = pos++;
}
@@ -1296,6 +1348,7 @@
usedEntries[base] += 1;
#endif
parameters[pos].type = FORMAT_PARAMETER;
+ parameters[pos].flags = 0;
indices[base] = pos;
base = pos++;
}
@@ -1305,6 +1358,7 @@
usedEntries[varsize] += 1;
#endif
parameters[pos].type = FORMAT_PARAMETER;
+ parameters[pos].flags = 0;
indices[varsize] = pos;
varsize = pos++;
}
@@ -1499,9 +1553,9 @@
max = (unsigned int)(&format[index] - tmpformat);
if (max > MAX_USER_DATA)
max = MAX_USER_DATA;
- StrCopyMax(parameters[pos].user_data,
- max,
- tmpformat);
+ trio_copy_max(parameters[pos].user_data,
+ max,
+ tmpformat);
break; /* while */
}
if (ch == SPECIFIER_USER_DEFINED_SEPARATOR)
@@ -1511,9 +1565,9 @@
max = (int)(&format[index] - tmpformat);
if (max > MAX_USER_NAME)
max = MAX_USER_NAME;
- StrCopyMax(parameters[pos].user_name,
- max,
- tmpformat);
+ trio_copy_max(parameters[pos].user_name,
+ max,
+ tmpformat);
tmpformat = (char *)&format[index];
}
}
@@ -1666,8 +1720,8 @@
else
{
#if defined(QUALIFIER_VARSIZE) || defined(QUALIFIER_FIXED_SIZE)
- if ((parameters[i].flags & FLAGS_VARSIZE_PARAMETER) ||
- (parameters[i].flags & FLAGS_FIXED_SIZE))
+ if (parameters[i].flags
+ & (FLAGS_VARSIZE_PARAMETER | FLAGS_FIXED_SIZE))
{
if (parameters[i].flags & FLAGS_VARSIZE_PARAMETER)
{
@@ -1797,13 +1851,16 @@
else
{
if (argarray == NULL)
- parameters[i].data.longdoubleNumber = (long double)va_arg(arglist, double);
+ parameters[i].data.longdoubleNumber =
+ (long double)va_arg(arglist, double);
else
{
if (parameters[i].flags & FLAGS_SHORT)
- parameters[i].data.longdoubleNumber = (long double)(*((float *)argarray[num]));
+ parameters[i].data.longdoubleNumber =
+ (long double)(*((float *)argarray[num]));
else
- parameters[i].data.longdoubleNumber = (long double)(long double)(*((double *)argarray[num]));
+ parameters[i].data.longdoubleNumber =
+ (long double)(long double)(*((double *)argarray[num]));
}
}
}
@@ -1825,22 +1882,22 @@
/*************************************************************************
*
- * @FORMATTING
+ * FORMATTING
*
************************************************************************/
/*************************************************************************
- * TrioWriteNumber [private]
+ * TrioWriteNumber
*
* Description:
* Output a number.
* The complexity of this function is a result of the complexity
* of the dependencies of the flags.
*/
-static void
-TrioWriteNumber(trio_T *self,
- trio_intmax_t snumber,
+TRIO_PRIVATE void
+TrioWriteNumber(trio_class_t *self,
+ trio_uintmax_t number,
unsigned long flags,
int width,
int precision,
@@ -1850,8 +1907,7 @@
char buffer[MAX_CHARS_IN(trio_uintmax_t) * (1 + MAX_LOCALE_SEPARATOR_LENGTH) + 1];
char *bufferend;
char *pointer;
- const char *digits;
- trio_uintmax_t number;
+ TRIO_CONST char *digits;
int i;
int length;
char *p;
@@ -1861,14 +1917,15 @@
assert(VALID(self));
assert(VALID(self->OutStream));
- assert((base >= MIN_BASE && base <= MAX_BASE) || (base == NO_BASE));
+ assert(((base >= MIN_BASE) && (base <= MAX_BASE)) || (base == NO_BASE));
digits = (flags & FLAGS_UPPER) ? internalDigitsUpper : internalDigitsLower;
isNegative = (flags & FLAGS_UNSIGNED)
? FALSE
- : (snumber < 0);
- number = (isNegative) ? -snumber : snumber;
+ : ((trio_intmax_t)number < 0);
+ if (isNegative)
+ number = -number;
if (flags & FLAGS_QUAD)
number &= (trio_ulonglong_t)-1;
@@ -1898,7 +1955,7 @@
* to the most significant digit, so we have to copy the
* thousand separator backwards
*/
- length = StrLength(internalThousandSeparator);
+ length = trio_length(internalThousandSeparator);
if (((int)(pointer - buffer) - length) > 0)
{
p = &internalThousandSeparator[length - 1];
@@ -2019,13 +2076,13 @@
}
/*************************************************************************
- * TrioWriteStringCharacter [private]
+ * TrioWriteStringCharacter
*
* Description:
* Output a single character of a string
*/
-static void
-TrioWriteStringCharacter(trio_T *self,
+TRIO_PRIVATE void
+TrioWriteStringCharacter(trio_class_t *self,
int ch,
unsigned long flags)
{
@@ -2073,14 +2130,14 @@
}
/*************************************************************************
- * TrioWriteString [private]
+ * TrioWriteString
*
* Description:
* Output a string
*/
-static void
-TrioWriteString(trio_T *self,
- const char *string,
+TRIO_PRIVATE void
+TrioWriteString(trio_class_t *self,
+ TRIO_CONST char *string,
unsigned long flags,
int width,
int precision)
@@ -2093,15 +2150,15 @@
if (string == NULL)
{
- string = null;
- length = sizeof(null) - 1;
+ string = internalNullString;
+ length = sizeof(internalNullString) - 1;
/* Disable quoting for the null pointer */
flags &= (~FLAGS_QUOTE);
width = 0;
}
else
{
- length = StrLength(string);
+ length = trio_length(string);
}
if ((NO_PRECISION != precision) &&
(precision < length))
@@ -2136,14 +2193,14 @@
}
/*************************************************************************
- * TrioWriteWideStringCharacter [private]
+ * TrioWriteWideStringCharacter
*
* Description:
* Output a wide string as a multi-byte sequence
*/
#if TRIO_WIDECHAR
-static int
-TrioWriteWideStringCharacter(trio_T *self,
+TRIO_PRIVATE int
+TrioWriteWideStringCharacter(trio_class_t *self,
wchar_t wch,
unsigned long flags,
int width)
@@ -2174,15 +2231,15 @@
#endif /* TRIO_WIDECHAR */
/*************************************************************************
- * TrioWriteString [private]
+ * TrioWriteWideString
*
* Description:
* Output a wide character string as a multi-byte string
*/
#if TRIO_WIDECHAR
-static void
-TrioWriteWideString(trio_T *self,
- const wchar_t *wstring,
+TRIO_PRIVATE void
+TrioWriteWideString(trio_class_t *self,
+ TRIO_CONST wchar_t *wstring,
unsigned long flags,
int width,
int precision)
@@ -2241,10 +2298,10 @@
#endif /* TRIO_WIDECHAR */
/*************************************************************************
- * TrioWriteDouble [private]
+ * TrioWriteDouble
*/
-static void
-TrioWriteDouble(trio_T *self,
+TRIO_PRIVATE void
+TrioWriteDouble(trio_class_t *self,
long double longdoubleNumber,
unsigned long flags,
int width,
@@ -2265,7 +2322,7 @@
BOOLEAN_T isNegative;
BOOLEAN_T isExponentNegative = FALSE;
BOOLEAN_T isHex;
- const char *digits;
+ TRIO_CONST char *digits;
char numberBuffer[MAX_MANTISSA_DIGITS
* (1 + MAX_LOCALE_SEPARATOR_LENGTH) + 1];
char *numberPointer;
@@ -2433,7 +2490,7 @@
/* Insert decimal point */
if ((flags & FLAGS_ALTERNATIVE) || ((fractionDigits > 0) && !onlyzero))
{
- i = StrLength(internalDecimalPoint);
+ i = trio_length(internalDecimalPoint);
while (i> 0)
{
*(--numberPointer) = internalDecimalPoint[--i];
@@ -2459,7 +2516,7 @@
* to the most significant digit, so we have to copy the
* thousand separator backwards
*/
- length = StrLength(internalThousandSeparator);
+ length = trio_length(internalThousandSeparator);
integerDigits += length;
if (((int)(numberPointer - numberBuffer) - length) > 0)
{
@@ -2504,7 +2561,7 @@
* sign + integer part + thousands separators + decimal point
* + fraction + exponent
*/
- expectedWidth = StrLength(numberPointer);
+ expectedWidth = trio_length(numberPointer);
if (isNegative || (flags & FLAGS_SHOWSIGN))
expectedWidth += sizeof("-") - 1;
if (exponentDigits > 0)
@@ -2588,19 +2645,22 @@
}
/*************************************************************************
- * TrioFormatProcess [private]
+ * TrioFormatProcess
+ *
+ * Description:
+ * This is the main engine for formatting output
*/
-static int
-TrioFormatProcess(trio_T *data,
- const char *format,
- parameter_T *parameters)
+TRIO_PRIVATE int
+TrioFormatProcess(trio_class_t *data,
+ TRIO_CONST char *format,
+ trio_parameter_t *parameters)
{
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
int charlen;
#endif
int i;
- const char *string;
+ TRIO_CONST char *string;
void *pointer;
unsigned long flags;
int width;
@@ -2693,9 +2753,11 @@
}
else
#endif
- TrioWriteStringCharacter(data,
- (int)parameters[i].data.number.as_signed,
- flags);
+ {
+ TrioWriteStringCharacter(data,
+ (int)parameters[i].data.number.as_signed,
+ flags);
+ }
if (flags & FLAGS_LEFTADJUST)
{
@@ -2752,7 +2814,7 @@
case FORMAT_POINTER:
{
- reference_T reference;
+ trio_reference_t reference;
reference.data = data;
reference.parameter = ¶meters[i];
@@ -2808,7 +2870,7 @@
#if defined(FORMAT_ERRNO)
case FORMAT_ERRNO:
- string = StrError(parameters[i].data.errorNumber);
+ string = trio_error(parameters[i].data.errorNumber);
if (string)
{
TrioWriteString(data,
@@ -2833,15 +2895,15 @@
#if defined(FORMAT_USER_DEFINED)
case FORMAT_USER_DEFINED:
{
- reference_T reference;
- userdef_T *def = NULL;
+ trio_reference_t reference;
+ trio_userdef_t *def = NULL;
if (parameters[i].user_name[0] == NIL)
{
/* Use handle */
if ((i > 0) ||
(parameters[i - 1].type == FORMAT_PARAMETER))
- def = (userdef_T *)parameters[i - 1].data.pointer;
+ def = (trio_userdef_t *)parameters[i - 1].data.pointer;
}
else
{
@@ -2875,41 +2937,43 @@
}
/*************************************************************************
- * TrioFormatRef [private]
+ * TrioFormatRef
*/
-static int
-TrioFormatRef(reference_T *reference,
- const char *format,
- va_list arglist,
- void **argarray)
+TRIO_PRIVATE int
+TrioFormatRef(trio_reference_t *reference,
+ TRIO_CONST char *format,
+ va_list arglist,
+ void **argarray)
{
int status;
- parameter_T parameters[MAX_PARAMETERS];
+ trio_parameter_t parameters[MAX_PARAMETERS];
- status = TrioPreprocess(TYPE_PRINT, format, parameters, arglist, argarray);
+ status = TrioParse(TYPE_PRINT, format, parameters, arglist, argarray);
if (status < 0)
return status;
- return TrioFormatProcess(reference->data, format, parameters);
+ status = TrioFormatProcess(reference->data, format, parameters);
+ if (reference->data->error != 0)
+ {
+ status = reference->data->error;
+ }
+ return status;
}
/*************************************************************************
- * TrioFormat [private]
- *
- * Description:
- * This is the main engine for formatting output
+ * TrioFormat
*/
-static int
+TRIO_PRIVATE int
TrioFormat(void *destination,
size_t destinationSize,
- void (*OutStream)(trio_T *, int),
- const char *format,
+ void (*OutStream)(trio_class_t *, int),
+ TRIO_CONST char *format,
va_list arglist,
void **argarray)
{
int status;
- trio_T data;
- parameter_T parameters[MAX_PARAMETERS];
+ trio_class_t data;
+ trio_parameter_t parameters[MAX_PARAMETERS];
assert(VALID(OutStream));
assert(VALID(format));
@@ -2918,6 +2982,7 @@
data.OutStream = OutStream;
data.location = destination;
data.max = destinationSize;
+ data.error = 0;
#if defined(USE_LOCALE)
if (NULL == internalLocaleValues)
@@ -2926,18 +2991,23 @@
}
#endif
- status = TrioPreprocess(TYPE_PRINT, format, parameters, arglist, argarray);
+ status = TrioParse(TYPE_PRINT, format, parameters, arglist, argarray);
if (status < 0)
return status;
- return TrioFormatProcess(&data, format, parameters);
+ status = TrioFormatProcess(&data, format, parameters);
+ if (data.error != 0)
+ {
+ status = data.error;
+ }
+ return status;
}
/*************************************************************************
- * TrioOutStreamFile [private]
+ * TrioOutStreamFile
*/
-static void
-TrioOutStreamFile(trio_T *self,
+TRIO_PRIVATE void
+TrioOutStreamFile(trio_class_t *self,
int output)
{
FILE *file = (FILE *)self->location;
@@ -2946,15 +3016,21 @@
assert(VALID(file));
self->processed++;
- self->committed++;
- (void)fputc(output, file);
+ if (fputc(output, file) == EOF)
+ {
+ self->error = TRIO_ERROR_RETURN(TRIO_EOF, 0);
+ }
+ else
+ {
+ self->committed++;
+ }
}
/*************************************************************************
- * TrioOutStreamFileDescriptor [private]
+ * TrioOutStreamFileDescriptor
*/
-static void
-TrioOutStreamFileDescriptor(trio_T *self,
+TRIO_PRIVATE void
+TrioOutStreamFileDescriptor(trio_class_t *self,
int output)
{
int fd = *((int *)self->location);
@@ -2963,16 +3039,22 @@
assert(VALID(self));
ch = (char)output;
- (void)write(fd, &ch, sizeof(char));
self->processed++;
- self->committed++;
+ if (write(fd, &ch, sizeof(char)) == -1)
+ {
+ self->error = TRIO_ERROR_RETURN(TRIO_ERRNO, 0);
+ }
+ else
+ {
+ self->committed++;
+ }
}
/*************************************************************************
- * TrioOutStreamString [private]
+ * TrioOutStreamString
*/
-static void
-TrioOutStreamString(trio_T *self,
+TRIO_PRIVATE void
+TrioOutStreamString(trio_class_t *self,
int output)
{
char **buffer = (char **)self->location;
@@ -2987,10 +3069,10 @@
}
/*************************************************************************
- * TrioOutStreamStringMax [private]
+ * TrioOutStreamStringMax
*/
-static void
-TrioOutStreamStringMax(trio_T *self,
+TRIO_PRIVATE void
+TrioOutStreamStringMax(trio_class_t *self,
int output)
{
char **buffer;
@@ -3009,63 +3091,51 @@
}
/*************************************************************************
- * TrioOutStreamStringDynamic [private]
+ * TrioOutStreamStringDynamic
*/
-#define DYNAMIC_START_SIZE 32
-struct dynamicBuffer {
- char *buffer;
- size_t length;
- size_t allocated;
-};
-
-static void
-TrioOutStreamStringDynamic(trio_T *self,
+TRIO_PRIVATE void
+TrioOutStreamStringDynamic(trio_class_t *self,
int output)
{
- struct dynamicBuffer *infop;
-
assert(VALID(self));
assert(VALID(self->location));
- infop = (struct dynamicBuffer *)self->location;
-
- if (infop->buffer == NULL)
+ if (self->error == 0)
{
- /* Start with a reasonable size */
- infop->buffer = (char *)TRIO_MALLOC(DYNAMIC_START_SIZE);
- if (infop->buffer == NULL)
- return; /* fail */
-
- infop->allocated = DYNAMIC_START_SIZE;
- self->processed = 0;
- self->committed = 0;
+ trio_xstring_append_char((trio_string_t *)self->location,
+ (char)output);
+ self->committed++;
}
- else if (self->committed + sizeof(NIL) >= infop->allocated)
- {
- char *newptr;
-
- /* Allocate increasing chunks */
- newptr = (char *)TRIO_REALLOC(infop->buffer, infop->allocated * 2);
-
- if (newptr == NULL)
- return;
-
- infop->buffer = newptr;
- infop->allocated *= 2;
- }
-
- infop->buffer[self->committed] = (char)output;
- self->committed++;
+ /* The processed variable must always be increased */
self->processed++;
-
- infop->length = self->committed;
}
/*************************************************************************
+ *
+ * Formatted printing functions
+ *
+ ************************************************************************/
+
+#if defined(TRIO_DOCUMENTATION)
+# include "doc/doc_printf.h"
+#endif
+/** @addtogroup Printf
+ @{
+*/
+
+/*************************************************************************
* printf
*/
-int
-trio_printf(const char *format,
+
+/**
+ Print to standard output stream.
+
+ @param format Formatting string.
+ @param ... Arguments.
+ @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_printf(TRIO_CONST char *format,
...)
{
int status;
@@ -3079,8 +3149,15 @@
return status;
}
-int
-trio_vprintf(const char *format,
+/**
+ Print to standard output stream.
+
+ @param format Formatting string.
+ @param args Arguments.
+ @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_vprintf(TRIO_CONST char *format,
va_list args)
{
assert(VALID(format));
@@ -3088,8 +3165,15 @@
return TrioFormat(stdout, 0, TrioOutStreamFile, format, args, NULL);
}
-int
-trio_printfv(const char *format,
+/**
+ Print to standard output stream.
+
+ @param format Formatting string.
+ @param args Arguments.
+ @return Number of printed characters.
+ */
+TRIO_PUBLIC int
+trio_printfv(TRIO_CONST char *format,
void ** args)
{
va_list dummy;
@@ -3102,9 +3186,18 @@
/*************************************************************************
* fprintf
*/
-int
+
+/**
+ Print to file.
+
+ @param file File pointer.
+ @param format Formatting string.
+ @param ... Arguments.
+ @return Number of printed characters.
+ */
+TRIO_PUBLIC int
trio_fprintf(FILE *file,
- const char *format,
+ TRIO_CONST char *format,
...)
{
int status;
@@ -3119,9 +3212,17 @@
return status;
}
-int
+/**
+ Print to file.
+
+ @param file File pointer.
+ @param format Formatting string.
+ @param args Arguments.
+ @return Number of printed characters.
+ */
+TRIO_PUBLIC int
trio_vfprintf(FILE *file,
- const char *format,
+ TRIO_CONST char *format,
va_list args)
{
assert(VALID(file));
@@ -3130,9 +3231,17 @@
return TrioFormat(file, 0, TrioOutStreamFile, format, args, NULL);
}
-int
+/**
+ Print to file.
+
+ @param file File pointer.
+ @param format Formatting string.
+ @param args Arguments.
+ @return Number of printed characters.
+ */
+TRIO_PUBLIC int
trio_fprintfv(FILE *file,
- const char *format,
+ TRIO_CONST char *format,
void ** args)
{
va_list dummy;
@@ -3146,9 +3255,18 @@
/*************************************************************************
* dprintf
*/
-int
+
+/**
+ Print to file descriptor.
+
+ @param fd File descriptor.
+ @param format Formatting string.
+ @param ... Arguments.
+ @return Number of printed characters.
+ */
+TRIO_PUBLIC int
trio_dprintf(int fd,
- const char *format,
+ TRIO_CONST char *format,
...)
{
int status;
@@ -3162,9 +3280,17 @@
return status;
}
-int
+/**
+ Print to file descriptor.
+
+ @param fd File descriptor.
+ @param format Formatting string.
+ @param args Arguments.
+ @return Number of printed characters.
+ */
+TRIO_PUBLIC int
trio_vdprintf(int fd,
- const char *format,
+ TRIO_CONST char *format,
va_list args)
{
assert(VALID(format));
@@ -3172,9 +3298,17 @@
return TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, args, NULL);
}
-int
+/**
+ Print to file descriptor.
+
+ @param fd File descriptor.
+ @param format Formatting string.
+ @param args Arguments.
+ @return Number of printed characters.
+ */
+TRIO_PUBLIC int
trio_dprintfv(int fd,
- const char *format,
+ TRIO_CONST char *format,
void **args)
{
va_list dummy;
@@ -3187,9 +3321,18 @@
/*************************************************************************
* sprintf
*/
-int
+
+/**
+ Print to string.
+
+ @param buffer Output string.
+ @param format Formatting string.
+ @param ... Arguments.
+ @return Number of printed characters.
+ */
+TRIO_PUBLIC int
trio_sprintf(char *buffer,
- const char *format,
+ TRIO_CONST char *format,
...)
{
int status;
@@ -3205,9 +3348,17 @@
return status;
}
-int
+/**
+ Print to string.
+
+ @param buffer Output string.
+ @param format Formatting string.
+ @param args Arguments.
+ @return Number of printed characters.
+ */
+TRIO_PUBLIC int
trio_vsprintf(char *buffer,
- const char *format,
+ TRIO_CONST char *format,
va_list args)
{
int status;
@@ -3220,9 +3371,17 @@
return status;
}
-int
+/**
+ Print to string.
+
+ @param buffer Output string.
+ @param format Formatting string.
+ @param args Arguments.
+ @return Number of printed characters.
+ */
+TRIO_PUBLIC int
trio_sprintfv(char *buffer,
- const char *format,
+ TRIO_CONST char *format,
void **args)
{
int status;
@@ -3239,10 +3398,20 @@
/*************************************************************************
* snprintf
*/
-int
+
+/**
+ Print at most @p max characters to string.
+
+ @param buffer Output string.
+ @param max Maximum number of characters to print.
+ @param format Formatting string.
+ @param ... Arguments.
+ @return Number of printed characters.
+ */
+TRIO_PUBLIC int
trio_snprintf(char *buffer,
- size_t bufferSize,
- const char *format,
+ size_t max,
+ TRIO_CONST char *format,
...)
{
int status;
@@ -3252,18 +3421,27 @@
assert(VALID(format));
va_start(args, format);
- status = TrioFormat(&buffer, bufferSize > 0 ? bufferSize - 1 : 0,
+ status = TrioFormat(&buffer, max > 0 ? max - 1 : 0,
TrioOutStreamStringMax, format, args, NULL);
- if (bufferSize > 0)
+ if (max > 0)
*buffer = NIL;
va_end(args);
return status;
}
-int
+/**
+ Print at most @p max characters to string.
+
+ @param buffer Output string.
+ @param max Maximum number of characters to print.
+ @param format Formatting string.
+ @param args Arguments.
+ @return Number of printed characters.
+ */
+TRIO_PUBLIC int
trio_vsnprintf(char *buffer,
- size_t bufferSize,
- const char *format,
+ size_t max,
+ TRIO_CONST char *format,
va_list args)
{
int status;
@@ -3271,17 +3449,26 @@
assert(VALID(buffer));
assert(VALID(format));
- status = TrioFormat(&buffer, bufferSize > 0 ? bufferSize - 1 : 0,
+ status = TrioFormat(&buffer, max > 0 ? max - 1 : 0,
TrioOutStreamStringMax, format, args, NULL);
- if (bufferSize > 0)
+ if (max > 0)
*buffer = NIL;
return status;
}
-int
+/**
+ Print at most @p max characters to string.
+
+ @param buffer Output string.
+ @param max Maximum number of characters to print.
+ @param format Formatting string.
+ @param args Arguments.
+ @return Number of printed characters.
+ */
+TRIO_PUBLIC int
trio_snprintfv(char *buffer,
- size_t bufferSize,
- const char *format,
+ size_t max,
+ TRIO_CONST char *format,
void **args)
{
int status;
@@ -3290,9 +3477,9 @@
assert(VALID(buffer));
assert(VALID(format));
- status = TrioFormat(&buffer, bufferSize > 0 ? bufferSize - 1 : 0,
+ status = TrioFormat(&buffer, max > 0 ? max - 1 : 0,
TrioOutStreamStringMax, format, dummy, args);
- if (bufferSize > 0)
+ if (max > 0)
*buffer = NIL;
return status;
}
@@ -3302,10 +3489,10 @@
* Appends the new string to the buffer string overwriting the '\0'
* character at the end of buffer.
*/
-int
+TRIO_PUBLIC int
trio_snprintfcat(char *buffer,
- size_t bufferSize,
- const char *format,
+ size_t max,
+ TRIO_CONST char *format,
...)
{
int status;
@@ -3317,20 +3504,20 @@
assert(VALID(buffer));
assert(VALID(format));
- buf_len = strlen(buffer);
+ buf_len = trio_length(buffer);
buffer = &buffer[buf_len];
- status = TrioFormat(&buffer, bufferSize - 1 - buf_len,
+ status = TrioFormat(&buffer, max - 1 - buf_len,
TrioOutStreamStringMax, format, args, NULL);
va_end(args);
*buffer = NIL;
return status;
}
-int
+TRIO_PUBLIC int
trio_vsnprintfcat(char *buffer,
- size_t bufferSize,
- const char *format,
+ size_t max,
+ TRIO_CONST char *format,
va_list args)
{
int status;
@@ -3338,9 +3525,9 @@
assert(VALID(buffer));
assert(VALID(format));
- buf_len = strlen(buffer);
+ buf_len = trio_length(buffer);
buffer = &buffer[buf_len];
- status = TrioFormat(&buffer, bufferSize - 1 - buf_len,
+ status = TrioFormat(&buffer, max - 1 - buf_len,
TrioOutStreamStringMax, format, args, NULL);
*buffer = NIL;
return status;
@@ -3351,141 +3538,152 @@
*/
/* Deprecated */
-char *
-trio_aprintf(const char *format,
+TRIO_PUBLIC char *
+trio_aprintf(TRIO_CONST char *format,
...)
{
va_list args;
- struct dynamicBuffer info;
+ trio_string_t *info;
+ char *result = NULL;
assert(VALID(format));
- info.buffer = NULL;
- info.length = 0;
- info.allocated = 0;
+ info = trio_xstring_duplicate("");
+ if (info)
+ {
+ va_start(args, format);
+ (void)TrioFormat(info, 0, TrioOutStreamStringDynamic,
+ format, args, NULL);
+ va_end(args);
- va_start(args, format);
- (void)TrioFormat(&info, 0, TrioOutStreamStringDynamic, format, args, NULL);
- va_end(args);
- if (info.length) {
- info.buffer[info.length] = NIL; /* we terminate this with a zero byte */
- return info.buffer;
- }
- else
- return NULL;
+ trio_string_terminate(info);
+ result = trio_string_extract(info);
+ trio_string_destroy(info);
+ }
+ return result;
}
/* Deprecated */
-char *
-trio_vaprintf(const char *format,
+TRIO_PUBLIC char *
+trio_vaprintf(TRIO_CONST char *format,
va_list args)
{
- struct dynamicBuffer info;
-
+ trio_string_t *info;
+ char *result = NULL;
+
assert(VALID(format));
- info.buffer = NULL;
- info.length = 0;
- info.allocated = 0;
-
- (void)TrioFormat(&info, 0, TrioOutStreamStringDynamic, format, args, NULL);
- if (info.length) {
- info.buffer[info.length] = NIL; /* we terminate this with a zero byte */
- return info.buffer;
- }
- else
- return NULL;
+ info = trio_xstring_duplicate("");
+ if (info)
+ {
+ (void)TrioFormat(info, 0, TrioOutStreamStringDynamic,
+ format, args, NULL);
+ trio_string_terminate(info);
+ result = trio_string_extract(info);
+ trio_string_destroy(info);
+ }
+ return result;
}
-int
+TRIO_PUBLIC int
trio_asprintf(char **result,
- const char *format,
+ TRIO_CONST char *format,
...)
{
va_list args;
int status;
- struct dynamicBuffer info;
+ trio_string_t *info;
assert(VALID(format));
- info.buffer = NULL;
- info.length = 0;
- info.allocated = 0;
-
- va_start(args, format);
- status = TrioFormat(&info, 0, TrioOutStreamStringDynamic, format, args, NULL);
- va_end(args);
- if (status < 0) {
- *result = NULL;
- return status;
- }
- if (info.length == 0) {
- /*
- * If the length is zero, no characters have been written and therefore
- * no memory has been allocated, but we must to allocate and return an
- * empty string.
- */
- info.buffer = (char *)TRIO_MALLOC(sizeof(char));
- if (info.buffer == NULL) {
- *result = NULL;
- return TRIO_ERROR_RETURN(TRIO_ENOMEM, 0);
- }
- }
- info.buffer[info.length] = NIL; /* we terminate this with a zero byte */
- *result = info.buffer;
+ *result = NULL;
+ info = trio_xstring_duplicate("");
+ if (info == NULL)
+ {
+ status = TRIO_ERROR_RETURN(TRIO_ENOMEM, 0);
+ }
+ else
+ {
+ va_start(args, format);
+ status = TrioFormat(info, 0, TrioOutStreamStringDynamic,
+ format, args, NULL);
+ va_end(args);
+ if (status >= 0)
+ {
+ trio_string_terminate(info);
+ *result = trio_string_extract(info);
+ }
+ trio_string_destroy(info);
+ }
return status;
}
-int
+TRIO_PUBLIC int
trio_vasprintf(char **result,
- const char *format,
+ TRIO_CONST char *format,
va_list args)
{
int status;
- struct dynamicBuffer info;
-
+ trio_string_t *info;
+
assert(VALID(format));
- info.buffer = NULL;
- info.length = 0;
- info.allocated = 0;
-
- status = TrioFormat(&info, 0, TrioOutStreamStringDynamic, format, args, NULL);
- if (status < 0) {
- *result = NULL;
- return status;
- }
- if (info.length == 0) {
- info.buffer = (char *)TRIO_MALLOC(sizeof(char));
- if (info.buffer == NULL) {
- *result = NULL;
- return TRIO_ERROR_RETURN(TRIO_ENOMEM, 0);
- }
- }
- info.buffer[info.length] = NIL; /* we terminate this with a zero byte */
- *result = info.buffer;
+ *result = NULL;
+ info = trio_xstring_duplicate("");
+ if (info == NULL)
+ {
+ status = TRIO_ERROR_RETURN(TRIO_ENOMEM, 0);
+ }
+ else
+ {
+ status = TrioFormat(info, 0, TrioOutStreamStringDynamic,
+ format, args, NULL);
+ if (status >= 0)
+ {
+ trio_string_terminate(info);
+ *result = trio_string_extract(info);
+ }
+ trio_string_destroy(info);
+ }
return status;
}
+/** @} End of Printf documentation module */
/*************************************************************************
*
- * @CALLBACK
+ * CALLBACK
*
************************************************************************/
+#if defined(TRIO_DOCUMENTATION)
+# include "doc/doc_register.h"
+#endif
+/**
+ @addtogroup UserDefined
+ @{
+*/
+
/*************************************************************************
- * trio_register [public]
+ * trio_register
*/
-void *
+
+/**
+ Register new user-defined specifier.
+
+ @param callback
+ @param name
+ @return Handle.
+ */
+TRIO_PUBLIC void *
trio_register(trio_callback_t callback,
- const char *name)
+ TRIO_CONST char *name)
{
- userdef_T *def;
- userdef_T *prev = NULL;
+ trio_userdef_t *def;
+ trio_userdef_t *prev = NULL;
if (callback == NULL)
return NULL;
@@ -3495,11 +3693,11 @@
/* Handle built-in namespaces */
if (name[0] == ':')
{
- if (StrEqual(name, ":enter"))
+ if (trio_equal(name, ":enter"))
{
internalEnterCriticalRegion = callback;
}
- else if (StrEqual(name, ":leave"))
+ else if (trio_equal(name, ":leave"))
{
internalLeaveCriticalRegion = callback;
}
@@ -3507,7 +3705,7 @@
}
/* Bail out if namespace is too long */
- if (StrLength(name) >= MAX_USER_NAME)
+ if (trio_length(name) >= MAX_USER_NAME)
return NULL;
/* Bail out if namespace already is registered */
@@ -3516,7 +3714,7 @@
return NULL;
}
- def = (userdef_T *)TRIO_MALLOC(sizeof(userdef_T));
+ def = (trio_userdef_t *)TRIO_MALLOC(sizeof(trio_userdef_t));
if (def)
{
if (internalEnterCriticalRegion)
@@ -3534,7 +3732,7 @@
def->callback = callback;
def->name = (name == NULL)
? NULL
- : StrDuplicate(name);
+ : trio_duplicate(name);
def->next = NULL;
if (internalLeaveCriticalRegion)
@@ -3549,9 +3747,9 @@
void
trio_unregister(void *handle)
{
- userdef_T *self = (userdef_T *)handle;
- userdef_T *def;
- userdef_T *prev = NULL;
+ trio_userdef_t *self = (trio_userdef_t *)handle;
+ trio_userdef_t *def;
+ trio_userdef_t *prev = NULL;
assert(VALID(self));
@@ -3571,7 +3769,7 @@
if (internalLeaveCriticalRegion)
(void)internalLeaveCriticalRegion(NULL);
}
- StrFree(self->name);
+ trio_destroy(self->name);
}
TRIO_FREE(self);
}
@@ -3579,12 +3777,12 @@
/*************************************************************************
* trio_get_format [public]
*/
-const char *
+TRIO_CONST char *
trio_get_format(void *ref)
{
- assert(((reference_T *)ref)->parameter->type == FORMAT_USER_DEFINED);
+ assert(((trio_reference_t *)ref)->parameter->type == FORMAT_USER_DEFINED);
- return (((reference_T *)ref)->parameter->user_data);
+ return (((trio_reference_t *)ref)->parameter->user_data);
}
/*************************************************************************
@@ -3593,9 +3791,9 @@
void *
trio_get_argument(void *ref)
{
- assert(((reference_T *)ref)->parameter->type == FORMAT_USER_DEFINED);
+ assert(((trio_reference_t *)ref)->parameter->type == FORMAT_USER_DEFINED);
- return ((reference_T *)ref)->parameter->data.pointer;
+ return ((trio_reference_t *)ref)->parameter->data.pointer;
}
/*************************************************************************
@@ -3604,14 +3802,14 @@
int
trio_get_width(void *ref)
{
- return ((reference_T *)ref)->parameter->width;
+ return ((trio_reference_t *)ref)->parameter->width;
}
void
trio_set_width(void *ref,
int width)
{
- ((reference_T *)ref)->parameter->width = width;
+ ((trio_reference_t *)ref)->parameter->width = width;
}
/*************************************************************************
@@ -3620,14 +3818,14 @@
int
trio_get_precision(void *ref)
{
- return (((reference_T *)ref)->parameter->precision);
+ return (((trio_reference_t *)ref)->parameter->precision);
}
void
trio_set_precision(void *ref,
int precision)
{
- ((reference_T *)ref)->parameter->precision = precision;
+ ((trio_reference_t *)ref)->parameter->precision = precision;
}
/*************************************************************************
@@ -3636,14 +3834,14 @@
int
trio_get_base(void *ref)
{
- return (((reference_T *)ref)->parameter->base);
+ return (((trio_reference_t *)ref)->parameter->base);
}
void
trio_set_base(void *ref,
int base)
{
- ((reference_T *)ref)->parameter->base = base;
+ ((trio_reference_t *)ref)->parameter->base = base;
}
/*************************************************************************
@@ -3652,7 +3850,7 @@
int
trio_get_long(void *ref)
{
- return (((reference_T *)ref)->parameter->flags & FLAGS_LONG);
+ return (((trio_reference_t *)ref)->parameter->flags & FLAGS_LONG);
}
void
@@ -3660,9 +3858,9 @@
int is_long)
{
if (is_long)
- ((reference_T *)ref)->parameter->flags |= FLAGS_LONG;
+ ((trio_reference_t *)ref)->parameter->flags |= FLAGS_LONG;
else
- ((reference_T *)ref)->parameter->flags &= ~FLAGS_LONG;
+ ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_LONG;
}
/*************************************************************************
@@ -3671,7 +3869,7 @@
int
trio_get_longlong(void *ref)
{
- return (((reference_T *)ref)->parameter->flags & FLAGS_QUAD);
+ return (((trio_reference_t *)ref)->parameter->flags & FLAGS_QUAD);
}
void
@@ -3679,9 +3877,9 @@
int is_longlong)
{
if (is_longlong)
- ((reference_T *)ref)->parameter->flags |= FLAGS_QUAD;
+ ((trio_reference_t *)ref)->parameter->flags |= FLAGS_QUAD;
else
- ((reference_T *)ref)->parameter->flags &= ~FLAGS_QUAD;
+ ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_QUAD;
}
/*************************************************************************
@@ -3690,7 +3888,7 @@
int
trio_get_longdouble(void *ref)
{
- return (((reference_T *)ref)->parameter->flags & FLAGS_LONGDOUBLE);
+ return (((trio_reference_t *)ref)->parameter->flags & FLAGS_LONGDOUBLE);
}
void
@@ -3698,9 +3896,9 @@
int is_longdouble)
{
if (is_longdouble)
- ((reference_T *)ref)->parameter->flags |= FLAGS_LONGDOUBLE;
+ ((trio_reference_t *)ref)->parameter->flags |= FLAGS_LONGDOUBLE;
else
- ((reference_T *)ref)->parameter->flags &= ~FLAGS_LONGDOUBLE;
+ ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_LONGDOUBLE;
}
/*************************************************************************
@@ -3709,7 +3907,7 @@
int
trio_get_short(void *ref)
{
- return (((reference_T *)ref)->parameter->flags & FLAGS_SHORT);
+ return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SHORT);
}
void
@@ -3717,9 +3915,9 @@
int is_short)
{
if (is_short)
- ((reference_T *)ref)->parameter->flags |= FLAGS_SHORT;
+ ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SHORT;
else
- ((reference_T *)ref)->parameter->flags &= ~FLAGS_SHORT;
+ ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SHORT;
}
/*************************************************************************
@@ -3728,7 +3926,7 @@
int
trio_get_shortshort(void *ref)
{
- return (((reference_T *)ref)->parameter->flags & FLAGS_SHORTSHORT);
+ return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SHORTSHORT);
}
void
@@ -3736,9 +3934,9 @@
int is_shortshort)
{
if (is_shortshort)
- ((reference_T *)ref)->parameter->flags |= FLAGS_SHORTSHORT;
+ ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SHORTSHORT;
else
- ((reference_T *)ref)->parameter->flags &= ~FLAGS_SHORTSHORT;
+ ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SHORTSHORT;
}
/*************************************************************************
@@ -3747,7 +3945,7 @@
int
trio_get_alternative(void *ref)
{
- return (((reference_T *)ref)->parameter->flags & FLAGS_ALTERNATIVE);
+ return (((trio_reference_t *)ref)->parameter->flags & FLAGS_ALTERNATIVE);
}
void
@@ -3755,9 +3953,9 @@
int is_alternative)
{
if (is_alternative)
- ((reference_T *)ref)->parameter->flags |= FLAGS_ALTERNATIVE;
+ ((trio_reference_t *)ref)->parameter->flags |= FLAGS_ALTERNATIVE;
else
- ((reference_T *)ref)->parameter->flags &= ~FLAGS_ALTERNATIVE;
+ ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_ALTERNATIVE;
}
/*************************************************************************
@@ -3766,7 +3964,7 @@
int
trio_get_alignment(void *ref)
{
- return (((reference_T *)ref)->parameter->flags & FLAGS_LEFTADJUST);
+ return (((trio_reference_t *)ref)->parameter->flags & FLAGS_LEFTADJUST);
}
void
@@ -3774,9 +3972,9 @@
int is_leftaligned)
{
if (is_leftaligned)
- ((reference_T *)ref)->parameter->flags |= FLAGS_LEFTADJUST;
+ ((trio_reference_t *)ref)->parameter->flags |= FLAGS_LEFTADJUST;
else
- ((reference_T *)ref)->parameter->flags &= ~FLAGS_LEFTADJUST;
+ ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_LEFTADJUST;
}
/*************************************************************************
@@ -3785,7 +3983,7 @@
int
trio_get_spacing(void *ref)
{
- return (((reference_T *)ref)->parameter->flags & FLAGS_SPACE);
+ return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SPACE);
}
void
@@ -3793,9 +3991,9 @@
int is_space)
{
if (is_space)
- ((reference_T *)ref)->parameter->flags |= FLAGS_SPACE;
+ ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SPACE;
else
- ((reference_T *)ref)->parameter->flags &= ~FLAGS_SPACE;
+ ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SPACE;
}
/*************************************************************************
@@ -3804,7 +4002,7 @@
int
trio_get_sign(void *ref)
{
- return (((reference_T *)ref)->parameter->flags & FLAGS_SHOWSIGN);
+ return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SHOWSIGN);
}
void
@@ -3812,9 +4010,9 @@
int is_sign)
{
if (is_sign)
- ((reference_T *)ref)->parameter->flags |= FLAGS_SHOWSIGN;
+ ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SHOWSIGN;
else
- ((reference_T *)ref)->parameter->flags &= ~FLAGS_SHOWSIGN;
+ ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SHOWSIGN;
}
/*************************************************************************
@@ -3823,7 +4021,7 @@
int
trio_get_padding(void *ref)
{
- return (((reference_T *)ref)->parameter->flags & FLAGS_NILPADDING);
+ return (((trio_reference_t *)ref)->parameter->flags & FLAGS_NILPADDING);
}
void
@@ -3831,9 +4029,9 @@
int is_padding)
{
if (is_padding)
- ((reference_T *)ref)->parameter->flags |= FLAGS_NILPADDING;
+ ((trio_reference_t *)ref)->parameter->flags |= FLAGS_NILPADDING;
else
- ((reference_T *)ref)->parameter->flags &= ~FLAGS_NILPADDING;
+ ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_NILPADDING;
}
/*************************************************************************
@@ -3842,7 +4040,7 @@
int
trio_get_quote(void *ref)
{
- return (((reference_T *)ref)->parameter->flags & FLAGS_QUOTE);
+ return (((trio_reference_t *)ref)->parameter->flags & FLAGS_QUOTE);
}
void
@@ -3850,9 +4048,9 @@
int is_quote)
{
if (is_quote)
- ((reference_T *)ref)->parameter->flags |= FLAGS_QUOTE;
+ ((trio_reference_t *)ref)->parameter->flags |= FLAGS_QUOTE;
else
- ((reference_T *)ref)->parameter->flags &= ~FLAGS_QUOTE;
+ ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_QUOTE;
}
/*************************************************************************
@@ -3861,7 +4059,7 @@
int
trio_get_upper(void *ref)
{
- return (((reference_T *)ref)->parameter->flags & FLAGS_UPPER);
+ return (((trio_reference_t *)ref)->parameter->flags & FLAGS_UPPER);
}
void
@@ -3869,9 +4067,9 @@
int is_upper)
{
if (is_upper)
- ((reference_T *)ref)->parameter->flags |= FLAGS_UPPER;
+ ((trio_reference_t *)ref)->parameter->flags |= FLAGS_UPPER;
else
- ((reference_T *)ref)->parameter->flags &= ~FLAGS_UPPER;
+ ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_UPPER;
}
/*************************************************************************
@@ -3881,7 +4079,7 @@
int
trio_get_largest(void *ref)
{
- return (((reference_T *)ref)->parameter->flags & FLAGS_INTMAX_T);
+ return (((trio_reference_t *)ref)->parameter->flags & FLAGS_INTMAX_T);
}
void
@@ -3889,9 +4087,9 @@
int is_largest)
{
if (is_largest)
- ((reference_T *)ref)->parameter->flags |= FLAGS_INTMAX_T;
+ ((trio_reference_t *)ref)->parameter->flags |= FLAGS_INTMAX_T;
else
- ((reference_T *)ref)->parameter->flags &= ~FLAGS_INTMAX_T;
+ ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_INTMAX_T;
}
#endif
@@ -3901,7 +4099,7 @@
int
trio_get_ptrdiff(void *ref)
{
- return (((reference_T *)ref)->parameter->flags & FLAGS_PTRDIFF_T);
+ return (((trio_reference_t *)ref)->parameter->flags & FLAGS_PTRDIFF_T);
}
void
@@ -3909,9 +4107,9 @@
int is_ptrdiff)
{
if (is_ptrdiff)
- ((reference_T *)ref)->parameter->flags |= FLAGS_PTRDIFF_T;
+ ((trio_reference_t *)ref)->parameter->flags |= FLAGS_PTRDIFF_T;
else
- ((reference_T *)ref)->parameter->flags &= ~FLAGS_PTRDIFF_T;
+ ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_PTRDIFF_T;
}
/*************************************************************************
@@ -3921,7 +4119,7 @@
int
trio_get_size(void *ref)
{
- return (((reference_T *)ref)->parameter->flags & FLAGS_SIZE_T);
+ return (((trio_reference_t *)ref)->parameter->flags & FLAGS_SIZE_T);
}
void
@@ -3929,9 +4127,9 @@
int is_size)
{
if (is_size)
- ((reference_T *)ref)->parameter->flags |= FLAGS_SIZE_T;
+ ((trio_reference_t *)ref)->parameter->flags |= FLAGS_SIZE_T;
else
- ((reference_T *)ref)->parameter->flags &= ~FLAGS_SIZE_T;
+ ((trio_reference_t *)ref)->parameter->flags &= ~FLAGS_SIZE_T;
}
#endif
@@ -3942,7 +4140,7 @@
trio_print_int(void *ref,
int number)
{
- reference_T *self = (reference_T *)ref;
+ trio_reference_t *self = (trio_reference_t *)ref;
TrioWriteNumber(self->data,
(trio_intmax_t)number,
@@ -3959,7 +4157,7 @@
trio_print_uint(void *ref,
unsigned int number)
{
- reference_T *self = (reference_T *)ref;
+ trio_reference_t *self = (trio_reference_t *)ref;
TrioWriteNumber(self->data,
(trio_intmax_t)number,
@@ -3976,7 +4174,7 @@
trio_print_double(void *ref,
double number)
{
- reference_T *self = (reference_T *)ref;
+ trio_reference_t *self = (trio_reference_t *)ref;
TrioWriteDouble(self->data,
number,
@@ -3993,7 +4191,7 @@
trio_print_string(void *ref,
char *string)
{
- reference_T *self = (reference_T *)ref;
+ trio_reference_t *self = (trio_reference_t *)ref;
TrioWriteString(self->data,
string,
@@ -4009,13 +4207,13 @@
trio_print_pointer(void *ref,
void *pointer)
{
- reference_T *self = (reference_T *)ref;
+ trio_reference_t *self = (trio_reference_t *)ref;
unsigned long flags;
trio_uintmax_t number;
if (NULL == pointer)
{
- const char *string = null;
+ TRIO_CONST char *string = internalNullString;
while (*string)
self->data->OutStream(self->data, *string++);
}
@@ -4025,7 +4223,7 @@
* The subtraction of the null pointer is a workaround
* to avoid a compiler warning. The performance overhead
* is negligible (and likely to be removed by an
- * optimizing compiler). The (char *) casting is done
+ * optimising compiler). The (char *) casting is done
* to please ANSI C++.
*/
number = (trio_uintmax_t)((char *)pointer - (char *)0);
@@ -4048,7 +4246,7 @@
*/
int
trio_print_ref(void *ref,
- const char *format,
+ TRIO_CONST char *format,
...)
{
int status;
@@ -4057,7 +4255,7 @@
assert(VALID(format));
va_start(arglist, format);
- status = TrioFormatRef((reference_T *)ref, format, arglist, NULL);
+ status = TrioFormatRef((trio_reference_t *)ref, format, arglist, NULL);
va_end(arglist);
return status;
}
@@ -4067,12 +4265,12 @@
*/
int
trio_vprint_ref(void *ref,
- const char *format,
+ TRIO_CONST char *format,
va_list arglist)
{
assert(VALID(format));
- return TrioFormatRef((reference_T *)ref, format, arglist, NULL);
+ return TrioFormatRef((trio_reference_t *)ref, format, arglist, NULL);
}
/*************************************************************************
@@ -4080,29 +4278,30 @@
*/
int
trio_printv_ref(void *ref,
- const char *format,
+ TRIO_CONST char *format,
void **argarray)
{
va_list dummy;
assert(VALID(format));
- return TrioFormatRef((reference_T *)ref, format, dummy, argarray);
+ return TrioFormatRef((trio_reference_t *)ref, format, dummy, argarray);
}
+/** @} End of UserDefined documentation module */
/*************************************************************************
*
- * @SCANNING
+ * SCANNING
*
************************************************************************/
/*************************************************************************
- * TrioSkipWhitespaces [private]
+ * TrioSkipWhitespaces
*/
-static int
-TrioSkipWhitespaces(trio_T *self)
+TRIO_PRIVATE int
+TrioSkipWhitespaces(trio_class_t *self)
{
int ch;
@@ -4115,11 +4314,11 @@
}
/*************************************************************************
- * TrioGetCollation [private]
+ * TrioGetCollation
*/
#if TRIO_EXTENSION
-static void
-TrioGetCollation()
+TRIO_PRIVATE void
+TrioGetCollation(void)
{
int i;
int j;
@@ -4137,7 +4336,7 @@
for (j = 0; j < MAX_CHARACTER_CLASS; j++)
{
second[0] = (char)j;
- if (StrEqualLocale(first, second))
+ if (trio_equal_locale(first, second))
internalCollationArray[i][k++] = (char)j;
}
internalCollationArray[i][k] = NIL;
@@ -4146,13 +4345,13 @@
#endif
/*************************************************************************
- * TrioGetCharacterClass [private]
+ * TrioGetCharacterClass
*
* FIXME:
* multibyte
*/
-static int
-TrioGetCharacterClass(const char *format,
+TRIO_PRIVATE int
+TrioGetCharacterClass(TRIO_CONST char *format,
int *indexPointer,
unsigned long *flagsPointer,
int *characterclass)
@@ -4264,7 +4463,7 @@
if (internalCollationUnconverted)
{
- /* Lazy evaluation of collation array */
+ /* Lazy evalutation of collation array */
TrioGetCollation();
internalCollationUnconverted = FALSE;
}
@@ -4292,88 +4491,88 @@
case QUALIFIER_COLON: /* Character class expressions */
- if (StrEqualMax(CLASS_ALNUM, sizeof(CLASS_ALNUM) - 1,
- &format[index]))
+ if (trio_equal_max(CLASS_ALNUM, sizeof(CLASS_ALNUM) - 1,
+ &format[index]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isalnum(i))
characterclass[i]++;
index += sizeof(CLASS_ALNUM) - 1;
}
- else if (StrEqualMax(CLASS_ALPHA, sizeof(CLASS_ALPHA) - 1,
- &format[index]))
+ else if (trio_equal_max(CLASS_ALPHA, sizeof(CLASS_ALPHA) - 1,
+ &format[index]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isalpha(i))
characterclass[i]++;
index += sizeof(CLASS_ALPHA) - 1;
}
- else if (StrEqualMax(CLASS_CNTRL, sizeof(CLASS_CNTRL) - 1,
- &format[index]))
+ else if (trio_equal_max(CLASS_CNTRL, sizeof(CLASS_CNTRL) - 1,
+ &format[index]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (iscntrl(i))
characterclass[i]++;
index += sizeof(CLASS_CNTRL) - 1;
}
- else if (StrEqualMax(CLASS_DIGIT, sizeof(CLASS_DIGIT) - 1,
- &format[index]))
+ else if (trio_equal_max(CLASS_DIGIT, sizeof(CLASS_DIGIT) - 1,
+ &format[index]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isdigit(i))
characterclass[i]++;
index += sizeof(CLASS_DIGIT) - 1;
}
- else if (StrEqualMax(CLASS_GRAPH, sizeof(CLASS_GRAPH) - 1,
- &format[index]))
+ else if (trio_equal_max(CLASS_GRAPH, sizeof(CLASS_GRAPH) - 1,
+ &format[index]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isgraph(i))
characterclass[i]++;
index += sizeof(CLASS_GRAPH) - 1;
}
- else if (StrEqualMax(CLASS_LOWER, sizeof(CLASS_LOWER) - 1,
- &format[index]))
+ else if (trio_equal_max(CLASS_LOWER, sizeof(CLASS_LOWER) - 1,
+ &format[index]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (islower(i))
characterclass[i]++;
index += sizeof(CLASS_LOWER) - 1;
}
- else if (StrEqualMax(CLASS_PRINT, sizeof(CLASS_PRINT) - 1,
- &format[index]))
+ else if (trio_equal_max(CLASS_PRINT, sizeof(CLASS_PRINT) - 1,
+ &format[index]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isprint(i))
characterclass[i]++;
index += sizeof(CLASS_PRINT) - 1;
}
- else if (StrEqualMax(CLASS_PUNCT, sizeof(CLASS_PUNCT) - 1,
- &format[index]))
+ else if (trio_equal_max(CLASS_PUNCT, sizeof(CLASS_PUNCT) - 1,
+ &format[index]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (ispunct(i))
characterclass[i]++;
index += sizeof(CLASS_PUNCT) - 1;
}
- else if (StrEqualMax(CLASS_SPACE, sizeof(CLASS_SPACE) - 1,
- &format[index]))
+ else if (trio_equal_max(CLASS_SPACE, sizeof(CLASS_SPACE) - 1,
+ &format[index]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isspace(i))
characterclass[i]++;
index += sizeof(CLASS_SPACE) - 1;
}
- else if (StrEqualMax(CLASS_UPPER, sizeof(CLASS_UPPER) - 1,
- &format[index]))
+ else if (trio_equal_max(CLASS_UPPER, sizeof(CLASS_UPPER) - 1,
+ &format[index]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isupper(i))
characterclass[i]++;
index += sizeof(CLASS_UPPER) - 1;
}
- else if (StrEqualMax(CLASS_XDIGIT, sizeof(CLASS_XDIGIT) - 1,
- &format[index]))
+ else if (trio_equal_max(CLASS_XDIGIT, sizeof(CLASS_XDIGIT) - 1,
+ &format[index]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isxdigit(i))
@@ -4403,13 +4602,13 @@
}
/*************************************************************************
- * TrioReadNumber [private]
+ * TrioReadNumber
*
* We implement our own number conversion in preference of strtol and
* strtoul, because we must handle 'long long' and thousand separators.
*/
-static BOOLEAN_T
-TrioReadNumber(trio_T *self,
+TRIO_PRIVATE BOOLEAN_T
+TrioReadNumber(trio_class_t *self,
trio_uintmax_t *target,
unsigned long flags,
int width,
@@ -4532,10 +4731,10 @@
}
/*************************************************************************
- * TrioReadChar [private]
+ * TrioReadChar
*/
-static int
-TrioReadChar(trio_T *self,
+TRIO_PRIVATE int
+TrioReadChar(trio_class_t *self,
char *target,
unsigned long flags,
int width)
@@ -4596,10 +4795,10 @@
}
/*************************************************************************
- * TrioReadString [private]
+ * TrioReadString
*/
-static BOOLEAN_T
-TrioReadString(trio_T *self,
+TRIO_PRIVATE BOOLEAN_T
+TrioReadString(trio_class_t *self,
char *target,
unsigned long flags,
int width)
@@ -4629,11 +4828,11 @@
}
/*************************************************************************
- * TrioReadWideChar [private]
+ * TrioReadWideChar
*/
#if TRIO_WIDECHAR
-static int
-TrioReadWideChar(trio_T *self,
+TRIO_PRIVATE int
+TrioReadWideChar(trio_class_t *self,
wchar_t *target,
unsigned long flags,
int width)
@@ -4688,11 +4887,11 @@
#endif /* TRIO_WIDECHAR */
/*************************************************************************
- * TrioReadWideString [private]
+ * TrioReadWideString
*/
#if TRIO_WIDECHAR
-static BOOLEAN_T
-TrioReadWideString(trio_T *self,
+TRIO_PRIVATE BOOLEAN_T
+TrioReadWideString(trio_class_t *self,
wchar_t *target,
unsigned long flags,
int width)
@@ -4725,18 +4924,18 @@
i += size;
}
if (target)
- target[i] = L'\0';
+ target[i] = WCONST('\0');
return TRUE;
}
#endif /* TRIO_WIDECHAR */
/*************************************************************************
- * TrioReadGroup [private]
+ * TrioReadGroup
*
* FIXME: characterclass does not work with multibyte characters
*/
-static BOOLEAN_T
-TrioReadGroup(trio_T *self,
+TRIO_PRIVATE BOOLEAN_T
+TrioReadGroup(trio_class_t *self,
char *target,
int *characterclass,
unsigned long flags,
@@ -4766,13 +4965,13 @@
}
/*************************************************************************
- * TrioReadDouble [private]
+ * TrioReadDouble
*
* FIXME:
* add long double
*/
-static BOOLEAN_T
-TrioReadDouble(trio_T *self,
+TRIO_PRIVATE BOOLEAN_T
+TrioReadDouble(trio_class_t *self,
double *target,
unsigned long flags,
int width)
@@ -4790,8 +4989,8 @@
TrioSkipWhitespaces(self);
/*
- * Read entire double number from stream. StrToDouble requires a
- * string as input, but InStream can be anything, so we have to
+ * Read entire double number from stream. trio_to_double requires
+ * a string as input, but InStream can be anything, so we have to
* collect all characters.
*/
ch = self->current;
@@ -4822,17 +5021,17 @@
doubleString[index] = NIL;
/* Case insensitive string comparison */
- if (StrEqual(&doubleString[start], INFINITE_UPPER) ||
- StrEqual(&doubleString[start], LONG_INFINITE_UPPER))
+ if (trio_equal(&doubleString[start], INFINITE_UPPER) ||
+ trio_equal(&doubleString[start], LONG_INFINITE_UPPER))
{
*target = ((start == 1 && doubleString[0] == '-'))
? trio_ninf()
: trio_pinf();
return TRUE;
}
- if (StrEqual(doubleString, NAN_LOWER))
+ if (trio_equal(doubleString, NAN_UPPER))
{
- /* NaN must not have a preceding + nor - */
+ /* NaN must not have a preceeding + nor - */
*target = trio_nan();
return TRUE;
}
@@ -4913,25 +5112,25 @@
return FALSE;
if (flags & FLAGS_LONGDOUBLE)
-/* *longdoublePointer = StrToLongDouble()*/
+/* *longdoublePointer = trio_to_long_double()*/
return FALSE; /* FIXME: Remove when long double is implemented */
else
{
- *target = StrToDouble(doubleString, NULL);
+ *target = trio_to_double(doubleString, NULL);
}
return TRUE;
}
/*************************************************************************
- * TrioReadPointer [private]
+ * TrioReadPointer
*/
-static BOOLEAN_T
-TrioReadPointer(trio_T *self,
+TRIO_PRIVATE BOOLEAN_T
+TrioReadPointer(trio_class_t *self,
void **target,
unsigned long flags)
{
trio_uintmax_t number;
- char buffer[sizeof(null)];
+ char buffer[sizeof(internalNullString)];
flags |= (FLAGS_UNSIGNED | FLAGS_ALTERNATIVE | FLAGS_NILPADDING);
@@ -4954,9 +5153,9 @@
? NULL
: buffer,
0,
- sizeof(null) - 1))
+ sizeof(internalNullString) - 1))
{
- if (StrEqualCase(buffer, null))
+ if (trio_equal_case(buffer, internalNullString))
{
if (target)
*target = NULL;
@@ -4967,26 +5166,19 @@
}
/*************************************************************************
- * TrioScan [private]
+ * TrioScanProcess
*/
-static int
-TrioScan(const void *source,
- size_t sourceSize,
- void (*InStream)(trio_T *, int *),
- const char *format,
- va_list arglist,
- void **argarray)
+TRIO_PRIVATE int
+TrioScanProcess(trio_class_t *data,
+ TRIO_CONST char *format,
+ trio_parameter_t *parameters)
{
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
int charlen;
-#endif
- int status;
- int assignment;
- parameter_T parameters[MAX_PARAMETERS];
- trio_T internalData;
- trio_T *data;
- int ch;
int cnt;
+#endif
+ int assignment;
+ int ch;
int index; /* Index of format string */
int i; /* Index of current parameter */
unsigned long flags;
@@ -4994,26 +5186,6 @@
int base;
void *pointer;
- assert(VALID(InStream));
- assert(VALID(format));
-
- memset(&internalData, 0, sizeof(internalData));
- data = &internalData;
- data->InStream = InStream;
- data->location = (void *)source;
- data->max = sourceSize;
-
-#if defined(USE_LOCALE)
- if (NULL == internalLocaleValues)
- {
- TrioSetLocale();
- }
-#endif
-
- status = TrioPreprocess(TYPE_SCAN, format, parameters, arglist, argarray);
- if (status < 0)
- return status;
-
assignment = 0;
i = 0;
index = 0;
@@ -5292,7 +5464,7 @@
data->InStream(data, &ch);
}
else
- return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
+ return assignment;
index++;
}
@@ -5301,10 +5473,53 @@
}
/*************************************************************************
- * TrioInStreamFile [private]
+ * TrioScan
*/
-static void
-TrioInStreamFile(trio_T *self,
+TRIO_PRIVATE int
+TrioScan(TRIO_CONST void *source,
+ size_t sourceSize,
+ void (*InStream)(trio_class_t *, int *),
+ TRIO_CONST char *format,
+ va_list arglist,
+ void **argarray)
+{
+ int status;
+ trio_parameter_t parameters[MAX_PARAMETERS];
+ trio_class_t data;
+
+ assert(VALID(InStream));
+ assert(VALID(format));
+
+ memset(&data, 0, sizeof(data));
+ data.InStream = InStream;
+ data.location = (void *)source;
+ data.max = sourceSize;
+ data.error = 0;
+
+#if defined(USE_LOCALE)
+ if (NULL == internalLocaleValues)
+ {
+ TrioSetLocale();
+ }
+#endif
+
+ status = TrioParse(TYPE_SCAN, format, parameters, arglist, argarray);
+ if (status < 0)
+ return status;
+
+ status = TrioScanProcess(&data, format, parameters);
+ if (data.error != 0)
+ {
+ status = data.error;
+ }
+ return status;
+}
+
+/*************************************************************************
+ * TrioInStreamFile
+ */
+TRIO_PRIVATE void
+TrioInStreamFile(trio_class_t *self,
int *intPointer)
{
FILE *file = (FILE *)self->location;
@@ -5313,6 +5528,12 @@
assert(VALID(file));
self->current = fgetc(file);
+ if (self->current == EOF)
+ {
+ self->error = (ferror(file))
+ ? TRIO_ERROR_RETURN(TRIO_ERRNO, 0)
+ : TRIO_ERROR_RETURN(TRIO_EOF, 0);
+ }
self->processed++;
self->committed++;
@@ -5323,10 +5544,10 @@
}
/*************************************************************************
- * TrioInStreamFileDescriptor [private]
+ * TrioInStreamFileDescriptor
*/
-static void
-TrioInStreamFileDescriptor(trio_T *self,
+TRIO_PRIVATE void
+TrioInStreamFileDescriptor(trio_class_t *self,
int *intPointer)
{
int fd = *((int *)self->location);
@@ -5336,9 +5557,17 @@
assert(VALID(self));
size = read(fd, &input, sizeof(char));
- self->current = (size == 0) ? EOF : input;
- self->processed++;
+ if (size == -1)
+ {
+ self->error = TRIO_ERROR_RETURN(TRIO_ERRNO, 0);
+ self->current = EOF;
+ }
+ else
+ {
+ self->current = (size == 0) ? EOF : input;
+ }
self->committed++;
+ self->processed++;
if (VALID(intPointer))
{
@@ -5347,10 +5576,10 @@
}
/*************************************************************************
- * TrioInStreamString [private]
+ * TrioInStreamString
*/
-static void
-TrioInStreamString(trio_T *self,
+TRIO_PRIVATE void
+TrioInStreamString(trio_class_t *self,
int *intPointer)
{
unsigned char **buffer;
@@ -5374,10 +5603,31 @@
}
/*************************************************************************
+ *
+ * Formatted scanning functions
+ *
+ ************************************************************************/
+
+#if defined(TRIO_DOCUMENTATION)
+# include "doc/doc_scanf.h"
+#endif
+/** @addtogroup Scanf
+ @{
+*/
+
+/*************************************************************************
* scanf
*/
-int
-trio_scanf(const char *format,
+
+/**
+ Scan characters from standard input stream.
+
+ @param format Formatting string.
+ @param ... Arguments.
+ @return Number of scanned characters.
+ */
+TRIO_PUBLIC int
+trio_scanf(TRIO_CONST char *format,
...)
{
int status;
@@ -5391,8 +5641,8 @@
return status;
}
-int
-trio_vscanf(const char *format,
+TRIO_PUBLIC int
+trio_vscanf(TRIO_CONST char *format,
va_list args)
{
assert(VALID(format));
@@ -5400,8 +5650,8 @@
return TrioScan(stdin, 0, TrioInStreamFile, format, args, NULL);
}
-int
-trio_scanfv(const char *format,
+TRIO_PUBLIC int
+trio_scanfv(TRIO_CONST char *format,
void **args)
{
va_list dummy;
@@ -5414,9 +5664,9 @@
/*************************************************************************
* fscanf
*/
-int
+TRIO_PUBLIC int
trio_fscanf(FILE *file,
- const char *format,
+ TRIO_CONST char *format,
...)
{
int status;
@@ -5431,9 +5681,9 @@
return status;
}
-int
+TRIO_PUBLIC int
trio_vfscanf(FILE *file,
- const char *format,
+ TRIO_CONST char *format,
va_list args)
{
assert(VALID(file));
@@ -5442,9 +5692,9 @@
return TrioScan(file, 0, TrioInStreamFile, format, args, NULL);
}
-int
+TRIO_PUBLIC int
trio_fscanfv(FILE *file,
- const char *format,
+ TRIO_CONST char *format,
void **args)
{
va_list dummy;
@@ -5458,9 +5708,9 @@
/*************************************************************************
* dscanf
*/
-int
+TRIO_PUBLIC int
trio_dscanf(int fd,
- const char *format,
+ TRIO_CONST char *format,
...)
{
int status;
@@ -5474,9 +5724,9 @@
return status;
}
-int
+TRIO_PUBLIC int
trio_vdscanf(int fd,
- const char *format,
+ TRIO_CONST char *format,
va_list args)
{
assert(VALID(format));
@@ -5484,9 +5734,9 @@
return TrioScan(&fd, 0, TrioInStreamFileDescriptor, format, args, NULL);
}
-int
+TRIO_PUBLIC int
trio_dscanfv(int fd,
- const char *format,
+ TRIO_CONST char *format,
void **args)
{
va_list dummy;
@@ -5499,9 +5749,9 @@
/*************************************************************************
* sscanf
*/
-int
-trio_sscanf(const char *buffer,
- const char *format,
+TRIO_PUBLIC int
+trio_sscanf(TRIO_CONST char *buffer,
+ TRIO_CONST char *format,
...)
{
int status;
@@ -5516,9 +5766,9 @@
return status;
}
-int
-trio_vsscanf(const char *buffer,
- const char *format,
+TRIO_PUBLIC int
+trio_vsscanf(TRIO_CONST char *buffer,
+ TRIO_CONST char *format,
va_list args)
{
assert(VALID(buffer));
@@ -5527,9 +5777,9 @@
return TrioScan(&buffer, 0, TrioInStreamString, format, args, NULL);
}
-int
-trio_sscanfv(const char *buffer,
- const char *format,
+TRIO_PUBLIC int
+trio_sscanfv(TRIO_CONST char *buffer,
+ TRIO_CONST char *format,
void **args)
{
va_list dummy;
@@ -5540,3 +5790,4 @@
return TrioScan(&buffer, 0, TrioInStreamString, format, dummy, args);
}
+/** @} End of Scanf documentation module */
diff --git a/trio.h b/trio.h
index 14f2f52..5a38f4a 100644
--- a/trio.h
+++ b/trio.h
@@ -13,6 +13,10 @@
* MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
* CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
*
+ *************************************************************************
+ *
+ * http://ctrio.sourceforge.net/
+ *
************************************************************************/
#ifndef TRIO_TRIO_H
@@ -41,6 +45,11 @@
# define isascii ((unsigned)(x) < 0x80)
#endif
+/* Error macros */
+#define TRIO_ERROR_CODE(x) ((-(x)) & 0x00FF)
+#define TRIO_ERROR_POSITION(x) ((-(x)) >> 8)
+#define TRIO_ERROR_NAME(x) trio_strerror(x)
+
/*
* Error codes.
*
@@ -53,14 +62,10 @@
TRIO_EDBLREF = 4,
TRIO_EGAP = 5,
TRIO_ENOMEM = 6,
- TRIO_ERANGE = 7
+ TRIO_ERANGE = 7,
+ TRIO_ERRNO = 8
};
-/* Error macros */
-#define TRIO_ERROR_CODE(x) ((-(x)) & 0x00FF)
-#define TRIO_ERROR_POSITION(x) ((-(x)) >> 8)
-#define TRIO_ERROR_NAME(x) trio_strerror(x)
-
const char *trio_strerror(int);
/*************************************************************************
@@ -183,13 +188,6 @@
#define vdscanf trio_vdscanf
#endif
-/* strio compatible names */
-#define StrScan trio_sscanf
-#define StrFormat trio_sprintf
-#define StrFormatMax trio_snprintf
-#define StrFormatAlloc trio_aprintf
-#define StrFormatAppendMax trio_snprintfcat
-
#ifdef __cplusplus
} /* extern "C" */
#endif
diff --git a/triodef.h b/triodef.h
index a3ca8b6..3e12cc4 100644
--- a/triodef.h
+++ b/triodef.h
@@ -15,8 +15,8 @@
*
************************************************************************/
-#ifndef __TRIO_TRIODEF_H__
-#define __TRIO_TRIODEF_H__
+#ifndef TRIO_TRIODEF_H
+#define TRIO_TRIODEF_H
/*************************************************************************
* Platform and compiler support detection
@@ -48,12 +48,17 @@
# define TRIO_PLATFORM_UNIX
#elif defined(__QNX__)
# define TRIO_PLATFORM_UNIX
+# define TRIO_PLATFORM_QNX
#elif defined(__CYGWIN__)
# define TRIO_PLATFORM_UNIX
#elif defined(AMIGA) && defined(TRIO_COMPILER_GCC)
# define TRIO_PLATFORM_UNIX
#elif defined(TRIO_COMPILER_MSVC) || defined(WIN32) || defined(_WIN32)
# define TRIO_PLATFORM_WIN32
+#elif defined(VMS) || defined(__VMS)
+# define TRIO_PLATFORM_VMS
+#elif defined(mpeix) || defined(__mpexl)
+# define TRIO_PLATFORM_MPEIX
#endif
#if defined(__STDC__)
@@ -81,4 +86,35 @@
# endif
#endif
-#endif /* __TRIO_TRIODEF_H__ */
+/*************************************************************************
+ * Generic defines
+ */
+
+#if !defined(TRIO_PUBLIC)
+# define TRIO_PUBLIC
+#endif
+#if !defined(TRIO_PRIVATE)
+# define TRIO_PRIVATE static
+#endif
+
+#if defined(TRIO_COMPILER_SUPPORTS_C90) || defined(__cplusplus)
+# define TRIO_CONST const
+# define TRIO_VOLATILE volatile
+# define TRIO_POINTER void *
+# define TRIO_PROTO(x) x
+#else
+# define TRIO_CONST
+# define TRIO_VOLATILE
+# define TRIO_POINTER char *
+# define TRIO_PROTO(x) ()
+#endif
+
+#if defined(TRIO_COMPILER_SUPPORTS_C99) || defined(__cplusplus)
+# define TRIO_INLINE inline
+#elif defined(TRIO_COMPILER_GCC)
+# define TRIO_INLINE __inline__
+#else
+# define TRIO_INLINE
+#endif
+
+#endif /* TRIO_TRIODEF_H */
diff --git a/trionan.c b/trionan.c
index b2a5ec2..0f70f5a 100644
--- a/trionan.c
+++ b/trionan.c
@@ -50,6 +50,7 @@
* NetBSD 1.4 x86 gcc
* NetBSD 1.4 StrongARM gcc
* NetBSD 1.5 Alpha gcc
+ * OpenVMS 7.1 Alpha DEC C 6.0
* RISC OS 4 StrongARM Norcroft C
* Solaris 2.5.1 x86 gcc
* Solaris 2.5.1 Sparc gcc
@@ -63,7 +64,6 @@
static const char rcsid[] = "@(#)$Id$";
-
/*************************************************************************
* Include files
*/
@@ -77,15 +77,17 @@
#if defined(TRIO_PLATFORM_UNIX)
# include <signal.h>
#endif
+#if defined(TRIO_COMPILER_DECC)
+# include <fp_class.h>
+#endif
#include <assert.h>
-#ifdef __STDC__
-# define CONST const
-# define VOLATILE volatile
-#else
-# define CONST
-# define VOLATILE
+#if defined(TRIO_DOCUMENTATION)
+# include "doc/doc_nan.h"
#endif
+/** @addtogroup SpecialQuantities
+ @{
+*/
/*************************************************************************
* Definitions
@@ -94,7 +96,11 @@
/* We must enable IEEE floating-point on Alpha */
#if defined(__alpha) && !defined(_IEEE_FP)
# if defined(TRIO_COMPILER_DECC)
-# error "Must be compiled with option -ieee"
+# if defined(TRIO_PLATFORM_VMS)
+# error "Must be compiled with option /IEEE_MODE=UNDERFLOW_TO_ZERO/FLOAT=IEEE"
+# else
+# error "Must be compiled with option -ieee"
+# endif
# elif defined(TRIO_COMPILER_GCC) && (defined(__osf__) || defined(__linux__))
# error "Must be compiled with option -mieee"
# endif
@@ -128,57 +134,61 @@
* Endian-agnostic indexing macro.
*
* The value of internalEndianMagic, when converted into a 64-bit
- * integer, becomes 0x0001020304050607 (we could have used a 64-bit
+ * integer, becomes 0x0706050403020100 (we could have used a 64-bit
* integer value instead of a double, but not all platforms supports
* that type). The value is automatically encoded with the correct
* endianess by the compiler, which means that we can support any
* kind of endianess. The individual bytes are then used as an index
* for the IEEE 754 bit-patterns and masks.
*/
-#define TRIO_DOUBLE_INDEX(x) (((unsigned char *)&internalEndianMagic)[(x)])
+#define TRIO_DOUBLE_INDEX(x) (((unsigned char *)&internalEndianMagic)[7-(x)])
-static CONST double internalEndianMagic = 1.4015997730788920e-309;
+static TRIO_CONST double internalEndianMagic = 7.949928895127363e-275;
/* Mask for the exponent */
-static CONST unsigned char ieee_754_exponent_mask[] = {
+static TRIO_CONST unsigned char ieee_754_exponent_mask[] = {
0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
/* Mask for the mantissa */
-static CONST unsigned char ieee_754_mantissa_mask[] = {
+static TRIO_CONST unsigned char ieee_754_mantissa_mask[] = {
0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};
/* Bit-pattern for infinity */
-static CONST unsigned char ieee_754_infinity_array[] = {
+static TRIO_CONST unsigned char ieee_754_infinity_array[] = {
0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
/* Bit-pattern for quiet NaN */
-static CONST unsigned char ieee_754_qnan_array[] = {
+static TRIO_CONST unsigned char ieee_754_qnan_array[] = {
0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
/*************************************************************************
+ * Functions
+ */
+
+/*
* trio_make_double
*/
-static double
-trio_make_double(CONST unsigned char *values)
+TRIO_PRIVATE double
+trio_make_double(TRIO_CONST unsigned char *values)
{
- VOLATILE double result;
+ TRIO_VOLATILE double result;
int i;
for (i = 0; i < (int)sizeof(double); i++) {
- ((VOLATILE unsigned char *)&result)[TRIO_DOUBLE_INDEX(i)] = values[i];
+ ((TRIO_VOLATILE unsigned char *)&result)[TRIO_DOUBLE_INDEX(i)] = values[i];
}
return result;
}
-/*************************************************************************
+/*
* trio_examine_double
*/
-static int
+TRIO_PRIVATE int
trio_is_special_quantity(double number,
int *has_mantissa)
{
@@ -200,9 +210,11 @@
#endif /* USE_IEEE_754 */
-/*************************************************************************
- * trio_pinf
- */
+/**
+ Generate positive infinity.
+
+ @return Floating-point representation of positive infinity.
+*/
TRIO_PUBLIC double
trio_pinf(void)
{
@@ -242,9 +254,11 @@
return result;
}
-/*************************************************************************
- * trio_ninf
- */
+/**
+ Generate negative infinity.
+
+ @return Floating-point value of negative infinity.
+*/
TRIO_PUBLIC double
trio_ninf(void)
{
@@ -261,9 +275,11 @@
return result;
}
-/*************************************************************************
- * trio_nan
- */
+/**
+ Generate NaN.
+
+ @return Floating-point representation of NaN.
+*/
TRIO_PUBLIC double
trio_nan(void)
{
@@ -306,11 +322,14 @@
return result;
}
-/*************************************************************************
- * trio_isnan
- */
+/**
+ Check for NaN.
+
+ @param number An arbitrary floating-point number.
+ @return Boolean value indicating whether or not the number is a NaN.
+*/
TRIO_PUBLIC int
-trio_isnan(VOLATILE double number)
+trio_isnan(TRIO_VOLATILE double number)
{
#if defined(isnan) || defined(TRIO_COMPILER_SUPPORTS_UNIX95)
/*
@@ -370,11 +389,14 @@
#endif
}
-/*************************************************************************
- * trio_isinf
- */
+/**
+ Check for infinity.
+
+ @param number An arbitrary floating-point number.
+ @return 1 if positive infinity, -1 if negative infinity, 0 otherwise.
+*/
TRIO_PUBLIC int
-trio_isinf(VOLATILE double number)
+trio_isinf(TRIO_VOLATILE double number)
{
#if defined(TRIO_COMPILER_DECC)
/*
@@ -438,7 +460,15 @@
#endif
}
+/** @} SpecialQuantities */
+
/*************************************************************************
+ * For test purposes.
+ *
+ * Add the following compiler option to include this test code.
+ *
+ * Unix : -DSTANDALONE
+ * VMS : /DEFINE=(STANDALONE)
*/
#if defined(STANDALONE)
# include <stdio.h>
diff --git a/trionan.h b/trionan.h
index 5b983b9..d80a348 100644
--- a/trionan.h
+++ b/trionan.h
@@ -15,50 +15,42 @@
*
************************************************************************/
-#ifndef __TRIO_NAN_H__
-#define __TRIO_NAN_H__
+#ifndef TRIO_NAN_H
+#define TRIO_NAN_H
+
+#include "triodef.h"
#ifdef __cplusplus
extern "C" {
#endif
-
-#ifndef TRIO_PUBLIC
-#define TRIO_PUBLIC
-#endif
-
/*
* Return NaN (Not-a-Number).
*/
-TRIO_PUBLIC
-double trio_nan(void);
+TRIO_PUBLIC double trio_nan(void);
/*
* Return positive infinity.
*/
-TRIO_PUBLIC
-double trio_pinf(void);
+TRIO_PUBLIC double trio_pinf(void);
/*
* Return negative infinity.
*/
-TRIO_PUBLIC
-double trio_ninf(void);
+TRIO_PUBLIC double trio_ninf(void);
/*
* If number is a NaN return non-zero, otherwise return zero.
*/
-TRIO_PUBLIC
-int trio_isnan(double number);
+TRIO_PUBLIC int trio_isnan(double number);
/*
* If number is positive infinity return 1, if number is negative
* infinity return -1, otherwise return 0.
*/
-TRIO_PUBLIC
-int trio_isinf(double number);
+TRIO_PUBLIC int trio_isinf(double number);
#ifdef __cplusplus
}
#endif
-#endif /* __TRIO_NAN_H__ */
+#endif /* TRIO_NAN_H */
diff --git a/triop.h b/triop.h
index ca49fab..ead673a 100644
--- a/triop.h
+++ b/triop.h
@@ -27,6 +27,7 @@
#define TRIO_TRIOP_H
#include <stdlib.h>
+#include <stdarg.h>
#ifdef __cplusplus
extern "C" {
@@ -53,7 +54,7 @@
#ifndef TRIO_EXTENSION
# define TRIO_EXTENSION 1
#endif
-#ifndef TRIO_WIDECHAR
+#ifndef TRIO_WIDECHAR /* Does not work yet. Do not enable */
# define TRIO_WIDECHAR 0
#endif
#ifndef TRIO_ERRORS
@@ -70,7 +71,11 @@
# define TRIO_FREE(x) free(x)
#endif
-typedef int (*trio_callback_t)(void *ref);
+/*************************************************************************
+ * User-defined specifiers
+ */
+
+typedef int (*trio_callback_t)(void *);
void *trio_register(trio_callback_t callback, const char *name);
void trio_unregister(void *handle);
diff --git a/triostr.c b/triostr.c
new file mode 100644
index 0000000..760be55
--- /dev/null
+++ b/triostr.c
@@ -0,0 +1,1753 @@
+/*************************************************************************
+ *
+ * $Id$
+ *
+ * Copyright (C) 2001 Bjorn Reese and Daniel Stenberg.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
+ * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
+ *
+ ************************************************************************/
+
+static const char rcsid[] = "@(#)$Id$";
+
+/*************************************************************************
+ * Include files
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+#include "triostr.h"
+
+/*************************************************************************
+ * Definitions
+ */
+
+#ifndef NULL
+# define NULL 0
+#endif
+#define NIL ((char)0)
+#ifndef FALSE
+# define FALSE (1 == 0)
+# define TRUE (! FALSE)
+#endif
+#define BOOLEAN_T int
+
+#if defined(TRIO_COMPILER_SUPPORTS_C99)
+# define USE_STRTOD
+# define USE_STRTOF
+#elif defined(TRIO_COMPILER_MSVC)
+# define USE_STRTOD
+#endif
+
+#if defined(TRIO_PLATFORM_UNIX)
+# define USE_STRCASECMP
+# define USE_STRNCASECMP
+# define USE_STRERROR
+# if defined(TRIO_PLATFORM_QNX)
+# define strcasecmp(x,y) stricmp(x,y)
+# define strncasecmp(x,y,n) strnicmp(x,y,n)
+# endif
+#elif defined(TRIO_PLATFORM_WIN32)
+# define USE_STRCASECMP
+# define strcasecmp(x,y) strcmpi(x,y)
+#endif
+
+/*************************************************************************
+ * Structures
+ */
+
+struct _trio_string_t
+{
+ char *content;
+ size_t length;
+ size_t allocated;
+};
+
+/*************************************************************************
+ * Static String Functions
+ */
+
+#if defined(TRIO_DOCUMENTATION)
+# include "doc/doc_static.h"
+#endif
+/** @addtogroup StaticStrings
+ @{
+*/
+
+/**
+ Create new string.
+
+ @param size Size of new string.
+ @return Pointer to string, or NULL if allocation failed.
+*/
+TRIO_PUBLIC TRIO_INLINE char *
+trio_create(size_t size)
+{
+ return (char *)TRIO_MALLOC(size);
+}
+
+
+/**
+ Destroy string.
+
+ @param string String to be freed.
+*/
+TRIO_PUBLIC TRIO_INLINE void
+trio_destroy(char *string)
+{
+ if (string)
+ {
+ TRIO_FREE(string);
+ }
+}
+
+
+/**
+ Count the number of characters in a string.
+
+ @param string String to measure.
+ @return Number of characters in @string.
+*/
+TRIO_PUBLIC TRIO_INLINE size_t
+trio_length(const char *string)
+{
+ return strlen(string);
+}
+
+
+/*
+ * TrioDuplicateMax
+ */
+TRIO_PRIVATE char *
+TrioDuplicateMax(const char *source, size_t size)
+{
+ char *target;
+
+ assert(source);
+
+ /* Make room for string plus a terminating zero */
+ size++;
+ target = trio_create(size);
+ if (target)
+ {
+ trio_copy_max(target, size, source);
+ }
+ return target;
+}
+
+
+/**
+ Append @p source at the end of @p target.
+
+ @param target Target string.
+ @param source Source string.
+ @return Boolean value indicating success or failure.
+
+ @pre @p target must point to a memory chunk with sufficient room to
+ contain the @p target string and @p source string.
+ @pre No boundary checking is performed, so insufficient memory will
+ result in a buffer overrun.
+ @post @p target will be zero terminated.
+*/
+TRIO_PUBLIC int
+trio_append(char *target,
+ const char *source)
+{
+ assert(target);
+ assert(source);
+
+ return (strcat(target, source) != NULL);
+}
+
+
+/**
+ Append at most @p max characters from @p source to @p target.
+
+ @param target Target string.
+ @param max Maximum number of characters to append.
+ @param source Source string.
+ @return Boolean value indicating success or failure.
+
+ @pre @p target must point to a memory chuck with sufficient room to
+ contain the @p target string and the @p source string (at most @p max
+ characters).
+ @pre No boundary checking is performed, so insufficient memory will
+ result in a buffer overrun.
+ @post @p target will be zero terminated.
+*/
+TRIO_PUBLIC int
+trio_append_max(char *target,
+ size_t max,
+ const char *source)
+{
+ size_t length;
+
+ assert(target);
+ assert(source);
+
+ length = trio_length(target);
+
+ if (max > length)
+ {
+ strncat(target, source, max - length - 1);
+ }
+ return TRUE;
+}
+
+
+/**
+ Determine if a string contains a substring.
+
+ @param string String to be searched.
+ @param substring String to be found.
+ @return Boolean value indicating success or failure.
+*/
+TRIO_PUBLIC TRIO_INLINE int
+trio_contains(const char *string,
+ const char *substring)
+{
+ assert(string);
+ assert(substring);
+
+ return (0 != strstr(string, substring));
+}
+
+
+/**
+ Copy @p source to @p target.
+
+ @param target Target string.
+ @param source Source string.
+ @return Boolean value indicating success or failure.
+
+ @pre @p target must point to a memory chunk with sufficient room to
+ contain the @p source string.
+ @pre No boundary checking is performed, so insufficient memory will
+ result in a buffer overrun.
+ @post @p target will be zero terminated.
+*/
+TRIO_PUBLIC int
+trio_copy(char *target,
+ const char *source)
+{
+ assert(target);
+ assert(source);
+
+ (void)strcpy(target, source);
+ return TRUE;
+}
+
+
+/**
+ Copy at most @p max characters from @p source to @p target.
+
+ @param target Target string.
+ @param max Maximum number of characters to append.
+ @param source Source string.
+ @return Boolean value indicating success or failure.
+
+ @pre @p target must point to a memory chunk with sufficient room to
+ contain the @p source string (at most @p max characters).
+ @pre No boundary checking is performed, so insufficient memory will
+ result in a buffer overrun.
+ @post @p target will be zero terminated.
+*/
+TRIO_PUBLIC int
+trio_copy_max(char *target,
+ size_t max,
+ const char *source)
+{
+ assert(target);
+ assert(source);
+ assert(max > 0); /* Includes != 0 */
+
+ (void)strncpy(target, source, max - 1);
+ target[max - 1] = (char)0;
+ return TRUE;
+}
+
+
+/**
+ Duplicate @p source.
+
+ @param source Source string.
+ @return A copy of the @p source string.
+
+ @post @p target will be zero terminated.
+*/
+TRIO_PUBLIC char *
+trio_duplicate(const char *source)
+{
+ return TrioDuplicateMax(source, trio_length(source));
+}
+
+
+/**
+ Duplicate at most @p max characters of @p source.
+
+ @param source Source string.
+ @param max Maximum number of characters to duplicate.
+ @return A copy of the @p source string.
+
+ @post @p target will be zero terminated.
+*/
+TRIO_PUBLIC char *
+trio_duplicate_max(const char *source,
+ size_t max)
+{
+ size_t length;
+
+ assert(source);
+ assert(max > 0);
+
+ length = trio_length(source);
+ if (length > max)
+ {
+ length = max;
+ }
+ return TrioDuplicateMax(source, length);
+}
+
+
+/**
+ Compare if two strings are equal.
+
+ @param first First string.
+ @param second Second string.
+ @return Boolean indicating whether the two strings are equal or not.
+
+ Case-insensitive comparison.
+*/
+TRIO_PUBLIC int
+trio_equal(const char *first,
+ const char *second)
+{
+ assert(first);
+ assert(second);
+
+ if ((first != NULL) && (second != NULL))
+ {
+#if defined(USE_STRCASECMP)
+ return (0 == strcasecmp(first, second));
+#else
+ while ((*first != NIL) && (*second != NIL))
+ {
+ if (toupper(*first) != toupper(*second))
+ {
+ break;
+ }
+ first++;
+ second++;
+ }
+ return ((*first == NIL) && (*second == NIL));
+#endif
+ }
+ return FALSE;
+}
+
+
+/**
+ Compare if two strings are equal.
+
+ @param first First string.
+ @param second Second string.
+ @return Boolean indicating whether the two strings are equal or not.
+
+ Case-sensitive comparison.
+*/
+TRIO_PUBLIC int
+trio_equal_case(const char *first,
+ const char *second)
+{
+ assert(first);
+ assert(second);
+
+ if ((first != NULL) && (second != NULL))
+ {
+ return (0 == strcmp(first, second));
+ }
+ return FALSE;
+}
+
+
+/**
+ Compare if two strings up until the first @p max characters are equal.
+
+ @param first First string.
+ @param max Maximum number of characters to compare.
+ @param second Second string.
+ @return Boolean indicating whether the two strings are equal or not.
+
+ Case-sensitive comparison.
+*/
+TRIO_PUBLIC int
+trio_equal_case_max(const char *first,
+ size_t max,
+ const char *second)
+{
+ assert(first);
+ assert(second);
+
+ if ((first != NULL) && (second != NULL))
+ {
+ return (0 == strncmp(first, second, max));
+ }
+ return FALSE;
+}
+
+
+/**
+ Compare if two strings are equal.
+
+ @param first First string.
+ @param second Second string.
+ @return Boolean indicating whether the two strings are equal or not.
+
+ Collating characters are considered equal.
+*/
+TRIO_PUBLIC int
+trio_equal_locale(const char *first,
+ const char *second)
+{
+ assert(first);
+ assert(second);
+
+#if defined(LC_COLLATE)
+ return (strcoll(first, second) == 0);
+#else
+ return trio_equal(first, second);
+#endif
+}
+
+
+/**
+ Compare if two strings up until the first @p max characters are equal.
+
+ @param first First string.
+ @param max Maximum number of characters to compare.
+ @param second Second string.
+ @return Boolean indicating whether the two strings are equal or not.
+
+ Case-insensitive comparison.
+*/
+TRIO_PUBLIC int
+trio_equal_max(const char *first,
+ size_t max,
+ const char *second)
+{
+ assert(first);
+ assert(second);
+
+ if ((first != NULL) && (second != NULL))
+ {
+#if defined(USE_STRNCASECMP)
+ return (0 == strncasecmp(first, second, max));
+#else
+ /* Not adequately tested yet */
+ size_t cnt = 0;
+ while ((*first != NIL) && (*second != NIL) && (cnt <= max))
+ {
+ if (toupper(*first) != toupper(*second))
+ {
+ break;
+ }
+ first++;
+ second++;
+ cnt++;
+ }
+ return ((cnt == max) || ((*first == NIL) && (*second == NIL)));
+#endif
+ }
+ return FALSE;
+}
+
+
+/**
+ Provide a textual description of an error code (errno).
+
+ @param error_number Error number.
+ @return Textual description of @p error_number.
+*/
+TRIO_PUBLIC const char *
+trio_error(int error_number)
+{
+#if defined(USE_STRERROR)
+ return strerror(error_number);
+#else
+ return "unknown";
+#endif
+}
+
+
+/**
+ Format the date/time according to @p format.
+
+ @param target Target string.
+ @param max Maximum number of characters to format.
+ @param format Formatting string.
+ @param datetime Date/time structure.
+ @return Number of formatted characters.
+
+ The formatting string accepts the same specifiers as the standard C
+ function strftime.
+*/
+TRIO_PUBLIC size_t
+trio_format_date_max(char *target,
+ size_t max,
+ const char *format,
+ const struct tm *datetime)
+{
+ assert(target);
+ assert(format);
+ assert(datetime);
+ assert(max > 0);
+
+ return strftime(target, max, format, datetime);
+}
+
+
+/**
+ Calculate a hash value for a string.
+
+ @param string String to be calculated on.
+ @param type Hash function.
+ @return Calculated hash value.
+
+ @p type can be one of the following
+ @li @c TRIO_HASH_PLAIN Plain hash function.
+*/
+TRIO_PUBLIC unsigned long
+trio_hash(const char *string,
+ int type)
+{
+ unsigned long value = 0L;
+ char ch;
+
+ assert(string);
+
+ switch (type)
+ {
+ case TRIO_HASH_PLAIN:
+ while ( (ch = *string++) != NIL )
+ {
+ value *= 31;
+ value += (unsigned long)ch;
+ }
+ break;
+ default:
+ assert(FALSE);
+ break;
+ }
+ return value;
+}
+
+
+/**
+ Find first occurrence of a character in a string.
+
+ @param string String to be searched.
+ @param character Character to be found.
+ @param A pointer to the found character, or NULL if character was not found.
+ */
+TRIO_PUBLIC TRIO_INLINE char *
+trio_index(const char *string,
+ char character)
+{
+ assert(string);
+
+ return strchr(string, character);
+}
+
+
+/**
+ Find last occurrence of a character in a string.
+
+ @param string String to be searched.
+ @param character Character to be found.
+ @param A pointer to the found character, or NULL if character was not found.
+ */
+TRIO_PUBLIC TRIO_INLINE char *
+trio_index_last(const char *string,
+ char character)
+{
+ assert(string);
+
+ return strchr(string, character);
+}
+
+
+/**
+ Convert the alphabetic letters in the string to lower-case.
+
+ @param target String to be converted.
+ @return Number of processed characters (converted or not).
+*/
+TRIO_PUBLIC TRIO_INLINE int
+trio_lower(char *target)
+{
+ assert(target);
+
+ return trio_span_function(target, target, tolower);
+}
+
+
+/**
+ Compare two strings using wildcards.
+
+ @param string String to be searched.
+ @param pattern Pattern, including wildcards, to search for.
+ @return Boolean value indicating success or failure.
+
+ Case-insensitive comparison.
+
+ The following wildcards can be used
+ @li @c * Match any number of characters.
+ @li @c ? Match a single character.
+*/
+TRIO_PUBLIC int
+trio_match(const char *string,
+ const char *pattern)
+{
+ assert(string);
+ assert(pattern);
+
+ for (; ('*' != *pattern); ++pattern, ++string)
+ {
+ if (NIL == *string)
+ {
+ return (NIL == *pattern);
+ }
+ if ((toupper((int)*string) != toupper((int)*pattern))
+ && ('?' != *pattern))
+ {
+ return FALSE;
+ }
+ }
+ /* two-line patch to prevent *too* much recursiveness: */
+ while ('*' == pattern[1])
+ pattern++;
+
+ do
+ {
+ if ( trio_match(string, &pattern[1]) )
+ {
+ return TRUE;
+ }
+ }
+ while (*string++);
+
+ return FALSE;
+}
+
+
+/**
+ Compare two strings using wildcards.
+
+ @param string String to be searched.
+ @param pattern Pattern, including wildcards, to search for.
+ @return Boolean value indicating success or failure.
+
+ Case-sensitive comparison.
+
+ The following wildcards can be used
+ @li @c * Match any number of characters.
+ @li @c ? Match a single character.
+*/
+TRIO_PUBLIC int
+trio_match_case(const char *string,
+ const char *pattern)
+{
+ assert(string);
+ assert(pattern);
+
+ for (; ('*' != *pattern); ++pattern, ++string)
+ {
+ if (NIL == *string)
+ {
+ return (NIL == *pattern);
+ }
+ if ((*string != *pattern)
+ && ('?' != *pattern))
+ {
+ return FALSE;
+ }
+ }
+ /* two-line patch to prevent *too* much recursiveness: */
+ while ('*' == pattern[1])
+ pattern++;
+
+ do
+ {
+ if ( trio_match_case(string, &pattern[1]) )
+ {
+ return TRUE;
+ }
+ }
+ while (*string++);
+
+ return FALSE;
+}
+
+
+/**
+ Execute a function on each character in string.
+
+ @param target Target string.
+ @param source Source string.
+ @param Function Function to be executed.
+ @return Number of processed characters.
+*/
+TRIO_PUBLIC size_t
+trio_span_function(char *target,
+ const char *source,
+ int (*Function)(int))
+{
+ size_t count = 0;
+
+ assert(target);
+ assert(source);
+ assert(Function);
+
+ while (*source != NIL)
+ {
+ *target++ = Function(*source++);
+ count++;
+ }
+ return count;
+}
+
+
+/**
+ Search for a substring in a string.
+
+ @param string String to be searched.
+ @param substring String to be found.
+ @return Pointer to first occurrence of @p substring in @p string, or NULL
+ if no match was found.
+*/
+TRIO_PUBLIC TRIO_INLINE char *
+trio_substring(const char *string,
+ const char *substring)
+{
+ assert(string);
+ assert(substring);
+
+ return strstr(string, substring);
+}
+
+
+/**
+ Search for a substring in the first @p max characters of a string.
+
+ @param string String to be searched.
+ @param max Maximum characters to be searched.
+ @param substring String to be found.
+ @return Pointer to first occurrence of @p substring in @p string, or NULL
+ if no match was found.
+*/
+TRIO_PUBLIC char *
+trio_substring_max(const char *string,
+ size_t max,
+ const char *substring)
+{
+ size_t count;
+ size_t size;
+ char *result = NULL;
+
+ assert(string);
+ assert(substring);
+
+ size = trio_length(substring);
+ if (size <= max)
+ {
+ for (count = 0; count <= max - size; count++)
+ {
+ if (trio_equal_max(substring, size, &string[count]))
+ {
+ result = (char *)&string[count];
+ break;
+ }
+ }
+ }
+ return result;
+}
+
+
+/**
+ Tokenize string.
+
+ @param string String to be tokenized.
+ @param tokens String containing list of delimiting characters.
+ @return Start of new token.
+
+ @warning @p string will be destroyed.
+*/
+TRIO_PUBLIC TRIO_INLINE char *
+trio_tokenize(char *string, const char *delimiters)
+{
+ assert(delimiters);
+
+ return strtok(string, delimiters);
+}
+
+
+/**
+ Convert string to floating-point number.
+
+ @param source String to be converted.
+ @param endp Pointer to end of the converted string.
+ @return A floating-point number.
+
+ The following Extended Backus-Naur form is used
+ @verbatim
+ double ::= [ <sign> ]
+ ( <number> |
+ <number> <decimal_point> <number> |
+ <decimal_point> <number> )
+ [ <exponential> [ <sign> ] <number> ]
+ number ::= 1*( <digit> )
+ digit ::= ( '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' )
+ exponential ::= ( 'e' | 'E' )
+ sign ::= ( '-' | '+' )
+ decimal_point ::= '.'
+ @endverbatim
+*/
+/* FIXME: Add EBNF for hex-floats */
+TRIO_PUBLIC double
+trio_to_double(const char *source,
+ const char **endp)
+{
+#if defined(USE_STRTOD)
+ return strtod(source, (char **)endp);
+#else
+ /* Preliminary code */
+ int isNegative = FALSE;
+ int isExponentNegative = FALSE;
+ unsigned long integer = 0;
+ unsigned long fraction = 0;
+ unsigned long fracdiv = 1;
+ unsigned long exponent = 0;
+ double value = 0.0;
+
+ /* First try hex-floats */
+ if ((source[0] == '0') && ((source[1] == 'x') || (source[1] == 'X')))
+ {
+ source += 2;
+ while (isxdigit((int)*source))
+ {
+ integer *= 16;
+ integer += (isdigit((int)*source)
+ ? (*source - '0')
+ : 10 + (toupper((int)*source) - 'A'));
+ source++;
+ }
+ if (*source == '.')
+ {
+ source++;
+ while (isxdigit((int)*source))
+ {
+ fraction *= 16;
+ fraction += (isdigit((int)*source)
+ ? (*source - '0')
+ : 10 + (toupper((int)*source) - 'A'));
+ fracdiv *= 16;
+ source++;
+ }
+ if ((*source == 'p') || (*source == 'P'))
+ {
+ source++;
+ if ((*source == '+') || (*source == '-'))
+ {
+ isExponentNegative = (*source == '-');
+ source++;
+ }
+ while (isdigit((int)*source))
+ {
+ exponent *= 10;
+ exponent += (*source - '0');
+ source++;
+ }
+ }
+ }
+ }
+ else /* Then try normal decimal floats */
+ {
+ isNegative = (*source == '-');
+ /* Skip sign */
+ if ((*source == '+') || (*source == '-'))
+ source++;
+
+ /* Integer part */
+ while (isdigit((int)*source))
+ {
+ integer *= 10;
+ integer += (*source - '0');
+ source++;
+ }
+
+ if (*source == '.')
+ {
+ source++; /* skip decimal point */
+ while (isdigit((int)*source))
+ {
+ fraction *= 10;
+ fraction += (*source - '0');
+ fracdiv *= 10;
+ source++;
+ }
+ }
+ if ((*source == 'e')
+ || (*source == 'E')
+#if TRIO_MICROSOFT
+ || (*source == 'd')
+ || (*source == 'D')
+#endif
+ )
+ {
+ source++; /* Skip exponential indicator */
+ isExponentNegative = (*source == '-');
+ if ((*source == '+') || (*source == '-'))
+ source++;
+ while (isdigit((int)*source))
+ {
+ exponent *= 10;
+ exponent += (*source - '0');
+ source++;
+ }
+ }
+ }
+
+ value = (double)integer;
+ if (fraction != 0)
+ {
+ value += (double)fraction / (double)fracdiv;
+ }
+ if (exponent != 0)
+ {
+ if (isExponentNegative)
+ value /= pow((double)10, (double)exponent);
+ else
+ value *= pow((double)10, (double)exponent);
+ }
+ if (isNegative)
+ value = -value;
+
+ if (endp)
+ *endp = source;
+ return value;
+#endif
+}
+
+
+/**
+ Convert string to floating-point number.
+
+ @param source String to be converted.
+ @param endp Pointer to end of the converted string.
+ @return A floating-point number.
+
+ See @ref trio_to_double.
+*/
+TRIO_PUBLIC TRIO_INLINE float
+trio_to_float(const char *source,
+ const char **endp)
+{
+#if defined(USE_STRTOF)
+ return strtof(source, (char **)endp);
+#else
+ return (float)trio_to_double(source, endp);
+#endif
+}
+
+
+/**
+ Convert string to signed integer.
+
+ @param string String to be converted.
+ @param endp Pointer to end of converted string.
+ @param base Radix number of number.
+*/
+TRIO_PUBLIC TRIO_INLINE long
+trio_to_long(const char *string,
+ char **endp,
+ int base)
+{
+ assert(string);
+ assert((base >= 2) && (base <= 36));
+
+ return strtol(string, endp, base);
+}
+
+
+/**
+ Convert string to unsigned integer.
+
+ @param string String to be converted.
+ @param endp Pointer to end of converted string.
+ @param base Radix number of number.
+*/
+TRIO_PUBLIC TRIO_INLINE unsigned long
+trio_to_unsigned_long(const char *string,
+ char **endp,
+ int base)
+{
+ assert(string);
+ assert((base >= 2) && (base <= 36));
+
+ return strtoul(string, endp, base);
+}
+
+
+/**
+ Convert the alphabetic letters in the string to upper-case.
+
+ @param target The string to be converted.
+ @return The number of processed characters (converted or not).
+*/
+TRIO_PUBLIC TRIO_INLINE int
+trio_upper(char *target)
+{
+ assert(target);
+
+ return trio_span_function(target, target, toupper);
+}
+
+
+/** @} End of StaticStrings */
+
+
+/*************************************************************************
+ * Dynamic String Functions
+ */
+
+#if defined(TRIO_DOCUMENTATION)
+# include "doc/doc_dynamic.h"
+#endif
+/** @addtogroup DynamicStrings
+ @{
+*/
+
+/*
+ * TrioStringAlloc
+ */
+TRIO_PRIVATE trio_string_t *
+TrioStringAlloc(void)
+{
+ trio_string_t *self;
+
+ self = (trio_string_t *)TRIO_MALLOC(sizeof(trio_string_t));
+ if (self)
+ {
+ self->content = NULL;
+ self->length = 0;
+ self->allocated = 0;
+ }
+ return self;
+}
+
+
+/*
+ * TrioStringGrow
+ *
+ * The size of the string will be increased by 'delta' characters. If
+ * 'delta' is zero, the size will be doubled.
+ */
+TRIO_PRIVATE BOOLEAN_T
+TrioStringGrow(trio_string_t *self,
+ size_t delta)
+{
+ BOOLEAN_T status = FALSE;
+ char *new_content;
+ size_t new_size;
+
+ new_size = (delta == 0)
+ ? ( (self->allocated == 0) ? 1 : self->allocated * 2 )
+ : self->allocated + delta;
+
+ new_content = (char *)TRIO_REALLOC(self->content, new_size);
+ if (new_content)
+ {
+ self->content = new_content;
+ self->allocated = new_size;
+ status = TRUE;
+ }
+ return status;
+}
+
+
+/*
+ * TrioStringGrowTo
+ *
+ * The size of the string will be increased to 'length' plus one characters.
+ * If 'length' is less than the original size, the original size will be
+ * used (that is, the size of the string is never decreased).
+ */
+TRIO_PRIVATE BOOLEAN_T
+TrioStringGrowTo(trio_string_t *self,
+ size_t length)
+{
+ length++; /* Room for terminating zero */
+ return (self->allocated < length)
+ ? TrioStringGrow(self, length - self->allocated)
+ : TRUE;
+}
+
+
+/**
+ Create a new dynamic string.
+
+ @param initial_size Initial size of the buffer.
+ @return Newly allocated dynamic string, or NULL if memory allocation failed.
+*/
+TRIO_PUBLIC trio_string_t *
+trio_string_create(int initial_size)
+{
+ trio_string_t *self;
+
+ self = TrioStringAlloc();
+ if (self)
+ {
+ if (TrioStringGrow(self,
+ (size_t)((initial_size > 0) ? initial_size : 1)))
+ {
+ self->content[0] = (char)0;
+ self->allocated = initial_size;
+ }
+ else
+ {
+ trio_string_destroy(self);
+ self = NULL;
+ }
+ }
+ return self;
+}
+
+
+/**
+ Deallocate the dynamic string and its contents.
+
+ @param self Dynamic string
+*/
+TRIO_PUBLIC void
+trio_string_destroy(trio_string_t *self)
+{
+ assert(self);
+
+ if (self)
+ {
+ trio_destroy(self->content);
+ TRIO_FREE(self);
+ }
+}
+
+
+/**
+ Get a pointer to the content.
+
+ @param self Dynamic string.
+ @param offset Offset into content.
+ @return Pointer to the content.
+
+ @p Offset can be zero, positive, or negative. If @p offset is zero,
+ then the start of the content will be returned. If @p offset is positive,
+ then a pointer to @p offset number of characters from the beginning of the
+ content is returned. If @p offset is negative, then a pointer to @p offset
+ number of characters from the ending of the string, starting at the
+ terminating zero, is returned.
+*/
+TRIO_PUBLIC char *
+trio_string_get(trio_string_t *self, int offset)
+{
+ char *result = NULL;
+
+ assert(self);
+
+ if (self->content != NULL)
+ {
+ if (self->length == 0)
+ {
+ (void)trio_string_length(self);
+ }
+ if (offset >= 0)
+ {
+ if (offset > self->length)
+ {
+ offset = self->length;
+ }
+ }
+ else
+ {
+ offset += self->length + 1;
+ if (offset < 0)
+ {
+ offset = 0;
+ }
+ }
+ result = &(self->content[offset]);
+ }
+ return result;
+}
+
+
+/**
+ Extract the content.
+
+ @param self Dynamic String
+ @return Content of dynamic string.
+
+ The content is removed from the dynamic string. This enables destruction
+ of the dynamic string without deallocation of the content.
+*/
+TRIO_PUBLIC char *
+trio_string_extract(trio_string_t *self)
+{
+ char *result;
+
+ assert(self);
+
+ result = self->content;
+ /* FIXME: Allocate new empty buffer? */
+ self->content = NULL;
+ self->length = self->allocated = 0;
+ return result;
+}
+
+
+/**
+ Set the content of the dynamic string.
+
+ @param self Dynamic String
+ @param buffer The new content.
+
+ Sets the content of the dynamic string to a copy @p buffer.
+ An existing content will be deallocated first, if necessary.
+
+ @remark
+ This function will make a copy of @p buffer.
+ You are responsible for deallocating @p buffer yourself.
+*/
+TRIO_PUBLIC void
+trio_xstring_set(trio_string_t *self,
+ char *buffer)
+{
+ assert(self);
+
+ trio_destroy(self->content);
+ self->content = trio_duplicate(buffer);
+}
+
+
+/*
+ * trio_string_size
+ */
+TRIO_PUBLIC int
+trio_string_size(trio_string_t *self)
+{
+ assert(self);
+
+ return self->allocated;
+}
+
+
+/*
+ * trio_string_terminate
+ */
+TRIO_PUBLIC void
+trio_string_terminate(trio_string_t *self)
+{
+ char *end;
+
+ assert(self);
+
+ end = trio_string_get(self, -1);
+ if (end)
+ {
+ *end = NIL;
+ }
+}
+
+
+/**
+ Append the second string to the first.
+
+ @param self Dynamic string to be modified.
+ @param other Dynamic string to copy from.
+ @return Boolean value indicating success or failure.
+*/
+TRIO_PUBLIC int
+trio_string_append(trio_string_t *self,
+ trio_string_t *other)
+{
+ size_t length;
+
+ assert(self);
+ assert(other);
+
+ length = self->length + other->length;
+ if (!TrioStringGrowTo(self, length))
+ goto error;
+ trio_copy(&self->content[self->length], other->content);
+ self->length = length;
+ return TRUE;
+
+ error:
+ return FALSE;
+}
+
+
+/*
+ * trio_xstring_append
+ */
+TRIO_PUBLIC int
+trio_xstring_append(trio_string_t *self,
+ const char *other)
+{
+ size_t length;
+
+ assert(self);
+ assert(other);
+
+ length = self->length + trio_length(other);
+ if (!TrioStringGrowTo(self, length))
+ goto error;
+ trio_copy(&self->content[self->length], other);
+ self->length = length;
+ return TRUE;
+
+ error:
+ return FALSE;
+}
+
+
+/*
+ * trio_xstring_append_char
+ */
+TRIO_PUBLIC int
+trio_xstring_append_char(trio_string_t *self,
+ char character)
+{
+ assert(self);
+
+ if (self->length >= trio_string_size(self))
+ {
+ if (!TrioStringGrow(self, 0))
+ goto error;
+ }
+ self->content[self->length] = character;
+ self->length++;
+ return TRUE;
+
+ error:
+ return FALSE;
+}
+
+
+/**
+ Search for the first occurrence of second parameter in the first.
+
+ @param self Dynamic string to be modified.
+ @param other Dynamic string to copy from.
+ @return Boolean value indicating success or failure.
+*/
+TRIO_PUBLIC int
+trio_string_contains(trio_string_t *self,
+ trio_string_t *other)
+{
+ assert(self);
+ assert(other);
+
+ return trio_contains(self->content, other->content);
+}
+
+
+/*
+ * trio_xstring_contains
+ */
+TRIO_PUBLIC int
+trio_xstring_contains(trio_string_t *self,
+ const char *other)
+{
+ assert(self);
+ assert(other);
+
+ return trio_contains(self->content, other);
+}
+
+
+/*
+ * trio_string_copy
+ */
+TRIO_PUBLIC int
+trio_string_copy(trio_string_t *self,
+ trio_string_t *other)
+{
+ assert(self);
+ assert(other);
+
+ self->length = 0;
+ return trio_string_append(self, other);
+}
+
+
+/*
+ * trio_xstring_copy
+ */
+TRIO_PUBLIC int
+trio_xstring_copy(trio_string_t *self,
+ const char *other)
+{
+ assert(self);
+ assert(other);
+
+ self->length = 0;
+ return trio_xstring_append(self, other);
+}
+
+
+/*
+ * trio_string_duplicate
+ */
+TRIO_PUBLIC trio_string_t *
+trio_string_duplicate(trio_string_t *other)
+{
+ trio_string_t *self;
+
+ assert(other);
+
+ self = TrioStringAlloc();
+ if (self)
+ {
+ self->content = TrioDuplicateMax(other->content, other->length);
+ if (self->content)
+ {
+ self->length = other->length;
+ self->allocated = self->length + 1;
+ }
+ else
+ {
+ self->length = self->allocated = 0;
+ }
+ }
+ return self;
+}
+
+
+/*
+ * trio_xstring_duplicate
+ */
+TRIO_PUBLIC trio_string_t *
+trio_xstring_duplicate(const char *other)
+{
+ trio_string_t *self;
+
+ assert(other);
+
+ self = TrioStringAlloc();
+ if (self)
+ {
+ self->content = TrioDuplicateMax(other, trio_length(other));
+ if (self->content)
+ {
+ self->length = trio_length(self->content);
+ self->allocated = self->length + 1;
+ }
+ else
+ {
+ self->length = self->allocated = 0;
+ }
+ }
+ return self;
+}
+
+
+/*
+ * trio_string_equal
+ */
+TRIO_PUBLIC int
+trio_string_equal(trio_string_t *self,
+ trio_string_t *other)
+{
+ assert(self);
+ assert(other);
+
+ return trio_equal(self->content, other->content);
+}
+
+
+/*
+ * trio_xstring_equal
+ */
+TRIO_PUBLIC int
+trio_xstring_equal(trio_string_t *self,
+ const char *other)
+{
+ assert(self);
+ assert(other);
+
+ return trio_equal(self->content, other);
+}
+
+
+/*
+ * trio_string_equal_max
+ */
+TRIO_PUBLIC int
+trio_string_equal_max(trio_string_t *self,
+ size_t max,
+ trio_string_t *other)
+{
+ assert(self);
+ assert(other);
+
+ return trio_equal_max(self->content, max, other->content);
+}
+
+
+/*
+ * trio_xstring_equal_max
+ */
+TRIO_PUBLIC int
+trio_xstring_equal_max(trio_string_t *self,
+ size_t max,
+ const char *other)
+{
+ assert(self);
+ assert(other);
+
+ return trio_equal_max(self->content, max, other);
+}
+
+
+/*
+ * trio_string_equal_case
+ */
+TRIO_PUBLIC int
+trio_string_equal_case(trio_string_t *self,
+ trio_string_t *other)
+{
+ assert(self);
+ assert(other);
+
+ return trio_equal_case(self->content, other->content);
+}
+
+
+/*
+ * trio_xstring_equal_case
+ */
+TRIO_PUBLIC int
+trio_xstring_equal_case(trio_string_t *self,
+ const char *other)
+{
+ assert(self);
+ assert(other);
+
+ return trio_equal_case(self->content, other);
+}
+
+
+/*
+ * trio_string_equal_case_max
+ */
+TRIO_PUBLIC int
+trio_string_equal_case_max(trio_string_t *self,
+ size_t max,
+ trio_string_t *other)
+{
+ assert(self);
+ assert(other);
+
+ return trio_equal_case_max(self->content, max, other->content);
+}
+
+
+/*
+ * trio_xstring_equal_case_max
+ */
+TRIO_PUBLIC int
+trio_xstring_equal_case_max(trio_string_t *self,
+ size_t max,
+ const char *other)
+{
+ assert(self);
+ assert(other);
+
+ return trio_equal_case_max(self->content, max, other);
+}
+
+
+/*
+ * trio_string_format_data_max
+ */
+TRIO_PUBLIC size_t
+trio_string_format_date_max(trio_string_t *self,
+ size_t max,
+ const char *format,
+ const struct tm *datetime)
+{
+ assert(self);
+
+ return trio_format_date_max(self->content, max, format, datetime);
+}
+
+
+/*
+ * trio_string_index
+ */
+TRIO_PUBLIC char *
+trio_string_index(trio_string_t *self,
+ int character)
+{
+ assert(self);
+
+ return trio_index(self->content, character);
+}
+
+
+/*
+ * trio_string_index_last
+ */
+TRIO_PUBLIC char *
+trio_string_index_last(trio_string_t *self,
+ int character)
+{
+ assert(self);
+
+ return trio_index_last(self->content, character);
+}
+
+
+/*
+ * trio_string_length
+ */
+TRIO_PUBLIC int
+trio_string_length(trio_string_t *self)
+{
+ assert(self);
+
+ if (self->length == 0)
+ {
+ self->length = trio_length(self->content);
+ }
+ return self->length;
+}
+
+
+/*
+ * trio_string_lower
+ */
+TRIO_PUBLIC int
+trio_string_lower(trio_string_t *self)
+{
+ assert(self);
+
+ return trio_lower(self->content);
+}
+
+
+/*
+ * trio_string_match
+ */
+TRIO_PUBLIC int
+trio_string_match(trio_string_t *self,
+ trio_string_t *other)
+{
+ assert(self);
+ assert(other);
+
+ return trio_match(self->content, other->content);
+}
+
+
+/*
+ * trio_xstring_match
+ */
+TRIO_PUBLIC int
+trio_xstring_match(trio_string_t *self,
+ const char *other)
+{
+ assert(self);
+ assert(other);
+
+ return trio_match(self->content, other);
+}
+
+
+/*
+ * trio_string_match_case
+ */
+TRIO_PUBLIC int
+trio_string_match_case(trio_string_t *self,
+ trio_string_t *other)
+{
+ assert(self);
+ assert(other);
+
+ return trio_match_case(self->content, other->content);
+}
+
+
+/*
+ * trio_xstring_match_case
+ */
+TRIO_PUBLIC int
+trio_xstring_match_case(trio_string_t *self,
+ const char *other)
+{
+ assert(self);
+ assert(other);
+
+ return trio_match_case(self->content, other);
+}
+
+
+/*
+ * trio_string_substring
+ */
+TRIO_PUBLIC char *
+trio_string_substring(trio_string_t *self,
+ trio_string_t *other)
+{
+ assert(self);
+ assert(other);
+
+ return trio_substring(self->content, other->content);
+}
+
+
+/*
+ * trio_xstring_substring
+ */
+TRIO_PUBLIC char *
+trio_xstring_substring(trio_string_t *self,
+ const char *other)
+{
+ assert(self);
+ assert(other);
+
+ return trio_substring(self->content, other);
+}
+
+
+/*
+ * trio_string_upper
+ */
+TRIO_PUBLIC int
+trio_string_upper(trio_string_t *self)
+{
+ assert(self);
+
+ return trio_upper(self->content);
+}
+
+/** @} End of DynamicStrings */
diff --git a/triostr.h b/triostr.h
new file mode 100644
index 0000000..94b01ee
--- /dev/null
+++ b/triostr.h
@@ -0,0 +1,119 @@
+/*************************************************************************
+ *
+ * $Id$
+ *
+ * Copyright (C) 2001 Bjorn Reese and Daniel Stenberg.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
+ * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
+ *
+ ************************************************************************/
+
+#ifndef TRIO_TRIOSTR_H
+#define TRIO_TRIOSTR_H
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include "triodef.h"
+#include "triop.h"
+
+enum {
+ TRIO_HASH_NONE = 0,
+ TRIO_HASH_PLAIN,
+ TRIO_HASH_TWOSIGNED
+};
+
+/*************************************************************************
+ * String functions
+ */
+
+int trio_append(char *target, const char *source);
+int trio_append_max(char *target, size_t max, const char *source);
+int trio_contains(const char *string, const char *substring);
+int trio_copy(char *target, const char *source);
+int trio_copy_max(char *target, size_t max, const char *source);
+char *trio_create(size_t size);
+void trio_destroy(char *string);
+char *trio_duplicate(const char *source);
+char *trio_duplicate_max(const char *source, size_t max);
+int trio_equal(const char *first, const char *second);
+int trio_equal_case(const char *first, const char *second);
+int trio_equal_case_max(const char *first, size_t max, const char *second);
+int trio_equal_locale(const char *first, const char *second);
+int trio_equal_max(const char *first, size_t max, const char *second);
+const char *trio_error(int);
+size_t trio_format_date_max(char *target, size_t max, const char *format, const struct tm *datetime);
+unsigned long trio_hash(const char *string, int type);
+char *trio_index(const char *string, char character);
+char *trio_index_last(const char *string, char character);
+size_t trio_length(const char *string);
+int trio_lower(char *target);
+int trio_match(const char *string, const char *pattern);
+int trio_match_case(const char *string, const char *pattern);
+size_t trio_span_function(char *target, const char *source, int (*Function)(int));
+char *trio_substring(const char *string, const char *substring);
+char *trio_substring_max(const char *string, size_t max, const char *substring);
+char *trio_tokenize(char *string, const char *delimiters);
+float trio_to_float(const char *source, const char **endp);
+double trio_to_double(const char *source, const char **endp);
+long trio_to_long(const char *source, char **endp, int base);
+unsigned long trio_to_unsigned_long(const char *source, char **endp, int base);
+int trio_upper(char *target);
+
+/*************************************************************************
+ * Dynamic string functions
+ */
+
+/*
+ * Opaque type for dynamic strings
+ */
+typedef struct _trio_string_t trio_string_t;
+
+trio_string_t *trio_string_create(int initial_size);
+void trio_string_destroy(trio_string_t *self);
+char *trio_string_get(trio_string_t *self, int offset);
+void trio_xstring_set(trio_string_t *self, char *buffer);
+char *trio_string_extract(trio_string_t *self);
+int trio_string_size(trio_string_t *self);
+void trio_string_terminate(trio_string_t *self);
+
+int trio_string_append(trio_string_t *self, trio_string_t *other);
+int trio_string_contains(trio_string_t *self, trio_string_t *other);
+int trio_string_copy(trio_string_t *self, trio_string_t *other);
+trio_string_t *trio_string_duplicate(trio_string_t *other);
+int trio_string_equal(trio_string_t *self, trio_string_t *other);
+int trio_string_equal_max(trio_string_t *self, size_t max, trio_string_t *second);
+int trio_string_equal_case(trio_string_t *self, trio_string_t *other);
+int trio_string_equal_case_max(trio_string_t *self, size_t max, trio_string_t *other);
+size_t trio_string_format_date_max(trio_string_t *self, size_t max, const char *format, const struct tm *datetime);
+char *trio_string_index(trio_string_t *self, int character);
+char *trio_string_index_last(trio_string_t *self, int character);
+int trio_string_length(trio_string_t *self);
+int trio_string_lower(trio_string_t *self);
+int trio_string_match(trio_string_t *self, trio_string_t *other);
+int trio_string_match_case(trio_string_t *self, trio_string_t *other);
+char *trio_string_substring(trio_string_t *self, trio_string_t *other);
+int trio_string_upper(trio_string_t *self);
+
+int trio_xstring_append_char(trio_string_t *self, char character);
+int trio_xstring_append(trio_string_t *self, const char *other);
+int trio_xstring_contains(trio_string_t *self, const char *other);
+int trio_xstring_copy(trio_string_t *self, const char *other);
+trio_string_t *trio_xstring_duplicate(const char *other);
+int trio_xstring_equal(trio_string_t *self, const char *other);
+int trio_xstring_equal_max(trio_string_t *self, size_t max, const char *other);
+int trio_xstring_equal_case(trio_string_t *self, const char *other);
+int trio_xstring_equal_case_max(trio_string_t *self, size_t max, const char *other);
+int trio_xstring_match(trio_string_t *self, const char *other);
+int trio_xstring_match_case(trio_string_t *self, const char *other);
+char *trio_xstring_substring(trio_string_t *self, const char *other);
+
+#endif /* TRIO_TRIOSTR_H */