/*************************************************************************
 *
 * $Id: trio.c,v 1.131 2010/09/12 11:08:08 breese Exp $
 *
 * Copyright (C) 1998, 2009 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.
 *
 *************************************************************************
 *
 * A note to trio contributors:
 *
 * Avoid heap allocation at all costs to ensure that the trio functions
 * are async-safe. The exceptions are the printf/fprintf functions, which
 * uses fputc, and the asprintf functions and the <alloc> modifier, which
 * by design are required to allocate form the heap.
 *
 ************************************************************************/

/*
 * TODO:
 *  - Scan is probably too permissive about its modifiers.
 *  - C escapes in %#[] ?
 *  - Multibyte characters (done for format parsing, except scan groups)
 *  - Complex numbers? (C99 _Complex)
 *  - Boolean values? (C99 _Bool)
 *  - C99 NaN(n-char-sequence) missing. The n-char-sequence can be used
 *    to print the mantissa, e.g. NaN(0xc000000000000000)
 *  - Should we support the GNU %a alloc modifier? GNU has an ugly hack
 *    for %a, because C99 used %a for other purposes. If specified as
 *    %as or %a[ it is interpreted as the alloc modifier, otherwise as
 *    the C99 hex-float. This means that you cannot scan %as as a hex-float
 *    immediately followed by an 's'.
 *  - Scanning of collating symbols.
 */

/*************************************************************************
 * Trio include files
 */
#include "triodef.h"
#include "trio.h"
#include "triop.h"

#if defined(TRIO_EMBED_NAN)
#define TRIO_PUBLIC_NAN static
#if TRIO_FEATURE_FLOAT
#define TRIO_FUNC_NAN
#define TRIO_FUNC_NINF
#define TRIO_FUNC_PINF
#define TRIO_FUNC_FPCLASSIFY_AND_SIGNBIT
#define TRIO_FUNC_ISINF
#endif
#endif
#include "trionan.h"

#if defined(TRIO_EMBED_STRING)
#define TRIO_PUBLIC_STRING static
#define TRIO_FUNC_LENGTH
#define TRIO_FUNC_LENGTH_MAX
#define TRIO_FUNC_TO_LONG
#if TRIO_FEATURE_LOCALE
#define TRIO_FUNC_COPY_MAX
#endif
#if TRIO_FEATURE_DYNAMICSTRING
#define TRIO_FUNC_XSTRING_DUPLICATE
#endif
#if TRIO_EXTENSION && TRIO_FEATURE_SCANF
#define TRIO_FUNC_EQUAL_LOCALE
#endif
#if TRIO_FEATURE_ERRNO
#define TRIO_FUNC_ERROR
#endif
#if TRIO_FEATURE_FLOAT && TRIO_FEATURE_SCANF
#define TRIO_FUNC_TO_DOUBLE
#endif
#if TRIO_FEATURE_DYNAMICSTRING
#define TRIO_FUNC_STRING_EXTRACT
#endif
#if TRIO_FEATURE_DYNAMICSTRING
#define TRIO_FUNC_STRING_TERMINATE
#endif
#if TRIO_FEATURE_USER_DEFINED
#define TRIO_FUNC_DUPLICATE
#endif
#if TRIO_FEATURE_DYNAMICSTRING
#define TRIO_FUNC_STRING_DESTROY
#endif
#if TRIO_FEATURE_USER_DEFINED
#define TRIO_FUNC_DESTROY
#endif
#if TRIO_FEATURE_USER_DEFINED || (TRIO_FEATURE_FLOAT && TRIO_FEATURE_SCANF)
#define TRIO_FUNC_EQUAL
#endif
#if TRIO_FEATURE_USER_DEFINED || TRIO_FEATURE_SCANF
#define TRIO_FUNC_EQUAL_CASE
#endif
#if (TRIO_EXTENSION && TRIO_FEATURE_SCANF)
#define TRIO_FUNC_EQUAL_MAX
#endif
#if TRIO_FEATURE_SCANF
#define TRIO_FUNC_TO_UPPER
#endif
#if TRIO_FEATURE_DYNAMICSTRING
#define TRIO_FUNC_XSTRING_APPEND_CHAR
#endif
#endif
#include "triostr.h"

/**************************************************************************
 *
 * Definitions
 *
 *************************************************************************/

#include <limits.h>
#if TRIO_FEATURE_FLOAT
#include <math.h>
#include <float.h>
#endif

#if defined(__STDC_ISO_10646__) || defined(MB_LEN_MAX) || defined(USE_MULTIBYTE) || \
    TRIO_FEATURE_WIDECHAR
#if (!defined(TRIO_PLATFORM_WINCE) && !defined(ANDROID))
#define TRIO_COMPILER_SUPPORTS_MULTIBYTE
#if !defined(MB_LEN_MAX)
#define MB_LEN_MAX 6
#endif
#endif
#endif

#if (TRIO_COMPILER_VISUALC - 0 >= 1100) || defined(TRIO_COMPILER_BORLAND)
#define TRIO_COMPILER_SUPPORTS_VISUALC_INT
#endif

#if TRIO_FEATURE_FLOAT
#if defined(PREDEF_STANDARD_C99) || defined(PREDEF_STANDARD_UNIX03)
#if !defined(HAVE_FLOORL) && !defined(TRIO_NO_FLOORL)
#define HAVE_FLOORL
#endif
#if !defined(HAVE_CEILL) && !defined(TRIO_NO_CEILL)
#define HAVE_CEILL
#endif
#if !defined(HAVE_POWL) && !defined(TRIO_NO_POWL)
#define HAVE_POWL
#endif
#if !defined(HAVE_FMODL) && !defined(TRIO_NO_FMODL)
#define HAVE_FMODL
#endif
#if !defined(HAVE_LOG10L) && !defined(TRIO_NO_LOG10L)
#define HAVE_LOG10L
#endif
#endif
#if defined(TRIO_COMPILER_VISUALC)
#if defined(floorl)
#define HAVE_FLOORL
#endif
#if defined(ceill)
#define HAVE_CEILL
#endif
#if defined(powl)
#define HAVE_POWL
#endif
#if defined(fmodl)
#define HAVE_FMODL
#endif
#if defined(log10l)
#define HAVE_LOG10L
#endif
#endif
#endif

/*************************************************************************
 * Generic definitions
 */

#if !(defined(DEBUG) || defined(NDEBUG))
#define NDEBUG
#endif

#include <assert.h>
#include <ctype.h>
#if defined(PREDEF_STANDARD_C99) && !defined(isascii)
#define isascii(x) ((x)&0x7F)
#endif
#if defined(TRIO_COMPILER_ANCIENT)
#include <varargs.h>
#else
#include <stdarg.h>
#endif
#include <stddef.h>
#if defined(TRIO_PLATFORM_WINCE)
extern int errno;
#else
#include <errno.h>
#endif

#ifndef NULL
#define NULL 0
#endif
#define NIL ((char)0)
#ifndef FALSE
#define FALSE (1 == 0)
#define TRUE (!FALSE)
#endif
#define BOOLEAN_T int

/* mincore() can be used for debugging purposes */
#define VALID(x) (NULL != (x))

#if TRIO_FEATURE_ERRORCODE
/*
 * Encode the error code and the position. This is decoded
 * with TRIO_ERROR_CODE and TRIO_ERROR_POSITION.
 */
#define TRIO_ERROR_RETURN(x, y) (-((x) + ((y) << 8)))
#else
#define TRIO_ERROR_RETURN(x, y) (-1)
#endif

typedef unsigned long trio_flags_t;

/*************************************************************************
 * Platform specific definitions
 */
#if defined(TRIO_PLATFORM_UNIX)
#include <unistd.h>
#include <signal.h>
#include <locale.h>
#if !defined(TRIO_FEATURE_LOCALE)
#define USE_LOCALE
#endif
#endif /* TRIO_PLATFORM_UNIX */
#if defined(TRIO_PLATFORM_VMS)
#include <unistd.h>
#endif
#if defined(TRIO_PLATFORM_WIN32)
#if defined(TRIO_PLATFORM_WINCE)
int read(int handle, char* buffer, unsigned int length);
int write(int handle, const char* buffer, unsigned int length);
#else
#include <io.h>
#define read _read
#define write _write
#endif
#endif /* TRIO_PLATFORM_WIN32 */

#if TRIO_FEATURE_WIDECHAR
#if defined(PREDEF_STANDARD_C94)
#include <wchar.h>
#include <wctype.h>
typedef wchar_t trio_wchar_t;
typedef wint_t trio_wint_t;
#else
typedef char trio_wchar_t;
typedef int trio_wint_t;
#define WCONST(x) L##x
#define WEOF EOF
#define iswalnum(x) isalnum(x)
#define iswalpha(x) isalpha(x)
#define iswcntrl(x) iscntrl(x)
#define iswdigit(x) isdigit(x)
#define iswgraph(x) isgraph(x)
#define iswlower(x) islower(x)
#define iswprint(x) isprint(x)
#define iswpunct(x) ispunct(x)
#define iswspace(x) isspace(x)
#define iswupper(x) isupper(x)
#define iswxdigit(x) isxdigit(x)
#endif
#endif

/*************************************************************************
 * Compiler dependent definitions
 */

/* Support for long long */
#ifndef __cplusplus
#if !defined(USE_LONGLONG)
#if defined(TRIO_COMPILER_GCC) && !defined(__STRICT_ANSI__)
#define USE_LONGLONG
#else
#if defined(TRIO_COMPILER_SUNPRO)
#define USE_LONGLONG
#else
#if defined(TRIO_COMPILER_MSVC) && (_MSC_VER >= 1400)
#define USE_LONGLONG
#else
#if defined(_LONG_LONG) || defined(_LONGLONG)
#define USE_LONGLONG
#endif
#endif
#endif
#endif
#endif
#endif

/* The extra long numbers */
#if defined(USE_LONGLONG)
typedef signed long long int trio_longlong_t;
typedef unsigned long long int trio_ulonglong_t;
#else
#if defined(TRIO_COMPILER_SUPPORTS_VISUALC_INT)
typedef signed __int64 trio_longlong_t;
typedef unsigned __int64 trio_ulonglong_t;
#else
typedef TRIO_SIGNED long int trio_longlong_t;
typedef unsigned long int trio_ulonglong_t;
#endif
#endif

/* Maximal and fixed integer types */
#if defined(PREDEF_STANDARD_C99)
#include <stdint.h>
typedef intmax_t trio_intmax_t;
typedef uintmax_t trio_uintmax_t;
typedef int8_t trio_int8_t;
typedef int16_t trio_int16_t;
typedef int32_t trio_int32_t;
typedef int64_t trio_int64_t;
#else
#if defined(PREDEF_STANDARD_UNIX98)
#include <inttypes.h>
typedef intmax_t trio_intmax_t;
typedef uintmax_t trio_uintmax_t;
typedef int8_t trio_int8_t;
typedef int16_t trio_int16_t;
typedef int32_t trio_int32_t;
typedef int64_t trio_int64_t;
#else
#if defined(TRIO_COMPILER_SUPPORTS_VISUALC_INT)
typedef trio_longlong_t trio_intmax_t;
typedef trio_ulonglong_t trio_uintmax_t;
typedef __int8 trio_int8_t;
typedef __int16 trio_int16_t;
typedef __int32 trio_int32_t;
typedef __int64 trio_int64_t;
#else
typedef trio_longlong_t trio_intmax_t;
typedef trio_ulonglong_t trio_uintmax_t;
#if defined(TRIO_INT8_T)
typedef TRIO_INT8_T trio_int8_t;
#else
typedef TRIO_SIGNED char trio_int8_t;
#endif
#if defined(TRIO_INT16_T)
typedef TRIO_INT16_T trio_int16_t;
#else
typedef TRIO_SIGNED short trio_int16_t;
#endif
#if defined(TRIO_INT32_T)
typedef TRIO_INT32_T trio_int32_t;
#else
typedef TRIO_SIGNED int trio_int32_t;
#endif
#if defined(TRIO_INT64_T)
typedef TRIO_INT64_T trio_int64_t;
#else
typedef trio_longlong_t trio_int64_t;
#endif
#endif
#endif
#endif

#if defined(HAVE_FLOORL)
#define trio_floor(x) floorl((x))
#else
#define trio_floor(x) floor((double)(x))
#endif

#if defined(HAVE_CEILL)
#define trio_ceil(x) ceill((x))
#else
#define trio_ceil(x) ceil((double)(x))
#endif

#if defined(HAVE_FMODL)
#define trio_fmod(x, y) fmodl((x), (y))
#else
#define trio_fmod(x, y) fmod((double)(x), (double)(y))
#endif

#if defined(HAVE_POWL)
#define trio_pow(x, y) powl((x), (y))
#else
#define trio_pow(x, y) pow((double)(x), (double)(y))
#endif

#if defined(HAVE_LOG10L)
#define trio_log10(x) log10l((x))
#else
#define trio_log10(x) log10((double)(x))
#endif

#if TRIO_FEATURE_FLOAT
#define TRIO_FABS(x) (((x) < 0.0) ? -(x) : (x))
#endif

/*************************************************************************
 * Internal Definitions
 */

#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable : 4244)
#endif

#if TRIO_FEATURE_FLOAT

#if !defined(DECIMAL_DIG)
#define DECIMAL_DIG DBL_DIG
#endif

/* Long double sizes */
#ifdef LDBL_DIG
#define MAX_MANTISSA_DIGITS LDBL_DIG
#define MAX_EXPONENT_DIGITS 4
#define MAX_DOUBLE_DIGITS LDBL_MAX_10_EXP
#else
#define MAX_MANTISSA_DIGITS DECIMAL_DIG
#define MAX_EXPONENT_DIGITS 3
#define MAX_DOUBLE_DIGITS DBL_MAX_10_EXP
#endif

#if defined(TRIO_COMPILER_ANCIENT) || !defined(LDBL_DIG)
#undef LDBL_DIG
#undef LDBL_MANT_DIG
#undef LDBL_EPSILON
#define LDBL_DIG DBL_DIG
#define LDBL_MANT_DIG DBL_MANT_DIG
#define LDBL_EPSILON DBL_EPSILON
#endif

#endif /* TRIO_FEATURE_FLOAT */

/* The maximal number of digits is for base 2 */
#define MAX_CHARS_IN(x) (sizeof(x) * CHAR_BIT)
/* The width of a pointer. The number of bits in a hex digit is 4 */
#define POINTER_WIDTH ((sizeof("0x") - 1) + sizeof(trio_pointer_t) * CHAR_BIT / 4)

#if TRIO_FEATURE_FLOAT
/* Infinite and Not-A-Number for floating-point */
#define INFINITE_LOWER "inf"
#define INFINITE_UPPER "INF"
#define LONG_INFINITE_LOWER "infinite"
#define LONG_INFINITE_UPPER "INFINITE"
#define NAN_LOWER "nan"
#define NAN_UPPER "NAN"
#endif

/* Various constants */
enum
{
	TYPE_PRINT = 1,
#if TRIO_FEATURE_SCANF
	TYPE_SCAN = 2,
#endif

	/* Flags. FLAGS_LAST must be less than ULONG_MAX */
	FLAGS_NEW = 0,
	FLAGS_STICKY = 1,
	FLAGS_SPACE = 2 * FLAGS_STICKY,
	FLAGS_SHOWSIGN = 2 * FLAGS_SPACE,
	FLAGS_LEFTADJUST = 2 * FLAGS_SHOWSIGN,
	FLAGS_ALTERNATIVE = 2 * FLAGS_LEFTADJUST,
	FLAGS_SHORT = 2 * FLAGS_ALTERNATIVE,
	FLAGS_SHORTSHORT = 2 * FLAGS_SHORT,
	FLAGS_LONG = 2 * FLAGS_SHORTSHORT,
	FLAGS_QUAD = 2 * FLAGS_LONG,
	FLAGS_LONGDOUBLE = 2 * FLAGS_QUAD,
	FLAGS_SIZE_T = 2 * FLAGS_LONGDOUBLE,
	FLAGS_PTRDIFF_T = 2 * FLAGS_SIZE_T,
	FLAGS_INTMAX_T = 2 * FLAGS_PTRDIFF_T,
	FLAGS_NILPADDING = 2 * FLAGS_INTMAX_T,
	FLAGS_UNSIGNED = 2 * FLAGS_NILPADDING,
	FLAGS_UPPER = 2 * FLAGS_UNSIGNED,
	FLAGS_WIDTH = 2 * FLAGS_UPPER,
	FLAGS_WIDTH_PARAMETER = 2 * FLAGS_WIDTH,
	FLAGS_PRECISION = 2 * FLAGS_WIDTH_PARAMETER,
	FLAGS_PRECISION_PARAMETER = 2 * FLAGS_PRECISION,
	FLAGS_BASE = 2 * FLAGS_PRECISION_PARAMETER,
	FLAGS_BASE_PARAMETER = 2 * FLAGS_BASE,
	FLAGS_FLOAT_E = 2 * FLAGS_BASE_PARAMETER,
	FLAGS_FLOAT_G = 2 * FLAGS_FLOAT_E,
	FLAGS_QUOTE = 2 * FLAGS_FLOAT_G,
	FLAGS_WIDECHAR = 2 * FLAGS_QUOTE,
	FLAGS_IGNORE = 2 * FLAGS_WIDECHAR,
	FLAGS_IGNORE_PARAMETER = 2 * FLAGS_IGNORE,
	FLAGS_VARSIZE_PARAMETER = 2 * FLAGS_IGNORE_PARAMETER,
	FLAGS_FIXED_SIZE = 2 * FLAGS_VARSIZE_PARAMETER,
	FLAGS_LAST = FLAGS_FIXED_SIZE,
	/* Reused flags */
	FLAGS_EXCLUDE = FLAGS_SHORT,
	FLAGS_USER_DEFINED = FLAGS_IGNORE,
	FLAGS_USER_DEFINED_PARAMETER = FLAGS_IGNORE_PARAMETER,
	FLAGS_ROUNDING = FLAGS_INTMAX_T,
	/* Compounded flags */
	FLAGS_ALL_VARSIZES = FLAGS_LONG | FLAGS_QUAD | FLAGS_INTMAX_T | FLAGS_PTRDIFF_T | FLAGS_SIZE_T,
	FLAGS_ALL_SIZES = FLAGS_ALL_VARSIZES | FLAGS_SHORTSHORT | FLAGS_SHORT,

	NO_POSITION = -1,
	NO_WIDTH = 0,
	NO_PRECISION = -1,
	NO_SIZE = -1,

	/* Do not change these */
	NO_BASE = -1,
	MIN_BASE = 2,
	MAX_BASE = 36,
	BASE_BINARY = 2,
	BASE_OCTAL = 8,
	BASE_DECIMAL = 10,
	BASE_HEX = 16,

	/* Maximal number of allowed parameters */
	MAX_PARAMETERS = 64,
	/* Maximal number of characters in class */
	MAX_CHARACTER_CLASS = UCHAR_MAX + 1,

#if TRIO_FEATURE_USER_DEFINED
	/* Maximal string lengths for user-defined specifiers */
	MAX_USER_NAME = 64,
	MAX_USER_DATA = 256,
#endif

	/* Maximal length of locale separator strings */
	MAX_LOCALE_SEPARATOR_LENGTH = MB_LEN_MAX,
	/* Maximal number of integers in grouping */
	MAX_LOCALE_GROUPS = 64
};

#define NO_GROUPING ((int)CHAR_MAX)

/* Fundamental formatting parameter types */
#define FORMAT_SENTINEL -1 /* marks end of parameters array */
#define FORMAT_UNKNOWN 0
#define FORMAT_INT 1
#define FORMAT_DOUBLE 2
#define FORMAT_CHAR 3
#define FORMAT_STRING 4
#define FORMAT_POINTER 5
#define FORMAT_COUNT 6
#define FORMAT_PARAMETER 7
#define FORMAT_GROUP 8
#define FORMAT_ERRNO 9
#define FORMAT_USER_DEFINED 10

/* Character constants */
#define CHAR_IDENTIFIER '%'
#define CHAR_ALT_IDENTIFIER '$'
#define CHAR_BACKSLASH '\\'
#define CHAR_QUOTE '\"'
#define CHAR_ADJUST ' '

#if TRIO_EXTENSION
/* 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:]"
#define CLASS_LOWER "[:lower:]"
#define CLASS_PRINT "[:print:]"
#define CLASS_PUNCT "[:punct:]"
#define CLASS_SPACE "[:space:]"
#define CLASS_UPPER "[:upper:]"
#define CLASS_XDIGIT "[:xdigit:]"
#endif

/*
 * SPECIFIERS:
 *
 *
 * a  Hex-float
 * A  Hex-float
 * c  Character
 * C  Widechar character (wint_t)
 * d  Decimal
 * e  Float
 * E  Float
 * F  Float
 * F  Float
 * g  Float
 * G  Float
 * i  Integer
 * m  Error message
 * n  Count
 * o  Octal
 * p  Pointer
 * s  String
 * S  Widechar string (wchar_t *)
 * u  Unsigned
 * x  Hex
 * X  Hex
 * [] Group
 * <> User-defined
 *
 * Reserved:
 *
 * D  Binary Coded Decimal %D(length,precision) (OS/390)
 */
#define SPECIFIER_CHAR 'c'
#define SPECIFIER_STRING 's'
#define SPECIFIER_DECIMAL 'd'
#define SPECIFIER_INTEGER 'i'
#define SPECIFIER_UNSIGNED 'u'
#define SPECIFIER_OCTAL 'o'
#define SPECIFIER_HEX 'x'
#define SPECIFIER_HEX_UPPER 'X'
#if TRIO_FEATURE_FLOAT
#define SPECIFIER_FLOAT_E 'e'
#define SPECIFIER_FLOAT_E_UPPER 'E'
#define SPECIFIER_FLOAT_F 'f'
#define SPECIFIER_FLOAT_F_UPPER 'F'
#define SPECIFIER_FLOAT_G 'g'
#define SPECIFIER_FLOAT_G_UPPER 'G'
#endif
#define SPECIFIER_POINTER 'p'
#if TRIO_FEATURE_SCANF
#define SPECIFIER_GROUP '['
#define SPECIFIER_UNGROUP ']'
#endif
#define SPECIFIER_COUNT 'n'
#if TRIO_UNIX98
#define SPECIFIER_CHAR_UPPER 'C'
#define SPECIFIER_STRING_UPPER 'S'
#endif
#define SPECIFIER_HEXFLOAT 'a'
#define SPECIFIER_HEXFLOAT_UPPER 'A'
#define SPECIFIER_ERRNO 'm'
#if TRIO_FEATURE_BINARY
#define SPECIFIER_BINARY 'b'
#define SPECIFIER_BINARY_UPPER 'B'
#endif
#if TRIO_FEATURE_USER_DEFINED
#define SPECIFIER_USER_DEFINED_BEGIN '<'
#define SPECIFIER_USER_DEFINED_END '>'
#define SPECIFIER_USER_DEFINED_SEPARATOR ':'
#define SPECIFIER_USER_DEFINED_EXTRA '|'
#endif

/*
 * QUALIFIERS:
 *
 *
 * Numbers = d,i,o,u,x,X
 * Float = a,A,e,E,f,F,g,G
 * String = s
 * Char = c
 *
 *
 * 9$ Position
 *      Use the 9th parameter. 9 can be any number between 1 and
 *      the maximal argument
 *
 * 9 Width
 *      Set width to 9. 9 can be any number, but must not be postfixed
 *      by '$'
 *
 * h  Short
 *    Numbers:
 *      (unsigned) short int
 *
 * hh Short short
 *    Numbers:
 *      (unsigned) char
 *
 * l  Long
 *    Numbers:
 *      (unsigned) long int
 *    String:
 *      as the S specifier
 *    Char:
 *      as the C specifier
 *
 * ll Long Long
 *    Numbers:
 *      (unsigned) long long int
 *
 * L  Long Double
 *    Float
 *      long double
 *
 * #  Alternative
 *    Float:
 *      Decimal-point is always present
 *    String:
 *      non-printable characters are handled as \number
 *
 *    Spacing
 *
 * +  Sign
 *
 * -  Alignment
 *
 * .  Precision
 *
 * *  Parameter
 *    print: use parameter
 *    scan: no parameter (ignore)
 *
 * q  Quad
 *
 * Z  size_t
 *
 * w  Widechar
 *
 * '  Thousands/quote
 *    Numbers:
 *      Integer part grouped in thousands
 *    Binary numbers:
 *      Number grouped in nibbles (4 bits)
 *    String:
 *      Quoted string
 *
 * j  intmax_t
 * t  prtdiff_t
 * z  size_t
 *
 * !  Sticky
 * @  Parameter (for both print and scan)
 *
 * I  n-bit Integer
 *    Numbers:
 *      The following options exists
 *        I8  = 8-bit integer
 *        I16 = 16-bit integer
 *        I32 = 32-bit integer
 *        I64 = 64-bit integer
 */
#define QUALIFIER_POSITION '$'
#define QUALIFIER_SHORT 'h'
#define QUALIFIER_LONG 'l'
#define QUALIFIER_LONG_UPPER 'L'
#define QUALIFIER_ALTERNATIVE '#'
#define QUALIFIER_SPACE ' '
#define QUALIFIER_PLUS '+'
#define QUALIFIER_MINUS '-'
#define QUALIFIER_DOT '.'
#define QUALIFIER_STAR '*'
#define QUALIFIER_CIRCUMFLEX '^' /* For scanlists */
#define QUALIFIER_SIZE_T 'z'
#define QUALIFIER_PTRDIFF_T 't'
#define QUALIFIER_INTMAX_T 'j'
#define QUALIFIER_QUAD 'q'
#define QUALIFIER_SIZE_T_UPPER 'Z'
#if TRIO_MISC
#define QUALIFIER_WIDECHAR 'w'
#endif
#define QUALIFIER_FIXED_SIZE 'I'
#define QUALIFIER_QUOTE '\''
#define QUALIFIER_STICKY '!'
#define QUALIFIER_VARSIZE '&' /* This should remain undocumented */
#define QUALIFIER_ROUNDING_UPPER 'R'
#if TRIO_EXTENSION
#define QUALIFIER_PARAM '@' /* Experimental */
#define QUALIFIER_COLON ':' /* For scanlists */
#define QUALIFIER_EQUAL '=' /* For scanlists */
#endif

