#include "triodef.h"
#include "trio.h"
#include "triop.h"
#include "trionan.h"
#include "triostr.h"
#include <math.h>
#include <limits.h>
#include <float.h>
#include <assert.h>
#include <ctype.h>
#include <varargs.h>
#include <stddef.h>
#include <errno.h>

Include dependency graph for trio.c:

Classes
struct	trio_parameter_t

struct	trio_custom_t

struct	_trio_class_t

struct	_trio_reference_t

struct	_trio_userdef_t

Macros
#define	NDEBUG

#define	isblank(x) (((x)==32) \|\| ((x)==9))

#define	NULL 0

#define	NIL ((char)0)

#define	FALSE (1 == 0)

#define	TRUE (! FALSE)

#define	BOOLEAN_T int

#define	VALID(x) (NULL != (x))

#define	TRIO_ERROR_RETURN(x, y) (- ((x) + ((y) << 8)))

#define	TRIO_VA_LIST_PTR va_list *

#define	TRIO_VA_LIST_ADDR(l) (&(l))

#define	TRIO_VA_LIST_DEREF(l) (*(l))

#define	floorl(x) floor((double)(x))

#define	fmodl(x, y) fmod((double)(x),(double)(y))

#define	powl(x, y) pow((double)(x),(double)(y))

#define	TRIO_FABS(x) (((x) < 0.0) ? -(x) : (x))

#define	DECIMAL_DIG DBL_DIG

#define	MAX_MANTISSA_DIGITS DECIMAL_DIG

#define	MAX_EXPONENT_DIGITS 3

#define	MAX_DOUBLE_DIGITS DBL_MAX_10_EXP

#define	LDBL_DIG DBL_DIG

#define	LDBL_MANT_DIG DBL_MANT_DIG

#define	LDBL_EPSILON DBL_EPSILON

#define	MAX_CHARS_IN(x) (sizeof(x) * CHAR_BIT)

#define	POINTER_WIDTH ((sizeof("0x") - 1) + sizeof(trio_pointer_t) * CHAR_BIT / 4)

#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"

#define	isascii(x) ((unsigned int)(x) < 128)

#define	NO_GROUPING ((int)CHAR_MAX)

#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

#define	CHAR_IDENTIFIER '%'

#define	CHAR_BACKSLASH '\\'

#define	CHAR_QUOTE '\"'

#define	CHAR_ADJUST ' '

#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:]"

#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'

#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'

#define	SPECIFIER_POINTER 'p'

#define	SPECIFIER_GROUP '['

#define	SPECIFIER_UNGROUP ']'

#define	SPECIFIER_COUNT 'n'

#define	SPECIFIER_CHAR_UPPER 'C'

#define	SPECIFIER_STRING_UPPER 'S'

#define	SPECIFIER_HEXFLOAT 'a'

#define	SPECIFIER_HEXFLOAT_UPPER 'A'

#define	SPECIFIER_ERRNO 'm'

#define	SPECIFIER_BINARY 'b'

#define	SPECIFIER_BINARY_UPPER 'B'

#define	SPECIFIER_USER_DEFINED_BEGIN '<'

#define	SPECIFIER_USER_DEFINED_END '>'

#define	SPECIFIER_USER_DEFINED_SEPARATOR ':'

#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'

#define	QUALIFIER_WIDECHAR 'w'

#define	QUALIFIER_FIXED_SIZE 'I'

#define	QUALIFIER_QUOTE '\''

#define	QUALIFIER_STICKY '!'

#define	QUALIFIER_VARSIZE '&' /* This should remain undocumented */

#define	QUALIFIER_PARAM '@' /* Experimental */

#define	QUALIFIER_COLON ':' /* For scanlists */

#define	QUALIFIER_EQUAL '=' /* For scanlists */

#define	QUALIFIER_ROUNDING_UPPER 'R'

Typedefs
typedef unsigned long	trio_flags_t

typedef TRIO_SIGNED long int	trio_longlong_t

typedef unsigned long int	trio_ulonglong_t

typedef trio_longlong_t	trio_intmax_t

typedef trio_ulonglong_t	trio_uintmax_t

typedef TRIO_SIGNED char	trio_int8_t

typedef TRIO_SIGNED short	trio_int16_t

typedef TRIO_SIGNED int	trio_int32_t

typedef trio_longlong_t	trio_int64_t

typedef struct _trio_class_t	trio_class_t

typedef struct _trio_reference_t	trio_reference_t

typedef struct _trio_userdef_t	trio_userdef_t

Enumerations
enum	{ TYPE_PRINT = 1 , TYPE_SCAN = 2 , 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_ALLOC = 2 * FLAGS_WIDECHAR , FLAGS_IGNORE = 2 * FLAGS_ALLOC , 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 , FLAGS_EXCLUDE = FLAGS_SHORT , FLAGS_USER_DEFINED = FLAGS_IGNORE , FLAGS_ROUNDING = FLAGS_INTMAX_T , 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 , NO_BASE = -1 , MIN_BASE = 2 , MAX_BASE = 36 , BASE_BINARY = 2 , BASE_OCTAL = 8 , BASE_DECIMAL = 10 , BASE_HEX = 16 , MAX_PARAMETERS = 64 , MAX_CHARACTER_CLASS = UCHAR_MAX + 1 , MAX_USER_NAME = 64 , MAX_USER_DATA = 256 , MAX_LOCALE_SEPARATOR_LENGTH = MB_LEN_MAX , MAX_LOCALE_GROUPS = 64 , DYNAMIC_START_SIZE = 32 }

Functions
TRIO_PRIVATE BOOLEAN_T TrioIsQualifier	TRIO_ARGS1 ((character), TRIO_CONST char character)

TRIO_PRIVATE int TrioCalcThousandSeparatorLength	TRIO_ARGS1 ((digits), int digits)

TRIO_PRIVATE BOOLEAN_T TrioFollowedBySeparator	TRIO_ARGS1 ((position), int position)

TRIO_PRIVATE int TrioGetPosition	TRIO_ARGS2 ((format, indexPointer), TRIO_CONST char format, int indexPointer)

TRIO_PRIVATE trio_userdef_t *TrioFindNamespace	TRIO_ARGS2 ((name, prev), TRIO_CONST char name, trio_userdef_t *prev)

TRIO_PRIVATE trio_long_double_t TrioPower	TRIO_ARGS2 ((number, exponent), int number, int exponent)

TRIO_PRIVATE double TrioLogarithm	TRIO_ARGS2 ((number, base), double number, int base)

TRIO_PRIVATE double TrioLogarithmBase	TRIO_ARGS1 ((base), int base)

TRIO_PRIVATE int TrioParse	TRIO_ARGS5 ((type, format, parameters, arglist, argarray), int type, TRIO_CONST char format, trio_parameter_t parameters, TRIO_VA_LIST_PTR arglist, trio_pointer_t *argarray)

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)

TRIO_PRIVATE void TrioWriteStringCharacter	TRIO_ARGS3 ((self, ch, flags), trio_class_t *self, int ch, trio_flags_t flags)

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)

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_PRIVATE int TrioFormatProcess	TRIO_ARGS3 ((data, format, parameters), trio_class_t data, TRIO_CONST char format, trio_parameter_t *parameters)

TRIO_PRIVATE int TrioFormatRef	TRIO_ARGS4 ((reference, format, arglist, argarray), trio_reference_t reference, TRIO_CONST char format, TRIO_VA_LIST_PTR arglist, trio_pointer_t *argarray)

TRIO_PRIVATE int TrioFormat	TRIO_ARGS6 ((destination, destinationSize, OutStream, format, arglist, argarray), trio_pointer_t destination, size_t destinationSize, void(OutStream) TRIO_PROTO((trio_class_t , int)), TRIO_CONST char format, TRIO_VA_LIST_PTR arglist, trio_pointer_t argarray)

TRIO_PRIVATE void TrioOutStreamFile	TRIO_ARGS2 ((self, output), trio_class_t *self, int output)

TRIO_PUBLIC int trio_printf	TRIO_VARGS2 ((format, va_alist), TRIO_CONST char *format, TRIO_VA_DECL)

TRIO_PUBLIC int trio_vprintf	TRIO_ARGS2 ((format, args), TRIO_CONST char *format, va_list args)

TRIO_PUBLIC int trio_printfv	TRIO_ARGS2 ((format, args), TRIO_CONST char format, trio_pointer_t args)

TRIO_PUBLIC int trio_fprintf	TRIO_VARGS3 ((file, format, va_alist), FILE file, TRIO_CONST char format, TRIO_VA_DECL)

TRIO_PUBLIC int trio_vfprintf	TRIO_ARGS3 ((file, format, args), FILE file, TRIO_CONST char format, va_list args)

TRIO_PUBLIC int trio_fprintfv	TRIO_ARGS3 ((file, format, args), FILE file, TRIO_CONST char format, trio_pointer_t *args)

TRIO_PUBLIC int trio_dprintf	TRIO_VARGS3 ((fd, format, va_alist), int fd, TRIO_CONST char *format, TRIO_VA_DECL)

TRIO_PUBLIC int trio_vdprintf	TRIO_ARGS3 ((fd, format, args), int fd, TRIO_CONST char *format, va_list args)

TRIO_PUBLIC int trio_dprintfv	TRIO_ARGS3 ((fd, format, args), int fd, TRIO_CONST char format, trio_pointer_t args)

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)

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_PUBLIC int trio_cprintfv	TRIO_ARGS4 ((stream, closure, format, args), trio_outstream_t stream, trio_pointer_t closure, TRIO_CONST char format, void *args)

TRIO_PUBLIC int trio_sprintf	TRIO_VARGS3 ((buffer, format, va_alist), char buffer, TRIO_CONST char format, TRIO_VA_DECL)

TRIO_PUBLIC int trio_vsprintf	TRIO_ARGS3 ((buffer, format, args), char buffer, TRIO_CONST char format, va_list args)

TRIO_PUBLIC int trio_sprintfv	TRIO_ARGS3 ((buffer, format, args), char buffer, TRIO_CONST char format, trio_pointer_t *args)

TRIO_PUBLIC int trio_snprintf	TRIO_VARGS4 ((buffer, max, format, va_alist), char buffer, size_t max, TRIO_CONST char format, TRIO_VA_DECL)

TRIO_PUBLIC int trio_vsnprintf	TRIO_ARGS4 ((buffer, max, format, args), char buffer, size_t max, TRIO_CONST char format, va_list args)

TRIO_PUBLIC int trio_snprintfv	TRIO_ARGS4 ((buffer, max, format, args), char buffer, size_t max, TRIO_CONST char format, trio_pointer_t *args)

TRIO_PUBLIC int trio_asprintf	TRIO_VARGS3 ((result, format, va_alist), char *result, TRIO_CONST char format, TRIO_VA_DECL)

TRIO_PUBLIC int trio_vasprintf	TRIO_ARGS3 ((result, format, args), char *result, TRIO_CONST char format, va_list args)

TRIO_PUBLIC trio_pointer_t trio_register	TRIO_ARGS2 ((callback, name), trio_callback_t callback, TRIO_CONST char *name)

void trio_unregister	TRIO_ARGS1 ((handle), trio_pointer_t handle)

TRIO_CONST char *trio_get_format	TRIO_ARGS1 ((ref), trio_pointer_t ref)

void trio_set_width	TRIO_ARGS2 ((ref, width), trio_pointer_t ref, int width)

void trio_set_precision	TRIO_ARGS2 ((ref, precision), trio_pointer_t ref, int precision)

void trio_set_base	TRIO_ARGS2 ((ref, base), trio_pointer_t ref, int base)

void trio_set_long	TRIO_ARGS2 ((ref, is_long), trio_pointer_t ref, int is_long)

void trio_set_longlong	TRIO_ARGS2 ((ref, is_longlong), trio_pointer_t ref, int is_longlong)