/*************************************************************************
 *
 * Internal Structures
 *
 *************************************************************************/

/* Parameters */
typedef struct
{
	/* An indication of which entry in the data union is used */
	int type;
	/* The flags */
	trio_flags_t flags;
	/* The width qualifier */
	int width;
	/* The precision qualifier */
	int precision;
	/* The base qualifier */
	int base;
	/* Base from specifier */
	int baseSpecifier;
	/* The size for the variable size qualifier */
	int varsize;
	/* Offset of the first character of the specifier */
	int beginOffset;
	/* Offset of the first character after the specifier */
	int endOffset;
	/* Position in the argument list that this parameter refers to */
	int position;
	/* The data from the argument list */
	union {
		char* string;
#if TRIO_FEATURE_WIDECHAR
		trio_wchar_t* wstring;
#endif
		trio_pointer_t pointer;
		union {
			trio_intmax_t as_signed;
			trio_uintmax_t as_unsigned;
		} number;
#if TRIO_FEATURE_FLOAT
		double doubleNumber;
		double* doublePointer;
		trio_long_double_t longdoubleNumber;
		trio_long_double_t* longdoublePointer;
#endif
		int errorNumber;
	} data;
#if TRIO_FEATURE_USER_DEFINED
	/* For the user-defined specifier */
	union {
		char namespace[MAX_USER_NAME];
		int handler; /* if flags & FLAGS_USER_DEFINED_PARAMETER */
	} user_defined;
	char user_data[MAX_USER_DATA];
#endif
} trio_parameter_t;

/* Container for customized functions */
typedef struct
{
	union {
		trio_outstream_t out;
		trio_instream_t in;
	} stream;
	trio_pointer_t closure;
} trio_custom_t;

/* General trio "class" */
typedef struct _trio_class_t
{
	/*
	 * The function to write characters to a stream.
	 */
	void(*OutStream) TRIO_PROTO((struct _trio_class_t*, int));
	/*
	 * The function to read characters from a stream.
	 */
	void(*InStream) TRIO_PROTO((struct _trio_class_t*, int*));
	/*
	 * The function to undo read characters from a stream.
	 */
	void(*UndoStream) TRIO_PROTO((struct _trio_class_t*));
	/*
	 * The current location in the stream.
	 */
	trio_pointer_t 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;
	union {
		/*
		 * The number of characters that are actually written. Processed and
		 * committed will only differ for the *nprintf functions.
		 */
		int committed;
		/*
		 * The number of look-ahead characters read.
		 */
		int cached;
	} actually;
	/*
	 * The upper limit of characters that may be written/read.
	 */
	int max;
	/*
	 * The last output error that was detected.
	 */
	int error;
} trio_class_t;

/* References (for user-defined callbacks) */
typedef struct _trio_reference_t
{
	trio_class_t* data;
	trio_parameter_t* parameter;
} trio_reference_t;

#if TRIO_FEATURE_USER_DEFINED
/* Registered entries (for user-defined callbacks) */
typedef struct _trio_userdef_t
{
	struct _trio_userdef_t* next;
	trio_callback_t callback;
	char* name;
} trio_userdef_t;
#endif

/*************************************************************************
 *
 * Internal Variables
 *
 *************************************************************************/
/* Unused but kept for reference */
/* static TRIO_CONST char rcsid[] = "@(#)$Id: trio.c,v 1.131 2010/09/12 11:08:08 breese Exp $"; */

#if TRIO_FEATURE_FLOAT
/*
 * 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 trio_long_double_t ___dummy_long_double = 0;
#endif
#endif

static TRIO_CONST char internalNullString[] = "(nil)";

#if defined(USE_LOCALE)
static struct lconv* internalLocaleValues = NULL;
#endif

/*
 * UNIX98 says "in a locale where the radix character is not defined,
 * the radix character defaults to a period (.)"
 */
#if TRIO_FEATURE_FLOAT || TRIO_FEATURE_LOCALE || defined(USE_LOCALE)
static int internalDecimalPointLength = 1;
static char internalDecimalPoint = '.';
static char internalDecimalPointString[MAX_LOCALE_SEPARATOR_LENGTH + 1] = ".";
#endif
#if TRIO_FEATURE_QUOTE || TRIO_FEATURE_LOCALE || TRIO_EXTENSION
static int internalThousandSeparatorLength = 1;
static char internalThousandSeparator[MAX_LOCALE_SEPARATOR_LENGTH + 1] = ",";
static char internalGrouping[MAX_LOCALE_GROUPS] = { (char)NO_GROUPING };
#endif

static TRIO_CONST char internalDigitsLower[] = "0123456789abcdefghijklmnopqrstuvwxyz";
static TRIO_CONST char internalDigitsUpper[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
#if TRIO_FEATURE_SCANF
static BOOLEAN_T internalDigitsUnconverted = TRUE;
static int internalDigitArray[128];
#if TRIO_EXTENSION
static BOOLEAN_T internalCollationUnconverted = TRUE;
static char internalCollationArray[MAX_CHARACTER_CLASS][MAX_CHARACTER_CLASS];
#endif
#endif

#if TRIO_FEATURE_USER_DEFINED
static TRIO_VOLATILE trio_callback_t internalEnterCriticalRegion = NULL;
static TRIO_VOLATILE trio_callback_t internalLeaveCriticalRegion = NULL;
static trio_userdef_t* internalUserDef = NULL;
#endif

/*************************************************************************
 *
 * Internal Functions
 *
 ************************************************************************/

#if defined(TRIO_EMBED_NAN)
#include "trionan.c"
#endif

#if defined(TRIO_EMBED_STRING)
#include "triostr.c"
#endif

/*************************************************************************
 * TrioInitializeParameter
 *
 * Description:
 *  Initialize a trio_parameter_t struct.
 */
TRIO_PRIVATE void TrioInitializeParameter TRIO_ARGS1((parameter), trio_parameter_t* parameter)
{
	parameter->type = FORMAT_UNKNOWN;
	parameter->flags = 0;
	parameter->width = 0;
	parameter->precision = 0;
	parameter->base = 0;
	parameter->baseSpecifier = 0;
	parameter->varsize = 0;
	parameter->beginOffset = 0;
	parameter->endOffset = 0;
	parameter->position = 0;
	parameter->data.pointer = 0;
#if TRIO_FEATURE_USER_DEFINED
	parameter->user_defined.handler = 0;
	parameter->user_data[0] = 0;
#endif
}

/*************************************************************************
 * TrioCopyParameter
 *
 * Description:
 *  Copies one trio_parameter_t struct to another.
 */
TRIO_PRIVATE void TrioCopyParameter TRIO_ARGS2((target, source), trio_parameter_t* target,
                                               TRIO_CONST trio_parameter_t* source)
{
#if TRIO_FEATURE_USER_DEFINED
	size_t i;
#endif

	target->type = source->type;
	target->flags = source->flags;
	target->width = source->width;
	target->precision = source->precision;
	target->base = source->base;
	target->baseSpecifier = source->baseSpecifier;
	target->varsize = source->varsize;
	target->beginOffset = source->beginOffset;
	target->endOffset = source->endOffset;
	target->position = source->position;
	target->data = source->data;

#if TRIO_FEATURE_USER_DEFINED
	target->user_defined = source->user_defined;

	for (i = 0U; i < sizeof(target->user_data); ++i)
	{
		if ((target->user_data[i] = source->user_data[i]) == NIL)
			break;
	}
#endif
}

/*************************************************************************
 * TrioIsQualifier
 *
 * Description:
 *  Remember to add all new qualifiers to this function.
 *  QUALIFIER_POSITION must not be added.
 */
TRIO_PRIVATE BOOLEAN_T TrioIsQualifier TRIO_ARGS1((character), TRIO_CONST char character)
{
	/* QUALIFIER_POSITION is not included */
	switch (character)
	{
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case QUALIFIER_PLUS:
		case QUALIFIER_MINUS:
		case QUALIFIER_SPACE:
		case QUALIFIER_DOT:
		case QUALIFIER_STAR:
		case QUALIFIER_ALTERNATIVE:
		case QUALIFIER_SHORT:
		case QUALIFIER_LONG:
		case QUALIFIER_CIRCUMFLEX:
		case QUALIFIER_LONG_UPPER:
		case QUALIFIER_SIZE_T:
		case QUALIFIER_PTRDIFF_T:
		case QUALIFIER_INTMAX_T:
		case QUALIFIER_QUAD:
		case QUALIFIER_SIZE_T_UPPER:
#if defined(QUALIFIER_WIDECHAR)
		case QUALIFIER_WIDECHAR:
#endif
		case QUALIFIER_QUOTE:
		case QUALIFIER_STICKY:
		case QUALIFIER_VARSIZE:
#if defined(QUALIFIER_PARAM)
		case QUALIFIER_PARAM:
#endif
		case QUALIFIER_FIXED_SIZE:
		case QUALIFIER_ROUNDING_UPPER:
			return TRUE;
		default:
			return FALSE;
	}
}

/*************************************************************************
 * TrioSetLocale
 */
#if defined(USE_LOCALE)
TRIO_PRIVATE void TrioSetLocale(TRIO_NOARGS)
{
	internalLocaleValues = (struct lconv*)localeconv();
	if (internalLocaleValues)
	{
		if ((internalLocaleValues->decimal_point) &&
		    (internalLocaleValues->decimal_point[0] != NIL))
		{
			internalDecimalPointLength = trio_length(internalLocaleValues->decimal_point);
			if (internalDecimalPointLength == 1)
			{
				internalDecimalPoint = internalLocaleValues->decimal_point[0];
			}
			else
			{
				internalDecimalPoint = NIL;
				trio_copy_max(internalDecimalPointString, sizeof(internalDecimalPointString),
				              internalLocaleValues->decimal_point);
			}
		}
#if TRIO_EXTENSION
		if ((internalLocaleValues->thousands_sep) &&
		    (internalLocaleValues->thousands_sep[0] != NIL))
		{
			trio_copy_max(internalThousandSeparator, sizeof(internalThousandSeparator),
			              internalLocaleValues->thousands_sep);
			internalThousandSeparatorLength = trio_length(internalThousandSeparator);
		}
#endif
#if TRIO_EXTENSION
		if ((internalLocaleValues->grouping) && (internalLocaleValues->grouping[0] != NIL))
		{
			trio_copy_max(internalGrouping, sizeof(internalGrouping),
			              internalLocaleValues->grouping);
		}
#endif
	}
}
#endif /* defined(USE_LOCALE) */

#if TRIO_FEATURE_FLOAT && TRIO_FEATURE_QUOTE
TRIO_PRIVATE int TrioCalcThousandSeparatorLength TRIO_ARGS1((digits), int digits)
{
	int count = 0;
	int step = NO_GROUPING;
	char* groupingPointer = internalGrouping;

	while (digits > 0)
	{
		if (*groupingPointer == CHAR_MAX)
		{
			/* Disable grouping */
			break; /* while */
		}
		else if (*groupingPointer == 0)
		{
			/* Repeat last group */
			if (step == NO_GROUPING)
			{
				/* Error in locale */
				break; /* while */
			}
		}
		else
		{
			step = *groupingPointer++;
		}
		if (digits > step)
			count += internalThousandSeparatorLength;
		digits -= step;
	}
	return count;
}
#endif /* TRIO_FEATURE_FLOAT && TRIO_FEATURE_QUOTE */

#if TRIO_FEATURE_QUOTE
TRIO_PRIVATE BOOLEAN_T TrioFollowedBySeparator TRIO_ARGS1((position), int position)
{
	int step = 0;
	char* groupingPointer = internalGrouping;

	position--;
	if (position == 0)
		return FALSE;
	while (position > 0)
	{
		if (*groupingPointer == CHAR_MAX)
		{
			/* Disable grouping */
			break; /* while */
		}
		else if (*groupingPointer != 0)
		{
			step = *groupingPointer++;
		}
		if (step == 0)
			break;
		position -= step;
	}
	return (position == 0);
}
#endif /* TRIO_FEATURE_QUOTE */

/*************************************************************************
 * TrioGetPosition
 *
 * Get the %n$ position.
 */
TRIO_PRIVATE int TrioGetPosition TRIO_ARGS2((format, offsetPointer), TRIO_CONST char* format,
                                            int* offsetPointer)
{
#if TRIO_FEATURE_POSITIONAL
	char* tmpformat;
	int number = 0;
	int offset = *offsetPointer;

	number = (int)trio_to_long(&format[offset], &tmpformat, BASE_DECIMAL);
	offset = (int)(tmpformat - format);
	if ((number != 0) && (QUALIFIER_POSITION == format[offset++]))
	{
		*offsetPointer = offset;
		/*
		 * number is decreased by 1, because n$ starts from 1, whereas
		 * the array it is indexing starts from 0.
		 */
		return number - 1;
	}
#endif
	return NO_POSITION;
}

/*************************************************************************
 * TrioFindNamespace
 *
 * Find registered user-defined specifier.
 * The prev argument is used for optimization only.
 */
#if TRIO_FEATURE_USER_DEFINED
TRIO_PRIVATE trio_userdef_t* TrioFindNamespace TRIO_ARGS2((name, prev), TRIO_CONST char* name,
                                                          trio_userdef_t** prev)
{
	trio_userdef_t* def;

	if (internalEnterCriticalRegion)
		(void)internalEnterCriticalRegion(NULL);

	for (def = internalUserDef; def; def = def->next)
	{
		/* Case-sensitive string comparison */
		if (trio_equal_case(def->name, name))
			break;

		if (prev)
			*prev = def;
	}

	if (internalLeaveCriticalRegion)
		(void)internalLeaveCriticalRegion(NULL);

	return def;
}
#endif

/*************************************************************************
 * TrioPower
 *
 * Description:
 *  Calculate pow(base, exponent), where number and exponent are integers.
 */
#if TRIO_FEATURE_FLOAT
TRIO_PRIVATE trio_long_double_t TrioPower TRIO_ARGS2((number, exponent), int number, int exponent)
{
	trio_long_double_t result;

	if (number == 10)
	{
		switch (exponent)
		{
				/* Speed up calculation of common cases */
			case 0:
				result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E-1);
				break;
			case 1:
				result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+0);
				break;
			case 2:
				result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+1);
				break;
			case 3:
				result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+2);
				break;
			case 4:
				result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+3);
				break;
			case 5:
				result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+4);
				break;
			case 6:
				result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+5);
				break;
			case 7:
				result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+6);
				break;
			case 8:
				result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+7);
				break;
			case 9:
				result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+8);
				break;
			default:
				result = trio_pow((trio_long_double_t)number, (trio_long_double_t)exponent);
				break;
		}
	}
	else
	{
		return trio_pow((trio_long_double_t)number, (trio_long_double_t)exponent);
	}
	return result;
}
#endif /* TRIO_FEATURE_FLOAT */

/*************************************************************************
 * TrioLogarithm
 */
#if TRIO_FEATURE_FLOAT
TRIO_PRIVATE trio_long_double_t TrioLogarithm TRIO_ARGS2((number, base), trio_long_double_t number,
                                                         int base)
{
	trio_long_double_t result;

	if (number <= 0.0)
	{
		/* xlC crashes on log(0) */
		result = (number == 0.0) ? trio_ninf() : trio_nan();
	}
	else
	{
		if (base == 10)
		{
			result = trio_log10(number);
		}
		else
		{
			result = trio_log10(number) / trio_log10((double)base);
		}
	}
	return result;
}
#endif /* TRIO_FEATURE_FLOAT */

/*************************************************************************
 * TrioLogarithmBase
 */
#if TRIO_FEATURE_FLOAT
TRIO_PRIVATE double TrioLogarithmBase TRIO_ARGS1((base), int base)
{
	switch (base)
	{
		case BASE_BINARY:
			return 1.0;
		case BASE_OCTAL:
			return 3.0;
		case BASE_DECIMAL:
			return 3.321928094887362345;
		case BASE_HEX:
			return 4.0;
		default:
			return TrioLogarithm((double)base, 2);
	}
}
#endif /* TRIO_FEATURE_FLOAT */

/*************************************************************************
 * TrioParseQualifiers
 *
 * Description:
 *  Parse the qualifiers of a potential conversion specifier
 */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
TRIO_PRIVATE int TrioParseQualifiers TRIO_ARGS4((type, format, offset, parameter), int type,
                                                TRIO_CONST char* format, int offset,
                                                trio_parameter_t* parameter)
{
	char ch;
	int dots = 0; /* Count number of dots in modifier part */
	char* tmpformat;

	parameter->beginOffset = offset - 1;
	parameter->flags = FLAGS_NEW;
	parameter->position = TrioGetPosition(format, &offset);

	/* Default values */
	parameter->width = NO_WIDTH;
	parameter->precision = NO_PRECISION;
	parameter->base = NO_BASE;
	parameter->varsize = NO_SIZE;

	while (TrioIsQualifier(format[offset]))
	{
		ch = format[offset++];

		switch (ch)
		{
			case QUALIFIER_SPACE:
				parameter->flags |= FLAGS_SPACE;
				break;

			case QUALIFIER_PLUS:
				parameter->flags |= FLAGS_SHOWSIGN;
				break;

			case QUALIFIER_MINUS:
				parameter->flags |= FLAGS_LEFTADJUST;
				parameter->flags &= ~FLAGS_NILPADDING;
				break;

			case QUALIFIER_ALTERNATIVE:
				parameter->flags |= FLAGS_ALTERNATIVE;
				break;

			case QUALIFIER_DOT:
				if (dots == 0) /* Precision */
				{
					dots++;

					/* Skip if no precision */
					if (QUALIFIER_DOT == format[offset])
						break;

					/* After the first dot we have the precision */
					parameter->flags |= FLAGS_PRECISION;
					if ((QUALIFIER_STAR == format[offset])
#if defined(QUALIFIER_PARAM)
					    || (QUALIFIER_PARAM == format[offset])
#endif
					)
					{
						offset++;
						parameter->flags |= FLAGS_PRECISION_PARAMETER;
						parameter->precision = TrioGetPosition(format, &offset);
					}
					else
					{
						parameter->precision =
						    trio_to_long(&format[offset], &tmpformat, BASE_DECIMAL);
						offset = (int)(tmpformat - format);
					}
				}
				else if (dots == 1) /* Base */
				{
					dots++;

					/* After the second dot we have the base */
					parameter->flags |= FLAGS_BASE;
					if ((QUALIFIER_STAR == format[offset])
#if defined(QUALIFIER_PARAM)
					    || (QUALIFIER_PARAM == format[offset])
#endif
					)
					{
						offset++;
						parameter->flags |= FLAGS_BASE_PARAMETER;
						parameter->base = TrioGetPosition(format, &offset);
					}
					else
					{
						parameter->base = trio_to_long(&format[offset], &tmpformat, BASE_DECIMAL);
						if (parameter->base > MAX_BASE)
							return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
						offset = (int)(tmpformat - format);
					}
				}
				else
				{
					return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
				}
				break; /* QUALIFIER_DOT */

#if defined(QUALIFIER_PARAM)
			case QUALIFIER_PARAM:
				parameter->type = TYPE_PRINT;
				/* FALLTHROUGH */
#endif
			case QUALIFIER_STAR:
				/* This has different meanings for print and scan */
				if (TYPE_PRINT == type)
				{
					/* Read with from parameter */
					int width = TrioGetPosition(format, &offset);
					parameter->flags |= (FLAGS_WIDTH | FLAGS_WIDTH_PARAMETER);
					if (NO_POSITION != width)
						parameter->width = width;
					/* else keep parameter->width = NO_WIDTH which != NO_POSITION */
				}
#if TRIO_FEATURE_SCANF
				else
				{
					/* Scan, but do not store result */
					parameter->flags |= FLAGS_IGNORE;
				}
#endif
				break; /* QUALIFIER_STAR */

			case '0':
				if (!(parameter->flags & FLAGS_LEFTADJUST))
					parameter->flags |= FLAGS_NILPADDING;
				/* FALLTHROUGH */
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
				parameter->flags |= FLAGS_WIDTH;
				/*
				 * &format[offset - 1] is used to "rewind" the read
				 * character from format
				 */
				parameter->width = trio_to_long(&format[offset - 1], &tmpformat, BASE_DECIMAL);
				offset = (int)(tmpformat - format);
				break;

			case QUALIFIER_SHORT:
				if (parameter->flags & FLAGS_SHORTSHORT)
					return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
				else if (parameter->flags & FLAGS_SHORT)
					parameter->flags |= FLAGS_SHORTSHORT;
				else
					parameter->flags |= FLAGS_SHORT;
				break;

			case QUALIFIER_LONG:
				if (parameter->flags & FLAGS_QUAD)
					return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
				else if (parameter->flags & FLAGS_LONG)
					parameter->flags |= FLAGS_QUAD;
				else
					parameter->flags |= FLAGS_LONG;
				break;

#if TRIO_FEATURE_LONGDOUBLE
			case QUALIFIER_LONG_UPPER:
				parameter->flags |= FLAGS_LONGDOUBLE;
				break;
#endif

#if TRIO_FEATURE_SIZE_T
			case QUALIFIER_SIZE_T:
				parameter->flags |= FLAGS_SIZE_T;
				/* Modify flags for later truncation of number */
				if (sizeof(size_t) == sizeof(trio_ulonglong_t))
					parameter->flags |= FLAGS_QUAD;
				else if (sizeof(size_t) == sizeof(long))
					parameter->flags |= FLAGS_LONG;
				break;
#endif

#if TRIO_FEATURE_PTRDIFF_T
			case QUALIFIER_PTRDIFF_T:
				parameter->flags |= FLAGS_PTRDIFF_T;
				if (sizeof(ptrdiff_t) == sizeof(trio_ulonglong_t))
					parameter->flags |= FLAGS_QUAD;
				else if (sizeof(ptrdiff_t) == sizeof(long))
					parameter->flags |= FLAGS_LONG;
				break;
#endif

#if TRIO_FEATURE_INTMAX_T
			case QUALIFIER_INTMAX_T:
				parameter->flags |= FLAGS_INTMAX_T;
				if (sizeof(trio_intmax_t) == sizeof(trio_ulonglong_t))
					parameter->flags |= FLAGS_QUAD;
				else if (sizeof(trio_intmax_t) == sizeof(long))
					parameter->flags |= FLAGS_LONG;
				break;
#endif

#if TRIO_FEATURE_QUAD
			case QUALIFIER_QUAD:
				parameter->flags |= FLAGS_QUAD;
				break;
#endif

#if TRIO_FEATURE_FIXED_SIZE
			case QUALIFIER_FIXED_SIZE:
				if (parameter->flags & FLAGS_FIXED_SIZE)
					return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);

				if (parameter->flags &
				    (FLAGS_ALL_SIZES | FLAGS_LONGDOUBLE | FLAGS_WIDECHAR | FLAGS_VARSIZE_PARAMETER))
					return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);

				if ((format[offset] == '6') && (format[offset + 1] == '4'))
				{
					parameter->varsize = sizeof(trio_int64_t);
					offset += 2;
				}
				else if ((format[offset] == '3') && (format[offset + 1] == '2'))
				{
					parameter->varsize = sizeof(trio_int32_t);
					offset += 2;
				}
				else if ((format[offset] == '1') && (format[offset + 1] == '6'))
				{
					parameter->varsize = sizeof(trio_int16_t);
					offset += 2;
				}
				else if (format[offset] == '8')
				{
					parameter->varsize = sizeof(trio_int8_t);
					offset++;
				}
				else
					return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);

				parameter->flags |= FLAGS_FIXED_SIZE;
				break;
#endif /* TRIO_FEATURE_FIXED_SIZE */

#if defined(QUALIFIER_WIDECHAR)
			case QUALIFIER_WIDECHAR:
				parameter->flags |= FLAGS_WIDECHAR;
				break;
#endif

#if TRIO_FEATURE_SIZE_T_UPPER
			case QUALIFIER_SIZE_T_UPPER:
				break;
#endif

#if TRIO_FEATURE_QUOTE
			case QUALIFIER_QUOTE:
				parameter->flags |= FLAGS_QUOTE;
				break;
#endif

#if TRIO_FEATURE_STICKY
			case QUALIFIER_STICKY:
				parameter->flags |= FLAGS_STICKY;
				break;
#endif

#if TRIO_FEATURE_VARSIZE
			case QUALIFIER_VARSIZE:
				parameter->flags |= FLAGS_VARSIZE_PARAMETER;
				break;
#endif

#if TRIO_FEATURE_ROUNDING
			case QUALIFIER_ROUNDING_UPPER:
				parameter->flags |= FLAGS_ROUNDING;
				break;
#endif

			default:
				/* Bail out completely to make the error more obvious */
				return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
		}

	} /* while qualifier */

	parameter->endOffset = offset;

	return 0;
}
#pragma GCC diagnostic pop

/*************************************************************************
 * TrioParseSpecifier
 *
 * Description:
 *  Parse the specifier part of a potential conversion specifier
 */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
TRIO_PRIVATE int TrioParseSpecifier TRIO_ARGS4((type, format, offset, parameter), int type,
                                               TRIO_CONST char* format, int offset,
                                               trio_parameter_t* parameter)
{
	parameter->baseSpecifier = NO_BASE;

	switch (format[offset++])
	{
#if defined(SPECIFIER_CHAR_UPPER)
		case SPECIFIER_CHAR_UPPER:
			parameter->flags |= FLAGS_WIDECHAR;
			/* FALLTHROUGH */
#endif
		case SPECIFIER_CHAR:
			if (parameter->flags & FLAGS_LONG)
				parameter->flags |= FLAGS_WIDECHAR;
			else if (parameter->flags & FLAGS_SHORT)
				parameter->flags &= ~FLAGS_WIDECHAR;
			parameter->type = FORMAT_CHAR;
			break;

#if defined(SPECIFIER_STRING_UPPER)
		case SPECIFIER_STRING_UPPER:
			parameter->flags |= FLAGS_WIDECHAR;
			/* FALLTHROUGH */
#endif
		case SPECIFIER_STRING:
			if (parameter->flags & FLAGS_LONG)
				parameter->flags |= FLAGS_WIDECHAR;
			else if (parameter->flags & FLAGS_SHORT)
				parameter->flags &= ~FLAGS_WIDECHAR;
			parameter->type = FORMAT_STRING;
			break;

#if defined(SPECIFIER_GROUP)
		case SPECIFIER_GROUP:
			if (TYPE_SCAN == type)
			{
				int depth = 1;
				parameter->type = FORMAT_GROUP;
				if (format[offset] == QUALIFIER_CIRCUMFLEX)
					offset++;
				if (format[offset] == SPECIFIER_UNGROUP)
					offset++;
				if (format[offset] == QUALIFIER_MINUS)
					offset++;
				/* Skip nested brackets */
				while (format[offset] != NIL)
				{
					if (format[offset] == SPECIFIER_GROUP)
					{
						depth++;
					}
					else if (format[offset] == SPECIFIER_UNGROUP)
					{
						if (--depth <= 0)
						{
							offset++;
							break;
						}
					}
					offset++;
				}
			}
			break;
#endif /* defined(SPECIFIER_GROUP) */

		case SPECIFIER_INTEGER:
			parameter->type = FORMAT_INT;
			break;

		case SPECIFIER_UNSIGNED:
			parameter->flags |= FLAGS_UNSIGNED;
			parameter->type = FORMAT_INT;
			break;

		case SPECIFIER_DECIMAL:
			parameter->baseSpecifier = BASE_DECIMAL;
			parameter->type = FORMAT_INT;
			break;

		case SPECIFIER_OCTAL:
			parameter->flags |= FLAGS_UNSIGNED;
			parameter->baseSpecifier = BASE_OCTAL;
			parameter->type = FORMAT_INT;
			break;

#if TRIO_FEATURE_BINARY
		case SPECIFIER_BINARY_UPPER:
			parameter->flags |= FLAGS_UPPER;
			/* FALLTHROUGH */
		case SPECIFIER_BINARY:
			parameter->flags |= FLAGS_NILPADDING;
			parameter->baseSpecifier = BASE_BINARY;
			parameter->type = FORMAT_INT;
			break;
#endif

		case SPECIFIER_HEX_UPPER:
			parameter->flags |= FLAGS_UPPER;
			/* FALLTHROUGH */
		case SPECIFIER_HEX:
			parameter->flags |= FLAGS_UNSIGNED;
			parameter->baseSpecifier = BASE_HEX;
			parameter->type = FORMAT_INT;
			break;

#if defined(SPECIFIER_FLOAT_E)
#if defined(SPECIFIER_FLOAT_E_UPPER)
		case SPECIFIER_FLOAT_E_UPPER:
			parameter->flags |= FLAGS_UPPER;
			/* FALLTHROUGH */
#endif
		case SPECIFIER_FLOAT_E:
			parameter->flags |= FLAGS_FLOAT_E;
			parameter->type = FORMAT_DOUBLE;
			break;
#endif

#if defined(SPECIFIER_FLOAT_G)
#if defined(SPECIFIER_FLOAT_G_UPPER)
		case SPECIFIER_FLOAT_G_UPPER:
			parameter->flags |= FLAGS_UPPER;
			/* FALLTHROUGH */
#endif
		case SPECIFIER_FLOAT_G:
			parameter->flags |= FLAGS_FLOAT_G;
			parameter->type = FORMAT_DOUBLE;
			break;
#endif

#if defined(SPECIFIER_FLOAT_F)
#if defined(SPECIFIER_FLOAT_F_UPPER)
		case SPECIFIER_FLOAT_F_UPPER:
			parameter->flags |= FLAGS_UPPER;
			/* FALLTHROUGH */
#endif
		case SPECIFIER_FLOAT_F:
			parameter->type = FORMAT_DOUBLE;
			break;
#endif

#if defined(TRIO_COMPILER_VISUALC)
#pragma warning(push)
#pragma warning(disable : 4127) /* Conditional expression is constant */
#endif
		case SPECIFIER_POINTER:
			if (sizeof(trio_pointer_t) == sizeof(trio_ulonglong_t))
				parameter->flags |= FLAGS_QUAD;
			else if (sizeof(trio_pointer_t) == sizeof(long))
				parameter->flags |= FLAGS_LONG;
			parameter->type = FORMAT_POINTER;
			break;
#if defined(TRIO_COMPILER_VISUALC)
#pragma warning(pop)
#endif

		case SPECIFIER_COUNT:
			parameter->type = FORMAT_COUNT;
			break;

#if TRIO_FEATURE_HEXFLOAT
		case SPECIFIER_HEXFLOAT_UPPER:
			parameter->flags |= FLAGS_UPPER;
			/* FALLTHROUGH */
		case SPECIFIER_HEXFLOAT:
			parameter->baseSpecifier = BASE_HEX;
			parameter->type = FORMAT_DOUBLE;
			break;
#endif

#if TRIO_FEATURE_ERRNO
		case SPECIFIER_ERRNO:
			parameter->type = FORMAT_ERRNO;
			break;
#endif

#if TRIO_FEATURE_USER_DEFINED
		case SPECIFIER_USER_DEFINED_BEGIN:
		{
			unsigned int max;
			int without_namespace = TRUE;
			char* tmpformat = (char*)&format[offset];
			int ch;

			parameter->type = FORMAT_USER_DEFINED;
			parameter->user_defined.namespace[0] = NIL;

			while ((ch = format[offset]) != NIL)
			{
				offset++;
				if ((ch == SPECIFIER_USER_DEFINED_END) || (ch == SPECIFIER_USER_DEFINED_EXTRA))
				{
					if (without_namespace)
						/* No namespace, handler will be passed as an argument */
						parameter->flags |= FLAGS_USER_DEFINED_PARAMETER;

					/* Copy the user data */
					max = (unsigned int)(&format[offset] - tmpformat);
					if (max > MAX_USER_DATA)
						max = MAX_USER_DATA;
					trio_copy_max(parameter->user_data, max, tmpformat);

					/* Skip extra data (which is only there to keep the compiler happy) */
					while ((ch != NIL) && (ch != SPECIFIER_USER_DEFINED_END))
						ch = format[offset++];

					break; /* while */
				}

				if (ch == SPECIFIER_USER_DEFINED_SEPARATOR)
				{
					without_namespace = FALSE;
					/* Copy the namespace for later looking-up */
					max = (int)(&format[offset] - tmpformat);
					if (max > MAX_USER_NAME)
						max = MAX_USER_NAME;
					trio_copy_max(parameter->user_defined.namespace, max, tmpformat);
					tmpformat = (char*)&format[offset];
				}
			}

			if (ch != SPECIFIER_USER_DEFINED_END)
				return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
		}
		break;
#endif /* TRIO_FEATURE_USER_DEFINED */

		default:
			/* Bail out completely to make the error more obvious */
			return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
	}

	parameter->endOffset = offset;

	return 0;
}
#pragma GCC diagnostic pop

/*************************************************************************
 * TrioParse
 *
 * Description:
 *  Parse the format string
 */
TRIO_PRIVATE int TrioParse TRIO_ARGS6((type, format, parameters, arglist, argfunc, argarray),
                                      int type, TRIO_CONST char* format,
                                      trio_parameter_t* parameters, va_list arglist,
                                      trio_argfunc_t argfunc, trio_pointer_t* argarray)
{
	/* Count the number of times a parameter is referenced */
	unsigned short usedEntries[MAX_PARAMETERS];
	/* Parameter counters */
	int parameterPosition;
	int maxParam = -1;
	/* Utility variables */
	int offset;           /* Offset into formatting string */
	BOOLEAN_T positional; /* Does the specifier have a positional? */
#if TRIO_FEATURE_STICKY
	BOOLEAN_T gotSticky = FALSE; /* Are there any sticky modifiers at all? */
#endif
	/*
	 * indices specifies the order in which the parameters must be
	 * read from the va_args (this is necessary to handle positionals)
	 */
	int indices[MAX_PARAMETERS];
	int pos = 0;
	/* Various variables */
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
	int charlen;
#endif
	int save_errno;
	int i = -1;
	int num;
	trio_parameter_t workParameter;
	int status;

	/* Both must be set or none must be set */
	assert(((argfunc == NULL) && (argarray == NULL)) || ((argfunc != NULL) && (argarray != NULL)));

	/*
	 * The 'parameters' array is not initialized, but we need to
	 * know which entries we have used.
	 */
	memset(usedEntries, 0, sizeof(usedEntries));

	save_errno = errno;
	offset = 0;
	parameterPosition = 0;
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
	(void)mblen(NULL, 0);
#endif

	while (format[offset])
	{
		TrioInitializeParameter(&workParameter);

#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
		if (!isascii(format[offset]))
		{
			/*
			 * Multibyte characters cannot be legal specifiers or
			 * modifiers, so we skip over them.
			 */
			charlen = mblen(&format[offset], MB_LEN_MAX);
			offset += (charlen > 0) ? charlen : 1;
			continue; /* while */
		}
#endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */

		switch (format[offset++])
		{

			case CHAR_IDENTIFIER:
			{
				if (CHAR_IDENTIFIER == format[offset])
				{
					/* skip double "%" */
					offset++;
					continue; /* while */
				}

				status = TrioParseQualifiers(type, format, offset, &workParameter);
				if (status < 0)
					return status; /* Return qualifier syntax error */

				status = TrioParseSpecifier(type, format, workParameter.endOffset, &workParameter);
				if (status < 0)
					return status; /* Return specifier syntax error */
			}
			break;

#if TRIO_EXTENSION
			case CHAR_ALT_IDENTIFIER:
			{
				status = TrioParseQualifiers(type, format, offset, &workParameter);
				if (status < 0)
					continue; /* False alert, not a user defined specifier */

				status = TrioParseSpecifier(type, format, workParameter.endOffset, &workParameter);
				if ((status < 0) || (FORMAT_USER_DEFINED != workParameter.type))
					continue; /* False alert, not a user defined specifier */
			}
			break;
#endif

			default:
				continue; /* while */
		}

		/* now handle the parsed conversion specification */
		positional = (NO_POSITION != workParameter.position);

		/*
		 * Parameters only need the type and value. The value is
		 * read later.
		 */
		if (workParameter.flags & FLAGS_WIDTH_PARAMETER)
		{
			if (workParameter.width == NO_WIDTH)
			{
				workParameter.width = parameterPosition++;
			}
			else
			{
				if (!positional)
					workParameter.position = workParameter.width + 1;
			}

			usedEntries[workParameter.width] += 1;
			if (workParameter.width > maxParam)
				maxParam = workParameter.width;
			parameters[pos].type = FORMAT_PARAMETER;
			parameters[pos].flags = 0;
			indices[workParameter.width] = pos;
			workParameter.width = pos++;
		}
		if (workParameter.flags & FLAGS_PRECISION_PARAMETER)
		{
			if (workParameter.precision == NO_PRECISION)
			{
				workParameter.precision = parameterPosition++;
			}
			else
			{
				if (!positional)
					workParameter.position = workParameter.precision + 1;
			}

			usedEntries[workParameter.precision] += 1;
			if (workParameter.precision > maxParam)
				maxParam = workParameter.precision;
			parameters[pos].type = FORMAT_PARAMETER;
			parameters[pos].flags = 0;
			indices[workParameter.precision] = pos;
			workParameter.precision = pos++;
		}
		if (workParameter.flags & FLAGS_BASE_PARAMETER)
		{
			if (workParameter.base == NO_BASE)
			{
				workParameter.base = parameterPosition++;
			}
			else
			{
				if (!positional)
					workParameter.position = workParameter.base + 1;
			}

			usedEntries[workParameter.base] += 1;
			if (workParameter.base > maxParam)
				maxParam = workParameter.base;
			parameters[pos].type = FORMAT_PARAMETER;
			parameters[pos].flags = 0;
			indices[workParameter.base] = pos;
			workParameter.base = pos++;
		}
#if TRIO_FEATURE_VARSIZE
		if (workParameter.flags & FLAGS_VARSIZE_PARAMETER)
		{
			workParameter.varsize = parameterPosition++;

			usedEntries[workParameter.varsize] += 1;
			if (workParameter.varsize > maxParam)
				maxParam = workParameter.varsize;
			parameters[pos].type = FORMAT_PARAMETER;
			parameters[pos].flags = 0;
			indices[workParameter.varsize] = pos;
			workParameter.varsize = pos++;
		}
#endif
#if TRIO_FEATURE_USER_DEFINED
		if (workParameter.flags & FLAGS_USER_DEFINED_PARAMETER)
		{
			workParameter.user_defined.handler = parameterPosition++;

			usedEntries[workParameter.user_defined.handler] += 1;
			if (workParameter.user_defined.handler > maxParam)
				maxParam = workParameter.user_defined.handler;
			parameters[pos].type = FORMAT_PARAMETER;
			parameters[pos].flags = FLAGS_USER_DEFINED;
			indices[workParameter.user_defined.handler] = pos;
			workParameter.user_defined.handler = pos++;
		}
#endif

		if (NO_POSITION == workParameter.position)
		{
			workParameter.position = parameterPosition++;
		}

		if (workParameter.position > maxParam)
			maxParam = workParameter.position;

		if (workParameter.position >= MAX_PARAMETERS)
		{
			/* Bail out completely to make the error more obvious */
			return TRIO_ERROR_RETURN(TRIO_ETOOMANY, offset);
		}

		indices[workParameter.position] = pos;

		/*  Count the number of times this entry has been used */
		usedEntries[workParameter.position] += 1;

		/* Find last sticky parameters */
#if TRIO_FEATURE_STICKY
		if (workParameter.flags & FLAGS_STICKY)
		{
			gotSticky = TRUE;
		}
		else if (gotSticky)
		{
			for (i = pos - 1; i >= 0; i--)
			{
				if (parameters[i].type == FORMAT_PARAMETER)
					continue;
				if ((parameters[i].flags & FLAGS_STICKY) &&
				    (parameters[i].type == workParameter.type))
				{
					/* Do not overwrite current qualifiers */
					workParameter.flags |= (parameters[i].flags & (unsigned long)~FLAGS_STICKY);
					if (workParameter.width == NO_WIDTH)
						workParameter.width = parameters[i].width;
					if (workParameter.precision == NO_PRECISION)
						workParameter.precision = parameters[i].precision;
					if (workParameter.base == NO_BASE)
						workParameter.base = parameters[i].base;
					break;
				}
			}
		}
#endif

		if (workParameter.base == NO_BASE)
			workParameter.base = BASE_DECIMAL;

		offset = workParameter.endOffset;

		TrioCopyParameter(&parameters[pos++], &workParameter);
	} /* while format characters left */

	parameters[pos].type = FORMAT_SENTINEL; /* end parameter array with sentinel */
	parameters[pos].beginOffset = offset;

	for (num = 0; num <= maxParam; num++)
	{
		if (usedEntries[num] != 1)
		{
			if (usedEntries[num] == 0) /* gap detected */
				return TRIO_ERROR_RETURN(TRIO_EGAP, num);
			else /* double references detected */
				return TRIO_ERROR_RETURN(TRIO_EDBLREF, num);
		}

		i = indices[num];

		/*
		 * FORMAT_PARAMETERS are only present if they must be read,
		 * so it makes no sense to check the ignore flag (besides,
		 * the flags variable is not set for that particular type)
		 */
		if ((parameters[i].type != FORMAT_PARAMETER) && (parameters[i].flags & FLAGS_IGNORE))
			continue; /* for all arguments */

		/*
		 * The stack arguments are read according to ANSI C89
		 * default argument promotions:
		 *
		 *  char           = int
		 *  short          = int
		 *  unsigned char  = unsigned int
		 *  unsigned short = unsigned int
		 *  float          = double
		 *
		 * In addition to the ANSI C89 these types are read (the
		 * default argument promotions of C99 has not been
		 * considered yet)
		 *
		 *  long long
		 *  long double
		 *  size_t
		 *  ptrdiff_t
		 *  intmax_t
		 */
		switch (parameters[i].type)
		{
			case FORMAT_GROUP:
			case FORMAT_STRING:
#if TRIO_FEATURE_WIDECHAR
				if (parameters[i].flags & FLAGS_WIDECHAR)
				{
					parameters[i].data.wstring =
					    (argfunc == NULL)
					        ? va_arg(arglist, trio_wchar_t*)
					        : (trio_wchar_t*)(argfunc(argarray, num, TRIO_TYPE_PWCHAR));
				}
				else
#endif
				{
					parameters[i].data.string =
					    (argfunc == NULL) ? va_arg(arglist, char*)
					                      : (char*)(argfunc(argarray, num, TRIO_TYPE_PCHAR));
				}
				break;

#if TRIO_FEATURE_USER_DEFINED
			case FORMAT_USER_DEFINED:
#endif
			case FORMAT_POINTER:
			case FORMAT_COUNT:
			case FORMAT_UNKNOWN:
				parameters[i].data.pointer = (argfunc == NULL)
				                                 ? va_arg(arglist, trio_pointer_t)
				                                 : argfunc(argarray, num, TRIO_TYPE_POINTER);
				break;

			case FORMAT_CHAR:
			case FORMAT_INT:
#if TRIO_FEATURE_SCANF
				if (TYPE_SCAN == type)
				{
					if (argfunc == NULL)
						parameters[i].data.pointer =
						    (trio_pointer_t)va_arg(arglist, trio_pointer_t);
					else
					{
						if (parameters[i].type == FORMAT_CHAR)
							parameters[i].data.pointer =
							    (trio_pointer_t)((char*)argfunc(argarray, num, TRIO_TYPE_CHAR));
						else if (parameters[i].flags & FLAGS_SHORT)
							parameters[i].data.pointer =
							    (trio_pointer_t)((short*)argfunc(argarray, num, TRIO_TYPE_SHORT));
						else
							parameters[i].data.pointer =
							    (trio_pointer_t)((int*)argfunc(argarray, num, TRIO_TYPE_INT));
					}
				}
				else
#endif /* TRIO_FEATURE_SCANF */
				{
#if TRIO_FEATURE_VARSIZE || TRIO_FEATURE_FIXED_SIZE
					if (parameters[i].flags & (FLAGS_VARSIZE_PARAMETER | FLAGS_FIXED_SIZE))
					{
						int varsize;
						if (parameters[i].flags & FLAGS_VARSIZE_PARAMETER)
						{
							/*
							 * Variable sizes are mapped onto the fixed sizes, in
							 * accordance with integer promotion.
							 *
							 * Please note that this may not be portable, as we
							 * only guess the size, not the layout of the numbers.
							 * For example, if int is little-endian, and long is
							 * big-endian, then this will fail.
							 */
							varsize =
							    (int)parameters[parameters[i].varsize].data.number.as_unsigned;
						}
						else
						{
							/* Used for the I<bits> modifiers */
							varsize = parameters[i].varsize;
						}
						parameters[i].flags &= ~FLAGS_ALL_VARSIZES;

						if (varsize <= (int)sizeof(int))
							;
						else if (varsize <= (int)sizeof(long))
							parameters[i].flags |= FLAGS_LONG;
#if TRIO_FEATURE_INTMAX_T
						else if (varsize <= (int)sizeof(trio_longlong_t))
							parameters[i].flags |= FLAGS_QUAD;
						else
							parameters[i].flags |= FLAGS_INTMAX_T;
#else
						else
							parameters[i].flags |= FLAGS_QUAD;
#endif
					}
#endif /* TRIO_FEATURE_VARSIZE */
#if TRIO_FEATURE_SIZE_T || TRIO_FEATURE_SIZE_T_UPPER
					if (parameters[i].flags & FLAGS_SIZE_T)
						parameters[i].data.number.as_unsigned =
						    (argfunc == NULL)
						        ? (trio_uintmax_t)va_arg(arglist, size_t)
						        : (trio_uintmax_t)(
						              *((size_t*)argfunc(argarray, num, TRIO_TYPE_SIZE)));
					else
#endif
#if TRIO_FEATURE_PTRDIFF_T
					    if (parameters[i].flags & FLAGS_PTRDIFF_T)
						parameters[i].data.number.as_unsigned =
						    (argfunc == NULL)
						        ? (trio_uintmax_t)va_arg(arglist, ptrdiff_t)
						        : (trio_uintmax_t)(
						              *((ptrdiff_t*)argfunc(argarray, num, TRIO_TYPE_PTRDIFF)));
					else
#endif
#if TRIO_FEATURE_INTMAX_T
					    if (parameters[i].flags & FLAGS_INTMAX_T)
						parameters[i].data.number.as_unsigned =
						    (argfunc == NULL)
						        ? (trio_uintmax_t)va_arg(arglist, trio_intmax_t)
						        : (trio_uintmax_t)(
						              *((trio_intmax_t*)argfunc(argarray, num, TRIO_TYPE_UINTMAX)));
					else
#endif
					    if (parameters[i].flags & FLAGS_QUAD)
						parameters[i].data.number.as_unsigned =
						    (argfunc == NULL) ? (trio_uintmax_t)va_arg(arglist, trio_ulonglong_t)
						                      : (trio_uintmax_t)(*((trio_ulonglong_t*)argfunc(
						                            argarray, num, TRIO_TYPE_ULONGLONG)));
					else if (parameters[i].flags & FLAGS_LONG)
						parameters[i].data.number.as_unsigned =
						    (argfunc == NULL) ? (trio_uintmax_t)va_arg(arglist, long)
						                      : (trio_uintmax_t)(*(
						                            (long*)argfunc(argarray, num, TRIO_TYPE_LONG)));
					else
					{
						if (argfunc == NULL)
							parameters[i].data.number.as_unsigned =
							    (trio_uintmax_t)va_arg(arglist, int);
						else
						{
							if (parameters[i].type == FORMAT_CHAR)
								parameters[i].data.number.as_unsigned = (trio_uintmax_t)(
								    *((char*)argfunc(argarray, num, TRIO_TYPE_CHAR)));
							else if (parameters[i].flags & FLAGS_SHORT)
								parameters[i].data.number.as_unsigned = (trio_uintmax_t)(
								    *((short*)argfunc(argarray, num, TRIO_TYPE_SHORT)));
							else
								parameters[i].data.number.as_unsigned = (trio_uintmax_t)(
								    *((int*)argfunc(argarray, num, TRIO_TYPE_INT)));
						}
					}
				}
				break;

			case FORMAT_PARAMETER:
				/*
				 * The parameter for the user-defined specifier is a pointer,
				 * whereas the rest (width, precision, base) uses an integer.
				 */
				if (parameters[i].flags & FLAGS_USER_DEFINED)
					parameters[i].data.pointer = (argfunc == NULL)
					                                 ? va_arg(arglist, trio_pointer_t)
					                                 : argfunc(argarray, num, TRIO_TYPE_POINTER);
				else
					parameters[i].data.number.as_unsigned =
					    (argfunc == NULL)
					        ? (trio_uintmax_t)va_arg(arglist, int)
					        : (trio_uintmax_t)(*((int*)argfunc(argarray, num, TRIO_TYPE_INT)));
				break;

#if TRIO_FEATURE_FLOAT
			case FORMAT_DOUBLE:
#if TRIO_FEATURE_SCANF
				if (TYPE_SCAN == type)
				{
					if (parameters[i].flags & FLAGS_LONGDOUBLE)
						parameters[i].data.longdoublePointer =
						    (argfunc == NULL)
						        ? va_arg(arglist, trio_long_double_t*)
						        : (trio_long_double_t*)argfunc(argarray, num, TRIO_TYPE_LONGDOUBLE);
					else
					{
						if (parameters[i].flags & FLAGS_LONG)
							parameters[i].data.doublePointer =
							    (argfunc == NULL)
							        ? va_arg(arglist, double*)
							        : (double*)argfunc(argarray, num, TRIO_TYPE_DOUBLE);
						else
							parameters[i].data.doublePointer =
							    (argfunc == NULL)
							        ? (double*)va_arg(arglist, float*)
							        : (double*)argfunc(argarray, num, TRIO_TYPE_DOUBLE);
					}
				}
				else
#endif /* TRIO_FEATURE_SCANF */
				{
					if (parameters[i].flags & FLAGS_LONGDOUBLE)
						parameters[i].data.longdoubleNumber =
						    (argfunc == NULL) ? va_arg(arglist, trio_long_double_t)
						                      : (trio_long_double_t)(*((trio_long_double_t*)argfunc(
						                            argarray, num, TRIO_TYPE_LONGDOUBLE)));
					else
					{
						if (argfunc == NULL)
							parameters[i].data.longdoubleNumber =
							    (trio_long_double_t)va_arg(arglist, double);
						else
						{
							if (parameters[i].flags & FLAGS_SHORT)
								parameters[i].data.longdoubleNumber = (trio_long_double_t)(
								    *((float*)argfunc(argarray, num, TRIO_TYPE_FLOAT)));
							else
								parameters[i].data.longdoubleNumber = (trio_long_double_t)(
								    *((double*)argfunc(argarray, num, TRIO_TYPE_DOUBLE)));
						}
					}
				}
				break;
#endif /* TRIO_FEATURE_FLOAT */

#if TRIO_FEATURE_ERRNO
			case FORMAT_ERRNO:
				parameters[i].data.errorNumber = save_errno;
				break;
#endif

			default:
				break;
		}
	} /* for all specifiers */
	return num;
}

/*************************************************************************
 *
 * FORMATTING
 *
 ************************************************************************/

/*************************************************************************
 * TrioWriteNumber
 *
 * Description:
 *  Output a number.
 *  The complexity of this function is a result of the complexity
 *  of the dependencies of the flags.
 */