void trio_set_longdouble	TRIO_ARGS2 ((ref, is_longdouble), trio_pointer_t ref, int is_longdouble)

void trio_set_short	TRIO_ARGS2 ((ref, is_short), trio_pointer_t ref, int is_short)

void trio_set_shortshort	TRIO_ARGS2 ((ref, is_shortshort), trio_pointer_t ref, int is_shortshort)

void trio_set_alternative	TRIO_ARGS2 ((ref, is_alternative), trio_pointer_t ref, int is_alternative)

void trio_set_alignment	TRIO_ARGS2 ((ref, is_leftaligned), trio_pointer_t ref, int is_leftaligned)

void trio_set_spacing	TRIO_ARGS2 ((ref, is_space), trio_pointer_t ref, int is_space)

void trio_set_sign	TRIO_ARGS2 ((ref, is_sign), trio_pointer_t ref, int is_sign)

void trio_set_padding	TRIO_ARGS2 ((ref, is_padding), trio_pointer_t ref, int is_padding)

void trio_set_quote	TRIO_ARGS2 ((ref, is_quote), trio_pointer_t ref, int is_quote)

void trio_set_upper	TRIO_ARGS2 ((ref, is_upper), trio_pointer_t ref, int is_upper)

void trio_set_largest	TRIO_ARGS2 ((ref, is_largest), trio_pointer_t ref, int is_largest)

void trio_set_ptrdiff	TRIO_ARGS2 ((ref, is_ptrdiff), trio_pointer_t ref, int is_ptrdiff)

void trio_set_size	TRIO_ARGS2 ((ref, is_size), trio_pointer_t ref, int is_size)

void trio_print_int	TRIO_ARGS2 ((ref, number), trio_pointer_t ref, int number)

void trio_print_uint	TRIO_ARGS2 ((ref, number), trio_pointer_t ref, unsigned int number)

void trio_print_double	TRIO_ARGS2 ((ref, number), trio_pointer_t ref, double number)

void trio_print_string	TRIO_ARGS2 ((ref, string), trio_pointer_t ref, char *string)

int trio_print_ref	TRIO_VARGS3 ((ref, format, va_alist), trio_pointer_t ref, TRIO_CONST char *format, TRIO_VA_DECL)

int trio_vprint_ref	TRIO_ARGS3 ((ref, format, arglist), trio_pointer_t ref, TRIO_CONST char *format, va_list arglist)

int trio_printv_ref	TRIO_ARGS3 ((ref, format, argarray), trio_pointer_t ref, TRIO_CONST char format, trio_pointer_t argarray)

void trio_print_pointer	TRIO_ARGS2 ((ref, pointer), trio_pointer_t ref, trio_pointer_t pointer)

TRIO_PUBLIC void trio_locale_set_decimal_point	TRIO_ARGS1 ((decimalPoint), char *decimalPoint)

TRIO_PUBLIC void trio_locale_set_thousand_separator	TRIO_ARGS1 ((thousandSeparator), char *thousandSeparator)

TRIO_PUBLIC void trio_locale_set_grouping	TRIO_ARGS1 ((grouping), char *grouping)

TRIO_PRIVATE int TrioSkipWhitespaces	TRIO_ARGS1 ((self), trio_class_t *self)

TRIO_PRIVATE void	TrioGetCollation (TRIO_NOARGS)

TRIO_PRIVATE int TrioGetCharacterClass	TRIO_ARGS4 ((format, indexPointer, flagsPointer, characterclass), TRIO_CONST char format, int indexPointer, trio_flags_t flagsPointer, int characterclass)

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_PRIVATE int TrioReadChar	TRIO_ARGS4 ((self, target, flags, width), trio_class_t self, char target, trio_flags_t flags, int width)

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)

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)

TRIO_PRIVATE BOOLEAN_T TrioReadPointer	TRIO_ARGS3 ((self, target, flags), trio_class_t self, trio_pointer_t target, trio_flags_t flags)

TRIO_PRIVATE int TrioScan	TRIO_ARGS6 ((source, sourceSize, InStream, format, arglist, argarray), trio_pointer_t source, size_t sourceSize, void(InStream) TRIO_PROTO((trio_class_t , int )), TRIO_CONST char format, TRIO_VA_LIST_PTR arglist, trio_pointer_t *argarray)

TRIO_PRIVATE void TrioInStreamFile	TRIO_ARGS2 ((self, intPointer), trio_class_t self, int intPointer)

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)

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_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)

TRIO_PUBLIC int trio_sscanf	TRIO_VARGS3 ((buffer, format, va_alist), TRIO_CONST char buffer, TRIO_CONST char format, TRIO_VA_DECL)

TRIO_PUBLIC int trio_vsscanf	TRIO_ARGS3 ((buffer, format, args), TRIO_CONST char buffer, TRIO_CONST char format, va_list args)

TRIO_PUBLIC int trio_sscanfv	TRIO_ARGS3 ((buffer, format, args), TRIO_CONST char buffer, TRIO_CONST char format, trio_pointer_t *args)

TRIO_PUBLIC TRIO_CONST char *trio_strerror	TRIO_ARGS1 ((errorcode), int errorcode)

Variables
static TRIO_CONST char	rcsid [] = "@(#)$Id$"

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

static int	internalDecimalPointLength = 1

static int	internalThousandSeparatorLength = 1

static char	internalDecimalPoint = '.'

static char	internalDecimalPointString [MAX_LOCALE_SEPARATOR_LENGTH+1] = "."

static char	internalThousandSeparator [MAX_LOCALE_SEPARATOR_LENGTH+1] = ","

static char	internalGrouping [MAX_LOCALE_GROUPS] = { (char)NO_GROUPING }

static TRIO_CONST char	internalDigitsLower [] = "0123456789abcdefghijklmnopqrstuvwxyz"

static TRIO_CONST char	internalDigitsUpper [] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"

static BOOLEAN_T	internalDigitsUnconverted = TRUE

static int	internalDigitArray [128]

static BOOLEAN_T	internalCollationUnconverted = TRUE

static char	internalCollationArray [MAX_CHARACTER_CLASS][MAX_CHARACTER_CLASS]

static TRIO_VOLATILE trio_callback_t	internalEnterCriticalRegion = NULL

static TRIO_VOLATILE trio_callback_t	internalLeaveCriticalRegion = NULL

static trio_userdef_t *	internalUserDef = NULL

Macro Definition Documentation

◆ BOOLEAN_T

#define BOOLEAN_T int

Definition at line 111 of file trio.c.

◆ CHAR_ADJUST

#define CHAR_ADJUST ' '

Definition at line 429 of file trio.c.

◆ CHAR_BACKSLASH

#define CHAR_BACKSLASH '\\'

Definition at line 427 of file trio.c.

◆ CHAR_IDENTIFIER

#define CHAR_IDENTIFIER '%'

Definition at line 426 of file trio.c.

◆ CHAR_QUOTE

#define CHAR_QUOTE '\"'

Definition at line 428 of file trio.c.

◆ CLASS_ALNUM

#define CLASS_ALNUM "[:alnum:]"

Definition at line 432 of file trio.c.

◆ CLASS_ALPHA

#define CLASS_ALPHA "[:alpha:]"

Definition at line 433 of file trio.c.

◆ CLASS_BLANK

#define CLASS_BLANK "[:blank:]"

Definition at line 434 of file trio.c.

◆ CLASS_CNTRL

#define CLASS_CNTRL "[:cntrl:]"

Definition at line 435 of file trio.c.

◆ CLASS_DIGIT

#define CLASS_DIGIT "[:digit:]"

Definition at line 436 of file trio.c.

◆ CLASS_GRAPH

#define CLASS_GRAPH "[:graph:]"

Definition at line 437 of file trio.c.

◆ CLASS_LOWER

#define CLASS_LOWER "[:lower:]"

Definition at line 438 of file trio.c.

◆ CLASS_PRINT

#define CLASS_PRINT "[:print:]"

Definition at line 439 of file trio.c.

◆ CLASS_PUNCT

#define CLASS_PUNCT "[:punct:]"

Definition at line 440 of file trio.c.

◆ CLASS_SPACE

#define CLASS_SPACE "[:space:]"

Definition at line 441 of file trio.c.

◆ CLASS_UPPER

#define CLASS_UPPER "[:upper:]"

Definition at line 442 of file trio.c.

◆ CLASS_XDIGIT

#define CLASS_XDIGIT "[:xdigit:]"

Definition at line 443 of file trio.c.

◆ DECIMAL_DIG

#define DECIMAL_DIG DBL_DIG

Definition at line 285 of file trio.c.

◆ FALSE

#define FALSE (1 == 0)

Definition at line 108 of file trio.c.

◆ floorl

#define floorl ( x ) floor((double)(x))

Definition at line 273 of file trio.c.

◆ fmodl

#define fmodl	(	x,
		y
	)	fmod((double)(x),(double)(y))

Definition at line 274 of file trio.c.

◆ FORMAT_CHAR

#define FORMAT_CHAR 3

Definition at line 412 of file trio.c.

◆ FORMAT_COUNT

#define FORMAT_COUNT 6

Definition at line 415 of file trio.c.

◆ FORMAT_DOUBLE

#define FORMAT_DOUBLE 2

Definition at line 411 of file trio.c.

◆ FORMAT_ERRNO

#define FORMAT_ERRNO 9

Definition at line 419 of file trio.c.

◆ FORMAT_GROUP

#define FORMAT_GROUP 8

Definition at line 417 of file trio.c.

◆ FORMAT_INT

#define FORMAT_INT 1

Definition at line 410 of file trio.c.

◆ FORMAT_PARAMETER

#define FORMAT_PARAMETER 7

Definition at line 416 of file trio.c.

◆ FORMAT_POINTER

#define FORMAT_POINTER 5

Definition at line 414 of file trio.c.

◆ FORMAT_STRING

#define FORMAT_STRING 4

Definition at line 413 of file trio.c.

◆ FORMAT_UNKNOWN

#define FORMAT_UNKNOWN 0

Definition at line 409 of file trio.c.

◆ FORMAT_USER_DEFINED

#define FORMAT_USER_DEFINED 10

Definition at line 422 of file trio.c.

◆ INFINITE_LOWER

#define INFINITE_LOWER "inf"

Definition at line 314 of file trio.c.

◆ INFINITE_UPPER

#define INFINITE_UPPER "INF"

Definition at line 315 of file trio.c.

◆ isascii

#define isascii ( x ) ((unsigned int)(x) < 128)

Definition at line 323 of file trio.c.

◆ isblank

#define isblank ( x ) (((x)==32) || ((x)==9))

Definition at line 93 of file trio.c.

◆ LDBL_DIG

#define LDBL_DIG DBL_DIG

Definition at line 303 of file trio.c.

◆ LDBL_EPSILON

#define LDBL_EPSILON DBL_EPSILON

Definition at line 305 of file trio.c.

◆ LDBL_MANT_DIG

#define LDBL_MANT_DIG DBL_MANT_DIG

Definition at line 304 of file trio.c.

◆ LONG_INFINITE_LOWER

#define LONG_INFINITE_LOWER "infinite"

Definition at line 316 of file trio.c.

◆ LONG_INFINITE_UPPER

#define LONG_INFINITE_UPPER "INFINITE"

Definition at line 317 of file trio.c.

◆ MAX_CHARS_IN

#define MAX_CHARS_IN ( x ) (sizeof(x) * CHAR_BIT)

Definition at line 309 of file trio.c.

◆ MAX_DOUBLE_DIGITS

#define MAX_DOUBLE_DIGITS DBL_MAX_10_EXP

Definition at line 296 of file trio.c.

◆ MAX_EXPONENT_DIGITS

#define MAX_EXPONENT_DIGITS 3

Definition at line 295 of file trio.c.

◆ MAX_MANTISSA_DIGITS

#define MAX_MANTISSA_DIGITS DECIMAL_DIG

Definition at line 294 of file trio.c.

◆ NAN_LOWER

#define NAN_LOWER "nan"

Definition at line 318 of file trio.c.

◆ NAN_UPPER

#define NAN_UPPER "NAN"

Definition at line 319 of file trio.c.

◆ NDEBUG

#define NDEBUG

Definition at line 87 of file trio.c.

◆ NIL

#define NIL ((char)0)

Definition at line 106 of file trio.c.

◆ NO_GROUPING

#define NO_GROUPING ((int)CHAR_MAX)

Definition at line 406 of file trio.c.

◆ NULL

#define NULL 0

Definition at line 104 of file trio.c.

◆ POINTER_WIDTH

#define POINTER_WIDTH ((sizeof("0x") - 1) + sizeof(trio_pointer_t) * CHAR_BIT / 4)

Definition at line 311 of file trio.c.

◆ powl

#define powl	(	x,
		y
	)	pow((double)(x),(double)(y))

Definition at line 275 of file trio.c.

◆ QUALIFIER_ALTERNATIVE

#define QUALIFIER_ALTERNATIVE '#'

Definition at line 607 of file trio.c.

◆ QUALIFIER_CIRCUMFLEX

#define QUALIFIER_CIRCUMFLEX '^' /* For scanlists */

Definition at line 613 of file trio.c.

◆ QUALIFIER_COLON

#define QUALIFIER_COLON ':' /* For scanlists */

Definition at line 636 of file trio.c.

◆ QUALIFIER_DOT

#define QUALIFIER_DOT '.'

Definition at line 611 of file trio.c.

◆ QUALIFIER_EQUAL

#define QUALIFIER_EQUAL '=' /* For scanlists */

Definition at line 637 of file trio.c.

◆ QUALIFIER_FIXED_SIZE

#define QUALIFIER_FIXED_SIZE 'I'

Definition at line 629 of file trio.c.

◆ QUALIFIER_INTMAX_T

#define QUALIFIER_INTMAX_T 'j'

Definition at line 617 of file trio.c.

◆ QUALIFIER_LONG

#define QUALIFIER_LONG 'l'

Definition at line 605 of file trio.c.

◆ QUALIFIER_LONG_UPPER

#define QUALIFIER_LONG_UPPER 'L'

Definition at line 606 of file trio.c.

◆ QUALIFIER_MINUS

#define QUALIFIER_MINUS '-'

Definition at line 610 of file trio.c.

◆ QUALIFIER_PARAM

#define QUALIFIER_PARAM '@' /* Experimental */

Definition at line 635 of file trio.c.

◆ QUALIFIER_PLUS

#define QUALIFIER_PLUS '+'

Definition at line 609 of file trio.c.

◆ QUALIFIER_POSITION

#define QUALIFIER_POSITION '$'

Definition at line 603 of file trio.c.

◆ QUALIFIER_PTRDIFF_T

#define QUALIFIER_PTRDIFF_T 't'

Definition at line 616 of file trio.c.

◆ QUALIFIER_QUAD

#define QUALIFIER_QUAD 'q'

Definition at line 620 of file trio.c.

◆ QUALIFIER_QUOTE

#define QUALIFIER_QUOTE '\''

Definition at line 632 of file trio.c.

◆ QUALIFIER_ROUNDING_UPPER

#define QUALIFIER_ROUNDING_UPPER 'R'

Definition at line 638 of file trio.c.

◆ QUALIFIER_SHORT

#define QUALIFIER_SHORT 'h'

Definition at line 604 of file trio.c.

◆ QUALIFIER_SIZE_T

#define QUALIFIER_SIZE_T 'z'

Definition at line 615 of file trio.c.

◆ QUALIFIER_SIZE_T_UPPER

#define QUALIFIER_SIZE_T_UPPER 'Z'

Definition at line 623 of file trio.c.

◆ QUALIFIER_SPACE

#define QUALIFIER_SPACE ' '

Definition at line 608 of file trio.c.

◆ QUALIFIER_STAR

#define QUALIFIER_STAR '*'

Definition at line 612 of file trio.c.

◆ QUALIFIER_STICKY

#define QUALIFIER_STICKY '!'

Definition at line 633 of file trio.c.

◆ QUALIFIER_VARSIZE

#define QUALIFIER_VARSIZE '&' /* This should remain undocumented */

Definition at line 634 of file trio.c.

◆ QUALIFIER_WIDECHAR

#define QUALIFIER_WIDECHAR 'w'

Definition at line 626 of file trio.c.

◆ SPECIFIER_BINARY

#define SPECIFIER_BINARY 'b'

Definition at line 507 of file trio.c.

◆ SPECIFIER_BINARY_UPPER

#define SPECIFIER_BINARY_UPPER 'B'

Definition at line 508 of file trio.c.

◆ SPECIFIER_CHAR

#define SPECIFIER_CHAR 'c'

Definition at line 477 of file trio.c.

◆ SPECIFIER_CHAR_UPPER

#define SPECIFIER_CHAR_UPPER 'C'

Definition at line 496 of file trio.c.

◆ SPECIFIER_COUNT

#define SPECIFIER_COUNT 'n'

Definition at line 494 of file trio.c.

◆ SPECIFIER_DECIMAL

#define SPECIFIER_DECIMAL 'd'

Definition at line 479 of file trio.c.

◆ SPECIFIER_ERRNO

#define SPECIFIER_ERRNO 'm'

Definition at line 504 of file trio.c.

◆ SPECIFIER_FLOAT_E

#define SPECIFIER_FLOAT_E 'e'

Definition at line 485 of file trio.c.

◆ SPECIFIER_FLOAT_E_UPPER

#define SPECIFIER_FLOAT_E_UPPER 'E'

Definition at line 486 of file trio.c.

◆ SPECIFIER_FLOAT_F

#define SPECIFIER_FLOAT_F 'f'

Definition at line 487 of file trio.c.

◆ SPECIFIER_FLOAT_F_UPPER

#define SPECIFIER_FLOAT_F_UPPER 'F'

Definition at line 488 of file trio.c.

◆ SPECIFIER_FLOAT_G

#define SPECIFIER_FLOAT_G 'g'

Definition at line 489 of file trio.c.

◆ SPECIFIER_FLOAT_G_UPPER

#define SPECIFIER_FLOAT_G_UPPER 'G'

Definition at line 490 of file trio.c.

◆ SPECIFIER_GROUP

#define SPECIFIER_GROUP '['

Definition at line 492 of file trio.c.

◆ SPECIFIER_HEX

#define SPECIFIER_HEX 'x'

Definition at line 483 of file trio.c.

◆ SPECIFIER_HEX_UPPER

#define SPECIFIER_HEX_UPPER 'X'

Definition at line 484 of file trio.c.

◆ SPECIFIER_HEXFLOAT

#define SPECIFIER_HEXFLOAT 'a'

Definition at line 500 of file trio.c.

◆ SPECIFIER_HEXFLOAT_UPPER

#define SPECIFIER_HEXFLOAT_UPPER 'A'

Definition at line 501 of file trio.c.

◆ SPECIFIER_INTEGER

#define SPECIFIER_INTEGER 'i'

Definition at line 480 of file trio.c.

◆ SPECIFIER_OCTAL

#define SPECIFIER_OCTAL 'o'

Definition at line 482 of file trio.c.

◆ SPECIFIER_POINTER

#define SPECIFIER_POINTER 'p'

Definition at line 491 of file trio.c.

◆ SPECIFIER_STRING

#define SPECIFIER_STRING 's'

Definition at line 478 of file trio.c.

◆ SPECIFIER_STRING_UPPER

#define SPECIFIER_STRING_UPPER 'S'

Definition at line 497 of file trio.c.

◆ SPECIFIER_UNGROUP

#define SPECIFIER_UNGROUP ']'

Definition at line 493 of file trio.c.

◆ SPECIFIER_UNSIGNED

#define SPECIFIER_UNSIGNED 'u'

Definition at line 481 of file trio.c.

◆ SPECIFIER_USER_DEFINED_BEGIN

#define SPECIFIER_USER_DEFINED_BEGIN '<'

Definition at line 509 of file trio.c.

◆ SPECIFIER_USER_DEFINED_END

#define SPECIFIER_USER_DEFINED_END '>'

Definition at line 510 of file trio.c.

◆ SPECIFIER_USER_DEFINED_SEPARATOR

#define SPECIFIER_USER_DEFINED_SEPARATOR ':'

Definition at line 511 of file trio.c.

◆ TRIO_ERROR_RETURN

#define TRIO_ERROR_RETURN	(	x,
		y
	)	(- ((x) + ((y) << 8)))

Definition at line 121 of file trio.c.

◆ TRIO_FABS

#define TRIO_FABS ( x ) (((x) < 0.0) ? -(x) : (x))

Definition at line 278 of file trio.c.

◆ TRIO_VA_LIST_ADDR

#define TRIO_VA_LIST_ADDR ( l ) (&(l))

Definition at line 128 of file trio.c.

◆ TRIO_VA_LIST_DEREF

#define TRIO_VA_LIST_DEREF ( l ) (*(l))

Definition at line 129 of file trio.c.

◆ TRIO_VA_LIST_PTR

#define TRIO_VA_LIST_PTR va_list *

Definition at line 127 of file trio.c.

◆ TRUE

#define TRUE (! FALSE)

Definition at line 109 of file trio.c.

◆ VALID

#define VALID ( x ) (NULL != (x))

Definition at line 114 of file trio.c.

Typedef Documentation

◆ trio_class_t

typedef struct _trio_class_t trio_class_t

◆ trio_flags_t

typedef unsigned long trio_flags_t

Definition at line 136 of file trio.c.

◆ trio_int16_t

typedef TRIO_SIGNED short trio_int16_t

Definition at line 256 of file trio.c.

◆ trio_int32_t

typedef TRIO_SIGNED int trio_int32_t

Definition at line 261 of file trio.c.

◆ trio_int64_t

typedef trio_longlong_t trio_int64_t

Definition at line 266 of file trio.c.

◆ trio_int8_t

typedef TRIO_SIGNED char trio_int8_t

Definition at line 251 of file trio.c.

◆ trio_intmax_t

typedef trio_longlong_t trio_intmax_t

Definition at line 246 of file trio.c.

◆ trio_longlong_t

typedef TRIO_SIGNED long int trio_longlong_t

Definition at line 213 of file trio.c.

◆ trio_reference_t

typedef struct _trio_reference_t trio_reference_t

◆ trio_uintmax_t

typedef trio_ulonglong_t trio_uintmax_t

Definition at line 247 of file trio.c.

◆ trio_ulonglong_t

typedef unsigned long int trio_ulonglong_t

Definition at line 214 of file trio.c.

◆ trio_userdef_t

typedef struct _trio_userdef_t trio_userdef_t

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
TYPE_PRINT
TYPE_SCAN
FLAGS_NEW
FLAGS_STICKY
FLAGS_SPACE
FLAGS_SHOWSIGN
FLAGS_LEFTADJUST
FLAGS_ALTERNATIVE
FLAGS_SHORT
FLAGS_SHORTSHORT
FLAGS_LONG
FLAGS_QUAD
FLAGS_LONGDOUBLE
FLAGS_SIZE_T
FLAGS_PTRDIFF_T
FLAGS_INTMAX_T
FLAGS_NILPADDING
FLAGS_UNSIGNED
FLAGS_UPPER
FLAGS_WIDTH
FLAGS_WIDTH_PARAMETER
FLAGS_PRECISION
FLAGS_PRECISION_PARAMETER
FLAGS_BASE
FLAGS_BASE_PARAMETER
FLAGS_FLOAT_E
FLAGS_FLOAT_G
FLAGS_QUOTE
FLAGS_WIDECHAR
FLAGS_ALLOC
FLAGS_IGNORE
FLAGS_IGNORE_PARAMETER
FLAGS_VARSIZE_PARAMETER
FLAGS_FIXED_SIZE
FLAGS_LAST
FLAGS_EXCLUDE
FLAGS_USER_DEFINED
FLAGS_ROUNDING
FLAGS_ALL_VARSIZES
FLAGS_ALL_SIZES
NO_POSITION
NO_WIDTH
NO_PRECISION
NO_SIZE
NO_BASE
MIN_BASE
MAX_BASE
BASE_BINARY
BASE_OCTAL
BASE_DECIMAL
BASE_HEX
MAX_PARAMETERS
MAX_CHARACTER_CLASS
MAX_USER_NAME
MAX_USER_DATA
MAX_LOCALE_SEPARATOR_LENGTH
MAX_LOCALE_GROUPS
DYNAMIC_START_SIZE