TRIO_PRIVATE void TrioWriteNumber TRIO_ARGS6((self, number, flags, width, precision, base),
                                             trio_class_t* self, trio_uintmax_t number,
                                             trio_flags_t flags, int width, int precision, int base)
{
	BOOLEAN_T isNegative;
	BOOLEAN_T isNumberZero;
	BOOLEAN_T isPrecisionZero;
	BOOLEAN_T ignoreNumber;
	char buffer[MAX_CHARS_IN(trio_uintmax_t) * (1 + MAX_LOCALE_SEPARATOR_LENGTH) + 1];
	char* bufferend;
	char* pointer;
	TRIO_CONST char* digits;
	int i;
#if TRIO_FEATURE_QUOTE
	int length;
	char* p;
#endif
	int count;
	int digitOffset;

	assert(VALID(self));
	assert(VALID(self->OutStream));
	assert(((base >= MIN_BASE) && (base <= MAX_BASE)) || (base == NO_BASE));

	digits = (flags & FLAGS_UPPER) ? internalDigitsUpper : internalDigitsLower;
	if (base == NO_BASE)
		base = BASE_DECIMAL;

	isNumberZero = (number == 0);
	isPrecisionZero = (precision == 0);
	ignoreNumber =
	    (isNumberZero && isPrecisionZero && !((flags & FLAGS_ALTERNATIVE) && (base == BASE_OCTAL)));

	if (flags & FLAGS_UNSIGNED)
	{
		isNegative = FALSE;
		flags &= ~FLAGS_SHOWSIGN;
	}
	else
	{
		isNegative = ((trio_intmax_t)number < 0);
		if (isNegative)
			number = -((trio_intmax_t)number);
	}

	if (flags & FLAGS_QUAD)
		number &= (trio_ulonglong_t)-1;
	else if (flags & FLAGS_LONG)
		number &= (unsigned long)-1;
	else
		number &= (unsigned int)-1;

	/* Build number */
	pointer = bufferend = &buffer[sizeof(buffer) - 1];
	*pointer-- = NIL;
	for (i = 1; i < (int)sizeof(buffer); i++)
	{
		digitOffset = number % base;
		*pointer-- = digits[digitOffset];
		number /= base;
		if (number == 0)
			break;

#if TRIO_FEATURE_QUOTE
		if ((flags & FLAGS_QUOTE) && TrioFollowedBySeparator(i + 1))
		{
			/*
			 * We are building the number from the least significant
			 * to the most significant digit, so we have to copy the
			 * thousand separator backwards
			 */
			length = internalThousandSeparatorLength;
			if (((int)(pointer - buffer) - length) > 0)
			{
				p = &internalThousandSeparator[length - 1];
				while (length-- > 0)
					*pointer-- = *p--;
			}
		}
#endif
	}

	if (!ignoreNumber)
	{
		/* Adjust width */
		width -= (bufferend - pointer) - 1;
	}

	/* Adjust precision */
	if (NO_PRECISION != precision)
	{
		precision -= (bufferend - pointer) - 1;
		if (precision < 0)
			precision = 0;
		flags |= FLAGS_NILPADDING;
	}

	/* Calculate padding */
	count = (!((flags & FLAGS_LEFTADJUST) || (precision == NO_PRECISION))) ? precision : 0;

	/* Adjust width further */
	if (isNegative || (flags & FLAGS_SHOWSIGN) || (flags & FLAGS_SPACE))
		width--;
	if ((flags & FLAGS_ALTERNATIVE) && !isNumberZero)
	{
		switch (base)
		{
			case BASE_BINARY:
			case BASE_HEX:
				width -= 2;
				break;
			case BASE_OCTAL:
				if (!(flags & FLAGS_NILPADDING) || (count == 0))
					width--;
				break;
			default:
				break;
		}
	}

	/* Output prefixes spaces if needed */
	if (!((flags & FLAGS_LEFTADJUST) ||
	      ((flags & FLAGS_NILPADDING) && (precision == NO_PRECISION))))
	{
		while (width-- > count)
			self->OutStream(self, CHAR_ADJUST);
	}

	/* width has been adjusted for signs and alternatives */
	if (isNegative)
		self->OutStream(self, '-');
	else if (flags & FLAGS_SHOWSIGN)
		self->OutStream(self, '+');
	else if (flags & FLAGS_SPACE)
		self->OutStream(self, ' ');

	/* Prefix is not written when the value is zero */
	if ((flags & FLAGS_ALTERNATIVE) && !isNumberZero)
	{
		switch (base)
		{
			case BASE_BINARY:
				self->OutStream(self, '0');
				self->OutStream(self, (flags & FLAGS_UPPER) ? 'B' : 'b');
				break;

			case BASE_OCTAL:
				if (!(flags & FLAGS_NILPADDING) || (count == 0))
					self->OutStream(self, '0');
				break;

			case BASE_HEX:
				self->OutStream(self, '0');
				self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x');
				break;

			default:
				break;
		} /* switch base */
	}

	/* Output prefixed zero padding if needed */
	if (flags & FLAGS_NILPADDING)
	{
		if (precision == NO_PRECISION)
			precision = width;
		while (precision-- > 0)
		{
			self->OutStream(self, '0');
			width--;
		}
	}

	if (!ignoreNumber)
	{
		/* Output the number itself */
		while (*(++pointer))
		{
			self->OutStream(self, *pointer);
		}
	}

	/* Output trailing spaces if needed */
	if (flags & FLAGS_LEFTADJUST)
	{
		while (width-- > 0)
			self->OutStream(self, CHAR_ADJUST);
	}
}

/*************************************************************************
 * TrioWriteStringCharacter
 *
 * Description:
 *  Output a single character of a string
 */
TRIO_PRIVATE void TrioWriteStringCharacter TRIO_ARGS3((self, ch, flags), trio_class_t* self, int ch,
                                                      trio_flags_t flags)
{
	if (flags & FLAGS_ALTERNATIVE)
	{
		if (!isprint(ch))
		{
			/*
			 * Non-printable characters are converted to C escapes or
			 * \number, if no C escape exists.
			 */
			self->OutStream(self, CHAR_BACKSLASH);
			switch (ch)
			{
				case '\007':
					self->OutStream(self, 'a');
					break;
				case '\b':
					self->OutStream(self, 'b');
					break;
				case '\f':
					self->OutStream(self, 'f');
					break;
				case '\n':
					self->OutStream(self, 'n');
					break;
				case '\r':
					self->OutStream(self, 'r');
					break;
				case '\t':
					self->OutStream(self, 't');
					break;
				case '\v':
					self->OutStream(self, 'v');
					break;
				case '\\':
					self->OutStream(self, '\\');
					break;
				default:
					self->OutStream(self, 'x');
					TrioWriteNumber(self, (trio_uintmax_t)ch, FLAGS_UNSIGNED | FLAGS_NILPADDING, 2,
					                2, BASE_HEX);
					break;
			}
		}
		else if (ch == CHAR_BACKSLASH)
		{
			self->OutStream(self, CHAR_BACKSLASH);
			self->OutStream(self, CHAR_BACKSLASH);
		}
		else
		{
			self->OutStream(self, ch);
		}
	}
	else
	{
		self->OutStream(self, ch);
	}
}

/*************************************************************************
 * TrioWriteString
 *
 * Description:
 *  Output a string
 */
TRIO_PRIVATE void TrioWriteString TRIO_ARGS5((self, string, flags, width, precision),
                                             trio_class_t* self, TRIO_CONST char* string,
                                             trio_flags_t flags, int width, int precision)
{
	int length;
	int ch;

	assert(VALID(self));
	assert(VALID(self->OutStream));

	if (string == NULL)
	{
		string = internalNullString;
		length = sizeof(internalNullString) - 1;
#if TRIO_FEATURE_QUOTE
		/* Disable quoting for the null pointer */
		flags &= (~FLAGS_QUOTE);
#endif
		width = 0;
	}
	else
	{
		if (precision == 0)
		{
			length = trio_length(string);
		}
		else
		{
			length = trio_length_max(string, precision);
		}
	}
	if ((NO_PRECISION != precision) && (precision < length))
	{
		length = precision;
	}
	width -= length;

#if TRIO_FEATURE_QUOTE
	if (flags & FLAGS_QUOTE)
		self->OutStream(self, CHAR_QUOTE);
#endif

	if (!(flags & FLAGS_LEFTADJUST))
	{
		while (width-- > 0)
			self->OutStream(self, CHAR_ADJUST);
	}

	while (length-- > 0)
	{
		/* The ctype parameters must be an unsigned char (or EOF) */
		ch = (int)((unsigned char)(*string++));
		TrioWriteStringCharacter(self, ch, flags);
	}

	if (flags & FLAGS_LEFTADJUST)
	{
		while (width-- > 0)
			self->OutStream(self, CHAR_ADJUST);
	}
#if TRIO_FEATURE_QUOTE
	if (flags & FLAGS_QUOTE)
		self->OutStream(self, CHAR_QUOTE);
#endif
}

/*************************************************************************
 * TrioWriteWideStringCharacter
 *
 * Description:
 *  Output a wide string as a multi-byte sequence
 */
#if TRIO_FEATURE_WIDECHAR
TRIO_PRIVATE int TrioWriteWideStringCharacter TRIO_ARGS4((self, wch, flags, width),
                                                         trio_class_t* self, trio_wchar_t wch,
                                                         trio_flags_t flags, int width)
{
	int size;
	int i;
	int ch;
	char* string;
	char buffer[MB_LEN_MAX + 1];

	if (width == NO_WIDTH)
		width = sizeof(buffer);

	size = wctomb(buffer, wch);
	if ((size <= 0) || (size > width) || (buffer[0] == NIL))
		return 0;

	string = buffer;
	i = size;
	while ((width >= i) && (width-- > 0) && (i-- > 0))
	{
		/* The ctype parameters must be an unsigned char (or EOF) */
		ch = (int)((unsigned char)(*string++));
		TrioWriteStringCharacter(self, ch, flags);
	}
	return size;
}
#endif /* TRIO_FEATURE_WIDECHAR */

/*************************************************************************
 * TrioWriteWideString
 *
 * Description:
 *  Output a wide character string as a multi-byte string
 */
#if TRIO_FEATURE_WIDECHAR
TRIO_PRIVATE void TrioWriteWideString TRIO_ARGS5((self, wstring, flags, width, precision),
                                                 trio_class_t* self,
                                                 TRIO_CONST trio_wchar_t* wstring,
                                                 trio_flags_t flags, int width, int precision)
{
	int length;
	int size;

	assert(VALID(self));
	assert(VALID(self->OutStream));

#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
	/* Required by TrioWriteWideStringCharacter */
	(void)mblen(NULL, 0);
#endif

	if (wstring == NULL)
	{
		TrioWriteString(self, NULL, flags, width, precision);
		return;
	}

	if (NO_PRECISION == precision)
	{
		length = INT_MAX;
	}
	else
	{
		length = precision;
		width -= length;
	}

#if TRIO_FEATURE_QUOTE
	if (flags & FLAGS_QUOTE)
		self->OutStream(self, CHAR_QUOTE);
#endif

	if (!(flags & FLAGS_LEFTADJUST))
	{
		while (width-- > 0)
			self->OutStream(self, CHAR_ADJUST);
	}

	while (length > 0)
	{
		size = TrioWriteWideStringCharacter(self, *wstring++, flags, length);
		if (size == 0)
			break; /* while */
		length -= size;
	}

	if (flags & FLAGS_LEFTADJUST)
	{
		while (width-- > 0)
			self->OutStream(self, CHAR_ADJUST);
	}
#if TRIO_FEATURE_QUOTE
	if (flags & FLAGS_QUOTE)
		self->OutStream(self, CHAR_QUOTE);
#endif
}
#endif /* TRIO_FEATURE_WIDECHAR */

/*************************************************************************
 * TrioWriteDouble
 *
 * http://wwwold.dkuug.dk/JTC1/SC22/WG14/www/docs/dr_211.htm
 *
 * "5.2.4.2.2 paragraph #4
 *
 *  The accuracy [...] is implementation defined, as is the accuracy
 *  of the conversion between floating-point internal representations
 *  and string representations performed by the libray routine in
 *  <stdio.h>"
 */
/* FIXME: handle all instances of constant long-double number (L)
 *   and *l() math functions.
 */
#if TRIO_FEATURE_FLOAT
TRIO_PRIVATE void TrioWriteDouble TRIO_ARGS6((self, number, flags, width, precision, base),
                                             trio_class_t* self, trio_long_double_t number,
                                             trio_flags_t flags, int width, int precision, int base)
{
	trio_long_double_t integerNumber;
	trio_long_double_t fractionNumber;
	trio_long_double_t workNumber;
	int integerDigits;
	int fractionDigits;
	int exponentDigits;
	int workDigits;
	int baseDigits;
	int integerThreshold;
	int fractionThreshold;
	int expectedWidth;
	int exponent = 0;
	unsigned int uExponent = 0;
	int exponentBase;
	trio_long_double_t dblBase;
	trio_long_double_t dblFractionBase;
	trio_long_double_t integerAdjust;
	trio_long_double_t fractionAdjust;
	trio_long_double_t workFractionNumber;
	trio_long_double_t workFractionAdjust;
	int fractionDigitsInspect;
	BOOLEAN_T isNegative;
	BOOLEAN_T isExponentNegative = FALSE;
	BOOLEAN_T requireTwoDigitExponent;
	BOOLEAN_T isHex;
	TRIO_CONST char* digits;
#if TRIO_FEATURE_QUOTE
	char* groupingPointer;
#endif
	int i;
	int offset;
	BOOLEAN_T hasOnlyZeroes;
	int leadingFractionZeroes = -1;
	register int trailingZeroes;
	BOOLEAN_T keepTrailingZeroes;
	BOOLEAN_T keepDecimalPoint;
	trio_long_double_t epsilon;
	BOOLEAN_T adjustNumber = FALSE;

	assert(VALID(self));
	assert(VALID(self->OutStream));
	assert(((base >= MIN_BASE) && (base <= MAX_BASE)) || (base == NO_BASE));

	/* Determine sign and look for special quantities */
	switch (trio_fpclassify_and_signbit(number, &isNegative))
	{
		case TRIO_FP_NAN:
			TrioWriteString(self, (flags & FLAGS_UPPER) ? NAN_UPPER : NAN_LOWER, flags, width,
			                precision);
			return;

		case TRIO_FP_INFINITE:
			if (isNegative)
			{
				/* Negative infinity */
				TrioWriteString(self,
				                (flags & FLAGS_UPPER) ? "-" INFINITE_UPPER : "-" INFINITE_LOWER,
				                flags, width, precision);
				return;
			}
			else
			{
				/* Positive infinity */
				TrioWriteString(self, (flags & FLAGS_UPPER) ? INFINITE_UPPER : INFINITE_LOWER,
				                flags, width, precision);
				return;
			}

		default:
			/* Finitude */
			break;
	}

	/* Normal numbers */
	if (flags & FLAGS_LONGDOUBLE)
	{
		baseDigits =
		    (base == 10) ? LDBL_DIG : (int)trio_floor(LDBL_MANT_DIG / TrioLogarithmBase(base));
		epsilon = LDBL_EPSILON;
	}
	else if (flags & FLAGS_SHORT)
	{
		baseDigits = (base == BASE_DECIMAL)
		                 ? FLT_DIG
		                 : (int)trio_floor(FLT_MANT_DIG / TrioLogarithmBase(base));
		epsilon = FLT_EPSILON;
	}
	else
	{
		baseDigits = (base == BASE_DECIMAL)
		                 ? DBL_DIG
		                 : (int)trio_floor(DBL_MANT_DIG / TrioLogarithmBase(base));
		epsilon = DBL_EPSILON;
	}

	digits = (flags & FLAGS_UPPER) ? internalDigitsUpper : internalDigitsLower;
	isHex = (base == BASE_HEX);
	if (base == NO_BASE)
		base = BASE_DECIMAL;
	dblBase = (trio_long_double_t)base;
	keepTrailingZeroes =
	    !((flags & FLAGS_ROUNDING) || ((flags & FLAGS_FLOAT_G) && !(flags & FLAGS_ALTERNATIVE)));

#if TRIO_FEATURE_ROUNDING
	if (flags & FLAGS_ROUNDING)
	{
		precision = baseDigits;
	}
#endif

	if (precision == NO_PRECISION)
	{
		if (isHex)
		{
			keepTrailingZeroes = FALSE;
			precision = FLT_MANT_DIG;
		}
		else
		{
			precision = FLT_DIG;
		}
	}

	if (isNegative)
	{
		number = -number;
	}

	if (isHex)
	{
		flags |= FLAGS_FLOAT_E;
	}

reprocess:

	if (flags & FLAGS_FLOAT_G)
	{
		if (precision == 0)
			precision = 1;

		if ((number < TRIO_SUFFIX_LONG(1.0E-4)) ||
		    (number >= TrioPower(base, (trio_long_double_t)precision)))
		{
			/* Use scientific notation */
			flags |= FLAGS_FLOAT_E;
		}
		else if (number < 1.0)
		{
			/*
			 * Use normal notation. If the integer part of the number is
			 * zero, then adjust the precision to include leading fractional
			 * zeros.
			 */
			workNumber = TrioLogarithm(number, base);
			workNumber = TRIO_FABS(workNumber);
			if (workNumber - trio_floor(workNumber) < epsilon)
				workNumber--;
			leadingFractionZeroes = (int)trio_floor(workNumber);
		}
	}

	if (flags & FLAGS_FLOAT_E)
	{
		/* Scale the number */
		workNumber = TrioLogarithm(number, base);
		if (trio_isinf(workNumber) == -1)
		{
			exponent = 0;
			/* Undo setting */
			if (flags & FLAGS_FLOAT_G)
				flags &= ~FLAGS_FLOAT_E;
		}
		else
		{
			exponent = (int)trio_floor(workNumber);
			workNumber = number;
			/*
			 * The expression A * 10^-B is equivalent to A / 10^B but the former
			 * usually gives better accuracy.
			 */
			workNumber *= TrioPower(dblBase, (trio_long_double_t)-exponent);
			if (trio_isinf(workNumber))
			{
				/*
				 * Scaling is done it two steps to avoid problems with subnormal
				 * numbers.
				 */
				workNumber /= TrioPower(dblBase, (trio_long_double_t)(exponent / 2));
				workNumber /= TrioPower(dblBase, (trio_long_double_t)(exponent - (exponent / 2)));
			}
			number = workNumber;
			isExponentNegative = (exponent < 0);
			uExponent = (isExponentNegative) ? -exponent : exponent;
			if (isHex)
				uExponent *= 4; /* log16(2) */
#if TRIO_FEATURE_QUOTE
			/* No thousand separators */
			flags &= ~FLAGS_QUOTE;
#endif
		}
	}

	integerNumber = trio_floor(number);
	fractionNumber = number - integerNumber;

	/*
	 * Truncated number.
	 *
	 * Precision is number of significant digits for FLOAT_G and number of
	 * fractional digits for others.
	 */
	integerDigits = 1;
	if (integerNumber > epsilon)
	{
		integerDigits += (int)TrioLogarithm(integerNumber, base);
	}

	fractionDigits = precision;
	if (flags & FLAGS_FLOAT_G)
	{
		if (leadingFractionZeroes > 0)
		{
			fractionDigits += leadingFractionZeroes;
		}
		if ((integerNumber > epsilon) || (number <= epsilon))
		{
			fractionDigits -= integerDigits;
		}
	}

	dblFractionBase = TrioPower(base, fractionDigits);

	if (integerNumber < 1.0)
	{
		workNumber = number * dblFractionBase + TRIO_SUFFIX_LONG(0.5);
		if (trio_floor(number * dblFractionBase) != trio_floor(workNumber))
		{
			adjustNumber = TRUE;
			/* Remove a leading fraction zero if fraction is rounded up */
			if ((int)TrioLogarithm(number * dblFractionBase, base) !=
			    (int)TrioLogarithm(workNumber, base))
			{
				--leadingFractionZeroes;
			}
		}
		workNumber /= dblFractionBase;
	}
	else
	{
		workNumber = number + TRIO_SUFFIX_LONG(0.5) / dblFractionBase;
		adjustNumber = (trio_floor(number) != trio_floor(workNumber));
	}
	if (adjustNumber)
	{
		if ((flags & FLAGS_FLOAT_G) && !(flags & FLAGS_FLOAT_E))
		{
			/* The adjustment may require a change to scientific notation */
			if ((workNumber < TRIO_SUFFIX_LONG(1.0E-4)) ||
			    (workNumber >= TrioPower(base, (trio_long_double_t)precision)))
			{
				/* Use scientific notation */
				flags |= FLAGS_FLOAT_E;
				goto reprocess;
			}
		}

		if (flags & FLAGS_FLOAT_E)
		{
			workDigits = 1 + TrioLogarithm(trio_floor(workNumber), base);
			if (integerDigits == workDigits)
			{
				/* Adjust if the same number of digits are used */
				number += TRIO_SUFFIX_LONG(0.5) / dblFractionBase;
				integerNumber = trio_floor(number);
				fractionNumber = number - integerNumber;
			}
			else
			{
				/* Adjust if number was rounded up one digit (ie. 0.99 to 1.00) */
				exponent++;
				isExponentNegative = (exponent < 0);
				uExponent = (isExponentNegative) ? -exponent : exponent;
				if (isHex)
					uExponent *= 4; /* log16(2) */
				workNumber = (number + TRIO_SUFFIX_LONG(0.5) / dblFractionBase) / dblBase;
				integerNumber = trio_floor(workNumber);
				fractionNumber = workNumber - integerNumber;
			}
		}
		else
		{
			if (workNumber > 1.0)
			{
				/* Adjust if number was rounded up one digit (ie. 99 to 100) */
				integerNumber = trio_floor(workNumber);
				fractionNumber = 0.0;
				integerDigits =
				    (integerNumber > epsilon) ? 1 + (int)TrioLogarithm(integerNumber, base) : 1;
				if (flags & FLAGS_FLOAT_G)
				{
					if (flags & FLAGS_ALTERNATIVE)
					{
						fractionDigits = precision;
						if ((integerNumber > epsilon) || (number <= epsilon))
						{
							fractionDigits -= integerDigits;
						}
					}
					else
					{
						fractionDigits = 0;
					}
				}
			}
			else
			{
				integerNumber = trio_floor(workNumber);
				fractionNumber = workNumber - integerNumber;
				if (flags & FLAGS_FLOAT_G)
				{
					if (flags & FLAGS_ALTERNATIVE)
					{
						fractionDigits = precision;
						if (leadingFractionZeroes > 0)
						{
							fractionDigits += leadingFractionZeroes;
						}
						if ((integerNumber > epsilon) || (number <= epsilon))
						{
							fractionDigits -= integerDigits;
						}
					}
				}
			}
		}
	}

	/* Estimate accuracy */
	integerAdjust = fractionAdjust = TRIO_SUFFIX_LONG(0.5);
#if TRIO_FEATURE_ROUNDING
	if (flags & FLAGS_ROUNDING)
	{
		if (integerDigits > baseDigits)
		{
			integerThreshold = baseDigits;
			fractionDigits = 0;
			dblFractionBase = 1.0;
			fractionThreshold = 0;
			precision = 0; /* Disable decimal-point */
			integerAdjust = TrioPower(base, integerDigits - integerThreshold - 1);
			fractionAdjust = 0.0;
		}
		else
		{
			integerThreshold = integerDigits;
			fractionThreshold = fractionDigits - integerThreshold;
			fractionAdjust = 1.0;
		}
	}
	else
#endif
	{
		integerThreshold = INT_MAX;
		fractionThreshold = INT_MAX;
	}

	/*
	 * Calculate expected width.
	 *  sign + integer part + thousands separators + decimal point
	 *  + fraction + exponent
	 */
	fractionAdjust /= dblFractionBase;
	hasOnlyZeroes = (trio_floor((fractionNumber + fractionAdjust) * dblFractionBase) < epsilon);
	keepDecimalPoint = ((flags & FLAGS_ALTERNATIVE) ||
	                    !((precision == 0) || (!keepTrailingZeroes && hasOnlyZeroes)));

	expectedWidth = integerDigits + fractionDigits;

	if (!keepTrailingZeroes)
	{
		trailingZeroes = 0;
		workFractionNumber = fractionNumber;
		workFractionAdjust = fractionAdjust;
		fractionDigitsInspect = fractionDigits;

		if (integerDigits > integerThreshold)
		{
			fractionDigitsInspect = 0;
		}
		else if (fractionThreshold <= fractionDigits)
		{
			fractionDigitsInspect = fractionThreshold + 1;
		}

		trailingZeroes = fractionDigits - fractionDigitsInspect;
		for (i = 0; i < fractionDigitsInspect; i++)
		{
			workFractionNumber *= dblBase;
			workFractionAdjust *= dblBase;
			workNumber = trio_floor(workFractionNumber + workFractionAdjust);
			workFractionNumber -= workNumber;
			offset = (int)trio_fmod(workNumber, dblBase);
			if (offset == 0)
			{
				trailingZeroes++;
			}
			else
			{
				trailingZeroes = 0;
			}
		}
		expectedWidth -= trailingZeroes;
	}

	if (keepDecimalPoint)
	{
		expectedWidth += internalDecimalPointLength;
	}

#if TRIO_FEATURE_QUOTE
	if (flags & FLAGS_QUOTE)
	{
		expectedWidth += TrioCalcThousandSeparatorLength(integerDigits);
	}
#endif

	if (isNegative || (flags & FLAGS_SHOWSIGN) || (flags & FLAGS_SPACE))
	{
		expectedWidth += sizeof("-") - 1;
	}

	exponentDigits = 0;
	if (flags & FLAGS_FLOAT_E)
	{
		exponentDigits =
		    (uExponent == 0)
		        ? 1
		        : (int)trio_ceil(TrioLogarithm((double)(uExponent + 1), (isHex) ? 10 : base));
	}
	requireTwoDigitExponent = ((base == BASE_DECIMAL) && (exponentDigits == 1));
	if (exponentDigits > 0)
	{
		expectedWidth += exponentDigits;
		expectedWidth += (requireTwoDigitExponent ? sizeof("E+0") - 1 : sizeof("E+") - 1);
	}

	if (isHex)
	{
		expectedWidth += sizeof("0X") - 1;
	}

	/* Output prefixing */
	if (flags & FLAGS_NILPADDING)
	{
		/* Leading zeros must be after sign */
		if (isNegative)
			self->OutStream(self, '-');
		else if (flags & FLAGS_SHOWSIGN)
			self->OutStream(self, '+');
		else if (flags & FLAGS_SPACE)
			self->OutStream(self, ' ');
		if (isHex)
		{
			self->OutStream(self, '0');
			self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x');
		}
		if (!(flags & FLAGS_LEFTADJUST))
		{
			for (i = expectedWidth; i < width; i++)
			{
				self->OutStream(self, '0');
			}
		}
	}
	else
	{
		/* Leading spaces must be before sign */
		if (!(flags & FLAGS_LEFTADJUST))
		{
			for (i = expectedWidth; i < width; i++)
			{
				self->OutStream(self, CHAR_ADJUST);
			}
		}
		if (isNegative)
			self->OutStream(self, '-');
		else if (flags & FLAGS_SHOWSIGN)
			self->OutStream(self, '+');
		else if (flags & FLAGS_SPACE)
			self->OutStream(self, ' ');
		if (isHex)
		{
			self->OutStream(self, '0');
			self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x');
		}
	}

	/* Output the integer part and thousand separators */
	for (i = 0; i < integerDigits; i++)
	{
		workNumber =
		    trio_floor(((integerNumber + integerAdjust) / TrioPower(base, integerDigits - i - 1)));
		if (i > integerThreshold)
		{
			/* Beyond accuracy */
			self->OutStream(self, digits[0]);
		}
		else
		{
			self->OutStream(self, digits[(int)trio_fmod(workNumber, dblBase)]);
		}

#if TRIO_FEATURE_QUOTE
		if (((flags & (FLAGS_FLOAT_E | FLAGS_QUOTE)) == FLAGS_QUOTE) &&
		    TrioFollowedBySeparator(integerDigits - i))
		{
			for (groupingPointer = internalThousandSeparator; *groupingPointer != NIL;
			     groupingPointer++)
			{
				self->OutStream(self, *groupingPointer);
			}
		}
#endif
	}

	/* Insert decimal point and build the fraction part */
	trailingZeroes = 0;

	if (keepDecimalPoint)
	{
		if (internalDecimalPoint)
		{
			self->OutStream(self, internalDecimalPoint);
		}
		else
		{
			for (i = 0; i < internalDecimalPointLength; i++)
			{
				self->OutStream(self, internalDecimalPointString[i]);
			}
		}
	}

	for (i = 0; i < fractionDigits; i++)
	{
		if ((integerDigits > integerThreshold) || (i > fractionThreshold))
		{
			/* Beyond accuracy */
			trailingZeroes++;
		}
		else
		{
			fractionNumber *= dblBase;
			fractionAdjust *= dblBase;
			workNumber = trio_floor(fractionNumber + fractionAdjust);
			if (workNumber > fractionNumber)
			{
				/* fractionNumber should never become negative */
				fractionNumber = 0.0;
				fractionAdjust = 0.0;
			}
			else
			{
				fractionNumber -= workNumber;
			}
			offset = (int)trio_fmod(workNumber, dblBase);
			if (offset == 0)
			{
				trailingZeroes++;
			}
			else
			{
				while (trailingZeroes > 0)
				{
					/* Not trailing zeroes after all */
					self->OutStream(self, digits[0]);
					trailingZeroes--;
				}
				self->OutStream(self, digits[offset]);
			}
		}
	}

	if (keepTrailingZeroes)
	{
		while (trailingZeroes > 0)
		{
			self->OutStream(self, digits[0]);
			trailingZeroes--;
		}
	}

	/* Output exponent */
	if (exponentDigits > 0)
	{
		self->OutStream(self, isHex ? ((flags & FLAGS_UPPER) ? 'P' : 'p')
		                            : ((flags & FLAGS_UPPER) ? 'E' : 'e'));
		self->OutStream(self, (isExponentNegative) ? '-' : '+');

		/* The exponent must contain at least two digits */
		if (requireTwoDigitExponent)
			self->OutStream(self, '0');

		if (isHex)
			base = 10;
		exponentBase = (int)TrioPower(base, exponentDigits - 1);
		for (i = 0; i < exponentDigits; i++)
		{
			self->OutStream(self, digits[(uExponent / exponentBase) % base]);
			exponentBase /= base;
		}
	}
	/* Output trailing spaces */
	if (flags & FLAGS_LEFTADJUST)
	{
		for (i = expectedWidth; i < width; i++)
		{
			self->OutStream(self, CHAR_ADJUST);
		}
	}
}
#endif /* TRIO_FEATURE_FLOAT */