Definition at line 328 of file trio.c.

     {
  TYPE_PRINT = 1,
  TYPE_SCAN  = 2,
 
  /* 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_ALLOC               = 2 * FLAGS_WIDECHAR,
  FLAGS_IGNORE              = 2 * FLAGS_ALLOC,
  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_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,
 
  /* Maximal string lengths for user-defined specifiers */
  MAX_USER_NAME = 64,
  MAX_USER_DATA = 256,
 
  /* Maximal length of locale separator strings */
  MAX_LOCALE_SEPARATOR_LENGTH = MB_LEN_MAX,
  /* Maximal number of integers in grouping */
  MAX_LOCALE_GROUPS = 64,
 
  /* Initial size of asprintf buffer */
  DYNAMIC_START_SIZE = 32
};

Function Documentation

◆ TRIO_ARGS1() [1/9]

TRIO_PRIVATE double TrioLogarithmBase TRIO_ARGS1	(	(base)	,
		int	base
	)

Definition at line 1158 of file trio.c.

{
  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);
    }
}

◆ TRIO_ARGS1() [2/9]

TRIO_PRIVATE BOOLEAN_T TrioIsQualifier TRIO_ARGS1	(	(character)	,
		TRIO_CONST char	character
	)

Definition at line 817 of file trio.c.

{
  /* 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_LONG_UPPER:
    case QUALIFIER_CIRCUMFLEX:
#if defined(QUALIFIER_SIZE_T)
    case QUALIFIER_SIZE_T:
#endif
#if defined(QUALIFIER_PTRDIFF_T)
    case QUALIFIER_PTRDIFF_T:
#endif
#if defined(QUALIFIER_INTMAX_T)
    case QUALIFIER_INTMAX_T:
#endif
#if defined(QUALIFIER_QUAD)
    case QUALIFIER_QUAD:
#endif
#if defined(QUALIFIER_SIZE_T_UPPER)
    case QUALIFIER_SIZE_T_UPPER:
#endif
#if defined(QUALIFIER_WIDECHAR)
    case QUALIFIER_WIDECHAR:
#endif
#if defined(QUALIFIER_QUOTE)
    case QUALIFIER_QUOTE:
#endif
#if defined(QUALIFIER_STICKY)
    case QUALIFIER_STICKY:
#endif
#if defined(QUALIFIER_VARSIZE)
    case QUALIFIER_VARSIZE:
#endif
#if defined(QUALIFIER_PARAM)
    case QUALIFIER_PARAM:
#endif
#if defined(QUALIFIER_FIXED_SIZE)
    case QUALIFIER_FIXED_SIZE:
#endif
#if defined(QUALIFIER_ROUNDING_UPPER)
    case QUALIFIER_ROUNDING_UPPER:
#endif
      return TRUE;
    default:
      return FALSE;
    }
}

◆ TRIO_ARGS1() [3/9]

TRIO_PUBLIC void trio_locale_set_decimal_point TRIO_ARGS1	(	(decimalPoint)	,
		char *	decimalPoint
	)

Definition at line 5043 of file trio.c.

{
#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);
    }
}

◆ TRIO_ARGS1() [4/9]

TRIO_PRIVATE int TrioCalcThousandSeparatorLength TRIO_ARGS1	(	(digits)	,
		int	digits
	)

Definition at line 924 of file trio.c.

{
#if TRIO_EXTENSION
  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;
#else
  return 0;
#endif
}

◆ TRIO_ARGS1() [5/9]

TRIO_PUBLIC TRIO_CONST char *trio_strerror TRIO_ARGS1	(	(errorcode)	,
		int	errorcode
	)

Definition at line 6867 of file trio.c.

{
  /* 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";
    }
}

◆ TRIO_ARGS1() [6/9]

TRIO_PUBLIC void trio_locale_set_grouping TRIO_ARGS1	(	(grouping)	,
		char *	grouping
	)

Definition at line 5102 of file trio.c.

{
#if defined(USE_LOCALE)
  if (NULL == internalLocaleValues)
    {
      TrioSetLocale();
    }
#endif
  trio_copy_max(internalGrouping,
        sizeof(internalGrouping),
        grouping);
}

◆ TRIO_ARGS1() [7/9]

TRIO_PRIVATE BOOLEAN_T TrioFollowedBySeparator TRIO_ARGS1	(	(position)	,
		int	position
	)

Definition at line 964 of file trio.c.

{
#if TRIO_EXTENSION
  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);
#else
  return FALSE;
#endif
}

◆ TRIO_ARGS1() [8/9]

TRIO_PRIVATE int TrioSkipWhitespaces TRIO_ARGS1	(	(self)	,
		trio_class_t *	self
	)

Definition at line 5128 of file trio.c.

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

◆ TRIO_ARGS1() [9/9]

TRIO_PUBLIC void trio_locale_set_thousand_separator TRIO_ARGS1	(	(thousandSeparator)	,
		char *	thousandSeparator
	)

Definition at line 5073 of file trio.c.

{
#if defined(USE_LOCALE)
  if (NULL == internalLocaleValues)
    {
      TrioSetLocale();
    }
#endif
  trio_copy_max(internalThousandSeparator,
        sizeof(internalThousandSeparator),
        thousandSeparator);
  internalThousandSeparatorLength = trio_length(internalThousandSeparator);
}

◆ TRIO_ARGS2() [1/6]

TRIO_PRIVATE int TrioGetPosition TRIO_ARGS2	(	(format, indexPointer)	,
		TRIO_CONST char *	format,
		int *	indexPointer
	)

Definition at line 1002 of file trio.c.

{
#if TRIO_UNIX98
  char *tmpformat;
  int number = 0;
  int index = *indexPointer;
 
  number = (int)trio_to_long(&format[index], &tmpformat, BASE_DECIMAL);
  index = (int)(tmpformat - format);
  if ((number != 0) && (QUALIFIER_POSITION == format[index++]))
    {
      *indexPointer = index;
      /*
       * 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;
}

◆ TRIO_ARGS2() [2/6]

TRIO_PRIVATE trio_userdef_t *TrioFindNamespace TRIO_ARGS2	(	(name, prev)	,
		TRIO_CONST char *	name,
		trio_userdef_t **	prev
	)

Definition at line 1035 of file trio.c.

{
  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;
}

◆ TRIO_ARGS2() [3/6]

TRIO_PRIVATE double TrioLogarithm TRIO_ARGS2	(	(number, base)	,
		double	number,
		int	base
	)

Definition at line 1128 of file trio.c.

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

◆ TRIO_ARGS2() [4/6]

TRIO_PRIVATE trio_long_double_t TrioPower TRIO_ARGS2	(	(number, exponent)	,
		int	number,
		int	exponent
	)

Definition at line 1069 of file trio.c.

{
  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 = powl((trio_long_double_t)number,
            (trio_long_double_t)exponent);
      break;
    }
    }
  else
    {
      return powl((trio_long_double_t)number, (trio_long_double_t)exponent);
    }
  return result;
}

◆ TRIO_ARGS2() [5/6]

TRIO_PRIVATE void TrioInStreamString TRIO_ARGS2	(	(self, intPointer)	,
		trio_class_t *	self,
		int *	intPointer
	)

Definition at line 6430 of file trio.c.

{
  FILE *file;
 
  assert(VALID(self));
  assert(VALID(self->location));
  assert(VALID(file));
 
  file = (FILE *)self->location;
 
  self->current = fgetc(file);
  if (self->current == EOF)
    {
      self->error = (ferror(file))
    ? TRIO_ERROR_RETURN(TRIO_ERRNO, 0)
    : TRIO_ERROR_RETURN(TRIO_EOF, 0);
    }
  else
    {
      self->processed++;
      self->committed++;
    }
 
  if (VALID(intPointer))
    {
      *intPointer = self->current;
    }
}

◆ TRIO_ARGS2() [6/6]

TRIO_PRIVATE void TrioOutStreamStringDynamic TRIO_ARGS2	(	(self, output)	,
		trio_class_t *	self,
		int	output
	)

Definition at line 3468 of file trio.c.

{
  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->committed++;
    }
}

◆ TRIO_ARGS3() [1/3]

TRIO_PRIVATE int TrioScanProcess TRIO_ARGS3	(	(data, format, parameters)	,
		trio_class_t *	data,
		TRIO_CONST char *	format,
		trio_parameter_t *	parameters
	)

Definition at line 3084 of file trio.c.

{
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
  int charlen;
#endif
  int i;
  TRIO_CONST char *string;
  trio_pointer_t pointer;
  trio_flags_t flags;
  int width;
  int precision;
  int base;
  int index;
 
  index = 0;
  i = 0;
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
  (void)mblen(NULL, 0);
#endif
 
  while (format[index])
    {
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
      if (! isascii(format[index]))
    {
      charlen = mblen(&format[index], MB_LEN_MAX);
      /*
       * Only valid multibyte characters are handled here. Invalid
       * multibyte characters (charlen == -1) are handled as normal
       * characters.
       */
      if (charlen != -1)
        {
          while (charlen-- > 0)
        {
          data->OutStream(data, format[index++]);
        }
          continue; /* while characters left in formatting string */
        }
    }
#endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */
      if (CHAR_IDENTIFIER == format[index])
    {
      if (CHAR_IDENTIFIER == format[index + 1])
        {
          data->OutStream(data, CHAR_IDENTIFIER);
          index += 2;
        }
      else
        {
          /* Skip the parameter entries */
          while (parameters[i].type == FORMAT_PARAMETER)
        i++;
 
          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 */
          base = parameters[i].base;
          if (flags & FLAGS_BASE_PARAMETER)
        {
          /* Get base from parameter list */
          base = (int)parameters[base].data.number.as_signed;
        }
 
          switch (parameters[i].type)
        {
        case FORMAT_CHAR:
          if (flags & FLAGS_QUOTE)
            data->OutStream(data, CHAR_QUOTE);
          if (! (flags & FLAGS_LEFTADJUST))
            {
              while (--width > 0)
            data->OutStream(data, CHAR_ADJUST);
            }
#if TRIO_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 (flags & FLAGS_QUOTE)
            data->OutStream(data, CHAR_QUOTE);
 
          break; /* FORMAT_CHAR */
 
        case FORMAT_INT:
          TrioWriteNumber(data,
                  parameters[i].data.number.as_unsigned,
                  flags,
                  width,
                  precision,
                  base);
 
          break; /* FORMAT_INT */
 
        case FORMAT_DOUBLE:
          TrioWriteDouble(data,
                  parameters[i].data.longdoubleNumber,
                  flags,
                  width,
                  precision,
                  base);
          break; /* FORMAT_DOUBLE */
 
        case FORMAT_STRING:
#if TRIO_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->committed
               */
#if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER)
              if (flags & FLAGS_SIZE_T)
            *(size_t *)pointer = (size_t)data->committed;
              else
#endif
#if defined(QUALIFIER_PTRDIFF_T)
              if (flags & FLAGS_PTRDIFF_T)
            *(ptrdiff_t *)pointer = (ptrdiff_t)data->committed;
              else
#endif
#if defined(QUALIFIER_INTMAX_T)
              if (flags & FLAGS_INTMAX_T)
            *(trio_intmax_t *)pointer = (trio_intmax_t)data->committed;
              else
#endif
              if (flags & FLAGS_QUAD)
            {
              *(trio_ulonglong_t *)pointer = (trio_ulonglong_t)data->committed;
            }
              else if (flags & FLAGS_LONG)
            {
              *(long int *)pointer = (long int)data->committed;
            }
              else if (flags & FLAGS_SHORT)
            {
              *(short int *)pointer = (short int)data->committed;
            }
              else
            {
              *(int *)pointer = (int)data->committed;
            }
            }
          break; /* FORMAT_COUNT */
 
        case FORMAT_PARAMETER:
          break; /* FORMAT_PARAMETER */
 
#if defined(FORMAT_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 /* defined(FORMAT_ERRNO) */
 
#if defined(FORMAT_USER_DEFINED)
        case FORMAT_USER_DEFINED:
          {
            trio_reference_t reference;
            trio_userdef_t *def = NULL;
 
            if (parameters[i].user_name[0] == NIL)
              {
            /* Use handle */
            if ((i > 0) ||
                (parameters[i - 1].type == FORMAT_PARAMETER))
              def = (trio_userdef_t *)parameters[i - 1].data.pointer;
              }
            else
              {
            /* Look up namespace */
            def = TrioFindNamespace(parameters[i].user_name, NULL);
              }
            if (def) {
              reference.data = data;
              reference.parameter = &parameters[i];
              def->callback(&reference);
            }
          }
          break;
#endif /* defined(FORMAT_USER_DEFINED) */
 
        default:
          break;
        } /* switch parameter type */
 
          /* Prepare for next */
          index = parameters[i].indexAfterSpecifier;
          i++;
        }
    }
      else /* not identifier */
    {
      data->OutStream(data, format[index++]);
    }
    }
  return data->processed;
}

◆ TRIO_ARGS3() [2/3]

TRIO_PRIVATE void TrioWriteStringCharacter TRIO_ARGS3	(	(self, ch, flags)	,
		trio_class_t *	self,
		int	ch,
		trio_flags_t	flags
	)

Definition at line 2379 of file trio.c.

{
  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);
    }
}

◆ TRIO_ARGS3() [3/3]

TRIO_PRIVATE BOOLEAN_T TrioReadPointer TRIO_ARGS3	(	(self, target, flags)	,
		trio_class_t *	self,
		trio_pointer_t *	target,
		trio_flags_t	flags
	)

Definition at line 6003 of file trio.c.

{
  trio_uintmax_t number;
  char buffer[sizeof(internalNullString)];
 
  flags |= (FLAGS_UNSIGNED | FLAGS_ALTERNATIVE | FLAGS_NILPADDING);
 
  if (TrioReadNumber(self,
             &number,
             flags,
             POINTER_WIDTH,
             BASE_HEX))
    {
      /*
       * The strange assignment of number is a workaround for a compiler
       * warning
       */
      if (target)
    *target = (char *)0 + number;
      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;
}

◆ TRIO_ARGS4() [1/4]

TRIO_PRIVATE int TrioGetCharacterClass TRIO_ARGS4	(	(format, indexPointer, flagsPointer, characterclass)	,
		TRIO_CONST char *	format,
		int *	indexPointer,
		trio_flags_t *	flagsPointer,
		int *	characterclass
	)

Definition at line 5180 of file trio.c.

{
  int index = *indexPointer;
  int i;
  char ch;
  char range_begin;
  char range_end;
 
  *flagsPointer &= ~FLAGS_EXCLUDE;
 
  if (format[index] == QUALIFIER_CIRCUMFLEX)
    {
      *flagsPointer |= FLAGS_EXCLUDE;
      index++;
    }
  /*
   * 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[index] == SPECIFIER_UNGROUP)
    {
      characterclass[(int)SPECIFIER_UNGROUP]++;
      index++;
    }
  /*
   * Minus is used to specify ranges. To include minus in the class,
   * it must be at the beginning of the list
   */
  if (format[index] == QUALIFIER_MINUS)
    {
      characterclass[(int)QUALIFIER_MINUS]++;
      index++;
    }
  /* Collect characters */
  for (ch = format[index];
       (ch != SPECIFIER_UNGROUP) && (ch != NIL);
       ch = format[++index])
    {
      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[index - 1];
      range_end = format[++index];
      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, index);
      if (range_begin > range_end)
        return TRIO_ERROR_RETURN(TRIO_ERANGE, index);
 
      for (i = (int)range_begin; i <= (int)range_end; i++)
        characterclass[i]++;
 
      ch = range_end;
      break;
 
#if TRIO_EXTENSION
 
    case SPECIFIER_GROUP:
 
      switch (format[index + 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 = index + 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;
 
          index = 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 = index + 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;
 
        index = i;
          }
          break;
 
        case QUALIFIER_COLON: /* Character class expressions */
 
          if (trio_equal_max(CLASS_ALNUM, sizeof(CLASS_ALNUM) - 1,
                 &format[index]))
        {
          for (i = 0; i < MAX_CHARACTER_CLASS; i++)
            if (isalnum(i))
              characterclass[i]++;
          index += sizeof(CLASS_ALNUM) - 1;
        }
          else if (trio_equal_max(CLASS_ALPHA, sizeof(CLASS_ALPHA) - 1,
                      &format[index]))
        {
          for (i = 0; i < MAX_CHARACTER_CLASS; i++)
            if (isalpha(i))
              characterclass[i]++;
          index += sizeof(CLASS_ALPHA) - 1;
        }
          else if (trio_equal_max(CLASS_CNTRL, sizeof(CLASS_CNTRL) - 1,
                      &format[index]))
        {
          for (i = 0; i < MAX_CHARACTER_CLASS; i++)
            if (iscntrl(i))
              characterclass[i]++;
          index += sizeof(CLASS_CNTRL) - 1;
        }
          else if (trio_equal_max(CLASS_DIGIT, sizeof(CLASS_DIGIT) - 1,
                      &format[index]))
        {
          for (i = 0; i < MAX_CHARACTER_CLASS; i++)
            if (isdigit(i))
              characterclass[i]++;
          index += sizeof(CLASS_DIGIT) - 1;
        }
          else if (trio_equal_max(CLASS_GRAPH, sizeof(CLASS_GRAPH) - 1,
                      &format[index]))
        {
          for (i = 0; i < MAX_CHARACTER_CLASS; i++)
            if (isgraph(i))
              characterclass[i]++;
          index += sizeof(CLASS_GRAPH) - 1;
        }
          else if (trio_equal_max(CLASS_LOWER, sizeof(CLASS_LOWER) - 1,
                      &format[index]))
        {
          for (i = 0; i < MAX_CHARACTER_CLASS; i++)
            if (islower(i))
              characterclass[i]++;
          index += sizeof(CLASS_LOWER) - 1;
        }
          else if (trio_equal_max(CLASS_PRINT, sizeof(CLASS_PRINT) - 1,
                      &format[index]))
        {
          for (i = 0; i < MAX_CHARACTER_CLASS; i++)
            if (isprint(i))
              characterclass[i]++;
          index += sizeof(CLASS_PRINT) - 1;
        }
          else if (trio_equal_max(CLASS_PUNCT, sizeof(CLASS_PUNCT) - 1,
                      &format[index]))
        {
          for (i = 0; i < MAX_CHARACTER_CLASS; i++)
            if (ispunct(i))
              characterclass[i]++;
          index += sizeof(CLASS_PUNCT) - 1;
        }
          else if (trio_equal_max(CLASS_SPACE, sizeof(CLASS_SPACE) - 1,
                      &format[index]))
        {
          for (i = 0; i < MAX_CHARACTER_CLASS; i++)
            if (isspace(i))
              characterclass[i]++;
          index += sizeof(CLASS_SPACE) - 1;
        }
          else if (trio_equal_max(CLASS_UPPER, sizeof(CLASS_UPPER) - 1,
                      &format[index]))
        {
          for (i = 0; i < MAX_CHARACTER_CLASS; i++)
            if (isupper(i))
              characterclass[i]++;
          index += sizeof(CLASS_UPPER) - 1;
        }
          else if (trio_equal_max(CLASS_XDIGIT, sizeof(CLASS_XDIGIT) - 1,
                      &format[index]))
        {
          for (i = 0; i < MAX_CHARACTER_CLASS; i++)
            if (isxdigit(i))
              characterclass[i]++;
          index += 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;
}

◆ TRIO_ARGS4() [2/4]

TRIO_PRIVATE int TrioFormatRef TRIO_ARGS4	(	(reference, format, arglist, argarray)	,
		trio_reference_t *	reference,
		TRIO_CONST char *	format,
		TRIO_VA_LIST_PTR	arglist,
		trio_pointer_t *	argarray
	)

Definition at line 3397 of file trio.c.

{
  int status;
  trio_parameter_t parameters[MAX_PARAMETERS];
 
  status = TrioParse(TYPE_PRINT, format, parameters, arglist, argarray);
  if (status < 0)
    return status;
 
  status = TrioFormatProcess(reference->data, format, parameters);
  if (reference->data->error != 0)
    {
      status = reference->data->error;
    }
  return status;
}

◆ TRIO_ARGS4() [3/4]

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

Definition at line 5569 of file trio.c.

{
  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;
}

◆ TRIO_ARGS4() [4/4]

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
	)

Definition at line 5817 of file trio.c.

{
  int ch;
  char doubleString[512];
  int index = 0;
  int start;
  int j;
  BOOLEAN_T isHex = FALSE;
 
  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[index++] = (char)ch;
      self->InStream(self, &ch);
      width--;
    }
 
  start = index;
  switch (ch)
    {
    case 'n':
    case 'N':
      /* Not-a-number */
      if (index != 0)
    break;
      /* FALLTHROUGH */
    case 'i':
    case 'I':
      /* Infinity */
      while (isalpha(ch) && (index - start < width))
    {
      doubleString[index++] = (char)ch;
      self->InStream(self, &ch);
    }
      doubleString[index] = NIL;
 
      /* Case insensitive string comparison */
      if (trio_equal(&doubleString[start], INFINITE_UPPER) ||
      trio_equal(&doubleString[start], LONG_INFINITE_UPPER))
    {
      if (flags & FLAGS_LONGDOUBLE)
        {
          if ((start == 1) && (doubleString[0] == '-'))
        {
          *((trio_long_double_t *)target) = trio_ninf();
        }
          else
        {
          *((trio_long_double_t *)target) = trio_pinf();
        }
        }
      else
        {
          if ((start == 1) && (doubleString[0] == '-'))
        {
          *((double *)target) = trio_ninf();
        }
          else
        {
          *((double *)target) = trio_pinf();
        }
        }
      return TRUE;
    }
      if (trio_equal(doubleString, NAN_UPPER))
    {
      /* NaN must not have a preceding + nor - */
      if (flags & FLAGS_LONGDOUBLE)
        {
          *((trio_long_double_t *)target) = trio_nan();
        }
      else
        {
          *((double *)target) = trio_nan();
        }
      return TRUE;
    }
      return FALSE;
 
    case '0':
      doubleString[index++] = (char)ch;
      self->InStream(self, &ch);
      if (trio_to_upper(ch) == 'X')
    {
      isHex = TRUE;
      doubleString[index++] = (char)ch;
      self->InStream(self, &ch);
    }
      break;
 
    default:
      break;
    }
 
  while ((ch != EOF) && (index - start < width))
    {
      /* Integer part */
      if (isHex ? isxdigit(ch) : isdigit(ch))
    {
      doubleString[index++] = (char)ch;
      self->InStream(self, &ch);
    }
      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 */
    }
      else
    break; /* while */
    }
  if (ch == '.')
    {
      /* Decimal part */
      doubleString[index++] = (char)ch;
      self->InStream(self, &ch);
      while ((isHex ? isxdigit(ch) : isdigit(ch)) &&
         (index - start < width))
    {
      doubleString[index++] = (char)ch;
      self->InStream(self, &ch);
    }
      if (isHex ? (trio_to_upper(ch) == 'P') : (trio_to_upper(ch) == 'E'))
    {
      /* Exponent */
      doubleString[index++] = (char)ch;
      self->InStream(self, &ch);
      if ((ch == '+') || (ch == '-'))
        {
          doubleString[index++] = (char)ch;
          self->InStream(self, &ch);
        }
      while (isdigit(ch) && (index - start < width))
        {
          doubleString[index++] = (char)ch;
          self->InStream(self, &ch);
        }
    }
    }
 
  if ((index == start) || (*doubleString == NIL))
    return FALSE;
 
  doubleString[index] = 0;
 
  if (flags & FLAGS_LONGDOUBLE)
    {
      *((trio_long_double_t *)target) = trio_to_long_double(doubleString, NULL);
    }
  else
    {
      *((double *)target) = trio_to_double(doubleString, NULL);
    }
  return TRUE;
}