/*************************************************************************
 * TrioFormatProcess
 *
 * Description:
 *  This is the main engine for formatting output
 */
TRIO_PRIVATE int TrioFormatProcess TRIO_ARGS3((data, format, parameters), trio_class_t* data,
                                              TRIO_CONST char* format, trio_parameter_t* parameters)
{
	int i;
#if TRIO_FEATURE_ERRNO
	TRIO_CONST char* string;
#endif
	trio_pointer_t pointer;
	trio_flags_t flags;
	int width;
	int precision;
	int base;
	int offset;

	offset = 0;
	i = 0;

	for (;;)
	{
		/* Skip the parameter entries */
		while (parameters[i].type == FORMAT_PARAMETER)
			i++;

		/* Copy non conversion-specifier part of format string */
		while (offset < parameters[i].beginOffset)
		{
			if (CHAR_IDENTIFIER == format[offset] && CHAR_IDENTIFIER == format[offset + 1])
			{
				data->OutStream(data, CHAR_IDENTIFIER);
				offset += 2;
			}
			else
			{
				data->OutStream(data, format[offset++]);
			}
		}

		/* Abort if we reached end of format string */
		if (parameters[i].type == FORMAT_SENTINEL)
			break;

		/* Ouput parameter */
		flags = parameters[i].flags;

		/* Find width */
		width = parameters[i].width;
		if (flags & FLAGS_WIDTH_PARAMETER)
		{
			/* Get width from parameter list */
			width = (int)parameters[width].data.number.as_signed;
			if (width < 0)
			{
				/*
				 * A negative width is the same as the - flag and
				 * a positive width.
				 */
				flags |= FLAGS_LEFTADJUST;
				flags &= ~FLAGS_NILPADDING;
				width = -width;
			}
		}

		/* Find precision */
		if (flags & FLAGS_PRECISION)
		{
			precision = parameters[i].precision;
			if (flags & FLAGS_PRECISION_PARAMETER)
			{
				/* Get precision from parameter list */
				precision = (int)parameters[precision].data.number.as_signed;
				if (precision < 0)
				{
					/*
					 * A negative precision is the same as no
					 * precision
					 */
					precision = NO_PRECISION;
				}
			}
		}
		else
		{
			precision = NO_PRECISION;
		}

		/* Find base */
		if (NO_BASE != parameters[i].baseSpecifier)
		{
			/* Base from specifier has priority */
			base = parameters[i].baseSpecifier;
		}
		else if (flags & FLAGS_BASE_PARAMETER)
		{
			/* Get base from parameter list */
			base = parameters[i].base;
			base = (int)parameters[base].data.number.as_signed;
		}
		else
		{
			/* Use base from format string */
			base = parameters[i].base;
		}

		switch (parameters[i].type)
		{
			case FORMAT_CHAR:
#if TRIO_FEATURE_QUOTE
				if (flags & FLAGS_QUOTE)
					data->OutStream(data, CHAR_QUOTE);
#endif
				if (!(flags & FLAGS_LEFTADJUST))
				{
					while (--width > 0)
						data->OutStream(data, CHAR_ADJUST);
				}
#if TRIO_FEATURE_WIDECHAR
				if (flags & FLAGS_WIDECHAR)
				{
					TrioWriteWideStringCharacter(
					    data, (trio_wchar_t)parameters[i].data.number.as_signed, flags, NO_WIDTH);
				}
				else
#endif
				{
					TrioWriteStringCharacter(data, (int)parameters[i].data.number.as_signed, flags);
				}

				if (flags & FLAGS_LEFTADJUST)
				{
					while (--width > 0)
						data->OutStream(data, CHAR_ADJUST);
				}
#if TRIO_FEATURE_QUOTE
				if (flags & FLAGS_QUOTE)
					data->OutStream(data, CHAR_QUOTE);
#endif

				break; /* FORMAT_CHAR */

			case FORMAT_INT:
				TrioWriteNumber(data, parameters[i].data.number.as_unsigned, flags, width,
				                precision, base);

				break; /* FORMAT_INT */

#if TRIO_FEATURE_FLOAT
			case FORMAT_DOUBLE:
				TrioWriteDouble(data, parameters[i].data.longdoubleNumber, flags, width, precision,
				                base);
				break; /* FORMAT_DOUBLE */
#endif

			case FORMAT_STRING:
#if TRIO_FEATURE_WIDECHAR
				if (flags & FLAGS_WIDECHAR)
				{
					TrioWriteWideString(data, parameters[i].data.wstring, flags, width, precision);
				}
				else
#endif
				{
					TrioWriteString(data, parameters[i].data.string, flags, width, precision);
				}
				break; /* FORMAT_STRING */

			case FORMAT_POINTER:
			{
				trio_reference_t reference;

				reference.data = data;
				reference.parameter = &parameters[i];
				trio_print_pointer(&reference, parameters[i].data.pointer);
			}
			break; /* FORMAT_POINTER */

			case FORMAT_COUNT:
				pointer = parameters[i].data.pointer;
				if (NULL != pointer)
				{
					/*
					 * C99 paragraph 7.19.6.1.8 says "the number of
					 * characters written to the output stream so far by
					 * this call", which is data->actually.committed
					 */
#if TRIO_FEATURE_SIZE_T || TRIO_FEATURE_SIZE_T_UPPER
					if (flags & FLAGS_SIZE_T)
						*(size_t*)pointer = (size_t)data->actually.committed;
					else
#endif
#if TRIO_FEATURE_PTRDIFF_T
					    if (flags & FLAGS_PTRDIFF_T)
						*(ptrdiff_t*)pointer = (ptrdiff_t)data->actually.committed;
					else
#endif
#if TRIO_FEATURE_INTMAX_T
					    if (flags & FLAGS_INTMAX_T)
						*(trio_intmax_t*)pointer = (trio_intmax_t)data->actually.committed;
					else
#endif
					    if (flags & FLAGS_QUAD)
					{
						*(trio_ulonglong_t*)pointer = (trio_ulonglong_t)data->actually.committed;
					}
					else if (flags & FLAGS_LONG)
					{
						*(long int*)pointer = (long int)data->actually.committed;
					}
					else if (flags & FLAGS_SHORT)
					{
						*(short int*)pointer = (short int)data->actually.committed;
					}
					else
					{
						*(int*)pointer = (int)data->actually.committed;
					}
				}
				break; /* FORMAT_COUNT */

			case FORMAT_PARAMETER:
				break; /* FORMAT_PARAMETER */

#if TRIO_FEATURE_ERRNO
			case FORMAT_ERRNO:
				string = trio_error(parameters[i].data.errorNumber);
				if (string)
				{
					TrioWriteString(data, string, flags, width, precision);
				}
				else
				{
					data->OutStream(data, '#');
					TrioWriteNumber(data, (trio_uintmax_t)parameters[i].data.errorNumber, flags,
					                width, precision, BASE_DECIMAL);
				}
				break; /* FORMAT_ERRNO */
#endif                 /* TRIO_FEATURE_ERRNO */

#if TRIO_FEATURE_USER_DEFINED
			case FORMAT_USER_DEFINED:
			{
				trio_reference_t reference;
				trio_userdef_t* def = NULL;

				if (parameters[i].flags & FLAGS_USER_DEFINED_PARAMETER)
				{
					/* Use handle */
					if ((i > 0) || (parameters[i - 1].type == FORMAT_PARAMETER))
						def = (trio_userdef_t*)parameters[i - 1].data.pointer;
				}
				else
				{
					/* Look up namespace */
					def = TrioFindNamespace(parameters[i].user_defined.namespace, NULL);
				}
				if (def)
				{
					reference.data = data;
					reference.parameter = &parameters[i];
					def->callback(&reference);
				}
			}
			break;
#endif /* TRIO_FEATURE_USER_DEFINED */

			default:
				break;
		} /* switch parameter type */

		/* Prepare for next */
		offset = parameters[i].endOffset;
		i++;
	}

	return data->processed;
}

/*************************************************************************
 * TrioFormatRef
 */
#if TRIO_EXTENSION
TRIO_PRIVATE int TrioFormatRef TRIO_ARGS5((reference, format, arglist, argfunc, argarray),
                                          trio_reference_t* reference, TRIO_CONST char* format,
                                          va_list arglist, trio_argfunc_t argfunc,
                                          trio_pointer_t* argarray)
{
	int status;
	trio_parameter_t parameters[MAX_PARAMETERS];

	status = TrioParse(TYPE_PRINT, format, parameters, arglist, argfunc, argarray);
	if (status < 0)
		return status;

	status = TrioFormatProcess(reference->data, format, parameters);
	if (reference->data->error != 0)
	{
		status = reference->data->error;
	}
	return status;
}
#endif /* TRIO_EXTENSION */

/*************************************************************************
 * TrioFormat
 */
TRIO_PRIVATE int TrioFormat TRIO_ARGS7((destination, destinationSize, OutStream, format, arglist,
                                        argfunc, argarray),
                                       trio_pointer_t destination, size_t destinationSize,
                                       void(*OutStream) TRIO_PROTO((trio_class_t*, int)),
                                       TRIO_CONST char* format, va_list arglist,
                                       trio_argfunc_t argfunc, trio_pointer_t* argarray)
{
	int status;
	trio_class_t data;
	trio_parameter_t parameters[MAX_PARAMETERS];

	assert(VALID(OutStream));
	assert(VALID(format));

	memset(&data, 0, sizeof(data));
	data.OutStream = OutStream;
	data.location = destination;
	data.max = destinationSize;
	data.error = 0;

#if defined(USE_LOCALE)
	if (NULL == internalLocaleValues)
	{
		TrioSetLocale();
	}
#endif

	status = TrioParse(TYPE_PRINT, format, parameters, arglist, argfunc, argarray);
	if (status < 0)
		return status;

	status = TrioFormatProcess(&data, format, parameters);
	if (data.error != 0)
	{
		status = data.error;
	}
	return status;
}

/*************************************************************************
 * TrioOutStreamFile
 */
#if TRIO_FEATURE_FILE || TRIO_FEATURE_STDIO
TRIO_PRIVATE void TrioOutStreamFile TRIO_ARGS2((self, output), trio_class_t* self, int output)
{
	FILE* file;

	assert(VALID(self));
	assert(VALID(self->location));

	file = (FILE*)self->location;
	self->processed++;
	if (fputc(output, file) == EOF)
	{
		self->error = TRIO_ERROR_RETURN(TRIO_EOF, 0);
	}
	else
	{
		self->actually.committed++;
	}
}
#endif /* TRIO_FEATURE_FILE || TRIO_FEATURE_STDIO */

/*************************************************************************
 * TrioOutStreamFileDescriptor
 */
#if TRIO_FEATURE_FD
TRIO_PRIVATE void TrioOutStreamFileDescriptor TRIO_ARGS2((self, output), trio_class_t* self,
                                                         int output)
{
	int fd;
	char ch;

	assert(VALID(self));

	fd = *((int*)self->location);
	ch = (char)output;
	self->processed++;
	if (write(fd, &ch, sizeof(char)) == -1)
	{
		self->error = TRIO_ERROR_RETURN(TRIO_ERRNO, 0);
	}
	else
	{
		self->actually.committed++;
	}
}
#endif /* TRIO_FEATURE_FD */

/*************************************************************************
 * TrioOutStreamCustom
 */
#if TRIO_FEATURE_CLOSURE
TRIO_PRIVATE void TrioOutStreamCustom TRIO_ARGS2((self, output), trio_class_t* self, int output)
{
	int status;
	trio_custom_t* data;

	assert(VALID(self));
	assert(VALID(self->location));

	data = (trio_custom_t*)self->location;
	if (data->stream.out)
	{
		status = (data->stream.out)(data->closure, output);
		if (status >= 0)
		{
			self->actually.committed++;
		}
		else
		{
			if (self->error == 0)
			{
				self->error = TRIO_ERROR_RETURN(TRIO_ECUSTOM, -status);
			}
		}
	}
	self->processed++;
}
#endif /* TRIO_FEATURE_CLOSURE */

/*************************************************************************
 * TrioOutStreamString
 */
TRIO_PRIVATE void TrioOutStreamString TRIO_ARGS2((self, output), trio_class_t* self, int output)
{
	char** buffer;

	assert(VALID(self));
	assert(VALID(self->location));

	buffer = (char**)self->location;
	**buffer = (char)output;
	(*buffer)++;
	self->processed++;
	self->actually.committed++;
}

/*************************************************************************
 * TrioOutStreamStringMax
 */
TRIO_PRIVATE void TrioOutStreamStringMax TRIO_ARGS2((self, output), trio_class_t* self, int output)
{
	char** buffer;

	assert(VALID(self));
	assert(VALID(self->location));

	buffer = (char**)self->location;

	if (self->processed < self->max)
	{
		**buffer = (char)output;
		(*buffer)++;
		self->actually.committed++;
	}
	self->processed++;
}

/*************************************************************************
 * TrioOutStreamStringDynamic
 */
#if TRIO_FEATURE_DYNAMICSTRING
TRIO_PRIVATE void TrioOutStreamStringDynamic TRIO_ARGS2((self, output), trio_class_t* self,
                                                        int output)
{
	assert(VALID(self));
	assert(VALID(self->location));

	if (self->error == 0)
	{
		trio_xstring_append_char((trio_string_t*)self->location, (char)output);
		self->actually.committed++;
	}
	/* The processed variable must always be increased */
	self->processed++;
}
#endif /* TRIO_FEATURE_DYNAMICSTRING */

/*************************************************************************
 * TrioArrayGetter
 */
static trio_pointer_t TrioArrayGetter(trio_pointer_t context, int index, int type)
{
	/* Utility function for the printfv family */
	trio_pointer_t* argarray = (trio_pointer_t*)context;
	return argarray[index];
}

/*************************************************************************
 *
 * Formatted printing functions
 *
 ************************************************************************/

/** @addtogroup Printf
    @{
*/

/*************************************************************************
 * printf
 */

/**
   Print to standard output stream.

   @param format Formatting string.
   @param ... Arguments.
   @return Number of printed characters.
 */
#if TRIO_FEATURE_STDIO
TRIO_PUBLIC int trio_printf TRIO_VARGS2((format, va_alist), TRIO_CONST char* format, TRIO_VA_DECL)
{
	int status;
	va_list args;

	assert(VALID(format));

	TRIO_VA_START(args, format);
	status = TrioFormat(stdout, 0, TrioOutStreamFile, format, args, NULL, NULL);
	TRIO_VA_END(args);
	return status;
}
#endif /* TRIO_FEATURE_STDIO */

/**
   Print to standard output stream.

   @param format Formatting string.
   @param args Arguments.
   @return Number of printed characters.
 */
#if TRIO_FEATURE_STDIO
TRIO_PUBLIC int trio_vprintf TRIO_ARGS2((format, args), TRIO_CONST char* format, va_list args)
{
	assert(VALID(format));

	return TrioFormat(stdout, 0, TrioOutStreamFile, format, args, NULL, NULL);
}
#endif /* TRIO_FEATURE_STDIO */

/**
   Print to standard output stream.

   @param format Formatting string.
   @param args Arguments.
   @return Number of printed characters.
 */
#if TRIO_FEATURE_STDIO
TRIO_PUBLIC int trio_printfv TRIO_ARGS2((format, args), TRIO_CONST char* format,
                                        trio_pointer_t* args)
{
	static va_list unused;

	assert(VALID(format));

	return TrioFormat(stdout, 0, TrioOutStreamFile, format, unused, TrioArrayGetter, args);
}
#endif /* TRIO_FEATURE_STDIO */

/*************************************************************************
 * fprintf
 */

/**
   Print to file.

   @param file File pointer.
   @param format Formatting string.
   @param ... Arguments.
   @return Number of printed characters.
 */
#if TRIO_FEATURE_FILE
TRIO_PUBLIC int trio_fprintf TRIO_VARGS3((file, format, va_alist), FILE* file,
                                         TRIO_CONST char* format, TRIO_VA_DECL)
{
	int status;
	va_list args;

	assert(VALID(file));
	assert(VALID(format));

	TRIO_VA_START(args, format);
	status = TrioFormat(file, 0, TrioOutStreamFile, format, args, NULL, NULL);
	TRIO_VA_END(args);
	return status;
}
#endif /* TRIO_FEATURE_FILE */

/**
   Print to file.

   @param file File pointer.
   @param format Formatting string.
   @param args Arguments.
   @return Number of printed characters.
 */
#if TRIO_FEATURE_FILE
TRIO_PUBLIC int trio_vfprintf TRIO_ARGS3((file, format, args), FILE* file, TRIO_CONST char* format,
                                         va_list args)
{
	assert(VALID(file));
	assert(VALID(format));

	return TrioFormat(file, 0, TrioOutStreamFile, format, args, NULL, NULL);
}
#endif /* TRIO_FEATURE_FILE */

/**
   Print to file.

   @param file File pointer.
   @param format Formatting string.
   @param args Arguments.
   @return Number of printed characters.
 */
#if TRIO_FEATURE_FILE
TRIO_PUBLIC int trio_fprintfv TRIO_ARGS3((file, format, args), FILE* file, TRIO_CONST char* format,
                                         trio_pointer_t* args)
{
	static va_list unused;

	assert(VALID(file));
	assert(VALID(format));

	return TrioFormat(file, 0, TrioOutStreamFile, format, unused, TrioArrayGetter, args);
}
#endif /* TRIO_FEATURE_FILE */

/*************************************************************************
 * dprintf
 */

/**
   Print to file descriptor.

   @param fd File descriptor.
   @param format Formatting string.
   @param ... Arguments.
   @return Number of printed characters.
 */
#if TRIO_FEATURE_FD
TRIO_PUBLIC int trio_dprintf TRIO_VARGS3((fd, format, va_alist), int fd, TRIO_CONST char* format,
                                         TRIO_VA_DECL)
{
	int status;
	va_list args;

	assert(VALID(format));

	TRIO_VA_START(args, format);
	status = TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, args, NULL, NULL);
	TRIO_VA_END(args);
	return status;
}
#endif /* TRIO_FEATURE_FD */

/**
   Print to file descriptor.

   @param fd File descriptor.
   @param format Formatting string.
   @param args Arguments.
   @return Number of printed characters.
 */
#if TRIO_FEATURE_FD
TRIO_PUBLIC int trio_vdprintf TRIO_ARGS3((fd, format, args), int fd, TRIO_CONST char* format,
                                         va_list args)
{
	assert(VALID(format));

	return TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, args, NULL, NULL);
}
#endif /* TRIO_FEATURE_FD */

/**
   Print to file descriptor.

   @param fd File descriptor.
   @param format Formatting string.
   @param args Arguments.
   @return Number of printed characters.
 */
#if TRIO_FEATURE_FD
TRIO_PUBLIC int trio_dprintfv TRIO_ARGS3((fd, format, args), int fd, TRIO_CONST char* format,
                                         trio_pointer_t* args)
{
	static va_list unused;

	assert(VALID(format));

	return TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, unused, TrioArrayGetter, args);
}
#endif /* TRIO_FEATURE_FD */

/*************************************************************************
 * cprintf
 */
#if TRIO_FEATURE_CLOSURE
TRIO_PUBLIC int trio_cprintf TRIO_VARGS4((stream, closure, format, va_alist),
                                         trio_outstream_t stream, trio_pointer_t closure,
                                         TRIO_CONST char* format, TRIO_VA_DECL)
{
	int status;
	va_list args;
	trio_custom_t data;

	assert(VALID(stream));
	assert(VALID(format));

	TRIO_VA_START(args, format);
	data.stream.out = stream;
	data.closure = closure;
	status = TrioFormat(&data, 0, TrioOutStreamCustom, format, args, NULL, NULL);
	TRIO_VA_END(args);
	return status;
}
#endif /* TRIO_FEATURE_CLOSURE */

#if TRIO_FEATURE_CLOSURE
TRIO_PUBLIC int trio_vcprintf TRIO_ARGS4((stream, closure, format, args), trio_outstream_t stream,
                                         trio_pointer_t closure, TRIO_CONST char* format,
                                         va_list args)
{
	trio_custom_t data;

	assert(VALID(stream));
	assert(VALID(format));

	data.stream.out = stream;
	data.closure = closure;
	return TrioFormat(&data, 0, TrioOutStreamCustom, format, args, NULL, NULL);
}
#endif /* TRIO_FEATURE_CLOSURE */

#if TRIO_FEATURE_CLOSURE
TRIO_PUBLIC int trio_cprintfv TRIO_ARGS4((stream, closure, format, args), trio_outstream_t stream,
                                         trio_pointer_t closure, TRIO_CONST char* format,
                                         trio_pointer_t* args)
{
	static va_list unused;
	trio_custom_t data;

	assert(VALID(stream));
	assert(VALID(format));

	data.stream.out = stream;
	data.closure = closure;
	return TrioFormat(&data, 0, TrioOutStreamCustom, format, unused, TrioArrayGetter, args);
}
#endif /* TRIO_FEATURE_CLOSURE */

#if TRIO_FEATURE_CLOSURE && TRIO_FEATURE_ARGFUNC
TRIO_PUBLIC int trio_cprintff TRIO_ARGS5((stream, closure, format, argfunc, context),
                                         trio_outstream_t stream, trio_pointer_t closure,
                                         TRIO_CONST char* format, trio_argfunc_t argfunc,
                                         trio_pointer_t context)
{
	static va_list unused;
	trio_custom_t data;

	assert(VALID(stream));
	assert(VALID(format));
	assert(VALID(argfunc));

	data.stream.out = stream;
	data.closure = closure;
	return TrioFormat(&data, 0, TrioOutStreamCustom, format, unused, argfunc,
	                  (trio_pointer_t*)context);
}
#endif /* TRIO_FEATURE_CLOSURE && TRIO_FEATURE_ARGFUNC */

/*************************************************************************
 * sprintf
 */

/**
   Print to string.

   @param buffer Output string.
   @param format Formatting string.
   @param ... Arguments.
   @return Number of printed characters.
 */