◆ TRIO_ARGS5() [1/4]

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
	)

Definition at line 2435 of file trio.c.

{
  int length;
  int ch;
 
  assert(VALID(self));
  assert(VALID(self->OutStream));
 
  if (string == NULL)
    {
      string = internalNullString;
      length = sizeof(internalNullString) - 1;
      /* Disable quoting for the null pointer */
      flags &= (~FLAGS_QUOTE);
      width = 0;
    }
  else
    {
      length = trio_length(string);
    }
  if ((NO_PRECISION != precision) &&
      (precision < length))
    {
      length = precision;
    }
  width -= length;
 
  if (flags & FLAGS_QUOTE)
    self->OutStream(self, CHAR_QUOTE);
 
  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 (flags & FLAGS_QUOTE)
    self->OutStream(self, CHAR_QUOTE);
}

◆ TRIO_ARGS5() [2/4]

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
	)

Definition at line 5778 of file trio.c.

{
  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 (target)
    target[i] = NIL;
  return TRUE;
}

◆ TRIO_ARGS5() [3/4]

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
	)

Definition at line 5439 of file trio.c.

{
  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);
 
  if (!(flags & FLAGS_UNSIGNED))
    {
      /* 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;
    }
      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 */
    }
      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_intmax_t)number) : number;
  return TRUE;
}

◆ TRIO_ARGS5() [4/4]

TRIO_PRIVATE int TrioParse TRIO_ARGS5	(	(type, format, parameters, arglist, argarray)	,
		int	type,
		TRIO_CONST char *	format,
		trio_parameter_t *	parameters,
		TRIO_VA_LIST_PTR	arglist,
		trio_pointer_t *	argarray
	)

Definition at line 1179 of file trio.c.

{
  /* Count the number of times a parameter is referenced */
  unsigned short usedEntries[MAX_PARAMETERS];
  /* Parameter counters */
  int parameterPosition;
  int currentParam;
  int maxParam = -1;
  /* Utility variables */
  trio_flags_t flags;
  int width;
  int precision;
  int varsize;
  int base;
  int index;  /* Index into formatting string */
  int dots;  /* Count number of dots in modifier part */
  BOOLEAN_T positional;  /* Does the specifier have a positional? */
  BOOLEAN_T gotSticky = FALSE;  /* Are there any sticky modifiers at all? */
  /*
   * 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 */
  char ch;
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
  int charlen;
#endif
  int save_errno;
  int i = -1;
  int num;
  char *tmpformat;
 
  /* One and only one of arglist and argarray must be used */
  assert((arglist != 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;
  index = 0;
  parameterPosition = 0;
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
  (void)mblen(NULL, 0);
#endif
 
  while (format[index])
    {
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
      if (! isascii(format[index]))
    {
      /*
       * Multibyte characters cannot be legal specifiers or
       * modifiers, so we skip over them.
       */
      charlen = mblen(&format[index], MB_LEN_MAX);
      index += (charlen > 0) ? charlen : 1;
      continue; /* while */
    }
#endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */
      if (CHAR_IDENTIFIER == format[index++])
    {
      if (CHAR_IDENTIFIER == format[index])
        {
          index++;
          continue; /* while */
        }
 
      flags = FLAGS_NEW;
      dots = 0;
      currentParam = TrioGetPosition(format, &index);
      positional = (NO_POSITION != currentParam);
      if (!positional)
        {
          /* We have no positional, get the next counter */
          currentParam = parameterPosition;
        }
          if(currentParam >= MAX_PARAMETERS)
        {
          /* Bail out completely to make the error more obvious */
          return TRIO_ERROR_RETURN(TRIO_ETOOMANY, index);
        }
 
      if (currentParam > maxParam)
        maxParam = currentParam;
 
      /* Default values */
      width = NO_WIDTH;
      precision = NO_PRECISION;
      base = NO_BASE;
      varsize = NO_SIZE;
 
      while (TrioIsQualifier(format[index]))
        {
          ch = format[index++];
 
          switch (ch)
        {
        case QUALIFIER_SPACE:
          flags |= FLAGS_SPACE;
          break;
 
        case QUALIFIER_PLUS:
          flags |= FLAGS_SHOWSIGN;
          break;
 
        case QUALIFIER_MINUS:
          flags |= FLAGS_LEFTADJUST;
          flags &= ~FLAGS_NILPADDING;
          break;
 
        case QUALIFIER_ALTERNATIVE:
          flags |= FLAGS_ALTERNATIVE;
          break;
 
        case QUALIFIER_DOT:
          if (dots == 0) /* Precision */
            {
              dots++;
 
              /* Skip if no precision */
              if (QUALIFIER_DOT == format[index])
            break;
 
              /* After the first dot we have the precision */
              flags |= FLAGS_PRECISION;
              if ((QUALIFIER_STAR == format[index])
#if defined(QUALIFIER_PARAM)
              || (QUALIFIER_PARAM == format[index])
#endif
              )
            {
              index++;
              flags |= FLAGS_PRECISION_PARAMETER;
 
              precision = TrioGetPosition(format, &index);
              if (precision == NO_POSITION)
                {
                  parameterPosition++;
                  if (positional)
                precision = parameterPosition;
                  else
                {
                  precision = currentParam;
                  currentParam = precision + 1;
                }
                }
              else
                {
                  if (! positional)
                currentParam = precision + 1;
                  if (width > maxParam)
                maxParam = precision;
                }
              if (currentParam > maxParam)
                maxParam = currentParam;
            }
              else
            {
              precision = trio_to_long(&format[index],
                           &tmpformat,
                           BASE_DECIMAL);
              index = (int)(tmpformat - format);
            }
            }
          else if (dots == 1) /* Base */
            {
              dots++;
 
              /* After the second dot we have the base */
              flags |= FLAGS_BASE;
              if ((QUALIFIER_STAR == format[index])
#if defined(QUALIFIER_PARAM)
              || (QUALIFIER_PARAM == format[index])
#endif
              )
            {
              index++;
              flags |= FLAGS_BASE_PARAMETER;
              base = TrioGetPosition(format, &index);
              if (base == NO_POSITION)
                {
                  parameterPosition++;
                  if (positional)
                base = parameterPosition;
                  else
                {
                  base = currentParam;
                  currentParam = base + 1;
                }
                }
              else
                {
                  if (! positional)
                currentParam = base + 1;
                  if (base > maxParam)
                maxParam = base;
                }
              if (currentParam > maxParam)
                maxParam = currentParam;
            }
              else
            {
              base = trio_to_long(&format[index],
                          &tmpformat,
                          BASE_DECIMAL);
              if (base > MAX_BASE)
                return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
              index = (int)(tmpformat - format);
            }
            }
          else
            {
              return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
            }
          break; /* QUALIFIER_DOT */
 
#if defined(QUALIFIER_PARAM)
        case QUALIFIER_PARAM:
          type = TYPE_PRINT;
          /* FALLTHROUGH */
#endif
        case QUALIFIER_STAR:
          /* This has different meanings for print and scan */
          if (TYPE_PRINT == type)
            {
              /* Read with from parameter */
              flags |= (FLAGS_WIDTH | FLAGS_WIDTH_PARAMETER);
              width = TrioGetPosition(format, &index);
              if (width == NO_POSITION)
            {
              parameterPosition++;
              if (positional)
                width = parameterPosition;
              else
                {
                  width = currentParam;
                  currentParam = width + 1;
                }
            }
              else
            {
              if (! positional)
                currentParam = width + 1;
              if (width > maxParam)
                maxParam = width;
            }
              if (currentParam > maxParam)
            maxParam = currentParam;
            }
          else
            {
              /* Scan, but do not store result */
              flags |= FLAGS_IGNORE;
            }
 
          break; /* QUALIFIER_STAR */
 
        case '0':
          if (! (flags & FLAGS_LEFTADJUST))
            flags |= FLAGS_NILPADDING;
          /* FALLTHROUGH */
        case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
          flags |= FLAGS_WIDTH;
          /* &format[index - 1] is used to "rewind" the read
           * character from format
           */
          width = trio_to_long(&format[index - 1],
                       &tmpformat,
                       BASE_DECIMAL);
          index = (int)(tmpformat - format);
          break;
 
        case QUALIFIER_SHORT:
          if (flags & FLAGS_SHORTSHORT)
            return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
          else if (flags & FLAGS_SHORT)
            flags |= FLAGS_SHORTSHORT;
          else
            flags |= FLAGS_SHORT;
          break;
 
        case QUALIFIER_LONG:
          if (flags & FLAGS_QUAD)
            return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
          else if (flags & FLAGS_LONG)
            flags |= FLAGS_QUAD;
          else
            flags |= FLAGS_LONG;
          break;
 
        case QUALIFIER_LONG_UPPER:
          flags |= FLAGS_LONGDOUBLE;
          break;
 
#if defined(QUALIFIER_SIZE_T)
        case QUALIFIER_SIZE_T:
          flags |= FLAGS_SIZE_T;
          /* Modify flags for later truncation of number */
          if (sizeof(size_t) == sizeof(trio_ulonglong_t))
            flags |= FLAGS_QUAD;
          else if (sizeof(size_t) == sizeof(long))
            flags |= FLAGS_LONG;
          break;
#endif
 
#if defined(QUALIFIER_PTRDIFF_T)
        case QUALIFIER_PTRDIFF_T:
          flags |= FLAGS_PTRDIFF_T;
          if (sizeof(ptrdiff_t) == sizeof(trio_ulonglong_t))
            flags |= FLAGS_QUAD;
          else if (sizeof(ptrdiff_t) == sizeof(long))
            flags |= FLAGS_LONG;
          break;
#endif
 
#if defined(QUALIFIER_INTMAX_T)
        case QUALIFIER_INTMAX_T:
          flags |= FLAGS_INTMAX_T;
          if (sizeof(trio_intmax_t) == sizeof(trio_ulonglong_t))
            flags |= FLAGS_QUAD;
          else if (sizeof(trio_intmax_t) == sizeof(long))
            flags |= FLAGS_LONG;
          break;
#endif
 
#if defined(QUALIFIER_QUAD)
        case QUALIFIER_QUAD:
          flags |= FLAGS_QUAD;
          break;
#endif
 
#if defined(QUALIFIER_FIXED_SIZE)
        case QUALIFIER_FIXED_SIZE:
          if (flags & FLAGS_FIXED_SIZE)
            return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
 
          if (flags & (FLAGS_ALL_SIZES | FLAGS_LONGDOUBLE |
                   FLAGS_WIDECHAR | FLAGS_VARSIZE_PARAMETER))
            return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
 
          if ((format[index] == '6') &&
              (format[index + 1] == '4'))
            {
              varsize = sizeof(trio_int64_t);
              index += 2;
            }
          else if ((format[index] == '3') &&
               (format[index + 1] == '2'))
            {
              varsize = sizeof(trio_int32_t);
              index += 2;
            }
          else if ((format[index] == '1') &&
               (format[index + 1] == '6'))
            {
              varsize = sizeof(trio_int16_t);
              index += 2;
            }
          else if (format[index] == '8')
            {
              varsize = sizeof(trio_int8_t);
              index++;
            }
          else
            return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
 
          flags |= FLAGS_FIXED_SIZE;
          break;
#endif
 
#if defined(QUALIFIER_WIDECHAR)
        case QUALIFIER_WIDECHAR:
          flags |= FLAGS_WIDECHAR;
          break;
#endif
 
#if defined(QUALIFIER_SIZE_T_UPPER)
        case QUALIFIER_SIZE_T_UPPER:
          break;
#endif
 
#if defined(QUALIFIER_QUOTE)
        case QUALIFIER_QUOTE:
          flags |= FLAGS_QUOTE;
          break;
#endif
 
#if defined(QUALIFIER_STICKY)
        case QUALIFIER_STICKY:
          flags |= FLAGS_STICKY;
          gotSticky = TRUE;
          break;
#endif
 
#if defined(QUALIFIER_VARSIZE)
        case QUALIFIER_VARSIZE:
          flags |= FLAGS_VARSIZE_PARAMETER;
          parameterPosition++;
          if (positional)
            varsize = parameterPosition;
          else
            {
              varsize = currentParam;
              currentParam = varsize + 1;
            }
          if (currentParam > maxParam)
            maxParam = currentParam;
          break;
#endif
 
#if defined(QUALIFIER_ROUNDING_UPPER)
        case QUALIFIER_ROUNDING_UPPER:
          flags |= FLAGS_ROUNDING;
          break;
#endif
 
        default:
          /* Bail out completely to make the error more obvious */
                  return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
        }
        } /* while qualifier */
 
      /*
       * Parameters only need the type and value. The value is
       * read later.
       */
      if (flags & FLAGS_WIDTH_PARAMETER)
        {
          usedEntries[width] += 1;
          parameters[pos].type = FORMAT_PARAMETER;
          parameters[pos].flags = 0;
          indices[width] = pos;
          width = pos++;
        }
      if (flags & FLAGS_PRECISION_PARAMETER)
        {
          usedEntries[precision] += 1;
          parameters[pos].type = FORMAT_PARAMETER;
          parameters[pos].flags = 0;
          indices[precision] = pos;
          precision = pos++;
        }
      if (flags & FLAGS_BASE_PARAMETER)
        {
          usedEntries[base] += 1;
          parameters[pos].type = FORMAT_PARAMETER;
          parameters[pos].flags = 0;
          indices[base] = pos;
          base = pos++;
        }
      if (flags & FLAGS_VARSIZE_PARAMETER)
        {
          usedEntries[varsize] += 1;
          parameters[pos].type = FORMAT_PARAMETER;
          parameters[pos].flags = 0;
          indices[varsize] = pos;
          varsize = pos++;
        }
 
      indices[currentParam] = pos;
 
      switch (format[index++])
        {
#if defined(SPECIFIER_CHAR_UPPER)
        case SPECIFIER_CHAR_UPPER:
          flags |= FLAGS_WIDECHAR;
          /* FALLTHROUGH */
#endif
        case SPECIFIER_CHAR:
          if (flags & FLAGS_LONG)
        flags |= FLAGS_WIDECHAR;
          else if (flags & FLAGS_SHORT)
        flags &= ~FLAGS_WIDECHAR;
          parameters[pos].type = FORMAT_CHAR;
          break;
 
#if defined(SPECIFIER_STRING_UPPER)
        case SPECIFIER_STRING_UPPER:
          flags |= FLAGS_WIDECHAR;
          /* FALLTHROUGH */
#endif
        case SPECIFIER_STRING:
          if (flags & FLAGS_LONG)
        flags |= FLAGS_WIDECHAR;
          else if (flags & FLAGS_SHORT)
        flags &= ~FLAGS_WIDECHAR;
          parameters[pos].type = FORMAT_STRING;
          break;
 
        case SPECIFIER_GROUP:
          if (TYPE_SCAN == type)
        {
          int depth = 1;
          parameters[pos].type = FORMAT_GROUP;
          if (format[index] == QUALIFIER_CIRCUMFLEX)
            index++;
          if (format[index] == SPECIFIER_UNGROUP)
            index++;
          if (format[index] == QUALIFIER_MINUS)
            index++;
          /* Skip nested brackets */
          while (format[index] != NIL)
            {
              if (format[index] == SPECIFIER_GROUP)
            {
              depth++;
            }
              else if (format[index] == SPECIFIER_UNGROUP)
            {
              if (--depth <= 0)
                {
                  index++;
                  break;
                }
            }
              index++;
            }
        }
          break;
 
        case SPECIFIER_INTEGER:
          parameters[pos].type = FORMAT_INT;
          break;
 
        case SPECIFIER_UNSIGNED:
          flags |= FLAGS_UNSIGNED;
          parameters[pos].type = FORMAT_INT;
          break;
 
        case SPECIFIER_DECIMAL:
          /* Disable base modifier */
          flags &= ~FLAGS_BASE_PARAMETER;
          base = BASE_DECIMAL;
          parameters[pos].type = FORMAT_INT;
          break;
 
        case SPECIFIER_OCTAL:
          flags |= FLAGS_UNSIGNED;
          flags &= ~FLAGS_BASE_PARAMETER;
          base = BASE_OCTAL;
          parameters[pos].type = FORMAT_INT;
          break;
 
#if defined(SPECIFIER_BINARY)
        case SPECIFIER_BINARY_UPPER:
          flags |= FLAGS_UPPER;
          /* FALLTHROUGH */
        case SPECIFIER_BINARY:
          flags |= FLAGS_NILPADDING;
          flags &= ~FLAGS_BASE_PARAMETER;
          base = BASE_BINARY;
          parameters[pos].type = FORMAT_INT;
          break;
#endif
 
        case SPECIFIER_HEX_UPPER:
          flags |= FLAGS_UPPER;
          /* FALLTHROUGH */
        case SPECIFIER_HEX:
          flags |= FLAGS_UNSIGNED;
          flags &= ~FLAGS_BASE_PARAMETER;
          base = BASE_HEX;
          parameters[pos].type = FORMAT_INT;
          break;
 
        case SPECIFIER_FLOAT_E_UPPER:
          flags |= FLAGS_UPPER;
          /* FALLTHROUGH */
        case SPECIFIER_FLOAT_E:
          flags |= FLAGS_FLOAT_E;
          parameters[pos].type = FORMAT_DOUBLE;
          break;
 
        case SPECIFIER_FLOAT_G_UPPER:
          flags |= FLAGS_UPPER;
          /* FALLTHROUGH */
        case SPECIFIER_FLOAT_G:
          flags |= FLAGS_FLOAT_G;
          parameters[pos].type = FORMAT_DOUBLE;
          break;
 
        case SPECIFIER_FLOAT_F_UPPER:
          flags |= FLAGS_UPPER;
          /* FALLTHROUGH */
        case SPECIFIER_FLOAT_F:
          parameters[pos].type = FORMAT_DOUBLE;
          break;
 
        case SPECIFIER_POINTER:
          if (sizeof(trio_pointer_t) == sizeof(trio_ulonglong_t))
        flags |= FLAGS_QUAD;
          else if (sizeof(trio_pointer_t) == sizeof(long))
        flags |= FLAGS_LONG;
          parameters[pos].type = FORMAT_POINTER;
          break;
 
        case SPECIFIER_COUNT:
          parameters[pos].type = FORMAT_COUNT;
          break;
 
#if defined(SPECIFIER_HEXFLOAT)
# if defined(SPECIFIER_HEXFLOAT_UPPER)
        case SPECIFIER_HEXFLOAT_UPPER:
          flags |= FLAGS_UPPER;
          /* FALLTHROUGH */
# endif
        case SPECIFIER_HEXFLOAT:
          base = BASE_HEX;
          parameters[pos].type = FORMAT_DOUBLE;
          break;
#endif
 
#if defined(FORMAT_ERRNO)
        case SPECIFIER_ERRNO:
          parameters[pos].type = FORMAT_ERRNO;
          break;
#endif
 
#if defined(SPECIFIER_USER_DEFINED_BEGIN)
        case SPECIFIER_USER_DEFINED_BEGIN:
          {
        unsigned int max;
        int without_namespace = TRUE;
 
        parameters[pos].type = FORMAT_USER_DEFINED;
        parameters[pos].user_name[0] = NIL;
        tmpformat = (char *)&format[index];
 
        while ((ch = format[index]))
          {
            index++;
            if (ch == SPECIFIER_USER_DEFINED_END)
              {
            if (without_namespace)
              {
                /* We must get the handle first */
                parameters[pos].type = FORMAT_PARAMETER;
                parameters[pos].indexAfterSpecifier = index;
                parameters[pos].flags = FLAGS_USER_DEFINED;
                /* Adjust parameters for insertion of new one */
                pos++;
                usedEntries[currentParam] += 1;
                parameters[pos].type = FORMAT_USER_DEFINED;
                currentParam++;
                indices[currentParam] = pos;
                if (currentParam > maxParam)
                  maxParam = currentParam;
              }
            /* Copy the user data */
            max = (unsigned int)(&format[index] - tmpformat);
            if (max > MAX_USER_DATA)
              max = MAX_USER_DATA;
            trio_copy_max(parameters[pos].user_data,
                      max,
                      tmpformat);
            break; /* while */
              }
            if (ch == SPECIFIER_USER_DEFINED_SEPARATOR)
              {
            without_namespace = FALSE;
            /* Copy the namespace for later looking-up */
            max = (int)(&format[index] - tmpformat);
            if (max > MAX_USER_NAME)
              max = MAX_USER_NAME;
            trio_copy_max(parameters[pos].user_name,
                      max,
                      tmpformat);
            tmpformat = (char *)&format[index];
              }
          }
        if (ch != SPECIFIER_USER_DEFINED_END)
          return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
          }
          break;
#endif /* defined(SPECIFIER_USER_DEFINED_BEGIN) */
 
        default:
          /* Bail out completely to make the error more obvious */
              return TRIO_ERROR_RETURN(TRIO_EINVAL, index);
        }
 
      /*  Count the number of times this entry has been used */
      usedEntries[currentParam] += 1;
 
      /* Find last sticky parameters */
      if (gotSticky && !(flags & FLAGS_STICKY))
        {
          for (i = pos - 1; i >= 0; i--)
        {
          if (parameters[i].type == FORMAT_PARAMETER)
            continue;
          if ((parameters[i].flags & FLAGS_STICKY) &&
              (parameters[i].type == parameters[pos].type))
            {
              /* Do not overwrite current qualifiers */
              flags |= (parameters[i].flags & (unsigned long)~FLAGS_STICKY);
              if (width == NO_WIDTH)
            width = parameters[i].width;
              if (precision == NO_PRECISION)
            precision = parameters[i].precision;
              if (base == NO_BASE)
            base = parameters[i].base;
              break;
            }
        }
        }
 
      parameters[pos].indexAfterSpecifier = index;
      parameters[pos].flags = flags;
      parameters[pos].width = width;
      parameters[pos].precision = precision;
      parameters[pos].base = (base == NO_BASE) ? BASE_DECIMAL : base;
      parameters[pos].varsize = varsize;
      pos++;
 
      if (! positional)
        parameterPosition++;
 
    } /* if identifier */
 
    } /* while format characters left */
 
  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_WIDECHAR
      if (flags & FLAGS_WIDECHAR)
        {
          parameters[i].data.wstring = (argarray == NULL)
        ? va_arg(TRIO_VA_LIST_DEREF(arglist), trio_wchar_t *)
        : (trio_wchar_t *)(argarray[num]);
        }
      else
#endif
        {
          parameters[i].data.string = (argarray == NULL)
        ? va_arg(TRIO_VA_LIST_DEREF(arglist), char *)
        : (char *)(argarray[num]);
        }
      break;
 
#if defined(FORMAT_USER_DEFINED)
    case FORMAT_USER_DEFINED:
#endif
    case FORMAT_POINTER:
    case FORMAT_COUNT:
    case FORMAT_UNKNOWN:
      parameters[i].data.pointer = (argarray == NULL)
        ? va_arg(TRIO_VA_LIST_DEREF(arglist), trio_pointer_t )
        : argarray[num];
      break;
 
    case FORMAT_CHAR:
    case FORMAT_INT:
      if (TYPE_SCAN == type)
        {
              if (argarray == NULL)
                parameters[i].data.pointer =
                  (trio_pointer_t)va_arg(TRIO_VA_LIST_DEREF(arglist), trio_pointer_t);
              else
                {
                  if (parameters[i].type == FORMAT_CHAR)
                    parameters[i].data.pointer =
                      (trio_pointer_t)((char *)argarray[num]);
                  else if (parameters[i].flags & FLAGS_SHORT)
                    parameters[i].data.pointer =
                      (trio_pointer_t)((short *)argarray[num]);
                  else
                    parameters[i].data.pointer =
                      (trio_pointer_t)((int *)argarray[num]);
                }
        }
      else
        {
#if defined(QUALIFIER_VARSIZE) || defined(QUALIFIER_FIXED_SIZE)
          if (parameters[i].flags
          & (FLAGS_VARSIZE_PARAMETER | FLAGS_FIXED_SIZE))
        {
          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 defined(QUALIFIER_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 /* defined(QUALIFIER_VARSIZE) */
#if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER)
          if (parameters[i].flags & FLAGS_SIZE_T)
        parameters[i].data.number.as_unsigned = (argarray == NULL)
          ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), size_t)
          : (trio_uintmax_t)(*((size_t *)argarray[num]));
          else
#endif
#if defined(QUALIFIER_PTRDIFF_T)
          if (parameters[i].flags & FLAGS_PTRDIFF_T)
        parameters[i].data.number.as_unsigned = (argarray == NULL)
          ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), ptrdiff_t)
          : (trio_uintmax_t)(*((ptrdiff_t *)argarray[num]));
          else
#endif
#if defined(QUALIFIER_INTMAX_T)
          if (parameters[i].flags & FLAGS_INTMAX_T)
        parameters[i].data.number.as_unsigned = (argarray == NULL)
          ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), trio_intmax_t)
          : (trio_uintmax_t)(*((trio_intmax_t *)argarray[num]));
          else