TRIO_PUBLIC int trio_sprintf TRIO_VARGS3((buffer, format, va_alist), char* buffer,
                                         TRIO_CONST char* format, TRIO_VA_DECL)
{
	int status;
	va_list args;

	assert(VALID(buffer));
	assert(VALID(format));

	TRIO_VA_START(args, format);
	status = TrioFormat(&buffer, 0, TrioOutStreamString, format, args, NULL, NULL);
	*buffer = NIL; /* Terminate with NIL character */
	TRIO_VA_END(args);
	return status;
}

/**
   Print to string.

   @param buffer Output string.
   @param format Formatting string.
   @param args Arguments.
   @return Number of printed characters.
 */
TRIO_PUBLIC int trio_vsprintf TRIO_ARGS3((buffer, format, args), char* buffer,
                                         TRIO_CONST char* format, va_list args)
{
	int status;

	assert(VALID(buffer));
	assert(VALID(format));

	status = TrioFormat(&buffer, 0, TrioOutStreamString, format, args, NULL, NULL);
	*buffer = NIL;
	return status;
}

/**
   Print to string.

   @param buffer Output string.
   @param format Formatting string.
   @param args Arguments.
   @return Number of printed characters.
 */
TRIO_PUBLIC int trio_sprintfv TRIO_ARGS3((buffer, format, args), char* buffer,
                                         TRIO_CONST char* format, trio_pointer_t* args)
{
	static va_list unused;
	int status;

	assert(VALID(buffer));
	assert(VALID(format));

	status = TrioFormat(&buffer, 0, TrioOutStreamString, format, unused, TrioArrayGetter, args);
	*buffer = NIL;
	return status;
}

/*************************************************************************
 * snprintf
 */

/**
   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 TRIO_VARGS4((buffer, max, format, va_alist), char* buffer, size_t max,
                                          TRIO_CONST char* format, TRIO_VA_DECL)
{
	int status;
	va_list args;

	assert(VALID(buffer) || (max == 0));
	assert(VALID(format));

	TRIO_VA_START(args, format);
	status = TrioFormat(&buffer, max > 0 ? max - 1 : 0, TrioOutStreamStringMax, format, args, NULL,
	                    NULL);
	if (max > 0)
		*buffer = NIL;
	TRIO_VA_END(args);
	return status;
}

/**
   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 TRIO_ARGS4((buffer, max, format, args), char* buffer, size_t max,
                                          TRIO_CONST char* format, va_list args)
{
	int status;

	assert(VALID(buffer) || (max == 0));
	assert(VALID(format));

	status = TrioFormat(&buffer, max > 0 ? max - 1 : 0, TrioOutStreamStringMax, format, args, NULL,
	                    NULL);
	if (max > 0)
		*buffer = NIL;
	return status;
}

/**
   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 TRIO_ARGS4((buffer, max, format, args), char* buffer, size_t max,
                                          TRIO_CONST char* format, trio_pointer_t* args)
{
	static va_list unused;
	int status;

	assert(VALID(buffer) || (max == 0));
	assert(VALID(format));

	status = TrioFormat(&buffer, max > 0 ? max - 1 : 0, TrioOutStreamStringMax, format, unused,
	                    TrioArrayGetter, args);
	if (max > 0)
		*buffer = NIL;
	return status;
}

/*************************************************************************
 * snprintfcat
 * Appends the new string to the buffer string overwriting the '\0'
 * character at the end of buffer.
 */
#if TRIO_EXTENSION
TRIO_PUBLIC int trio_snprintfcat TRIO_VARGS4((buffer, max, format, va_alist), char* buffer,
                                             size_t max, TRIO_CONST char* format, TRIO_VA_DECL)
{
	int status;
	va_list args;
	size_t buf_len;

	TRIO_VA_START(args, format);

	assert(VALID(buffer));
	assert(VALID(format));

	buf_len = trio_length(buffer);
	buffer = &buffer[buf_len];

	status =
	    TrioFormat(&buffer, max - 1 - buf_len, TrioOutStreamStringMax, format, args, NULL, NULL);
	TRIO_VA_END(args);
	*buffer = NIL;
	return status;
}
#endif

#if TRIO_EXTENSION
TRIO_PUBLIC int trio_vsnprintfcat TRIO_ARGS4((buffer, max, format, args), char* buffer, size_t max,
                                             TRIO_CONST char* format, va_list args)
{
	int status;
	size_t buf_len;

	assert(VALID(buffer));
	assert(VALID(format));

	buf_len = trio_length(buffer);
	buffer = &buffer[buf_len];
	status =
	    TrioFormat(&buffer, max - 1 - buf_len, TrioOutStreamStringMax, format, args, NULL, NULL);
	*buffer = NIL;
	return status;
}
#endif

/*************************************************************************
 * trio_aprintf
 */

#if TRIO_DEPRECATED && TRIO_FEATURE_DYNAMICSTRING
TRIO_PUBLIC char* trio_aprintf TRIO_VARGS2((format, va_alist), TRIO_CONST char* format,
                                           TRIO_VA_DECL)
{
	va_list args;
	trio_string_t* info;
	char* result = NULL;

	assert(VALID(format));

	info = trio_xstring_duplicate("");
	if (info)
	{
		TRIO_VA_START(args, format);
		(void)TrioFormat(info, 0, TrioOutStreamStringDynamic, format, args, NULL, NULL);
		TRIO_VA_END(args);

		trio_string_terminate(info);
		result = trio_string_extract(info);
		trio_string_destroy(info);
	}
	return result;
}
#endif /* TRIO_DEPRECATED && TRIO_FEATURE_DYNAMICSTRING */

#if TRIO_DEPRECATED && TRIO_FEATURE_DYNAMICSTRING
TRIO_PUBLIC char* trio_vaprintf TRIO_ARGS2((format, args), TRIO_CONST char* format, va_list args)
{
	trio_string_t* info;
	char* result = NULL;

	assert(VALID(format));

	info = trio_xstring_duplicate("");
	if (info)
	{
		(void)TrioFormat(info, 0, TrioOutStreamStringDynamic, format, args, NULL, NULL);
		trio_string_terminate(info);
		result = trio_string_extract(info);
		trio_string_destroy(info);
	}
	return result;
}
#endif /* TRIO_DEPRECATED && TRIO_FEATURE_DYNAMICSTRING */

/**
   Allocate and print to string.
   The memory allocated and returned by @p result must be freed by the
   calling application.

   @param result Output string.
   @param format Formatting string.
   @param ... Arguments.
   @return Number of printed characters.
 */
#if TRIO_FEATURE_DYNAMICSTRING
TRIO_PUBLIC int trio_asprintf TRIO_VARGS3((result, format, va_alist), char** result,
                                          TRIO_CONST char* format, TRIO_VA_DECL)
{
	va_list args;
	int status;
	trio_string_t* info;

	assert(VALID(format));

	*result = NULL;

	info = trio_xstring_duplicate("");
	if (info == NULL)
	{
		status = TRIO_ERROR_RETURN(TRIO_ENOMEM, 0);
	}
	else
	{
		TRIO_VA_START(args, format);
		status = TrioFormat(info, 0, TrioOutStreamStringDynamic, format, args, NULL, NULL);
		TRIO_VA_END(args);
		if (status >= 0)
		{
			trio_string_terminate(info);
			*result = trio_string_extract(info);
		}
		trio_string_destroy(info);
	}
	return status;
}
#endif /* TRIO_FEATURE_DYNAMICSTRING */

/**
   Allocate and print to string.
   The memory allocated and returned by @p result must be freed by the
   calling application.

   @param result Output string.
   @param format Formatting string.
   @param args Arguments.
   @return Number of printed characters.
 */
#if TRIO_FEATURE_DYNAMICSTRING
TRIO_PUBLIC int trio_vasprintf TRIO_ARGS3((result, format, args), char** result,
                                          TRIO_CONST char* format, va_list args)
{
	int status;
	trio_string_t* info;

	assert(VALID(format));

	*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, NULL);
		if (status >= 0)
		{
			trio_string_terminate(info);
			*result = trio_string_extract(info);
		}
		trio_string_destroy(info);
	}
	return status;
}
#endif /* TRIO_FEATURE_DYNAMICSTRING */

/**
   Allocate and print to string.
   The memory allocated and returned by @p result must be freed by the
   calling application.

   @param result Output string.
   @param format Formatting string.
   @param args Arguments.
   @return Number of printed characters.
 */
#if TRIO_FEATURE_DYNAMICSTRING
TRIO_PUBLIC int trio_asprintfv TRIO_ARGS3((result, format, args), char** result,
                                          TRIO_CONST char* format, trio_pointer_t* args)
{
	static va_list unused;
	int status;
	trio_string_t* info;

	assert(VALID(format));

	*result = NULL;

	info = trio_xstring_duplicate("");
	if (info == NULL)
	{
		status = TRIO_ERROR_RETURN(TRIO_ENOMEM, 0);
	}
	else
	{
		status =
		    TrioFormat(info, 0, TrioOutStreamStringDynamic, format, unused, TrioArrayGetter, args);
		if (status >= 0)
		{
			trio_string_terminate(info);
			*result = trio_string_extract(info);
		}
		trio_string_destroy(info);
	}
	return status;
}
#endif /* TRIO_FEATURE_DYNAMICSTRING */

#if defined(TRIO_DOCUMENTATION)
#include "doc/doc_printf.h"
#endif

/** @} End of Printf documentation module */

/*************************************************************************
 *
 * CALLBACK
 *
 ************************************************************************/

#if defined(TRIO_DOCUMENTATION)
#include "doc/doc_register.h"
#endif
/**
   @addtogroup UserDefined
   @{
*/

#if TRIO_FEATURE_USER_DEFINED

/*************************************************************************
 * trio_register
 */

/**
   Register new user-defined specifier.

   @param callback
   @param name
   @return Handle.
 */
TRIO_PUBLIC trio_pointer_t trio_register TRIO_ARGS2((callback, name), trio_callback_t callback,
                                                    TRIO_CONST char* name)
{
	trio_userdef_t* def;
	trio_userdef_t* prev = NULL;

	if (callback == NULL)
		return NULL;

	if (name)
	{
		/* Handle built-in namespaces */
		if (name[0] == ':')
		{
			if (trio_equal(name, ":enter"))
			{
				internalEnterCriticalRegion = callback;
			}
			else if (trio_equal(name, ":leave"))
			{
				internalLeaveCriticalRegion = callback;
			}
			return NULL;
		}

		/* Bail out if namespace is too long */
		if (trio_length(name) >= MAX_USER_NAME)
			return NULL;

		/* Bail out if namespace already is registered */
		def = TrioFindNamespace(name, &prev);
		if (def)
			return NULL;
	}

	def = (trio_userdef_t*)TRIO_MALLOC(sizeof(trio_userdef_t));
	if (def)
	{
		if (internalEnterCriticalRegion)
			(void)internalEnterCriticalRegion(NULL);

		if (name)
		{
			/* Link into internal list */
			if (prev == NULL)
				internalUserDef = def;
			else
				prev->next = def;
		}
		/* Initialize */
		def->callback = callback;
		def->name = (name == NULL) ? NULL : trio_duplicate(name);
		def->next = NULL;

		if (internalLeaveCriticalRegion)
			(void)internalLeaveCriticalRegion(NULL);
	}
	return (trio_pointer_t)def;
}

/**
   Unregister an existing user-defined specifier.

   @param handle
 */
void trio_unregister TRIO_ARGS1((handle), trio_pointer_t handle)
{
	trio_userdef_t* self = (trio_userdef_t*)handle;
	trio_userdef_t* def;
	trio_userdef_t* prev = NULL;

	assert(VALID(self));

	if (self->name)
	{
		def = TrioFindNamespace(self->name, &prev);
		if (def)
		{
			if (internalEnterCriticalRegion)
				(void)internalEnterCriticalRegion(NULL);

			if (prev == NULL)
				internalUserDef = internalUserDef->next;
			else
				prev->next = def->next;

			if (internalLeaveCriticalRegion)
				(void)internalLeaveCriticalRegion(NULL);
		}
		trio_destroy(self->name);
	}
	TRIO_FREE(self);
}

/*************************************************************************
 * trio_get_format [public]
 */
TRIO_CONST char* trio_get_format TRIO_ARGS1((ref), trio_pointer_t ref)
{
#if TRIO_FEATURE_USER_DEFINED
	assert(((trio_reference_t*)ref)->parameter->type == FORMAT_USER_DEFINED);
#endif

	return (((trio_reference_t*)ref)->parameter->user_data);
}

/*************************************************************************
 * trio_get_argument [public]
 */
trio_pointer_t trio_get_argument TRIO_ARGS1((ref), trio_pointer_t ref)
{
#if TRIO_FEATURE_USER_DEFINED
	assert(((trio_reference_t*)ref)->parameter->type == FORMAT_USER_DEFINED);
#endif

	return ((trio_reference_t*)ref)->parameter->data.pointer;
}

/*************************************************************************
 * trio_get_width / trio_set_width [public]
 */
int trio_get_width TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return ((trio_reference_t*)ref)->parameter->width;
}

void trio_set_width TRIO_ARGS2((ref, width), trio_pointer_t ref, int width)
{
	((trio_reference_t*)ref)->parameter->width = width;
}

/*************************************************************************
 * trio_get_precision / trio_set_precision [public]
 */
int trio_get_precision TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return (((trio_reference_t*)ref)->parameter->precision);
}

void trio_set_precision TRIO_ARGS2((ref, precision), trio_pointer_t ref, int precision)
{
	((trio_reference_t*)ref)->parameter->precision = precision;
}

/*************************************************************************
 * trio_get_base / trio_set_base [public]
 */
int trio_get_base TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return (((trio_reference_t*)ref)->parameter->base);
}

void trio_set_base TRIO_ARGS2((ref, base), trio_pointer_t ref, int base)
{
	((trio_reference_t*)ref)->parameter->base = base;
}

/*************************************************************************
 * trio_get_long / trio_set_long [public]
 */
int trio_get_long TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return (((trio_reference_t*)ref)->parameter->flags & FLAGS_LONG) ? TRUE : FALSE;
}