#endif
          if (parameters[i].flags & FLAGS_QUAD)
        parameters[i].data.number.as_unsigned = (argarray == NULL)
          ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), trio_ulonglong_t)
          : (trio_uintmax_t)(*((trio_ulonglong_t *)argarray[num]));
          else if (parameters[i].flags & FLAGS_LONG)
        parameters[i].data.number.as_unsigned = (argarray == NULL)
          ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), long)
          : (trio_uintmax_t)(*((long *)argarray[num]));
          else
        {
          if (argarray == NULL)
            parameters[i].data.number.as_unsigned = (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), int);
          else
            {
              if (parameters[i].type == FORMAT_CHAR)
            parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((char *)argarray[num]));
              else if (parameters[i].flags & FLAGS_SHORT)
            parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((short *)argarray[num]));
              else
            parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((int *)argarray[num]));
            }
        }
        }
      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 = (argarray == NULL)
          ? va_arg(TRIO_VA_LIST_DEREF(arglist), trio_pointer_t )
          : argarray[num];
      else
        parameters[i].data.number.as_unsigned = (argarray == NULL)
          ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), int)
          : (trio_uintmax_t)(*((int *)argarray[num]));
      break;
 
    case FORMAT_DOUBLE:
      if (TYPE_SCAN == type)
        {
          if (parameters[i].flags & FLAGS_LONGDOUBLE)
        parameters[i].data.longdoublePointer = (argarray == NULL)
          ? va_arg(TRIO_VA_LIST_DEREF(arglist), trio_long_double_t *)
          : (trio_long_double_t *)argarray[num];
          else
                {
          if (parameters[i].flags & FLAGS_LONG)
            parameters[i].data.doublePointer = (argarray == NULL)
              ? va_arg(TRIO_VA_LIST_DEREF(arglist), double *)
              : (double *)argarray[num];
          else
            parameters[i].data.doublePointer = (argarray == NULL)
              ? (double *)va_arg(TRIO_VA_LIST_DEREF(arglist), float *)
              : (double *)((float *)argarray[num]);
                }
        }
      else
        {
          if (parameters[i].flags & FLAGS_LONGDOUBLE)
        parameters[i].data.longdoubleNumber = (argarray == NULL)
          ? va_arg(TRIO_VA_LIST_DEREF(arglist), trio_long_double_t)
          : (trio_long_double_t)(*((trio_long_double_t *)argarray[num]));
          else
        {
          if (argarray == NULL)
            parameters[i].data.longdoubleNumber =
              (trio_long_double_t)va_arg(TRIO_VA_LIST_DEREF(arglist), double);
          else
            {
              if (parameters[i].flags & FLAGS_SHORT)
            parameters[i].data.longdoubleNumber =
              (trio_long_double_t)(*((float *)argarray[num]));
              else
            parameters[i].data.longdoubleNumber =
              (trio_long_double_t)(*((double *)argarray[num]));
            }
        }
        }
      break;
 
#if defined(FORMAT_ERRNO)
    case FORMAT_ERRNO:
      parameters[i].data.errorNumber = save_errno;
      break;
#endif
 
    default:
      break;
    }
    } /* for all specifiers */
  return num;
}

◆ TRIO_ARGS6() [1/4]

TRIO_PRIVATE int TrioFormat TRIO_ARGS6	(	(destination, destinationSize, OutStream, format, arglist, argarray)	,
		trio_pointer_t	destination,
		size_t	destinationSize,
		void *OutStream	TRIO_PROTO(trio_class_t *, int),
		TRIO_CONST char *	format,
		TRIO_VA_LIST_PTR	arglist,
		trio_pointer_t *	argarray
	)

Definition at line 3423 of file trio.c.

{
  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, argarray);
  if (status < 0)
    return status;
 
  status = TrioFormatProcess(&data, format, parameters);
  if (data.error != 0)
    {
      status = data.error;
    }
  return status;
}

◆ TRIO_ARGS6() [2/4]

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
	)

Definition at line 2618 of file trio.c.

{
  trio_long_double_t integerNumber;
  trio_long_double_t fractionNumber;
  trio_long_double_t workNumber;
  int integerDigits;
  int fractionDigits;
  int exponentDigits;
  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 dblIntegerBase;
  trio_long_double_t dblFractionBase;
  trio_long_double_t integerAdjust;
  trio_long_double_t fractionAdjust;
  BOOLEAN_T isNegative;
  BOOLEAN_T isExponentNegative = FALSE;
  BOOLEAN_T requireTwoDigitExponent;
  BOOLEAN_T isHex;
  TRIO_CONST char *digits;
  char *groupingPointer;
  int i;
  int index;
  BOOLEAN_T hasOnlyZeroes;
  int zeroes = 0;
  register int trailingZeroes;
  BOOLEAN_T keepTrailingZeroes;
  BOOLEAN_T keepDecimalPoint;
  trio_long_double_t epsilon;
 
  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)floor(LDBL_MANT_DIG / TrioLogarithmBase(base));
      epsilon = LDBL_EPSILON;
    }
  else if (flags & FLAGS_SHORT)
    {
      baseDigits = (base == BASE_DECIMAL)
    ? FLT_DIG
    : (int)floor(FLT_MANT_DIG / TrioLogarithmBase(base));
      epsilon = FLT_EPSILON;
    }
  else
    {
      baseDigits = (base == BASE_DECIMAL)
    ? DBL_DIG
    : (int)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 (flags & FLAGS_ROUNDING)
    precision = baseDigits;
 
  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;
 
  if (flags & FLAGS_FLOAT_G)
    {
      if (precision == 0)
    precision = 1;
 
      if ((number < 1.0E-4) || (number > powl(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 - floorl(workNumber) < 0.001)
        workNumber--;
      zeroes = (int)floorl(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)floorl(workNumber);
      number /= powl(dblBase, (trio_long_double_t)exponent);
      isExponentNegative = (exponent < 0);
      uExponent = (isExponentNegative) ? -exponent : exponent;
      if (isHex)
        uExponent *= 4; /* log16(2) */
      /* No thousand separators */
      flags &= ~FLAGS_QUOTE;
    }
    }
 
  integerNumber = floorl(number);
  fractionNumber = number - integerNumber;
 
  /*
   * Truncated number.
   *
   * Precision is number of significant digits for FLOAT_G
   * and number of fractional digits for others.
   */
  integerDigits = (integerNumber > epsilon)
    ? 1 + (int)TrioLogarithm(integerNumber, base)
    : 1;
  fractionDigits = ((flags & FLAGS_FLOAT_G) && (zeroes == 0))
    ? precision - integerDigits
    : zeroes + precision;
 
  dblFractionBase = TrioPower(base, fractionDigits);
 
  workNumber = number + 0.5 / dblFractionBase;
  if (floorl(number) != floorl(workNumber))
    {
      if (flags & FLAGS_FLOAT_E)
    {
      /* 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 + 0.5 / dblFractionBase) / dblBase;
      integerNumber = floorl(workNumber);
      fractionNumber = workNumber - integerNumber;
    }
      else
    {
      /* Adjust if number was rounded up one digit (ie. 99 to 100) */
      integerNumber = floorl(number + 0.5);
      fractionNumber = 0.0;
      integerDigits = (integerNumber > epsilon)
        ? 1 + (int)TrioLogarithm(integerNumber, base)
        : 1;
    }
    }
 
  /* Estimate accuracy */
  integerAdjust = fractionAdjust = 0.5;
  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
    {
      integerThreshold = INT_MAX;
      fractionThreshold = INT_MAX;
    }
 
  /*
   * Calculate expected width.
   *  sign + integer part + thousands separators + decimal point
   *  + fraction + exponent
   */
  fractionAdjust /= dblFractionBase;
  hasOnlyZeroes = (floorl((fractionNumber + fractionAdjust) * dblFractionBase) < epsilon);
  keepDecimalPoint = ( (flags & FLAGS_ALTERNATIVE) ||
               !((precision == 0) ||
             (!keepTrailingZeroes && hasOnlyZeroes)) );
  if (flags & FLAGS_FLOAT_E)
    {
      exponentDigits = (uExponent == 0)
    ? 1
    : (int)ceil(TrioLogarithm((double)(uExponent + 1),
                  (isHex) ? 10.0 : base));
    }
  else
    exponentDigits = 0;
  requireTwoDigitExponent = ((base == BASE_DECIMAL) && (exponentDigits == 1));
 
  expectedWidth = integerDigits + fractionDigits
    + (keepDecimalPoint
       ? internalDecimalPointLength
       : 0)
    + ((flags & FLAGS_QUOTE)
       ? TrioCalcThousandSeparatorLength(integerDigits)
       : 0);
  if (isNegative || (flags & FLAGS_SHOWSIGN) || (flags & FLAGS_SPACE))
    expectedWidth += sizeof("-") - 1;
  if (exponentDigits > 0)
    expectedWidth += exponentDigits +
      ((requireTwoDigitExponent ? sizeof("E+0") : 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 

Classes

Macros

Typedefs

Enumerations

Functions

Variables