void trio_set_long TRIO_ARGS2((ref, is_long), trio_pointer_t ref, int is_long)
{
	if (is_long)
		((trio_reference_t*)ref)->parameter->flags |= FLAGS_LONG;
	else
		((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_LONG;
}

/*************************************************************************
 * trio_get_longlong / trio_set_longlong [public]
 */
int trio_get_longlong TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return (((trio_reference_t*)ref)->parameter->flags & FLAGS_QUAD) ? TRUE : FALSE;
}

void trio_set_longlong TRIO_ARGS2((ref, is_longlong), trio_pointer_t ref, int is_longlong)
{
	if (is_longlong)
		((trio_reference_t*)ref)->parameter->flags |= FLAGS_QUAD;
	else
		((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_QUAD;
}

/*************************************************************************
 * trio_get_longdouble / trio_set_longdouble [public]
 */
#if TRIO_FEATURE_FLOAT
int trio_get_longdouble TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return (((trio_reference_t*)ref)->parameter->flags & FLAGS_LONGDOUBLE) ? TRUE : FALSE;
}

void trio_set_longdouble TRIO_ARGS2((ref, is_longdouble), trio_pointer_t ref, int is_longdouble)
{
	if (is_longdouble)
		((trio_reference_t*)ref)->parameter->flags |= FLAGS_LONGDOUBLE;
	else
		((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_LONGDOUBLE;
}
#endif /* TRIO_FEATURE_FLOAT */

/*************************************************************************
 * trio_get_short / trio_set_short [public]
 */
int trio_get_short TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return (((trio_reference_t*)ref)->parameter->flags & FLAGS_SHORT) ? TRUE : FALSE;
}

void trio_set_short TRIO_ARGS2((ref, is_short), trio_pointer_t ref, int is_short)
{
	if (is_short)
		((trio_reference_t*)ref)->parameter->flags |= FLAGS_SHORT;
	else
		((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_SHORT;
}

/*************************************************************************
 * trio_get_shortshort / trio_set_shortshort [public]
 */
int trio_get_shortshort TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return (((trio_reference_t*)ref)->parameter->flags & FLAGS_SHORTSHORT) ? TRUE : FALSE;
}

void trio_set_shortshort TRIO_ARGS2((ref, is_shortshort), trio_pointer_t ref, int is_shortshort)
{
	if (is_shortshort)
		((trio_reference_t*)ref)->parameter->flags |= FLAGS_SHORTSHORT;
	else
		((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_SHORTSHORT;
}

/*************************************************************************
 * trio_get_alternative / trio_set_alternative [public]
 */
int trio_get_alternative TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return (((trio_reference_t*)ref)->parameter->flags & FLAGS_ALTERNATIVE) ? TRUE : FALSE;
}

void trio_set_alternative TRIO_ARGS2((ref, is_alternative), trio_pointer_t ref, int is_alternative)
{
	if (is_alternative)
		((trio_reference_t*)ref)->parameter->flags |= FLAGS_ALTERNATIVE;
	else
		((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_ALTERNATIVE;
}

/*************************************************************************
 * trio_get_alignment / trio_set_alignment [public]
 */
int trio_get_alignment TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return (((trio_reference_t*)ref)->parameter->flags & FLAGS_LEFTADJUST) ? TRUE : FALSE;
}

void trio_set_alignment TRIO_ARGS2((ref, is_leftaligned), trio_pointer_t ref, int is_leftaligned)
{
	if (is_leftaligned)
		((trio_reference_t*)ref)->parameter->flags |= FLAGS_LEFTADJUST;
	else
		((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_LEFTADJUST;
}

/*************************************************************************
 * trio_get_spacing /trio_set_spacing [public]
 */
int trio_get_spacing TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return (((trio_reference_t*)ref)->parameter->flags & FLAGS_SPACE) ? TRUE : FALSE;
}

void trio_set_spacing TRIO_ARGS2((ref, is_space), trio_pointer_t ref, int is_space)
{
	if (is_space)
		((trio_reference_t*)ref)->parameter->flags |= FLAGS_SPACE;
	else
		((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_SPACE;
}

/*************************************************************************
 * trio_get_sign / trio_set_sign [public]
 */
int trio_get_sign TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return (((trio_reference_t*)ref)->parameter->flags & FLAGS_SHOWSIGN) ? TRUE : FALSE;
}

void trio_set_sign TRIO_ARGS2((ref, is_sign), trio_pointer_t ref, int is_sign)
{
	if (is_sign)
		((trio_reference_t*)ref)->parameter->flags |= FLAGS_SHOWSIGN;
	else
		((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_SHOWSIGN;
}

/*************************************************************************
 * trio_get_padding / trio_set_padding [public]
 */
int trio_get_padding TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return (((trio_reference_t*)ref)->parameter->flags & FLAGS_NILPADDING) ? TRUE : FALSE;
}

void trio_set_padding TRIO_ARGS2((ref, is_padding), trio_pointer_t ref, int is_padding)
{
	if (is_padding)
		((trio_reference_t*)ref)->parameter->flags |= FLAGS_NILPADDING;
	else
		((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_NILPADDING;
}

/*************************************************************************
 * trio_get_quote / trio_set_quote [public]
 */
#if TRIO_FEATURE_QUOTE
int trio_get_quote TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return (((trio_reference_t*)ref)->parameter->flags & FLAGS_QUOTE) ? TRUE : FALSE;
}

void trio_set_quote TRIO_ARGS2((ref, is_quote), trio_pointer_t ref, int is_quote)
{
	if (is_quote)
		((trio_reference_t*)ref)->parameter->flags |= FLAGS_QUOTE;
	else
		((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_QUOTE;
}
#endif /* TRIO_FEATURE_QUOTE */

/*************************************************************************
 * trio_get_upper / trio_set_upper [public]
 */
int trio_get_upper TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return (((trio_reference_t*)ref)->parameter->flags & FLAGS_UPPER) ? TRUE : FALSE;
}

void trio_set_upper TRIO_ARGS2((ref, is_upper), trio_pointer_t ref, int is_upper)
{
	if (is_upper)
		((trio_reference_t*)ref)->parameter->flags |= FLAGS_UPPER;
	else
		((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_UPPER;
}

/*************************************************************************
 * trio_get_largest / trio_set_largest [public]
 */
#if TRIO_FEATURE_INTMAX_T
int trio_get_largest TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return (((trio_reference_t*)ref)->parameter->flags & FLAGS_INTMAX_T) ? TRUE : FALSE;
}

void trio_set_largest TRIO_ARGS2((ref, is_largest), trio_pointer_t ref, int is_largest)
{
	if (is_largest)
		((trio_reference_t*)ref)->parameter->flags |= FLAGS_INTMAX_T;
	else
		((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_INTMAX_T;
}
#endif /* TRIO_FEATURE_INTMAX_T */

/*************************************************************************
 * trio_get_ptrdiff / trio_set_ptrdiff [public]
 */
#if TRIO_FEATURE_PTRDIFF_T
int trio_get_ptrdiff TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return (((trio_reference_t*)ref)->parameter->flags & FLAGS_PTRDIFF_T) ? TRUE : FALSE;
}

void trio_set_ptrdiff TRIO_ARGS2((ref, is_ptrdiff), trio_pointer_t ref, int is_ptrdiff)
{
	if (is_ptrdiff)
		((trio_reference_t*)ref)->parameter->flags |= FLAGS_PTRDIFF_T;
	else
		((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_PTRDIFF_T;
}
#endif /* TRIO_FEATURE_PTRDIFF_T */

/*************************************************************************
 * trio_get_size / trio_set_size [public]
 */
#if TRIO_FEATURE_SIZE_T
int trio_get_size TRIO_ARGS1((ref), trio_pointer_t ref)
{
	return (((trio_reference_t*)ref)->parameter->flags & FLAGS_SIZE_T) ? TRUE : FALSE;
}

void trio_set_size TRIO_ARGS2((ref, is_size), trio_pointer_t ref, int is_size)
{
	if (is_size)
		((trio_reference_t*)ref)->parameter->flags |= FLAGS_SIZE_T;
	else
		((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_SIZE_T;
}
#endif /* TRIO_FEATURE_SIZE_T */

/*************************************************************************
 * trio_print_int [public]
 */
void trio_print_int TRIO_ARGS2((ref, number), trio_pointer_t ref, int number)
{
	trio_reference_t* self = (trio_reference_t*)ref;

	TrioWriteNumber(self->data, (trio_uintmax_t)number, self->parameter->flags,
	                self->parameter->width, self->parameter->precision, self->parameter->base);
}

/*************************************************************************
 * trio_print_uint [public]
 */
void trio_print_uint TRIO_ARGS2((ref, number), trio_pointer_t ref, unsigned int number)
{
	trio_reference_t* self = (trio_reference_t*)ref;

	TrioWriteNumber(self->data, (trio_uintmax_t)number, self->parameter->flags | FLAGS_UNSIGNED,
	                self->parameter->width, self->parameter->precision, self->parameter->base);
}

/*************************************************************************
 * trio_print_double [public]
 */
#if TRIO_FEATURE_FLOAT
void trio_print_double TRIO_ARGS2((ref, number), trio_pointer_t ref, double number)
{
	trio_reference_t* self = (trio_reference_t*)ref;

	TrioWriteDouble(self->data, number, self->parameter->flags, self->parameter->width,
	                self->parameter->precision, self->parameter->base);
}
#endif /* TRIO_FEATURE_FLOAT */

/*************************************************************************
 * trio_print_string [public]
 */
void trio_print_string TRIO_ARGS2((ref, string), trio_pointer_t ref, TRIO_CONST char* string)
{
	trio_reference_t* self = (trio_reference_t*)ref;

	TrioWriteString(self->data, string, self->parameter->flags, self->parameter->width,
	                self->parameter->precision);
}

/*************************************************************************
 * trio_print_ref [public]
 */
int trio_print_ref TRIO_VARGS3((ref, format, va_alist), trio_pointer_t ref, TRIO_CONST char* format,
                               TRIO_VA_DECL)
{
	int status;
	va_list arglist;

	assert(VALID(format));

	TRIO_VA_START(arglist, format);
	status = TrioFormatRef((trio_reference_t*)ref, format, arglist, NULL, NULL);
	TRIO_VA_END(arglist);
	return status;
}

/*************************************************************************
 * trio_vprint_ref [public]
 */
int trio_vprint_ref TRIO_ARGS3((ref, format, arglist), trio_pointer_t ref, TRIO_CONST char* format,
                               va_list arglist)
{
	assert(VALID(format));

	return TrioFormatRef((trio_reference_t*)ref, format, arglist, NULL, NULL);
}

/*************************************************************************
 * trio_printv_ref [public]
 */
int trio_printv_ref TRIO_ARGS3((ref, format, argarray), trio_pointer_t ref, TRIO_CONST char* format,
                               trio_pointer_t* argarray)
{
	static va_list unused;

	assert(VALID(format));

	return TrioFormatRef((trio_reference_t*)ref, format, unused, TrioArrayGetter, argarray);
}

#endif

/*************************************************************************
 * trio_print_pointer [public]
 */
void trio_print_pointer TRIO_ARGS2((ref, pointer), trio_pointer_t ref, trio_pointer_t pointer)
{
	trio_reference_t* self = (trio_reference_t*)ref;
	trio_flags_t flags;
	trio_uintmax_t number;

	if (NULL == pointer)
	{
		TRIO_CONST char* string = internalNullString;
		while (*string)
			self->data->OutStream(self->data, *string++);
	}
	else
	{
		/*
		 * 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
		 * to please ANSI C++.
		 */
		number = (trio_uintmax_t)((char*)pointer - (char*)0);
		/* Shrink to size of pointer */
		number &= (trio_uintmax_t)-1;
		flags = self->parameter->flags;
		flags |= (FLAGS_UNSIGNED | FLAGS_ALTERNATIVE | FLAGS_NILPADDING);
		TrioWriteNumber(self->data, number, flags, POINTER_WIDTH, NO_PRECISION, BASE_HEX);
	}
}

/** @} End of UserDefined documentation module */

/*************************************************************************
 *
 * LOCALES
 *
 ************************************************************************/

/*************************************************************************
 * trio_locale_set_decimal_point
 *
 * Decimal point can only be one character. The input argument is a
 * string to enable multibyte characters. At most MB_LEN_MAX characters
 * will be used.
 */
#if TRIO_FEATURE_LOCALE
TRIO_PUBLIC void trio_locale_set_decimal_point TRIO_ARGS1((decimalPoint), char* decimalPoint)
{
#if defined(USE_LOCALE)
	if (NULL == internalLocaleValues)
	{
		TrioSetLocale();
	}
#endif
	internalDecimalPointLength = trio_length(decimalPoint);
	if (internalDecimalPointLength == 1)
	{
		internalDecimalPoint = *decimalPoint;
	}
	else
	{
		internalDecimalPoint = NIL;
		trio_copy_max(internalDecimalPointString, sizeof(internalDecimalPointString), decimalPoint);
	}
}
#endif

/*************************************************************************
 * trio_locale_set_thousand_separator
 *
 * See trio_locale_set_decimal_point
 */
#if TRIO_FEATURE_LOCALE || TRIO_EXTENSION
TRIO_PUBLIC void trio_locale_set_thousand_separator TRIO_ARGS1((thousandSeparator),
                                                               char* thousandSeparator)
{
#if defined(USE_LOCALE)
	if (NULL == internalLocaleValues)
	{
		TrioSetLocale();
	}
#endif
	trio_copy_max(internalThousandSeparator, sizeof(internalThousandSeparator), thousandSeparator);
	internalThousandSeparatorLength = trio_length(internalThousandSeparator);
}
#endif

/*************************************************************************
 * trio_locale_set_grouping
 *
 * Array of bytes. Reversed order.
 *
 *  CHAR_MAX : No further grouping
 *  0        : Repeat last group for the remaining digits (not necessary
 *             as C strings are zero-terminated)
 *  n        : Set current group to n
 *
 * Same order as the grouping attribute in LC_NUMERIC.
 */
#if TRIO_FEATURE_LOCALE || TRIO_EXTENSION
TRIO_PUBLIC void trio_locale_set_grouping TRIO_ARGS1((grouping), char* grouping)
{
#if defined(USE_LOCALE)
	if (NULL == internalLocaleValues)
	{
		TrioSetLocale();
	}
#endif
	trio_copy_max(internalGrouping, sizeof(internalGrouping), grouping);
}
#endif

/*************************************************************************
 *
 * SCANNING
 *
 ************************************************************************/

#if TRIO_FEATURE_SCANF

/*************************************************************************
 * TrioSkipWhitespaces
 */
TRIO_PRIVATE int TrioSkipWhitespaces TRIO_ARGS1((self), trio_class_t* self)
{
	int ch;

	ch = self->current;
	while (isspace(ch))
	{
		self->InStream(self, &ch);
	}
	return ch;
}

/*************************************************************************
 * TrioGetCollation
 */
#if TRIO_EXTENSION
TRIO_PRIVATE void TrioGetCollation(TRIO_NOARGS)
{
	int i;
	int j;
	int k;
	char first[2];
	char second[2];

	/* This is computationally expensive */
	first[1] = NIL;
	second[1] = NIL;
	for (i = 0; i < MAX_CHARACTER_CLASS; i++)
	{
		k = 0;
		first[0] = (char)i;
		for (j = 0; j < MAX_CHARACTER_CLASS; j++)
		{
			second[0] = (char)j;
			if (trio_equal_locale(first, second))
				internalCollationArray[i][k++] = (char)j;
		}
		internalCollationArray[i][k] = NIL;
	}
}
#endif

/*************************************************************************
 * TrioGetCharacterClass
 *
 * FIXME:
 *  multibyte
 */
TRIO_PRIVATE int TrioGetCharacterClass TRIO_ARGS4((format, offsetPointer, flagsPointer,
                                                   characterclass),
                                                  TRIO_CONST char* format, int* offsetPointer,
                                                  trio_flags_t* flagsPointer, int* characterclass)
{
	int offset = *offsetPointer;
	int i;
	char ch;
	char range_begin;
	char range_end;

	*flagsPointer &= ~FLAGS_EXCLUDE;

	if (format[offset] == QUALIFIER_CIRCUMFLEX)
	{
		*flagsPointer |= FLAGS_EXCLUDE;
		offset++;
	}
	/*
	 * If the ungroup character is at the beginning of the scanlist,
	 * it will be part of the class, and a second ungroup character
	 * must follow to end the group.
	 */
	if (format[offset] == SPECIFIER_UNGROUP)
	{
		characterclass[(int)SPECIFIER_UNGROUP]++;
		offset++;
	}
	/*
	 * Minus is used to specify ranges. To include minus in the class,
	 * it must be at the beginning of the list
	 */
	if (format[offset] == QUALIFIER_MINUS)
	{
		characterclass[(int)QUALIFIER_MINUS]++;
		offset++;
	}
	/* Collect characters */
	for (ch = format[offset]; (ch != SPECIFIER_UNGROUP) && (ch != NIL); ch = format[++offset])
	{
		switch (ch)
		{
			case QUALIFIER_MINUS: /* Scanlist ranges */

				/*
				 * Both C99 and UNIX98 describes ranges as implementation-
				 * defined.
				 *
				 * We support the following behaviour (although this may
				 * change as we become wiser)
				 * - only increasing ranges, ie. [a-b] but not [b-a]
				 * - transitive ranges, ie. [a-b-c] == [a-c]
				 * - trailing minus, ie. [a-] is interpreted as an 'a'
				 *   and a '-'
				 * - duplicates (although we can easily convert these
				 *   into errors)
				 */
				range_begin = format[offset - 1];
				range_end = format[++offset];
				if (range_end == SPECIFIER_UNGROUP)
				{
					/* Trailing minus is included */
					characterclass[(int)ch]++;
					ch = range_end;
					break; /* for */
				}
				if (range_end == NIL)
					return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
				if (range_begin > range_end)
					return TRIO_ERROR_RETURN(TRIO_ERANGE, offset);

				for (i = (int)range_begin; i <= (int)range_end; i++)
					characterclass[i]++;

				ch = range_end;
				break;

#if TRIO_EXTENSION

			case SPECIFIER_GROUP:

				switch (format[offset + 1])
				{
					case QUALIFIER_DOT: /* Collating symbol */
						/*
						 * FIXME: This will be easier to implement when multibyte
						 * characters have been implemented. Until now, we ignore
						 * this feature.
						 */
						for (i = offset + 2;; i++)
						{
							if (format[i] == NIL)
								/* Error in syntax */
								return -1;
							else if (format[i] == QUALIFIER_DOT)
								break; /* for */
						}
						if (format[++i] != SPECIFIER_UNGROUP)
							return -1;

						offset = i;
						break;

					case QUALIFIER_EQUAL: /* Equivalence class expressions */
					{
						unsigned int j;
						unsigned int k;

						if (internalCollationUnconverted)
						{
							/* Lazy evaluation of collation array */
							TrioGetCollation();
							internalCollationUnconverted = FALSE;
						}
						for (i = offset + 2;; i++)
						{
							if (format[i] == NIL)
								/* Error in syntax */
								return -1;
							else if (format[i] == QUALIFIER_EQUAL)
								break; /* for */
							else
							{
								/* Mark any equivalent character */
								k = (unsigned int)format[i];
								for (j = 0; internalCollationArray[k][j] != NIL; j++)
									characterclass[(int)internalCollationArray[k][j]]++;
							}
						}
						if (format[++i] != SPECIFIER_UNGROUP)
							return -1;

						offset = i;
					}
					break;

					case QUALIFIER_COLON: /* Character class expressions */

						if (trio_equal_max(CLASS_ALNUM, sizeof(CLASS_ALNUM) - 1, &format[offset]))
						{
							for (i = 0; i < MAX_CHARACTER_CLASS; i++)
								if (isalnum(i))
									characterclass[i]++;
							offset += sizeof(CLASS_ALNUM) - 1;
						}
						else if (trio_equal_max(CLASS_ALPHA, sizeof(CLASS_ALPHA) - 1,
						                        &format[offset]))
						{
							for (i = 0; i < MAX_CHARACTER_CLASS; i++)
								if (isalpha(i))
									characterclass[i]++;
							offset += sizeof(CLASS_ALPHA) - 1;
						}
						else if (trio_equal_max(CLASS_CNTRL, sizeof(CLASS_CNTRL) - 1,
						                        &format[offset]))
						{
							for (i = 0; i < MAX_CHARACTER_CLASS; i++)
								if (iscntrl(i))
									characterclass[i]++;
							offset += sizeof(CLASS_CNTRL) - 1;
						}
						else if (trio_equal_max(CLASS_DIGIT, sizeof(CLASS_DIGIT) - 1,
						                        &format[offset]))
						{
							for (i = 0; i < MAX_CHARACTER_CLASS; i++)
								if (isdigit(i))
									characterclass[i]++;
							offset += sizeof(CLASS_DIGIT) - 1;
						}
						else if (trio_equal_max(CLASS_GRAPH, sizeof(CLASS_GRAPH) - 1,
						                        &format[offset]))
						{
							for (i = 0; i < MAX_CHARACTER_CLASS; i++)
								if (isgraph(i))
									characterclass[i]++;
							offset += sizeof(CLASS_GRAPH) - 1;
						}
						else if (trio_equal_max(CLASS_LOWER, sizeof(CLASS_LOWER) - 1,
						                        &format[offset]))
						{
							for (i = 0; i < MAX_CHARACTER_CLASS; i++)
								if (islower(i))
									characterclass[i]++;
							offset += sizeof(CLASS_LOWER) - 1;
						}
						else if (trio_equal_max(CLASS_PRINT, sizeof(CLASS_PRINT) - 1,
						                        &format[offset]))
						{
							for (i = 0; i < MAX_CHARACTER_CLASS; i++)
								if (isprint(i))
									characterclass[i]++;
							offset += sizeof(CLASS_PRINT) - 1;
						}
						else if (trio_equal_max(CLASS_PUNCT, sizeof(CLASS_PUNCT) - 1,
						                        &format[offset]))
						{
							for (i = 0; i < MAX_CHARACTER_CLASS; i++)
								if (ispunct(i))
									characterclass[i]++;
							offset += sizeof(CLASS_PUNCT) - 1;
						}
						else if (trio_equal_max(CLASS_SPACE, sizeof(CLASS_SPACE) - 1,
						                        &format[offset]))
						{
							for (i = 0; i < MAX_CHARACTER_CLASS; i++)
								if (isspace(i))
									characterclass[i]++;
							offset += sizeof(CLASS_SPACE) - 1;
						}
						else if (trio_equal_max(CLASS_UPPER, sizeof(CLASS_UPPER) - 1,
						                        &format[offset]))
						{
							for (i = 0; i < MAX_CHARACTER_CLASS; i++)
								if (isupper(i))
									characterclass[i]++;
							offset += sizeof(CLASS_UPPER) - 1;
						}
						else if (trio_equal_max(CLASS_XDIGIT, sizeof(CLASS_XDIGIT) - 1,
						                        &format[offset]))
						{
							for (i = 0; i < MAX_CHARACTER_CLASS; i++)
								if (isxdigit(i))
									characterclass[i]++;
							offset += sizeof(CLASS_XDIGIT) - 1;
						}
						else
						{
							characterclass[(int)ch]++;
						}
						break;

					default:
						characterclass[(int)ch]++;
						break;
				}
				break;

#endif /* TRIO_EXTENSION */

			default:
				characterclass[(int)ch]++;
				break;
		}
	}
	return 0;
}

/*************************************************************************
 * TrioReadNumber
 *
 * We implement our own number conversion in preference of strtol and
 * strtoul, because we must handle 'long long' and thousand separators.
 */
TRIO_PRIVATE BOOLEAN_T TrioReadNumber TRIO_ARGS5((self, target, flags, width, base),
                                                 trio_class_t* self, trio_uintmax_t* target,
                                                 trio_flags_t flags, int width, int base)
{
	trio_uintmax_t number = 0;
	int digit;
	int count;
	BOOLEAN_T isNegative = FALSE;
	BOOLEAN_T gotNumber = FALSE;
	int j;

	assert(VALID(self));
	assert(VALID(self->InStream));
	assert((base >= MIN_BASE && base <= MAX_BASE) || (base == NO_BASE));

	if (internalDigitsUnconverted)
	{
		/* Lazy evaluation of digits array */
		memset(internalDigitArray, -1, sizeof(internalDigitArray));
		for (j = 0; j < (int)sizeof(internalDigitsLower) - 1; j++)
		{
			internalDigitArray[(int)internalDigitsLower[j]] = j;
			internalDigitArray[(int)internalDigitsUpper[j]] = j;
		}
		internalDigitsUnconverted = FALSE;
	}

	TrioSkipWhitespaces(self);

	/* Leading sign */
	if (self->current == '+')
	{
		self->InStream(self, NULL);
	}
	else if (self->current == '-')
	{
		self->InStream(self, NULL);
		isNegative = TRUE;
	}

	count = self->processed;

	if (flags & FLAGS_ALTERNATIVE)
	{
		switch (base)
		{
			case NO_BASE:
			case BASE_OCTAL:
			case BASE_HEX:
			case BASE_BINARY:
				if (self->current == '0')
				{
					self->InStream(self, NULL);
					if (self->current)
					{
						if ((base == BASE_HEX) && (trio_to_upper(self->current) == 'X'))
						{
							self->InStream(self, NULL);
						}
						else if ((base == BASE_BINARY) && (trio_to_upper(self->current) == 'B'))
						{
							self->InStream(self, NULL);
						}
					}
				}
				else
					return FALSE;
				break;
			default:
				break;
		}
	}

	while (((width == NO_WIDTH) || (self->processed - count < width)) &&
	       (!((self->current == EOF) || isspace(self->current))))
	{
		if (isascii(self->current))
		{
			digit = internalDigitArray[self->current];
			/* Abort if digit is not allowed in the specified base */
			if ((digit == -1) || (digit >= base))
				break;
		}
#if TRIO_FEATURE_QUOTE
		else if (flags & FLAGS_QUOTE)
		{
			/* Compare with thousands separator */
			for (j = 0; internalThousandSeparator[j] && self->current; j++)
			{
				if (internalThousandSeparator[j] != self->current)
					break;

				self->InStream(self, NULL);
			}
			if (internalThousandSeparator[j])
				break; /* Mismatch */
			else
				continue; /* Match */
		}
#endif
		else
			break;

		number *= base;
		number += digit;
		gotNumber = TRUE; /* we need at least one digit */

		self->InStream(self, NULL);
	}

	/* Was anything read at all? */
	if (!gotNumber)
		return FALSE;

	if (target)
		*target = (isNegative) ? (trio_uintmax_t)(-((trio_intmax_t)number)) : number;
	return TRUE;
}

/*************************************************************************
 * TrioReadChar
 */
TRIO_PRIVATE int TrioReadChar TRIO_ARGS4((self, target, flags, width), trio_class_t* self,
                                         char* target, trio_flags_t flags, int width)
{
	int i;
	char ch;
	trio_uintmax_t number;

	assert(VALID(self));
	assert(VALID(self->InStream));

	for (i = 0; (self->current != EOF) && (i < width); i++)
	{
		ch = (char)self->current;
		self->InStream(self, NULL);
		if ((flags & FLAGS_ALTERNATIVE) && (ch == CHAR_BACKSLASH))
		{
			switch (self->current)
			{
				case '\\':
					ch = '\\';
					break;
				case 'a':
					ch = '\007';
					break;
				case 'b':
					ch = '\b';
					break;
				case 'f':
					ch = '\f';
					break;
				case 'n':
					ch = '\n';
					break;
				case 'r':
					ch = '\r';
					break;
				case 't':
					ch = '\t';
					break;
				case 'v':
					ch = '\v';
					break;
				default:
					if (isdigit(self->current))
					{
						/* Read octal number */
						if (!TrioReadNumber(self, &number, 0, 3, BASE_OCTAL))
							return 0;
						ch = (char)number;
					}
					else if (trio_to_upper(self->current) == 'X')
					{
						/* Read hexadecimal number */
						self->InStream(self, NULL);
						if (!TrioReadNumber(self, &number, 0, 2, BASE_HEX))
							return 0;
						ch = (char)number;
					}
					else
					{
						ch = (char)self->current;
					}
					break;
			}
		}

		if (target)
			target[i] = ch;
	}
	return i + 1;
}

/*************************************************************************
 * TrioReadString
 */
TRIO_PRIVATE BOOLEAN_T TrioReadString TRIO_ARGS4((self, target, flags, width), trio_class_t* self,
                                                 char* target, trio_flags_t flags, int width)
{
	int i;

	assert(VALID(self));
	assert(VALID(self->InStream));

	TrioSkipWhitespaces(self);

	/*
	 * Continue until end of string is reached, a whitespace is encountered,
	 * or width is exceeded
	 */
	for (i = 0; ((width == NO_WIDTH) || (i < width)) &&
	            (!((self->current == EOF) || isspace(self->current)));
	     i++)
	{
		if (TrioReadChar(self, (target ? &target[i] : 0), flags, 1) == 0)
			break; /* for */
	}
	if (target)
		target[i] = NIL;
	return TRUE;
}

/*************************************************************************
 * TrioReadWideChar
 */
#if TRIO_FEATURE_WIDECHAR
TRIO_PRIVATE int TrioReadWideChar TRIO_ARGS4((self, target, flags, width), trio_class_t* self,
                                             trio_wchar_t* target, trio_flags_t flags, int width)
{
	int i;
	int j;
	int size;
	int amount = 0;
	trio_wchar_t wch;
	char buffer[MB_LEN_MAX + 1];

	assert(VALID(self));
	assert(VALID(self->InStream));

	for (i = 0; (self->current != EOF) && (i < width); i++)
	{
		if (isascii(self->current))
		{
			if (TrioReadChar(self, buffer, flags, 1) == 0)
				return 0;
			buffer[1] = NIL;
		}
		else
		{
			/*
			 * Collect a multibyte character, by enlarging buffer until
			 * it contains a fully legal multibyte character, or the
			 * buffer is full.
			 */
			j = 0;
			do
			{
				buffer[j++] = (char)self->current;
				buffer[j] = NIL;
				self->InStream(self, NULL);
			} while ((j < (int)sizeof(buffer)) && (mblen(buffer, (size_t)j) != j));
		}
		if (target)
		{
			size = mbtowc(&wch, buffer, sizeof(buffer));
			if (size > 0)
				target[i] = wch;
		}
		amount += size;
		self->InStream(self, NULL);
	}
	return amount;
}
#endif /* TRIO_FEATURE_WIDECHAR */

/*************************************************************************
 * TrioReadWideString
 */
#if TRIO_FEATURE_WIDECHAR
TRIO_PRIVATE BOOLEAN_T TrioReadWideString TRIO_ARGS4((self, target, flags, width),
                                                     trio_class_t* self, trio_wchar_t* target,
                                                     trio_flags_t flags, int width)
{
	int i;
	int size;

	assert(VALID(self));
	assert(VALID(self->InStream));

	TrioSkipWhitespaces(self);

#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
	/* Required by TrioReadWideChar */
	(void)mblen(NULL, 0);
#endif

	/*
	 * Continue until end of string is reached, a whitespace is encountered,
	 * or width is exceeded
	 */
	for (i = 0; ((width == NO_WIDTH) || (i < width)) &&
	            (!((self->current == EOF) || isspace(self->current)));)
	{
		size = TrioReadWideChar(self, &target[i], flags, 1);
		if (size == 0)
			break; /* for */

		i += size;
	}
	if (target)
		target[i] = WCONST('\0');
	return TRUE;
}
#endif /* TRIO_FEATURE_WIDECHAR */

/*************************************************************************
 * TrioReadGroup
 *
 * Reads non-empty character groups.
 *
 * FIXME: characterclass does not work with multibyte characters
 */
TRIO_PRIVATE BOOLEAN_T TrioReadGroup TRIO_ARGS5((self, target, characterclass, flags, width),
                                                trio_class_t* self, char* target,
                                                int* characterclass, trio_flags_t flags, int width)
{
	int ch;
	int i;

	assert(VALID(self));
	assert(VALID(self->InStream));

	ch = self->current;
	for (i = 0; ((width == NO_WIDTH) || (i < width)) &&
	            (!((ch == EOF) || (((flags & FLAGS_EXCLUDE) != 0) ^ (characterclass[ch] == 0))));
	     i++)
	{
		if (target)
			target[i] = (char)ch;
		self->InStream(self, &ch);
	}

	if (i == 0)
		return FALSE;

	/* Terminate the string if input saved */
	if (target)
		target[i] = NIL;
	return TRUE;
}

/*************************************************************************
 * TrioReadDouble
 *
 * FIXME:
 *  add long double
 *  handle base
 */
#if TRIO_FEATURE_FLOAT
TRIO_PRIVATE BOOLEAN_T TrioReadDouble TRIO_ARGS4((self, target, flags, width), trio_class_t* self,
                                                 trio_pointer_t target, trio_flags_t flags,
                                                 int width)
{
	int ch;
	char doubleString[512];
	int offset = 0;
	int start;
#if TRIO_FEATURE_QUOTE
	int j;
#endif
	BOOLEAN_T isHex = FALSE;
	trio_long_double_t infinity;

	doubleString[0] = 0;

	if ((width == NO_WIDTH) || (width > (int)sizeof(doubleString) - 1))
		width = sizeof(doubleString) - 1;

	TrioSkipWhitespaces(self);

	/*
	 * 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;
	if ((ch == '+') || (ch == '-'))
	{
		doubleString[offset++] = (char)ch;
		self->InStream(self, &ch);
		width--;
	}

	start = offset;
	switch (ch)
	{
		case 'n':
		case 'N':
			/* Not-a-number */
			if (offset != 0)
				break;
			/* FALLTHROUGH */
		case 'i':
		case 'I':
			/* Infinity */
			while (isalpha(ch) && (offset - start < width))
			{
				doubleString[offset++] = (char)ch;
				self->InStream(self, &ch);
			}
			doubleString[offset] = NIL;

			/* Case insensitive string comparison */
			if (trio_equal(&doubleString[start], INFINITE_UPPER) ||
			    trio_equal(&doubleString[start], LONG_INFINITE_UPPER))
			{
				infinity = ((start == 1) && (doubleString[0] == '-')) ? trio_ninf() : trio_pinf();
				if (!target)
					return FALSE;

				if (flags & FLAGS_LONGDOUBLE)
				{
					*((trio_long_double_t*)target) = infinity;
				}
				else if (flags & FLAGS_LONG)
				{
					*((double*)target) = infinity;
				}
				else
				{
					*((float*)target) = infinity;
				}
				return TRUE;
			}
			if (trio_equal(doubleString, NAN_UPPER))
			{
				if (!target)
					return FALSE;

				/* NaN must not have a preceeding + nor - */
				if (flags & FLAGS_LONGDOUBLE)
				{
					*((trio_long_double_t*)target) = trio_nan();
				}
				else if (flags & FLAGS_LONG)
				{
					*((double*)target) = trio_nan();
				}
				else
				{
					*((float*)target) = trio_nan();
				}
				return TRUE;
			}
			return FALSE;

		case '0':
			doubleString[offset++] = (char)ch;
			self->InStream(self, &ch);
			if (trio_to_upper(ch) == 'X')
			{
				isHex = TRUE;
				doubleString[offset++] = (char)ch;
				self->InStream(self, &ch);
			}
			break;

		default:
			break;
	}

	while ((ch != EOF) && (offset - start < width))
	{
		/* Integer part */
		if (isHex ? isxdigit(ch) : isdigit(ch))
		{
			doubleString[offset++] = (char)ch;
			self->InStream(self, &ch);
		}
#if TRIO_FEATURE_QUOTE
		else if (flags & FLAGS_QUOTE)
		{
			/* Compare with thousands separator */
			for (j = 0; internalThousandSeparator[j] && self->current; j++)
			{
				if (internalThousandSeparator[j] != self->current)
					break;

				self->InStream(self, &ch);
			}
			if (internalThousandSeparator[j])
				break; /* Mismatch */
			else
				continue; /* Match */
		}
#endif
		else
			break; /* while */
	}
	if (ch == '.')
	{
		/* Decimal part */
		doubleString[offset++] = (char)ch;
		self->InStream(self, &ch);
		while ((isHex ? isxdigit(ch) : isdigit(ch)) && (offset - start < width))
		{
			doubleString[offset++] = (char)ch;
			self->InStream(self, &ch);
		}
	}
	if (isHex ? (trio_to_upper(ch) == 'P') : (trio_to_upper(ch) == 'E'))
	{
		/* Exponent */
		doubleString[offset++] = (char)ch;
		self->InStream(self, &ch);
		if ((ch == '+') || (ch == '-'))
		{
			doubleString[offset++] = (char)ch;
			self->InStream(self, &ch);
		}
		while (isdigit(ch) && (offset - start < width))
		{
			doubleString[offset++] = (char)ch;
			self->InStream(self, &ch);
		}
	}

	if ((offset == start) || (*doubleString == NIL))
		return FALSE;

	doubleString[offset] = 0;

	if (flags & FLAGS_LONGDOUBLE)
	{
		if (!target)
			return FALSE;

		*((trio_long_double_t*)target) = trio_to_long_double(doubleString, NULL);
	}
	else if (flags & FLAGS_LONG)
	{
		if (!target)
			return FALSE;

		*((double*)target) = trio_to_double(doubleString, NULL);
	}
	else
	{
		if (!target)
			return FALSE;

		*((float*)target) = trio_to_float(doubleString, NULL);
	}
	return TRUE;
}
#endif /* TRIO_FEATURE_FLOAT */

/*************************************************************************
 * TrioReadPointer
 */
TRIO_PRIVATE BOOLEAN_T TrioReadPointer TRIO_ARGS3((self, target, flags), trio_class_t* self,
                                                  trio_pointer_t* target, trio_flags_t flags)
{
	trio_uintmax_t number;
	char buffer[sizeof(internalNullString)];

	flags |= (FLAGS_UNSIGNED | FLAGS_ALTERNATIVE | FLAGS_NILPADDING);

	if (TrioReadNumber(self, &number, flags, POINTER_WIDTH, BASE_HEX))
	{
		if (target)
		{
#if defined(TRIO_COMPILER_GCC) || defined(TRIO_COMPILER_MIPSPRO)
			/*
			 * The strange assignment of number is a workaround for a compiler
			 * warning
			 */
			*target = &((char*)0)[number];
#else
			*target = (trio_pointer_t)number;
#endif
		}
		return TRUE;
	}
	else if (TrioReadString(self, (flags & FLAGS_IGNORE) ? NULL : buffer, 0,
	                        sizeof(internalNullString) - 1))
	{
		if (trio_equal_case(buffer, internalNullString))
		{
			if (target)
				*target = NULL;
			return TRUE;
		}
	}
	return FALSE;
}

/*************************************************************************
 * TrioScanProcess
 */
TRIO_PRIVATE int TrioScanProcess TRIO_ARGS3((data, format, parameters), trio_class_t* data,
                                            TRIO_CONST char* format, trio_parameter_t* parameters)
{
	int status;
	int assignment;
	int ch;
	int offset; /* Offset of format string */
	int i;      /* Offset of current parameter */
	trio_flags_t flags;
	int width;
	int base;
	trio_pointer_t pointer;

	/* Return on empty format string */
	if (format[0] == NIL)
		return 0;

	status = 0;
	assignment = 0;
	i = 0;
	offset = 0;
	data->InStream(data, &ch);

	for (;;)
	{
		/* Skip the parameter entries */
		while (parameters[i].type == FORMAT_PARAMETER)
		{
			assert(i <= MAX_PARAMETERS);
			i++;
		}

		/* Compare non conversion-specifier part of format string */
		while (offset < parameters[i].beginOffset)
		{
			if ((CHAR_IDENTIFIER == format[offset]) && (CHAR_IDENTIFIER == format[offset + 1]))
			{
				/* Two % in format matches one % in input stream */
				if (CHAR_IDENTIFIER == ch)
				{
					data->InStream(data, &ch);
					offset += 2;
					continue; /* while format chars left */
				}
				else
				{
					status = TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
					goto end;
				}
			}
			else /* Not an % identifier */
			{
				if (isspace((int)format[offset]))
				{
					/* Whitespaces may match any amount of whitespaces */
					ch = TrioSkipWhitespaces(data);
				}
				else if (ch == format[offset])
				{
					data->InStream(data, &ch);
				}
				else
				{
					status = assignment;
					goto end;
				}

				offset++;
			}
		}

		if (parameters[i].type == FORMAT_SENTINEL)
			break;

		if ((EOF == ch) && (parameters[i].type != FORMAT_COUNT))
		{
			status = (assignment > 0) ? assignment : EOF;
			goto end;
		}

		flags = parameters[i].flags;

		/* Find width */
		width = parameters[i].width;
		if (flags & FLAGS_WIDTH_PARAMETER)
		{
			/* Get width from parameter list */
			width = (int)parameters[width].data.number.as_signed;
		}

		/* Find base */
		if (NO_BASE != parameters[i].baseSpecifier)
		{
			/* Base from specifier has priority */
			base = parameters[i].baseSpecifier;
		}
		else if (flags & FLAGS_BASE_PARAMETER)
		{
			/* Get base from parameter list */
			base = parameters[i].base;
			base = (int)parameters[base].data.number.as_signed;
		}
		else
		{
			/* Use base from format string */
			base = parameters[i].base;
		}

		switch (parameters[i].type)
		{
			case FORMAT_INT:
			{
				trio_uintmax_t number;

				if (0 == base)
					base = BASE_DECIMAL;

				if (!TrioReadNumber(data, &number, flags, width, base))
				{
					status = assignment;
					goto end;
				}

				if (!(flags & FLAGS_IGNORE))
				{
					assignment++;

					pointer = parameters[i].data.pointer;
#if TRIO_FEATURE_SIZE_T || TRIO_FEATURE_SIZE_T_UPPER
					if (flags & FLAGS_SIZE_T)
						*(size_t*)pointer = (size_t)number;
					else
#endif
#if TRIO_FEATURE_PTRDIFF_T
					    if (flags & FLAGS_PTRDIFF_T)
						*(ptrdiff_t*)pointer = (ptrdiff_t)number;
					else
#endif
#if TRIO_FEATURE_INTMAX_T
					    if (flags & FLAGS_INTMAX_T)
						*(trio_intmax_t*)pointer = (trio_intmax_t)number;
					else
#endif
					    if (flags & FLAGS_QUAD)
						*(trio_ulonglong_t*)pointer = (trio_ulonglong_t)number;
					else if (flags & FLAGS_LONG)
						*(long int*)pointer = (long int)number;
					else if (flags & FLAGS_SHORT)
						*(short int*)pointer = (short int)number;
					else
						*(int*)pointer = (int)number;
				}
			}
			break; /* FORMAT_INT */

			case FORMAT_STRING:
#if TRIO_FEATURE_WIDECHAR
				if (flags & FLAGS_WIDECHAR)
				{
					if (!TrioReadWideString(
					        data, (flags & FLAGS_IGNORE) ? NULL : parameters[i].data.wstring, flags,
					        width))
					{
						status = assignment;
						goto end;
					}
				}
				else
#endif
				{
					if (!TrioReadString(data,
					                    (flags & FLAGS_IGNORE) ? NULL : parameters[i].data.string,
					                    flags, width))
					{
						status = assignment;
						goto end;
					}
				}
				if (!(flags & FLAGS_IGNORE))
					assignment++;
				break; /* FORMAT_STRING */

#if TRIO_FEATURE_FLOAT
			case FORMAT_DOUBLE:
			{
				if (flags & FLAGS_IGNORE)
				{
					pointer = NULL;
				}
				else
				{
					pointer = (flags & FLAGS_LONGDOUBLE)
					              ? (trio_pointer_t)parameters[i].data.longdoublePointer
					              : (trio_pointer_t)parameters[i].data.doublePointer;
				}
				if (!TrioReadDouble(data, pointer, flags, width))
				{
					status = assignment;
					goto end;
				}
				if (!(flags & FLAGS_IGNORE))
				{
					assignment++;
				}
				break; /* FORMAT_DOUBLE */
			}
#endif

			case FORMAT_GROUP:
			{
				int characterclass[MAX_CHARACTER_CLASS + 1];

				/* Skip over modifiers */
				while (format[offset] != SPECIFIER_GROUP)
				{
					offset++;
				}
				/* Skip over group specifier */
				offset++;

				memset(characterclass, 0, sizeof(characterclass));
				status = TrioGetCharacterClass(format, &offset, &flags, characterclass);
				if (status < 0)
					goto end;

				if (!TrioReadGroup(data, (flags & FLAGS_IGNORE) ? NULL : parameters[i].data.string,
				                   characterclass, flags, parameters[i].width))
				{
					status = assignment;
					goto end;
				}
				if (!(flags & FLAGS_IGNORE))
					assignment++;
			}
			break; /* FORMAT_GROUP */

			case FORMAT_COUNT:
				pointer = parameters[i].data.pointer;
				if (NULL != pointer)
				{
					int count = data->processed;
					if (ch != EOF)
						count--; /* a character is read, but is not consumed yet */
#if TRIO_FEATURE_SIZE_T || TRIO_FEATURE_SIZE_T_UPPER
					if (flags & FLAGS_SIZE_T)
						*(size_t*)pointer = (size_t)count;
					else
#endif
#if TRIO_FEATURE_PTRDIFF_T
					    if (flags & FLAGS_PTRDIFF_T)
						*(ptrdiff_t*)pointer = (ptrdiff_t)count;
					else
#endif
#if TRIO_FEATURE_INTMAX_T
					    if (flags & FLAGS_INTMAX_T)
						*(trio_intmax_t*)pointer = (trio_intmax_t)count;
					else
#endif
					    if (flags & FLAGS_QUAD)
					{
						*(trio_ulonglong_t*)pointer = (trio_ulonglong_t)count;
					}
					else if (flags & FLAGS_LONG)
					{
						*(long int*)pointer = (long int)count;
					}
					else if (flags & FLAGS_SHORT)
					{
						*(short int*)pointer = (short int)count;
					}
					else
					{
						*(int*)pointer = (int)count;
					}
				}
				break; /* FORMAT_COUNT */

			case FORMAT_CHAR:
#if TRIO_FEATURE_WIDECHAR
				if (flags & FLAGS_WIDECHAR)
				{
					if (TrioReadWideChar(data,
					                     (flags & FLAGS_IGNORE) ? NULL : parameters[i].data.wstring,
					                     flags, (width == NO_WIDTH) ? 1 : width) == 0)
					{
						status = assignment;
						goto end;
					}
				}
				else
#endif
				{
					if (TrioReadChar(data,
					                 (flags & FLAGS_IGNORE) ? NULL : parameters[i].data.string,
					                 flags, (width == NO_WIDTH) ? 1 : width) == 0)
					{
						status = assignment;
						goto end;
					}
				}
				if (!(flags & FLAGS_IGNORE))
					assignment++;
				break; /* FORMAT_CHAR */

			case FORMAT_POINTER:
				if (!TrioReadPointer(
				        data,
				        (flags & FLAGS_IGNORE) ? NULL : (trio_pointer_t*)parameters[i].data.pointer,
				        flags))
				{
					status = assignment;
					goto end;
				}
				if (!(flags & FLAGS_IGNORE))
					assignment++;
				break; /* FORMAT_POINTER */

			case FORMAT_PARAMETER:
				break; /* FORMAT_PARAMETER */

			default:
				status = TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
				goto end;
		}

		ch = data->current;
		offset = parameters[i].endOffset;
		i++;
	}

	status = assignment;
end:
	if (data->UndoStream)
		data->UndoStream(data);
	return status;
}

/*************************************************************************
 * TrioScan
 */
TRIO_PRIVATE int TrioScan TRIO_ARGS8(
    (source, sourceSize, InStream, UndoStream, format, arglist, argfunc, argarray),
    trio_pointer_t source, size_t sourceSize, void(*InStream) TRIO_PROTO((trio_class_t*, int*)),
    void(*UndoStream) TRIO_PROTO((trio_class_t*)), TRIO_CONST char* format, va_list arglist,
    trio_argfunc_t argfunc, trio_pointer_t* 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.UndoStream = UndoStream;
	data.location = (trio_pointer_t)source;
	data.max = sourceSize;
	data.error = 0;

#if defined(USE_LOCALE)
	if (NULL == internalLocaleValues)
	{
		TrioSetLocale();
	}
#endif

	status = TrioParse(TYPE_SCAN, format, parameters, arglist, argfunc, argarray);
	if (status < 0)
		return status;

	status = TrioScanProcess(&data, format, parameters);
	if (data.error != 0)
	{
		status = data.error;
	}
	return status;
}

/*************************************************************************
 * TrioInStreamFile
 */
#if TRIO_FEATURE_FILE || TRIO_FEATURE_STDIO
TRIO_PRIVATE void TrioInStreamFile TRIO_ARGS2((self, intPointer), trio_class_t* self,
                                              int* intPointer)
{
	FILE* file = (FILE*)self->location;

	assert(VALID(self));
	assert(VALID(file));

	self->actually.cached = 0;

	/* The initial value of self->current is zero */
	if (self->current == EOF)
	{
		self->error =
		    (ferror(file)) ? TRIO_ERROR_RETURN(TRIO_ERRNO, 0) : TRIO_ERROR_RETURN(TRIO_EOF, 0);
	}
	else
	{
		self->processed++;
		self->actually.cached++;
	}

	self->current = fgetc(file);

	if (VALID(intPointer))
	{
		*intPointer = self->current;
	}
}
#endif /* TRIO_FEATURE_FILE || TRIO_FEATURE_STDIO */

/*************************************************************************
 * TrioUndoStreamFile
 */
#if TRIO_FEATURE_FILE || TRIO_FEATURE_STDIO
TRIO_PRIVATE void TrioUndoStreamFile TRIO_ARGS1((self), trio_class_t* self)
{
	FILE* file = (FILE*)self->location;

	assert(VALID(self));
	assert(VALID(file));

	if (self->actually.cached > 0)
	{
		assert(self->actually.cached == 1);

		self->current = ungetc(self->current, file);
		self->actually.cached = 0;
	}
}
#endif /* TRIO_FEATURE_FILE || TRIO_FEATURE_STDIO */

/*************************************************************************
 * TrioInStreamFileDescriptor
 */
#if TRIO_FEATURE_FD
TRIO_PRIVATE void TrioInStreamFileDescriptor TRIO_ARGS2((self, intPointer), trio_class_t* self,
                                                        int* intPointer)
{
	int fd = *((int*)self->location);
	int size;
	unsigned char input;

	assert(VALID(self));

	self->actually.cached = 0;

	size = read(fd, &input, sizeof(char));
	if (size == -1)
	{
		self->error = TRIO_ERROR_RETURN(TRIO_ERRNO, 0);
		self->current = EOF;
	}
	else
	{
		self->current = (size == 0) ? EOF : input;
	}
	if (self->current != EOF)
	{
		self->actually.cached++;
		self->processed++;
	}

	if (VALID(intPointer))
	{
		*intPointer = self->current;
	}
}
#endif /* TRIO_FEATURE_FD */

/*************************************************************************
 * TrioInStreamCustom
 */
#if TRIO_FEATURE_CLOSURE
TRIO_PRIVATE void TrioInStreamCustom TRIO_ARGS2((self, intPointer), trio_class_t* self,
                                                int* intPointer)
{
	trio_custom_t* data;

	assert(VALID(self));
	assert(VALID(self->location));

	self->actually.cached = 0;

	data = (trio_custom_t*)self->location;

	self->current = (data->stream.in == NULL) ? NIL : (data->stream.in)(data->closure);

	if (self->current == NIL)
	{
		self->current = EOF;
	}
	else
	{
		self->processed++;
		self->actually.cached++;
	}

	if (VALID(intPointer))
	{
		*intPointer = self->current;
	}
}
#endif /* TRIO_FEATURE_CLOSURE */

/*************************************************************************
 * TrioInStreamString
 */
TRIO_PRIVATE void TrioInStreamString TRIO_ARGS2((self, intPointer), trio_class_t* self,
                                                int* intPointer)
{
	unsigned char** buffer;

	assert(VALID(self));
	assert(VALID(self->location));

	self->actually.cached = 0;

	buffer = (unsigned char**)self->location;
	self->current = (*buffer)[0];
	if (self->current == NIL)
	{
		self->current = EOF;
	}
	else
	{
		(*buffer)++;
		self->processed++;
		self->actually.cached++;
	}

	if (VALID(intPointer))
	{
		*intPointer = self->current;
	}
}

/*************************************************************************
 *
 * Formatted scanning functions
 *
 ************************************************************************/

#if defined(TRIO_DOCUMENTATION)
#include "doc/doc_scanf.h"
#endif
/** @addtogroup Scanf
    @{
*/

/*************************************************************************
 * scanf
 */

/**
   Scan characters from standard input stream.

   @param format Formatting string.
   @param ... Arguments.
   @return Number of scanned characters.
 */
#if TRIO_FEATURE_STDIO
TRIO_PUBLIC int trio_scanf TRIO_VARGS2((format, va_alist), TRIO_CONST char* format, TRIO_VA_DECL)
{
	int status;
	va_list args;

	assert(VALID(format));

	TRIO_VA_START(args, format);
	status = TrioScan((trio_pointer_t)stdin, 0, TrioInStreamFile, TrioUndoStreamFile, format, args,
	                  NULL, NULL);
	TRIO_VA_END(args);
	return status;
}
#endif /* TRIO_FEATURE_STDIO */

/**
   Scan characters from standard input stream.

   @param format Formatting string.
   @param args Arguments.
   @return Number of scanned characters.
 */
#if TRIO_FEATURE_STDIO
TRIO_PUBLIC int trio_vscanf TRIO_ARGS2((format, args), TRIO_CONST char* format, va_list args)
{
	assert(VALID(format));

	return TrioScan((trio_pointer_t)stdin, 0, TrioInStreamFile, TrioUndoStreamFile, format, args,
	                NULL, NULL);
}
#endif /* TRIO_FEATURE_STDIO */

/**
   Scan characters from standard input stream.

   @param format Formatting string.
   @param args Arguments.
   @return Number of scanned characters.
 */
#if TRIO_FEATURE_STDIO
TRIO_PUBLIC int trio_scanfv TRIO_ARGS2((format, args), TRIO_CONST char* format,
                                       trio_pointer_t* args)
{
	static va_list unused;

	assert(VALID(format));

	return TrioScan((trio_pointer_t)stdin, 0, TrioInStreamFile, TrioUndoStreamFile, format, unused,
	                TrioArrayGetter, args);
}
#endif /* TRIO_FEATURE_STDIO */

/*************************************************************************
 * fscanf
 */

/**
   Scan characters from file.

   @param file File pointer.
   @param format Formatting string.
   @param ... Arguments.
   @return Number of scanned characters.
 */
#if TRIO_FEATURE_FILE
TRIO_PUBLIC int trio_fscanf TRIO_VARGS3((file, format, va_alist), FILE* file,
                                        TRIO_CONST char* format, TRIO_VA_DECL)
{
	int status;
	va_list args;

	assert(VALID(file));
	assert(VALID(format));

	TRIO_VA_START(args, format);
	status = TrioScan((trio_pointer_t)file, 0, TrioInStreamFile, TrioUndoStreamFile, format, args,
	                  NULL, NULL);
	TRIO_VA_END(args);
	return status;
}
#endif /* TRIO_FEATURE_FILE */

/**
   Scan characters from file.

   @param file File pointer.
   @param format Formatting string.
   @param args Arguments.
   @return Number of scanned characters.
 */
#if TRIO_FEATURE_FILE
TRIO_PUBLIC int trio_vfscanf TRIO_ARGS3((file, format, args), FILE* file, TRIO_CONST char* format,
                                        va_list args)
{
	assert(VALID(file));
	assert(VALID(format));

	return TrioScan((trio_pointer_t)file, 0, TrioInStreamFile, TrioUndoStreamFile, format, args,
	                NULL, NULL);
}
#endif /* TRIO_FEATURE_FILE */

/**
   Scan characters from file.

   @param file File pointer.
   @param format Formatting string.
   @param args Arguments.
   @return Number of scanned characters.
 */
#if TRIO_FEATURE_FILE
TRIO_PUBLIC int trio_fscanfv TRIO_ARGS3((file, format, args), FILE* file, TRIO_CONST char* format,
                                        trio_pointer_t* args)
{
	static va_list unused;

	assert(VALID(file));
	assert(VALID(format));

	return TrioScan((trio_pointer_t)file, 0, TrioInStreamFile, TrioUndoStreamFile, format, unused,
	                TrioArrayGetter, args);
}
#endif /* TRIO_FEATURE_FILE */

/*************************************************************************
 * dscanf
 */

/**
   Scan characters from file descriptor.

   @param fd File descriptor.
   @param format Formatting string.
   @param ... Arguments.
   @return Number of scanned characters.
 */
#if TRIO_FEATURE_FD
TRIO_PUBLIC int trio_dscanf TRIO_VARGS3((fd, format, va_alist), int fd, TRIO_CONST char* format,
                                        TRIO_VA_DECL)
{
	int status;
	va_list args;

	assert(VALID(format));

	TRIO_VA_START(args, format);
	status = TrioScan((trio_pointer_t)&fd, 0, TrioInStreamFileDescriptor, NULL, format, args, NULL,
	                  NULL);
	TRIO_VA_END(args);
	return status;
}
#endif /* TRIO_FEATURE_FD */

/**
   Scan characters from file descriptor.

   @param fd File descriptor.
   @param format Formatting string.
   @param args Arguments.
   @return Number of scanned characters.
 */
#if TRIO_FEATURE_FD
TRIO_PUBLIC int trio_vdscanf TRIO_ARGS3((fd, format, args), int fd, TRIO_CONST char* format,
                                        va_list args)
{
	assert(VALID(format));

	return TrioScan((trio_pointer_t)&fd, 0, TrioInStreamFileDescriptor, NULL, format, args, NULL,
	                NULL);
}
#endif /* TRIO_FEATURE_FD */

/**
   Scan characters from file descriptor.

   @param fd File descriptor.
   @param format Formatting string.
   @param args Arguments.
   @return Number of scanned characters.
 */
#if TRIO_FEATURE_FD
TRIO_PUBLIC int trio_dscanfv TRIO_ARGS3((fd, format, args), int fd, TRIO_CONST char* format,
                                        trio_pointer_t* args)
{
	static va_list unused;

	assert(VALID(format));

	return TrioScan((trio_pointer_t)&fd, 0, TrioInStreamFileDescriptor, NULL, format, unused,
	                TrioArrayGetter, args);
}
#endif /* TRIO_FEATURE_FD */

/*************************************************************************
 * cscanf
 */
#if TRIO_FEATURE_CLOSURE
TRIO_PUBLIC int trio_cscanf TRIO_VARGS4((stream, closure, format, va_alist), trio_instream_t stream,
                                        trio_pointer_t closure, TRIO_CONST char* format,
                                        TRIO_VA_DECL)
{
	int status;
	va_list args;
	trio_custom_t data;

	assert(VALID(stream));
	assert(VALID(format));

	TRIO_VA_START(args, format);
	data.stream.in = stream;
	data.closure = closure;
	status = TrioScan(&data, 0, TrioInStreamCustom, NULL, format, args, NULL, NULL);
	TRIO_VA_END(args);
	return status;
}
#endif /* TRIO_FEATURE_CLOSURE */

#if TRIO_FEATURE_CLOSURE
TRIO_PUBLIC int trio_vcscanf TRIO_ARGS4((stream, closure, format, args), trio_instream_t stream,
                                        trio_pointer_t closure, TRIO_CONST char* format,
                                        va_list args)
{
	trio_custom_t data;

	assert(VALID(stream));
	assert(VALID(format));

	data.stream.in = stream;
	data.closure = closure;
	return TrioScan(&data, 0, TrioInStreamCustom, NULL, format, args, NULL, NULL);
}
#endif /* TRIO_FEATURE_CLOSURE */

#if TRIO_FEATURE_CLOSURE
TRIO_PUBLIC int trio_cscanfv TRIO_ARGS4((stream, closure, format, args), trio_instream_t stream,
                                        trio_pointer_t closure, TRIO_CONST char* format,
                                        trio_pointer_t* args)
{
	static va_list unused;
	trio_custom_t data;

	assert(VALID(stream));
	assert(VALID(format));

	data.stream.in = stream;
	data.closure = closure;
	return TrioScan(&data, 0, TrioInStreamCustom, NULL, format, unused, TrioArrayGetter, args);
}
#endif /* TRIO_FEATURE_CLOSURE */

#if TRIO_FEATURE_CLOSURE && TRIO_FEATURE_ARGFUNC
TRIO_PUBLIC int trio_cscanff TRIO_ARGS5((stream, closure, format, argfunc, context),
                                        trio_instream_t stream, trio_pointer_t closure,
                                        TRIO_CONST char* format, trio_argfunc_t argfunc,
                                        trio_pointer_t context)
{
	static va_list unused;
	trio_custom_t data;

	assert(VALID(stream));
	assert(VALID(format));
	assert(VALID(argfunc));

	data.stream.in = stream;
	data.closure = closure;
	return TrioScan(&data, 0, TrioInStreamCustom, NULL, format, unused, argfunc,
	                (trio_pointer_t*)context);
}
#endif /* TRIO_FEATURE_CLOSURE && TRIO_FEATURE_ARGFUNC */

/*************************************************************************
 * sscanf
 */

/**
   Scan characters from string.

   @param buffer Input string.
   @param format Formatting string.
   @param ... Arguments.
   @return Number of scanned characters.
 */
TRIO_PUBLIC int trio_sscanf TRIO_VARGS3((buffer, format, va_alist), TRIO_CONST char* buffer,
                                        TRIO_CONST char* format, TRIO_VA_DECL)
{
	int status;
	va_list args;

	assert(VALID(buffer));
	assert(VALID(format));

	TRIO_VA_START(args, format);
	status =
	    TrioScan((trio_pointer_t)&buffer, 0, TrioInStreamString, NULL, format, args, NULL, NULL);
	TRIO_VA_END(args);
	return status;
}

/**
   Scan characters from string.

   @param buffer Input string.
   @param format Formatting string.
   @param args Arguments.
   @return Number of scanned characters.
 */
TRIO_PUBLIC int trio_vsscanf TRIO_ARGS3((buffer, format, args), TRIO_CONST char* buffer,
                                        TRIO_CONST char* format, va_list args)
{
	assert(VALID(buffer));
	assert(VALID(format));

	return TrioScan((trio_pointer_t)&buffer, 0, TrioInStreamString, NULL, format, args, NULL, NULL);
}

/**
   Scan characters from string.

   @param buffer Input string.
   @param format Formatting string.
   @param args Arguments.
   @return Number of scanned characters.
 */
TRIO_PUBLIC int trio_sscanfv TRIO_ARGS3((buffer, format, args), TRIO_CONST char* buffer,
                                        TRIO_CONST char* format, trio_pointer_t* args)
{
	static va_list unused;

	assert(VALID(buffer));
	assert(VALID(format));

	return TrioScan((trio_pointer_t)&buffer, 0, TrioInStreamString, NULL, format, unused,
	                TrioArrayGetter, args);
}

#endif /* TRIO_FEATURE_SCANF */

/** @} End of Scanf documentation module */

/*************************************************************************
 * trio_strerror
 */
TRIO_PUBLIC TRIO_CONST char* trio_strerror TRIO_ARGS1((errorcode), int errorcode)
{
#if TRIO_FEATURE_STRERR
	/* Textual versions of the error codes */
	switch (TRIO_ERROR_CODE(errorcode))
	{
		case TRIO_EOF:
			return "End of file";
		case TRIO_EINVAL:
			return "Invalid argument";
		case TRIO_ETOOMANY:
			return "Too many arguments";
		case TRIO_EDBLREF:
			return "Double reference";
		case TRIO_EGAP:
			return "Reference gap";
		case TRIO_ENOMEM:
			return "Out of memory";
		case TRIO_ERANGE:
			return "Invalid range";
		case TRIO_ECUSTOM:
			return "Custom error";
		default:
			return "Unknown";
	}
#else
	return "Unknown";
#endif
}

#ifdef _WIN32
#pragma warning(pop)
#endif
