forks
/
freerdp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity
freerdp/winpr/libwinpr/utils/trio/trio.c

7195 lines
179 KiB
C
Raw Normal View History

v2.10.0
2023-05-09 21:29:50 +00:00
/*************************************************************************
*
* $Id: trio.c,v 1.131 2010/09/12 11:08:08 breese Exp $
*
* Copyright (C) 1998, 2009 Bjorn Reese and Daniel Stenberg.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
* MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND
* CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER.
*
*************************************************************************
*
* A note to trio contributors:
*
* Avoid heap allocation at all costs to ensure that the trio functions
* are async-safe. The exceptions are the printf/fprintf functions, which
* uses fputc, and the asprintf functions and the <alloc> modifier, which
* by design are required to allocate form the heap.
*
************************************************************************/
/*
* TODO:
* - Scan is probably too permissive about its modifiers.
* - C escapes in %#[] ?
* - Multibyte characters (done for format parsing, except scan groups)
* - Complex numbers? (C99 _Complex)
* - Boolean values? (C99 _Bool)
* - C99 NaN(n-char-sequence) missing. The n-char-sequence can be used
* to print the mantissa, e.g. NaN(0xc000000000000000)
* - Should we support the GNU %a alloc modifier? GNU has an ugly hack
* for %a, because C99 used %a for other purposes. If specified as
* %as or %a[ it is interpreted as the alloc modifier, otherwise as
* the C99 hex-float. This means that you cannot scan %as as a hex-float
* immediately followed by an 's'.
* - Scanning of collating symbols.
*/
/*************************************************************************
* Trio include files
*/
#include "triodef.h"
#include "trio.h"
#include "triop.h"
#if defined(TRIO_EMBED_NAN)
#define TRIO_PUBLIC_NAN static
#if TRIO_FEATURE_FLOAT
#define TRIO_FUNC_NAN
#define TRIO_FUNC_NINF
#define TRIO_FUNC_PINF
#define TRIO_FUNC_FPCLASSIFY_AND_SIGNBIT
#define TRIO_FUNC_ISINF
#endif
#endif
#include "trionan.h"
#if defined(TRIO_EMBED_STRING)
#define TRIO_PUBLIC_STRING static
#define TRIO_FUNC_LENGTH
#define TRIO_FUNC_LENGTH_MAX
#define TRIO_FUNC_TO_LONG
#if TRIO_FEATURE_LOCALE
#define TRIO_FUNC_COPY_MAX
#endif
#if TRIO_FEATURE_DYNAMICSTRING
#define TRIO_FUNC_XSTRING_DUPLICATE
#endif
#if TRIO_EXTENSION && TRIO_FEATURE_SCANF
#define TRIO_FUNC_EQUAL_LOCALE
#endif
#if TRIO_FEATURE_ERRNO
#define TRIO_FUNC_ERROR
#endif
#if TRIO_FEATURE_FLOAT && TRIO_FEATURE_SCANF
#define TRIO_FUNC_TO_DOUBLE
#endif
#if TRIO_FEATURE_DYNAMICSTRING
#define TRIO_FUNC_STRING_EXTRACT
#endif
#if TRIO_FEATURE_DYNAMICSTRING
#define TRIO_FUNC_STRING_TERMINATE
#endif
#if TRIO_FEATURE_USER_DEFINED
#define TRIO_FUNC_DUPLICATE
#endif
#if TRIO_FEATURE_DYNAMICSTRING
#define TRIO_FUNC_STRING_DESTROY
#endif
#if TRIO_FEATURE_USER_DEFINED
#define TRIO_FUNC_DESTROY
#endif
#if TRIO_FEATURE_USER_DEFINED || (TRIO_FEATURE_FLOAT && TRIO_FEATURE_SCANF)
#define TRIO_FUNC_EQUAL
#endif
#if TRIO_FEATURE_USER_DEFINED || TRIO_FEATURE_SCANF
#define TRIO_FUNC_EQUAL_CASE
#endif
#if (TRIO_EXTENSION && TRIO_FEATURE_SCANF)
#define TRIO_FUNC_EQUAL_MAX
#endif
#if TRIO_FEATURE_SCANF
#define TRIO_FUNC_TO_UPPER
#endif
#if TRIO_FEATURE_DYNAMICSTRING
#define TRIO_FUNC_XSTRING_APPEND_CHAR
#endif
#endif
#include "triostr.h"
/**************************************************************************
*
* Definitions
*
*************************************************************************/
#include <limits.h>
#if TRIO_FEATURE_FLOAT
#include <math.h>
#include <float.h>
#endif
#if defined(__STDC_ISO_10646__) || defined(MB_LEN_MAX) || defined(USE_MULTIBYTE) || \
TRIO_FEATURE_WIDECHAR
#if (!defined(TRIO_PLATFORM_WINCE) && !defined(ANDROID))
#define TRIO_COMPILER_SUPPORTS_MULTIBYTE
#if !defined(MB_LEN_MAX)
#define MB_LEN_MAX 6
#endif
#endif
#endif
#if (TRIO_COMPILER_VISUALC - 0 >= 1100) || defined(TRIO_COMPILER_BORLAND)
#define TRIO_COMPILER_SUPPORTS_VISUALC_INT
#endif
#if TRIO_FEATURE_FLOAT
#if defined(PREDEF_STANDARD_C99) || defined(PREDEF_STANDARD_UNIX03)
#if !defined(HAVE_FLOORL) && !defined(TRIO_NO_FLOORL)
#define HAVE_FLOORL
#endif
#if !defined(HAVE_CEILL) && !defined(TRIO_NO_CEILL)
#define HAVE_CEILL
#endif
#if !defined(HAVE_POWL) && !defined(TRIO_NO_POWL)
#define HAVE_POWL
#endif
#if !defined(HAVE_FMODL) && !defined(TRIO_NO_FMODL)
#define HAVE_FMODL
#endif
#if !defined(HAVE_LOG10L) && !defined(TRIO_NO_LOG10L)
#define HAVE_LOG10L
#endif
#endif
#if defined(TRIO_COMPILER_VISUALC)
#if defined(floorl)
#define HAVE_FLOORL
#endif
#if defined(ceill)
#define HAVE_CEILL
#endif
#if defined(powl)
#define HAVE_POWL
#endif
#if defined(fmodl)
#define HAVE_FMODL
#endif
#if defined(log10l)
#define HAVE_LOG10L
#endif
#endif
#endif
/*************************************************************************
* Generic definitions
*/
#if !(defined(DEBUG) || defined(NDEBUG))
#define NDEBUG
#endif
#include <assert.h>
#include <ctype.h>
#if defined(PREDEF_STANDARD_C99) && !defined(isascii)
#define isascii(x) ((x)&0x7F)
#endif
#if defined(TRIO_COMPILER_ANCIENT)
#include <varargs.h>
#else
#include <stdarg.h>
#endif
#include <stddef.h>
#if defined(TRIO_PLATFORM_WINCE)
extern int errno;
#else
#include <errno.h>
#endif
#ifndef NULL
#define NULL 0
#endif
#define NIL ((char)0)
#ifndef FALSE
#define FALSE (1 == 0)
#define TRUE (!FALSE)
#endif
#define BOOLEAN_T int
/* mincore() can be used for debugging purposes */
#define VALID(x) (NULL != (x))
#if TRIO_FEATURE_ERRORCODE
/*
* Encode the error code and the position. This is decoded
* with TRIO_ERROR_CODE and TRIO_ERROR_POSITION.
*/
#define TRIO_ERROR_RETURN(x, y) (-((x) + ((y) << 8)))
#else
#define TRIO_ERROR_RETURN(x, y) (-1)
#endif
typedef unsigned long trio_flags_t;
/*************************************************************************
* Platform specific definitions
*/
#if defined(TRIO_PLATFORM_UNIX)
#include <unistd.h>
#include <signal.h>
#include <locale.h>
#if !defined(TRIO_FEATURE_LOCALE)
#define USE_LOCALE
#endif
#endif /* TRIO_PLATFORM_UNIX */
#if defined(TRIO_PLATFORM_VMS)
#include <unistd.h>
#endif
#if defined(TRIO_PLATFORM_WIN32)
#if defined(TRIO_PLATFORM_WINCE)
int read(int handle, char* buffer, unsigned int length);
int write(int handle, const char* buffer, unsigned int length);
#else
#include <io.h>
#define read _read
#define write _write
#endif
#endif /* TRIO_PLATFORM_WIN32 */
#if TRIO_FEATURE_WIDECHAR
#if defined(PREDEF_STANDARD_C94)
#include <wchar.h>
#include <wctype.h>
typedef wchar_t trio_wchar_t;
typedef wint_t trio_wint_t;
#else
typedef char trio_wchar_t;
typedef int trio_wint_t;
#define WCONST(x) L##x
#define WEOF EOF
#define iswalnum(x) isalnum(x)
#define iswalpha(x) isalpha(x)
#define iswcntrl(x) iscntrl(x)
#define iswdigit(x) isdigit(x)
#define iswgraph(x) isgraph(x)
#define iswlower(x) islower(x)
#define iswprint(x) isprint(x)
#define iswpunct(x) ispunct(x)
#define iswspace(x) isspace(x)
#define iswupper(x) isupper(x)
#define iswxdigit(x) isxdigit(x)
#endif
#endif
/*************************************************************************
* Compiler dependent definitions
*/
/* Support for long long */
#ifndef __cplusplus
#if !defined(USE_LONGLONG)
#if defined(TRIO_COMPILER_GCC) && !defined(__STRICT_ANSI__)
#define USE_LONGLONG
#else
#if defined(TRIO_COMPILER_SUNPRO)
#define USE_LONGLONG
#else
#if defined(TRIO_COMPILER_MSVC) && (_MSC_VER >= 1400)
#define USE_LONGLONG
#else
#if defined(_LONG_LONG) || defined(_LONGLONG)
#define USE_LONGLONG
#endif
#endif
#endif
#endif
#endif
#endif
/* The extra long numbers */
#if defined(USE_LONGLONG)
typedef signed long long int trio_longlong_t;
typedef unsigned long long int trio_ulonglong_t;
#else
#if defined(TRIO_COMPILER_SUPPORTS_VISUALC_INT)
typedef signed __int64 trio_longlong_t;
typedef unsigned __int64 trio_ulonglong_t;
#else
typedef TRIO_SIGNED long int trio_longlong_t;
typedef unsigned long int trio_ulonglong_t;
#endif
#endif
/* Maximal and fixed integer types */
#if defined(PREDEF_STANDARD_C99)
#include <stdint.h>
typedef intmax_t trio_intmax_t;
typedef uintmax_t trio_uintmax_t;
typedef int8_t trio_int8_t;
typedef int16_t trio_int16_t;
typedef int32_t trio_int32_t;
typedef int64_t trio_int64_t;
#else
#if defined(PREDEF_STANDARD_UNIX98)
#include <inttypes.h>
typedef intmax_t trio_intmax_t;
typedef uintmax_t trio_uintmax_t;
typedef int8_t trio_int8_t;
typedef int16_t trio_int16_t;
typedef int32_t trio_int32_t;
typedef int64_t trio_int64_t;
#else
#if defined(TRIO_COMPILER_SUPPORTS_VISUALC_INT)
typedef trio_longlong_t trio_intmax_t;
typedef trio_ulonglong_t trio_uintmax_t;
typedef __int8 trio_int8_t;
typedef __int16 trio_int16_t;
typedef __int32 trio_int32_t;
typedef __int64 trio_int64_t;
#else
typedef trio_longlong_t trio_intmax_t;
typedef trio_ulonglong_t trio_uintmax_t;
#if defined(TRIO_INT8_T)
typedef TRIO_INT8_T trio_int8_t;
#else
typedef TRIO_SIGNED char trio_int8_t;
#endif
#if defined(TRIO_INT16_T)
typedef TRIO_INT16_T trio_int16_t;
#else
typedef TRIO_SIGNED short trio_int16_t;
#endif
#if defined(TRIO_INT32_T)
typedef TRIO_INT32_T trio_int32_t;
#else
typedef TRIO_SIGNED int trio_int32_t;
#endif
#if defined(TRIO_INT64_T)
typedef TRIO_INT64_T trio_int64_t;
#else
typedef trio_longlong_t trio_int64_t;
#endif
#endif
#endif
#endif
#if defined(HAVE_FLOORL)
#define trio_floor(x) floorl((x))
#else
#define trio_floor(x) floor((double)(x))
#endif
#if defined(HAVE_CEILL)
#define trio_ceil(x) ceill((x))
#else
#define trio_ceil(x) ceil((double)(x))
#endif
#if defined(HAVE_FMODL)
#define trio_fmod(x, y) fmodl((x), (y))
#else
#define trio_fmod(x, y) fmod((double)(x), (double)(y))
#endif
#if defined(HAVE_POWL)
#define trio_pow(x, y) powl((x), (y))
#else
#define trio_pow(x, y) pow((double)(x), (double)(y))
#endif
#if defined(HAVE_LOG10L)
#define trio_log10(x) log10l((x))
#else
#define trio_log10(x) log10((double)(x))
#endif
#if TRIO_FEATURE_FLOAT
#define TRIO_FABS(x) (((x) < 0.0) ? -(x) : (x))
#endif
/*************************************************************************
* Internal Definitions
*/
#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable : 4244)
#endif
#if TRIO_FEATURE_FLOAT
#if !defined(DECIMAL_DIG)
#define DECIMAL_DIG DBL_DIG
#endif
/* Long double sizes */
#ifdef LDBL_DIG
#define MAX_MANTISSA_DIGITS LDBL_DIG
#define MAX_EXPONENT_DIGITS 4
#define MAX_DOUBLE_DIGITS LDBL_MAX_10_EXP
#else
#define MAX_MANTISSA_DIGITS DECIMAL_DIG
#define MAX_EXPONENT_DIGITS 3
#define MAX_DOUBLE_DIGITS DBL_MAX_10_EXP
#endif
#if defined(TRIO_COMPILER_ANCIENT) || !defined(LDBL_DIG)
#undef LDBL_DIG
#undef LDBL_MANT_DIG
#undef LDBL_EPSILON
#define LDBL_DIG DBL_DIG
#define LDBL_MANT_DIG DBL_MANT_DIG
#define LDBL_EPSILON DBL_EPSILON
#endif
#endif /* TRIO_FEATURE_FLOAT */
/* The maximal number of digits is for base 2 */
#define MAX_CHARS_IN(x) (sizeof(x) * CHAR_BIT)
/* The width of a pointer. The number of bits in a hex digit is 4 */
#define POINTER_WIDTH ((sizeof("0x") - 1) + sizeof(trio_pointer_t) * CHAR_BIT / 4)
#if TRIO_FEATURE_FLOAT
/* Infinite and Not-A-Number for floating-point */
#define INFINITE_LOWER "inf"
#define INFINITE_UPPER "INF"
#define LONG_INFINITE_LOWER "infinite"
#define LONG_INFINITE_UPPER "INFINITE"
#define NAN_LOWER "nan"
#define NAN_UPPER "NAN"
#endif
/* Various constants */
enum
{
TYPE_PRINT = 1,
#if TRIO_FEATURE_SCANF
TYPE_SCAN = 2,
#endif
/* Flags. FLAGS_LAST must be less than ULONG_MAX */
FLAGS_NEW = 0,
FLAGS_STICKY = 1,
FLAGS_SPACE = 2 * FLAGS_STICKY,
FLAGS_SHOWSIGN = 2 * FLAGS_SPACE,
FLAGS_LEFTADJUST = 2 * FLAGS_SHOWSIGN,
FLAGS_ALTERNATIVE = 2 * FLAGS_LEFTADJUST,
FLAGS_SHORT = 2 * FLAGS_ALTERNATIVE,
FLAGS_SHORTSHORT = 2 * FLAGS_SHORT,
FLAGS_LONG = 2 * FLAGS_SHORTSHORT,
FLAGS_QUAD = 2 * FLAGS_LONG,
FLAGS_LONGDOUBLE = 2 * FLAGS_QUAD,
FLAGS_SIZE_T = 2 * FLAGS_LONGDOUBLE,
FLAGS_PTRDIFF_T = 2 * FLAGS_SIZE_T,
FLAGS_INTMAX_T = 2 * FLAGS_PTRDIFF_T,
FLAGS_NILPADDING = 2 * FLAGS_INTMAX_T,
FLAGS_UNSIGNED = 2 * FLAGS_NILPADDING,
FLAGS_UPPER = 2 * FLAGS_UNSIGNED,
FLAGS_WIDTH = 2 * FLAGS_UPPER,
FLAGS_WIDTH_PARAMETER = 2 * FLAGS_WIDTH,
FLAGS_PRECISION = 2 * FLAGS_WIDTH_PARAMETER,
FLAGS_PRECISION_PARAMETER = 2 * FLAGS_PRECISION,
FLAGS_BASE = 2 * FLAGS_PRECISION_PARAMETER,
FLAGS_BASE_PARAMETER = 2 * FLAGS_BASE,
FLAGS_FLOAT_E = 2 * FLAGS_BASE_PARAMETER,
FLAGS_FLOAT_G = 2 * FLAGS_FLOAT_E,
FLAGS_QUOTE = 2 * FLAGS_FLOAT_G,
FLAGS_WIDECHAR = 2 * FLAGS_QUOTE,
FLAGS_IGNORE = 2 * FLAGS_WIDECHAR,
FLAGS_IGNORE_PARAMETER = 2 * FLAGS_IGNORE,
FLAGS_VARSIZE_PARAMETER = 2 * FLAGS_IGNORE_PARAMETER,
FLAGS_FIXED_SIZE = 2 * FLAGS_VARSIZE_PARAMETER,
FLAGS_LAST = FLAGS_FIXED_SIZE,
/* Reused flags */
FLAGS_EXCLUDE = FLAGS_SHORT,
FLAGS_USER_DEFINED = FLAGS_IGNORE,
FLAGS_USER_DEFINED_PARAMETER = FLAGS_IGNORE_PARAMETER,
FLAGS_ROUNDING = FLAGS_INTMAX_T,
/* Compounded flags */
FLAGS_ALL_VARSIZES = FLAGS_LONG | FLAGS_QUAD | FLAGS_INTMAX_T | FLAGS_PTRDIFF_T | FLAGS_SIZE_T,
FLAGS_ALL_SIZES = FLAGS_ALL_VARSIZES | FLAGS_SHORTSHORT | FLAGS_SHORT,
NO_POSITION = -1,
NO_WIDTH = 0,
NO_PRECISION = -1,
NO_SIZE = -1,
/* Do not change these */
NO_BASE = -1,
MIN_BASE = 2,
MAX_BASE = 36,
BASE_BINARY = 2,
BASE_OCTAL = 8,
BASE_DECIMAL = 10,
BASE_HEX = 16,
/* Maximal number of allowed parameters */
MAX_PARAMETERS = 64,
/* Maximal number of characters in class */
MAX_CHARACTER_CLASS = UCHAR_MAX + 1,
#if TRIO_FEATURE_USER_DEFINED
/* Maximal string lengths for user-defined specifiers */
MAX_USER_NAME = 64,
MAX_USER_DATA = 256,
#endif
/* Maximal length of locale separator strings */
MAX_LOCALE_SEPARATOR_LENGTH = MB_LEN_MAX,
/* Maximal number of integers in grouping */
MAX_LOCALE_GROUPS = 64
};
#define NO_GROUPING ((int)CHAR_MAX)
/* Fundamental formatting parameter types */
#define FORMAT_SENTINEL -1 /* marks end of parameters array */
#define FORMAT_UNKNOWN 0
#define FORMAT_INT 1
#define FORMAT_DOUBLE 2
#define FORMAT_CHAR 3
#define FORMAT_STRING 4
#define FORMAT_POINTER 5
#define FORMAT_COUNT 6
#define FORMAT_PARAMETER 7
#define FORMAT_GROUP 8
#define FORMAT_ERRNO 9
#define FORMAT_USER_DEFINED 10
/* Character constants */
#define CHAR_IDENTIFIER '%'
#define CHAR_ALT_IDENTIFIER '$'
#define CHAR_BACKSLASH '\\'
#define CHAR_QUOTE '\"'
#define CHAR_ADJUST ' '
#if TRIO_EXTENSION
/* Character class expressions */
#define CLASS_ALNUM "[:alnum:]"
#define CLASS_ALPHA "[:alpha:]"
#define CLASS_BLANK "[:blank:]"
#define CLASS_CNTRL "[:cntrl:]"
#define CLASS_DIGIT "[:digit:]"
#define CLASS_GRAPH "[:graph:]"
#define CLASS_LOWER "[:lower:]"
#define CLASS_PRINT "[:print:]"
#define CLASS_PUNCT "[:punct:]"
#define CLASS_SPACE "[:space:]"
#define CLASS_UPPER "[:upper:]"
#define CLASS_XDIGIT "[:xdigit:]"
#endif
/*
* SPECIFIERS:
*
*
* a Hex-float
* A Hex-float
* c Character
* C Widechar character (wint_t)
* d Decimal
* e Float
* E Float
* F Float
* F Float
* g Float
* G Float
* i Integer
* m Error message
* n Count
* o Octal
* p Pointer
* s String
* S Widechar string (wchar_t *)
* u Unsigned
* x Hex
* X Hex
* [] Group
* <> User-defined
*
* Reserved:
*
* D Binary Coded Decimal %D(length,precision) (OS/390)
*/
#define SPECIFIER_CHAR 'c'
#define SPECIFIER_STRING 's'
#define SPECIFIER_DECIMAL 'd'
#define SPECIFIER_INTEGER 'i'
#define SPECIFIER_UNSIGNED 'u'
#define SPECIFIER_OCTAL 'o'
#define SPECIFIER_HEX 'x'
#define SPECIFIER_HEX_UPPER 'X'
#if TRIO_FEATURE_FLOAT
#define SPECIFIER_FLOAT_E 'e'
#define SPECIFIER_FLOAT_E_UPPER 'E'
#define SPECIFIER_FLOAT_F 'f'
#define SPECIFIER_FLOAT_F_UPPER 'F'
#define SPECIFIER_FLOAT_G 'g'
#define SPECIFIER_FLOAT_G_UPPER 'G'
#endif
#define SPECIFIER_POINTER 'p'
#if TRIO_FEATURE_SCANF
#define SPECIFIER_GROUP '['
#define SPECIFIER_UNGROUP ']'
#endif
#define SPECIFIER_COUNT 'n'
#if TRIO_UNIX98
#define SPECIFIER_CHAR_UPPER 'C'
#define SPECIFIER_STRING_UPPER 'S'
#endif
#define SPECIFIER_HEXFLOAT 'a'
#define SPECIFIER_HEXFLOAT_UPPER 'A'
#define SPECIFIER_ERRNO 'm'
#if TRIO_FEATURE_BINARY
#define SPECIFIER_BINARY 'b'
#define SPECIFIER_BINARY_UPPER 'B'
#endif
#if TRIO_FEATURE_USER_DEFINED
#define SPECIFIER_USER_DEFINED_BEGIN '<'
#define SPECIFIER_USER_DEFINED_END '>'
#define SPECIFIER_USER_DEFINED_SEPARATOR ':'
#define SPECIFIER_USER_DEFINED_EXTRA '|'
#endif
/*
* QUALIFIERS:
*
*
* Numbers = d,i,o,u,x,X
* Float = a,A,e,E,f,F,g,G
* String = s
* Char = c
*
*
* 9$ Position
* Use the 9th parameter. 9 can be any number between 1 and
* the maximal argument
*
* 9 Width
* Set width to 9. 9 can be any number, but must not be postfixed
* by '$'
*
* h Short
* Numbers:
* (unsigned) short int
*
* hh Short short
* Numbers:
* (unsigned) char
*
* l Long
* Numbers:
* (unsigned) long int
* String:
* as the S specifier
* Char:
* as the C specifier
*
* ll Long Long
* Numbers:
* (unsigned) long long int
*
* L Long Double
* Float
* long double
*
* # Alternative
* Float:
* Decimal-point is always present
* String:
* non-printable characters are handled as \number
*
* Spacing
*
* + Sign
*
* - Alignment
*
* . Precision
*
* * Parameter
* print: use parameter
* scan: no parameter (ignore)
*
* q Quad
*
* Z size_t
*
* w Widechar
*
* ' Thousands/quote
* Numbers:
* Integer part grouped in thousands
* Binary numbers:
* Number grouped in nibbles (4 bits)
* String:
* Quoted string
*
* j intmax_t
* t prtdiff_t
* z size_t
*
* ! Sticky
* @ Parameter (for both print and scan)
*
* I n-bit Integer
* Numbers:
* The following options exists
* I8 = 8-bit integer
* I16 = 16-bit integer
* I32 = 32-bit integer
* I64 = 64-bit integer
*/
#define QUALIFIER_POSITION '$'
#define QUALIFIER_SHORT 'h'
#define QUALIFIER_LONG 'l'
#define QUALIFIER_LONG_UPPER 'L'
#define QUALIFIER_ALTERNATIVE '#'
#define QUALIFIER_SPACE ' '
#define QUALIFIER_PLUS '+'
#define QUALIFIER_MINUS '-'
#define QUALIFIER_DOT '.'
#define QUALIFIER_STAR '*'
#define QUALIFIER_CIRCUMFLEX '^' /* For scanlists */
#define QUALIFIER_SIZE_T 'z'
#define QUALIFIER_PTRDIFF_T 't'
#define QUALIFIER_INTMAX_T 'j'
#define QUALIFIER_QUAD 'q'
#define QUALIFIER_SIZE_T_UPPER 'Z'
#if TRIO_MISC
#define QUALIFIER_WIDECHAR 'w'
#endif
#define QUALIFIER_FIXED_SIZE 'I'
#define QUALIFIER_QUOTE '\''
#define QUALIFIER_STICKY '!'
#define QUALIFIER_VARSIZE '&' /* This should remain undocumented */
#define QUALIFIER_ROUNDING_UPPER 'R'
#if TRIO_EXTENSION
#define QUALIFIER_PARAM '@' /* Experimental */
#define QUALIFIER_COLON ':' /* For scanlists */
#define QUALIFIER_EQUAL '=' /* For scanlists */
#endif
/*************************************************************************
*
* Internal Structures
*
*************************************************************************/
/* Parameters */
typedef struct
{
/* An indication of which entry in the data union is used */
int type;
/* The flags */
trio_flags_t flags;
/* The width qualifier */
int width;
/* The precision qualifier */
int precision;
/* The base qualifier */
int base;
/* Base from specifier */
int baseSpecifier;
/* The size for the variable size qualifier */
int varsize;
/* Offset of the first character of the specifier */
int beginOffset;
/* Offset of the first character after the specifier */
int endOffset;
/* Position in the argument list that this parameter refers to */
int position;
/* The data from the argument list */
union {
char* string;
#if TRIO_FEATURE_WIDECHAR
trio_wchar_t* wstring;
#endif
trio_pointer_t pointer;
union {
trio_intmax_t as_signed;
trio_uintmax_t as_unsigned;
} number;
#if TRIO_FEATURE_FLOAT
double doubleNumber;
double* doublePointer;
trio_long_double_t longdoubleNumber;
trio_long_double_t* longdoublePointer;
#endif
int errorNumber;
} data;
#if TRIO_FEATURE_USER_DEFINED
/* For the user-defined specifier */
union {
char namespace[MAX_USER_NAME];
int handler; /* if flags & FLAGS_USER_DEFINED_PARAMETER */
} user_defined;
char user_data[MAX_USER_DATA];
#endif
} trio_parameter_t;
/* Container for customized functions */
typedef struct
{
union {
trio_outstream_t out;
trio_instream_t in;
} stream;
trio_pointer_t closure;
} trio_custom_t;
/* General trio "class" */
typedef struct _trio_class_t
{
/*
* The function to write characters to a stream.
*/
void(*OutStream) TRIO_PROTO((struct _trio_class_t*, int));
/*
* The function to read characters from a stream.
*/
void(*InStream) TRIO_PROTO((struct _trio_class_t*, int*));
/*
* The function to undo read characters from a stream.
*/
void(*UndoStream) TRIO_PROTO((struct _trio_class_t*));
/*
* The current location in the stream.
*/
trio_pointer_t location;
/*
* The character currently being processed.
*/
int current;
/*
* The number of characters that would have been written/read
* if there had been sufficient space.
*/
int processed;
union {
/*
* The number of characters that are actually written. Processed and
* committed will only differ for the *nprintf functions.
*/
int committed;
/*
* The number of look-ahead characters read.
*/
int cached;
} actually;
/*
* The upper limit of characters that may be written/read.
*/
int max;
/*
* The last output error that was detected.
*/
int error;
} trio_class_t;
/* References (for user-defined callbacks) */
typedef struct _trio_reference_t
{
trio_class_t* data;
trio_parameter_t* parameter;
} trio_reference_t;
#if TRIO_FEATURE_USER_DEFINED
/* Registered entries (for user-defined callbacks) */
typedef struct _trio_userdef_t
{
struct _trio_userdef_t* next;
trio_callback_t callback;
char* name;
} trio_userdef_t;
#endif
/*************************************************************************
*
* Internal Variables
*
*************************************************************************/
/* Unused but kept for reference */
/* static TRIO_CONST char rcsid[] = "@(#)$Id: trio.c,v 1.131 2010/09/12 11:08:08 breese Exp $"; */
#if TRIO_FEATURE_FLOAT
/*
* Need this to workaround a parser bug in HP C/iX compiler that fails
* to resolves macro definitions that includes type 'long double',
* e.g: va_arg(arg_ptr, long double)
*/
#if defined(TRIO_PLATFORM_MPEIX)
static TRIO_CONST trio_long_double_t ___dummy_long_double = 0;
#endif
#endif
static TRIO_CONST char internalNullString[] = "(nil)";
#if defined(USE_LOCALE)
static struct lconv* internalLocaleValues = NULL;
#endif
/*
* UNIX98 says "in a locale where the radix character is not defined,
* the radix character defaults to a period (.)"
*/
#if TRIO_FEATURE_FLOAT || TRIO_FEATURE_LOCALE || defined(USE_LOCALE)
static int internalDecimalPointLength = 1;
static char internalDecimalPoint = '.';
static char internalDecimalPointString[MAX_LOCALE_SEPARATOR_LENGTH + 1] = ".";
#endif
#if TRIO_FEATURE_QUOTE || TRIO_FEATURE_LOCALE || TRIO_EXTENSION
static int internalThousandSeparatorLength = 1;
static char internalThousandSeparator[MAX_LOCALE_SEPARATOR_LENGTH + 1] = ",";
static char internalGrouping[MAX_LOCALE_GROUPS] = { (char)NO_GROUPING };
#endif
static TRIO_CONST char internalDigitsLower[] = "0123456789abcdefghijklmnopqrstuvwxyz";
static TRIO_CONST char internalDigitsUpper[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
#if TRIO_FEATURE_SCANF
static BOOLEAN_T internalDigitsUnconverted = TRUE;
static int internalDigitArray[128];
#if TRIO_EXTENSION
static BOOLEAN_T internalCollationUnconverted = TRUE;
static char internalCollationArray[MAX_CHARACTER_CLASS][MAX_CHARACTER_CLASS];
#endif
#endif
#if TRIO_FEATURE_USER_DEFINED
static TRIO_VOLATILE trio_callback_t internalEnterCriticalRegion = NULL;
static TRIO_VOLATILE trio_callback_t internalLeaveCriticalRegion = NULL;
static trio_userdef_t* internalUserDef = NULL;
#endif
/*************************************************************************
*
* Internal Functions
*
************************************************************************/
#if defined(TRIO_EMBED_NAN)
#include "trionan.c"
#endif
#if defined(TRIO_EMBED_STRING)
#include "triostr.c"
#endif
/*************************************************************************
* TrioInitializeParameter
*
* Description:
* Initialize a trio_parameter_t struct.
*/
TRIO_PRIVATE void TrioInitializeParameter TRIO_ARGS1((parameter), trio_parameter_t* parameter)
{
parameter->type = FORMAT_UNKNOWN;
parameter->flags = 0;
parameter->width = 0;
parameter->precision = 0;
parameter->base = 0;
parameter->baseSpecifier = 0;
parameter->varsize = 0;
parameter->beginOffset = 0;
parameter->endOffset = 0;
parameter->position = 0;
parameter->data.pointer = 0;
#if TRIO_FEATURE_USER_DEFINED
parameter->user_defined.handler = 0;
parameter->user_data[0] = 0;
#endif
}
/*************************************************************************
* TrioCopyParameter
*
* Description:
* Copies one trio_parameter_t struct to another.
*/
TRIO_PRIVATE void TrioCopyParameter TRIO_ARGS2((target, source), trio_parameter_t* target,
TRIO_CONST trio_parameter_t* source)
{
#if TRIO_FEATURE_USER_DEFINED
size_t i;
#endif
target->type = source->type;
target->flags = source->flags;
target->width = source->width;
target->precision = source->precision;
target->base = source->base;
target->baseSpecifier = source->baseSpecifier;
target->varsize = source->varsize;
target->beginOffset = source->beginOffset;
target->endOffset = source->endOffset;
target->position = source->position;
target->data = source->data;
#if TRIO_FEATURE_USER_DEFINED
target->user_defined = source->user_defined;
for (i = 0U; i < sizeof(target->user_data); ++i)
{
if ((target->user_data[i] = source->user_data[i]) == NIL)
break;
}
#endif
}
/*************************************************************************
* TrioIsQualifier
*
* Description:
* Remember to add all new qualifiers to this function.
* QUALIFIER_POSITION must not be added.
*/
TRIO_PRIVATE BOOLEAN_T TrioIsQualifier TRIO_ARGS1((character), TRIO_CONST char character)
{
/* QUALIFIER_POSITION is not included */
switch (character)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case QUALIFIER_PLUS:
case QUALIFIER_MINUS:
case QUALIFIER_SPACE:
case QUALIFIER_DOT:
case QUALIFIER_STAR:
case QUALIFIER_ALTERNATIVE:
case QUALIFIER_SHORT:
case QUALIFIER_LONG:
case QUALIFIER_CIRCUMFLEX:
case QUALIFIER_LONG_UPPER:
case QUALIFIER_SIZE_T:
case QUALIFIER_PTRDIFF_T:
case QUALIFIER_INTMAX_T:
case QUALIFIER_QUAD:
case QUALIFIER_SIZE_T_UPPER:
#if defined(QUALIFIER_WIDECHAR)
case QUALIFIER_WIDECHAR:
#endif
case QUALIFIER_QUOTE:
case QUALIFIER_STICKY:
case QUALIFIER_VARSIZE:
#if defined(QUALIFIER_PARAM)
case QUALIFIER_PARAM:
#endif
case QUALIFIER_FIXED_SIZE:
case QUALIFIER_ROUNDING_UPPER:
return TRUE;
default:
return FALSE;
}
}
/*************************************************************************
* TrioSetLocale
*/
#if defined(USE_LOCALE)
TRIO_PRIVATE void TrioSetLocale(TRIO_NOARGS)
{
internalLocaleValues = (struct lconv*)localeconv();
if (internalLocaleValues)
{
if ((internalLocaleValues->decimal_point) &&
(internalLocaleValues->decimal_point[0] != NIL))
{
internalDecimalPointLength = trio_length(internalLocaleValues->decimal_point);
if (internalDecimalPointLength == 1)
{
internalDecimalPoint = internalLocaleValues->decimal_point[0];
}
else
{
internalDecimalPoint = NIL;
trio_copy_max(internalDecimalPointString, sizeof(internalDecimalPointString),
internalLocaleValues->decimal_point);
}
}
#if TRIO_EXTENSION
if ((internalLocaleValues->thousands_sep) &&
(internalLocaleValues->thousands_sep[0] != NIL))
{
trio_copy_max(internalThousandSeparator, sizeof(internalThousandSeparator),
internalLocaleValues->thousands_sep);
internalThousandSeparatorLength = trio_length(internalThousandSeparator);
}
#endif
#if TRIO_EXTENSION
if ((internalLocaleValues->grouping) && (internalLocaleValues->grouping[0] != NIL))
{
trio_copy_max(internalGrouping, sizeof(internalGrouping),
internalLocaleValues->grouping);
}
#endif
}
}
#endif /* defined(USE_LOCALE) */
#if TRIO_FEATURE_FLOAT && TRIO_FEATURE_QUOTE
TRIO_PRIVATE int TrioCalcThousandSeparatorLength TRIO_ARGS1((digits), int digits)
{
int count = 0;
int step = NO_GROUPING;
char* groupingPointer = internalGrouping;
while (digits > 0)
{
if (*groupingPointer == CHAR_MAX)
{
/* Disable grouping */
break; /* while */
}
else if (*groupingPointer == 0)
{
/* Repeat last group */
if (step == NO_GROUPING)
{
/* Error in locale */
break; /* while */
}
}
else
{
step = *groupingPointer++;
}
if (digits > step)
count += internalThousandSeparatorLength;
digits -= step;
}
return count;
}
#endif /* TRIO_FEATURE_FLOAT && TRIO_FEATURE_QUOTE */
#if TRIO_FEATURE_QUOTE
TRIO_PRIVATE BOOLEAN_T TrioFollowedBySeparator TRIO_ARGS1((position), int position)
{
int step = 0;
char* groupingPointer = internalGrouping;
position--;
if (position == 0)
return FALSE;
while (position > 0)
{
if (*groupingPointer == CHAR_MAX)
{
/* Disable grouping */
break; /* while */
}
else if (*groupingPointer != 0)
{
step = *groupingPointer++;
}
if (step == 0)
break;
position -= step;
}
return (position == 0);
}
#endif /* TRIO_FEATURE_QUOTE */
/*************************************************************************
* TrioGetPosition
*
* Get the %n$ position.
*/
TRIO_PRIVATE int TrioGetPosition TRIO_ARGS2((format, offsetPointer), TRIO_CONST char* format,
int* offsetPointer)
{
#if TRIO_FEATURE_POSITIONAL
char* tmpformat;
int number = 0;
int offset = *offsetPointer;
number = (int)trio_to_long(&format[offset], &tmpformat, BASE_DECIMAL);
offset = (int)(tmpformat - format);
if ((number != 0) && (QUALIFIER_POSITION == format[offset++]))
{
*offsetPointer = offset;
/*
* number is decreased by 1, because n$ starts from 1, whereas
* the array it is indexing starts from 0.
*/
return number - 1;
}
#endif
return NO_POSITION;
}
/*************************************************************************
* TrioFindNamespace
*
* Find registered user-defined specifier.
* The prev argument is used for optimization only.
*/
#if TRIO_FEATURE_USER_DEFINED
TRIO_PRIVATE trio_userdef_t* TrioFindNamespace TRIO_ARGS2((name, prev), TRIO_CONST char* name,
trio_userdef_t** prev)
{
trio_userdef_t* def;
if (internalEnterCriticalRegion)
(void)internalEnterCriticalRegion(NULL);
for (def = internalUserDef; def; def = def->next)
{
/* Case-sensitive string comparison */
if (trio_equal_case(def->name, name))
break;
if (prev)
*prev = def;
}
if (internalLeaveCriticalRegion)
(void)internalLeaveCriticalRegion(NULL);
return def;
}
#endif
/*************************************************************************
* TrioPower
*
* Description:
* Calculate pow(base, exponent), where number and exponent are integers.
*/
#if TRIO_FEATURE_FLOAT
TRIO_PRIVATE trio_long_double_t TrioPower TRIO_ARGS2((number, exponent), int number, int exponent)
{
trio_long_double_t result;
if (number == 10)
{
switch (exponent)
{
/* Speed up calculation of common cases */
case 0:
result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E-1);
break;
case 1:
result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+0);
break;
case 2:
result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+1);
break;
case 3:
result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+2);
break;
case 4:
result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+3);
break;
case 5:
result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+4);
break;
case 6:
result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+5);
break;
case 7:
result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+6);
break;
case 8:
result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+7);
break;
case 9:
result = (trio_long_double_t)number * TRIO_SUFFIX_LONG(1E+8);
break;
default:
result = trio_pow((trio_long_double_t)number, (trio_long_double_t)exponent);
break;
}
}
else
{
return trio_pow((trio_long_double_t)number, (trio_long_double_t)exponent);
}
return result;
}
#endif /* TRIO_FEATURE_FLOAT */
/*************************************************************************
* TrioLogarithm
*/
#if TRIO_FEATURE_FLOAT
TRIO_PRIVATE trio_long_double_t TrioLogarithm TRIO_ARGS2((number, base), trio_long_double_t number,
int base)
{
trio_long_double_t result;
if (number <= 0.0)
{
/* xlC crashes on log(0) */
result = (number == 0.0) ? trio_ninf() : trio_nan();
}
else
{
if (base == 10)
{
result = trio_log10(number);
}
else
{
result = trio_log10(number) / trio_log10((double)base);
}
}
return result;
}
#endif /* TRIO_FEATURE_FLOAT */
/*************************************************************************
* TrioLogarithmBase
*/
#if TRIO_FEATURE_FLOAT
TRIO_PRIVATE double TrioLogarithmBase TRIO_ARGS1((base), int base)
{
switch (base)
{
case BASE_BINARY:
return 1.0;
case BASE_OCTAL:
return 3.0;
case BASE_DECIMAL:
return 3.321928094887362345;
case BASE_HEX:
return 4.0;
default:
return TrioLogarithm((double)base, 2);
}
}
#endif /* TRIO_FEATURE_FLOAT */
/*************************************************************************
* TrioParseQualifiers
*
* Description:
* Parse the qualifiers of a potential conversion specifier
*/
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
TRIO_PRIVATE int TrioParseQualifiers TRIO_ARGS4((type, format, offset, parameter), int type,
TRIO_CONST char* format, int offset,
trio_parameter_t* parameter)
{
char ch;
int dots = 0; /* Count number of dots in modifier part */
char* tmpformat;
parameter->beginOffset = offset - 1;
parameter->flags = FLAGS_NEW;
parameter->position = TrioGetPosition(format, &offset);
/* Default values */
parameter->width = NO_WIDTH;
parameter->precision = NO_PRECISION;
parameter->base = NO_BASE;
parameter->varsize = NO_SIZE;
while (TrioIsQualifier(format[offset]))
{
ch = format[offset++];
switch (ch)
{
case QUALIFIER_SPACE:
parameter->flags |= FLAGS_SPACE;
break;
case QUALIFIER_PLUS:
parameter->flags |= FLAGS_SHOWSIGN;
break;
case QUALIFIER_MINUS:
parameter->flags |= FLAGS_LEFTADJUST;
parameter->flags &= ~FLAGS_NILPADDING;
break;
case QUALIFIER_ALTERNATIVE:
parameter->flags |= FLAGS_ALTERNATIVE;
break;
case QUALIFIER_DOT:
if (dots == 0) /* Precision */
{
dots++;
/* Skip if no precision */
if (QUALIFIER_DOT == format[offset])
break;
/* After the first dot we have the precision */
parameter->flags |= FLAGS_PRECISION;
if ((QUALIFIER_STAR == format[offset])
#if defined(QUALIFIER_PARAM)
|| (QUALIFIER_PARAM == format[offset])
#endif
)
{
offset++;
parameter->flags |= FLAGS_PRECISION_PARAMETER;
parameter->precision = TrioGetPosition(format, &offset);
}
else
{
parameter->precision =
trio_to_long(&format[offset], &tmpformat, BASE_DECIMAL);
offset = (int)(tmpformat - format);
}
}
else if (dots == 1) /* Base */
{
dots++;
/* After the second dot we have the base */
parameter->flags |= FLAGS_BASE;
if ((QUALIFIER_STAR == format[offset])
#if defined(QUALIFIER_PARAM)
|| (QUALIFIER_PARAM == format[offset])
#endif
)
{
offset++;
parameter->flags |= FLAGS_BASE_PARAMETER;
parameter->base = TrioGetPosition(format, &offset);
}
else
{
parameter->base = trio_to_long(&format[offset], &tmpformat, BASE_DECIMAL);
if (parameter->base > MAX_BASE)
return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
offset = (int)(tmpformat - format);
}
}
else
{
return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
}
break; /* QUALIFIER_DOT */
#if defined(QUALIFIER_PARAM)
case QUALIFIER_PARAM:
parameter->type = TYPE_PRINT;
/* FALLTHROUGH */
#endif
case QUALIFIER_STAR:
/* This has different meanings for print and scan */
if (TYPE_PRINT == type)
{
/* Read with from parameter */
int width = TrioGetPosition(format, &offset);
parameter->flags |= (FLAGS_WIDTH | FLAGS_WIDTH_PARAMETER);
if (NO_POSITION != width)
parameter->width = width;
/* else keep parameter->width = NO_WIDTH which != NO_POSITION */
}
#if TRIO_FEATURE_SCANF
else
{
/* Scan, but do not store result */
parameter->flags |= FLAGS_IGNORE;
}
#endif
break; /* QUALIFIER_STAR */
case '0':
if (!(parameter->flags & FLAGS_LEFTADJUST))
parameter->flags |= FLAGS_NILPADDING;
/* FALLTHROUGH */
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
parameter->flags |= FLAGS_WIDTH;
/*
* &format[offset - 1] is used to "rewind" the read
* character from format
*/
parameter->width = trio_to_long(&format[offset - 1], &tmpformat, BASE_DECIMAL);
offset = (int)(tmpformat - format);
break;
case QUALIFIER_SHORT:
if (parameter->flags & FLAGS_SHORTSHORT)
return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
else if (parameter->flags & FLAGS_SHORT)
parameter->flags |= FLAGS_SHORTSHORT;
else
parameter->flags |= FLAGS_SHORT;
break;
case QUALIFIER_LONG:
if (parameter->flags & FLAGS_QUAD)
return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
else if (parameter->flags & FLAGS_LONG)
parameter->flags |= FLAGS_QUAD;
else
parameter->flags |= FLAGS_LONG;
break;
#if TRIO_FEATURE_LONGDOUBLE
case QUALIFIER_LONG_UPPER:
parameter->flags |= FLAGS_LONGDOUBLE;
break;
#endif
#if TRIO_FEATURE_SIZE_T
case QUALIFIER_SIZE_T:
parameter->flags |= FLAGS_SIZE_T;
/* Modify flags for later truncation of number */
if (sizeof(size_t) == sizeof(trio_ulonglong_t))
parameter->flags |= FLAGS_QUAD;
else if (sizeof(size_t) == sizeof(long))
parameter->flags |= FLAGS_LONG;
break;
#endif
#if TRIO_FEATURE_PTRDIFF_T
case QUALIFIER_PTRDIFF_T:
parameter->flags |= FLAGS_PTRDIFF_T;
if (sizeof(ptrdiff_t) == sizeof(trio_ulonglong_t))
parameter->flags |= FLAGS_QUAD;
else if (sizeof(ptrdiff_t) == sizeof(long))
parameter->flags |= FLAGS_LONG;
break;
#endif
#if TRIO_FEATURE_INTMAX_T
case QUALIFIER_INTMAX_T:
parameter->flags |= FLAGS_INTMAX_T;
if (sizeof(trio_intmax_t) == sizeof(trio_ulonglong_t))
parameter->flags |= FLAGS_QUAD;
else if (sizeof(trio_intmax_t) == sizeof(long))
parameter->flags |= FLAGS_LONG;
break;
#endif
#if TRIO_FEATURE_QUAD
case QUALIFIER_QUAD:
parameter->flags |= FLAGS_QUAD;
break;
#endif
#if TRIO_FEATURE_FIXED_SIZE
case QUALIFIER_FIXED_SIZE:
if (parameter->flags & FLAGS_FIXED_SIZE)
return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
if (parameter->flags &
(FLAGS_ALL_SIZES | FLAGS_LONGDOUBLE | FLAGS_WIDECHAR | FLAGS_VARSIZE_PARAMETER))
return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
if ((format[offset] == '6') && (format[offset + 1] == '4'))
{
parameter->varsize = sizeof(trio_int64_t);
offset += 2;
}
else if ((format[offset] == '3') && (format[offset + 1] == '2'))
{
parameter->varsize = sizeof(trio_int32_t);
offset += 2;
}
else if ((format[offset] == '1') && (format[offset + 1] == '6'))
{
parameter->varsize = sizeof(trio_int16_t);
offset += 2;
}
else if (format[offset] == '8')
{
parameter->varsize = sizeof(trio_int8_t);
offset++;
}
else
return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
parameter->flags |= FLAGS_FIXED_SIZE;
break;
#endif /* TRIO_FEATURE_FIXED_SIZE */
#if defined(QUALIFIER_WIDECHAR)
case QUALIFIER_WIDECHAR:
parameter->flags |= FLAGS_WIDECHAR;
break;
#endif
#if TRIO_FEATURE_SIZE_T_UPPER
case QUALIFIER_SIZE_T_UPPER:
break;
#endif
#if TRIO_FEATURE_QUOTE
case QUALIFIER_QUOTE:
parameter->flags |= FLAGS_QUOTE;
break;
#endif
#if TRIO_FEATURE_STICKY
case QUALIFIER_STICKY:
parameter->flags |= FLAGS_STICKY;
break;
#endif
#if TRIO_FEATURE_VARSIZE
case QUALIFIER_VARSIZE:
parameter->flags |= FLAGS_VARSIZE_PARAMETER;
break;
#endif
#if TRIO_FEATURE_ROUNDING
case QUALIFIER_ROUNDING_UPPER:
parameter->flags |= FLAGS_ROUNDING;
break;
#endif
default:
/* Bail out completely to make the error more obvious */
return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
}
} /* while qualifier */
parameter->endOffset = offset;
return 0;
}
#pragma GCC diagnostic pop
/*************************************************************************
* TrioParseSpecifier
*
* Description:
* Parse the specifier part of a potential conversion specifier
*/
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
TRIO_PRIVATE int TrioParseSpecifier TRIO_ARGS4((type, format, offset, parameter), int type,
TRIO_CONST char* format, int offset,
trio_parameter_t* parameter)
{
parameter->baseSpecifier = NO_BASE;
switch (format[offset++])
{
#if defined(SPECIFIER_CHAR_UPPER)
case SPECIFIER_CHAR_UPPER:
parameter->flags |= FLAGS_WIDECHAR;
/* FALLTHROUGH */
#endif
case SPECIFIER_CHAR:
if (parameter->flags & FLAGS_LONG)
parameter->flags |= FLAGS_WIDECHAR;
else if (parameter->flags & FLAGS_SHORT)
parameter->flags &= ~FLAGS_WIDECHAR;
parameter->type = FORMAT_CHAR;
break;
#if defined(SPECIFIER_STRING_UPPER)
case SPECIFIER_STRING_UPPER:
parameter->flags |= FLAGS_WIDECHAR;
/* FALLTHROUGH */
#endif
case SPECIFIER_STRING:
if (parameter->flags & FLAGS_LONG)
parameter->flags |= FLAGS_WIDECHAR;
else if (parameter->flags & FLAGS_SHORT)
parameter->flags &= ~FLAGS_WIDECHAR;
parameter->type = FORMAT_STRING;
break;
#if defined(SPECIFIER_GROUP)
case SPECIFIER_GROUP:
if (TYPE_SCAN == type)
{
int depth = 1;
parameter->type = FORMAT_GROUP;
if (format[offset] == QUALIFIER_CIRCUMFLEX)
offset++;
if (format[offset] == SPECIFIER_UNGROUP)
offset++;
if (format[offset] == QUALIFIER_MINUS)
offset++;
/* Skip nested brackets */
while (format[offset] != NIL)
{
if (format[offset] == SPECIFIER_GROUP)
{
depth++;
}
else if (format[offset] == SPECIFIER_UNGROUP)
{
if (--depth <= 0)
{
offset++;
break;
}
}
offset++;
}
}
break;
#endif /* defined(SPECIFIER_GROUP) */
case SPECIFIER_INTEGER:
parameter->type = FORMAT_INT;
break;
case SPECIFIER_UNSIGNED:
parameter->flags |= FLAGS_UNSIGNED;
parameter->type = FORMAT_INT;
break;
case SPECIFIER_DECIMAL:
parameter->baseSpecifier = BASE_DECIMAL;
parameter->type = FORMAT_INT;
break;
case SPECIFIER_OCTAL:
parameter->flags |= FLAGS_UNSIGNED;
parameter->baseSpecifier = BASE_OCTAL;
parameter->type = FORMAT_INT;
break;
#if TRIO_FEATURE_BINARY
case SPECIFIER_BINARY_UPPER:
parameter->flags |= FLAGS_UPPER;
/* FALLTHROUGH */
case SPECIFIER_BINARY:
parameter->flags |= FLAGS_NILPADDING;
parameter->baseSpecifier = BASE_BINARY;
parameter->type = FORMAT_INT;
break;
#endif
case SPECIFIER_HEX_UPPER:
parameter->flags |= FLAGS_UPPER;
/* FALLTHROUGH */
case SPECIFIER_HEX:
parameter->flags |= FLAGS_UNSIGNED;
parameter->baseSpecifier = BASE_HEX;
parameter->type = FORMAT_INT;
break;
#if defined(SPECIFIER_FLOAT_E)
#if defined(SPECIFIER_FLOAT_E_UPPER)
case SPECIFIER_FLOAT_E_UPPER:
parameter->flags |= FLAGS_UPPER;
/* FALLTHROUGH */
#endif
case SPECIFIER_FLOAT_E:
parameter->flags |= FLAGS_FLOAT_E;
parameter->type = FORMAT_DOUBLE;
break;
#endif
#if defined(SPECIFIER_FLOAT_G)
#if defined(SPECIFIER_FLOAT_G_UPPER)
case SPECIFIER_FLOAT_G_UPPER:
parameter->flags |= FLAGS_UPPER;
/* FALLTHROUGH */
#endif
case SPECIFIER_FLOAT_G:
parameter->flags |= FLAGS_FLOAT_G;
parameter->type = FORMAT_DOUBLE;
break;
#endif
#if defined(SPECIFIER_FLOAT_F)
#if defined(SPECIFIER_FLOAT_F_UPPER)
case SPECIFIER_FLOAT_F_UPPER:
parameter->flags |= FLAGS_UPPER;
/* FALLTHROUGH */
#endif
case SPECIFIER_FLOAT_F:
parameter->type = FORMAT_DOUBLE;
break;
#endif
#if defined(TRIO_COMPILER_VISUALC)
#pragma warning(push)
#pragma warning(disable : 4127) /* Conditional expression is constant */
#endif
case SPECIFIER_POINTER:
if (sizeof(trio_pointer_t) == sizeof(trio_ulonglong_t))
parameter->flags |= FLAGS_QUAD;
else if (sizeof(trio_pointer_t) == sizeof(long))
parameter->flags |= FLAGS_LONG;
parameter->type = FORMAT_POINTER;
break;
#if defined(TRIO_COMPILER_VISUALC)
#pragma warning(pop)
#endif
case SPECIFIER_COUNT:
parameter->type = FORMAT_COUNT;
break;
#if TRIO_FEATURE_HEXFLOAT
case SPECIFIER_HEXFLOAT_UPPER:
parameter->flags |= FLAGS_UPPER;
/* FALLTHROUGH */
case SPECIFIER_HEXFLOAT:
parameter->baseSpecifier = BASE_HEX;
parameter->type = FORMAT_DOUBLE;
break;
#endif
#if TRIO_FEATURE_ERRNO
case SPECIFIER_ERRNO:
parameter->type = FORMAT_ERRNO;
break;
#endif
#if TRIO_FEATURE_USER_DEFINED
case SPECIFIER_USER_DEFINED_BEGIN:
{
unsigned int max;
int without_namespace = TRUE;
char* tmpformat = (char*)&format[offset];
int ch;
parameter->type = FORMAT_USER_DEFINED;
parameter->user_defined.namespace[0] = NIL;
while ((ch = format[offset]) != NIL)
{
offset++;
if ((ch == SPECIFIER_USER_DEFINED_END) || (ch == SPECIFIER_USER_DEFINED_EXTRA))
{
if (without_namespace)
/* No namespace, handler will be passed as an argument */
parameter->flags |= FLAGS_USER_DEFINED_PARAMETER;
/* Copy the user data */
max = (unsigned int)(&format[offset] - tmpformat);
if (max > MAX_USER_DATA)
max = MAX_USER_DATA;
trio_copy_max(parameter->user_data, max, tmpformat);
/* Skip extra data (which is only there to keep the compiler happy) */
while ((ch != NIL) && (ch != SPECIFIER_USER_DEFINED_END))
ch = format[offset++];
break; /* while */
}
if (ch == SPECIFIER_USER_DEFINED_SEPARATOR)
{
without_namespace = FALSE;
/* Copy the namespace for later looking-up */
max = (int)(&format[offset] - tmpformat);
if (max > MAX_USER_NAME)
max = MAX_USER_NAME;
trio_copy_max(parameter->user_defined.namespace, max, tmpformat);
tmpformat = (char*)&format[offset];
}
}
if (ch != SPECIFIER_USER_DEFINED_END)
return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
}
break;
#endif /* TRIO_FEATURE_USER_DEFINED */
default:
/* Bail out completely to make the error more obvious */
return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
}
parameter->endOffset = offset;
return 0;
}
#pragma GCC diagnostic pop
/*************************************************************************
* TrioParse
*
* Description:
* Parse the format string
*/
TRIO_PRIVATE int TrioParse TRIO_ARGS6((type, format, parameters, arglist, argfunc, argarray),
int type, TRIO_CONST char* format,
trio_parameter_t* parameters, va_list arglist,
trio_argfunc_t argfunc, trio_pointer_t* argarray)
{
/* Count the number of times a parameter is referenced */
unsigned short usedEntries[MAX_PARAMETERS];
/* Parameter counters */
int parameterPosition;
int maxParam = -1;
/* Utility variables */
int offset; /* Offset into formatting string */
BOOLEAN_T positional; /* Does the specifier have a positional? */
#if TRIO_FEATURE_STICKY
BOOLEAN_T gotSticky = FALSE; /* Are there any sticky modifiers at all? */
#endif
/*
* indices specifies the order in which the parameters must be
* read from the va_args (this is necessary to handle positionals)
*/
int indices[MAX_PARAMETERS];
int pos = 0;
/* Various variables */
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
int charlen;
#endif
int save_errno;
int i = -1;
int num;
trio_parameter_t workParameter;
int status;
/* Both must be set or none must be set */
assert(((argfunc == NULL) && (argarray == NULL)) || ((argfunc != NULL) && (argarray != NULL)));
/*
* The 'parameters' array is not initialized, but we need to
* know which entries we have used.
*/
memset(usedEntries, 0, sizeof(usedEntries));
save_errno = errno;
offset = 0;
parameterPosition = 0;
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
(void)mblen(NULL, 0);
#endif
while (format[offset])
{
TrioInitializeParameter(&workParameter);
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
if (!isascii(format[offset]))
{
/*
* Multibyte characters cannot be legal specifiers or
* modifiers, so we skip over them.
*/
charlen = mblen(&format[offset], MB_LEN_MAX);
offset += (charlen > 0) ? charlen : 1;
continue; /* while */
}
#endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */
switch (format[offset++])
{
case CHAR_IDENTIFIER:
{
if (CHAR_IDENTIFIER == format[offset])
{
/* skip double "%" */
offset++;
continue; /* while */
}
status = TrioParseQualifiers(type, format, offset, &workParameter);
if (status < 0)
return status; /* Return qualifier syntax error */
status = TrioParseSpecifier(type, format, workParameter.endOffset, &workParameter);
if (status < 0)
return status; /* Return specifier syntax error */
}
break;
#if TRIO_EXTENSION
case CHAR_ALT_IDENTIFIER:
{
status = TrioParseQualifiers(type, format, offset, &workParameter);
if (status < 0)
continue; /* False alert, not a user defined specifier */
status = TrioParseSpecifier(type, format, workParameter.endOffset, &workParameter);
if ((status < 0) || (FORMAT_USER_DEFINED != workParameter.type))
continue; /* False alert, not a user defined specifier */
}
break;
#endif
default:
continue; /* while */
}
/* now handle the parsed conversion specification */
positional = (NO_POSITION != workParameter.position);
/*
* Parameters only need the type and value. The value is
* read later.
*/
if (workParameter.flags & FLAGS_WIDTH_PARAMETER)
{
if (workParameter.width == NO_WIDTH)
{
workParameter.width = parameterPosition++;
}
else
{
if (!positional)
workParameter.position = workParameter.width + 1;
}
usedEntries[workParameter.width] += 1;
if (workParameter.width > maxParam)
maxParam = workParameter.width;
parameters[pos].type = FORMAT_PARAMETER;
parameters[pos].flags = 0;
indices[workParameter.width] = pos;
workParameter.width = pos++;
}
if (workParameter.flags & FLAGS_PRECISION_PARAMETER)
{
if (workParameter.precision == NO_PRECISION)
{
workParameter.precision = parameterPosition++;
}
else
{
if (!positional)
workParameter.position = workParameter.precision + 1;
}
usedEntries[workParameter.precision] += 1;
if (workParameter.precision > maxParam)
maxParam = workParameter.precision;
parameters[pos].type = FORMAT_PARAMETER;
parameters[pos].flags = 0;
indices[workParameter.precision] = pos;
workParameter.precision = pos++;
}
if (workParameter.flags & FLAGS_BASE_PARAMETER)
{
if (workParameter.base == NO_BASE)
{
workParameter.base = parameterPosition++;
}
else
{
if (!positional)
workParameter.position = workParameter.base + 1;
}
usedEntries[workParameter.base] += 1;
if (workParameter.base > maxParam)
maxParam = workParameter.base;
parameters[pos].type = FORMAT_PARAMETER;
parameters[pos].flags = 0;
indices[workParameter.base] = pos;
workParameter.base = pos++;
}
#if TRIO_FEATURE_VARSIZE
if (workParameter.flags & FLAGS_VARSIZE_PARAMETER)
{
workParameter.varsize = parameterPosition++;
usedEntries[workParameter.varsize] += 1;
if (workParameter.varsize > maxParam)
maxParam = workParameter.varsize;
parameters[pos].type = FORMAT_PARAMETER;
parameters[pos].flags = 0;
indices[workParameter.varsize] = pos;
workParameter.varsize = pos++;
}
#endif
#if TRIO_FEATURE_USER_DEFINED
if (workParameter.flags & FLAGS_USER_DEFINED_PARAMETER)
{
workParameter.user_defined.handler = parameterPosition++;
usedEntries[workParameter.user_defined.handler] += 1;
if (workParameter.user_defined.handler > maxParam)
maxParam = workParameter.user_defined.handler;
parameters[pos].type = FORMAT_PARAMETER;
parameters[pos].flags = FLAGS_USER_DEFINED;
indices[workParameter.user_defined.handler] = pos;
workParameter.user_defined.handler = pos++;
}
#endif
if (NO_POSITION == workParameter.position)
{
workParameter.position = parameterPosition++;
}
if (workParameter.position > maxParam)
maxParam = workParameter.position;
if (workParameter.position >= MAX_PARAMETERS)
{
/* Bail out completely to make the error more obvious */
return TRIO_ERROR_RETURN(TRIO_ETOOMANY, offset);
}
indices[workParameter.position] = pos;
/* Count the number of times this entry has been used */
usedEntries[workParameter.position] += 1;
/* Find last sticky parameters */
#if TRIO_FEATURE_STICKY
if (workParameter.flags & FLAGS_STICKY)
{
gotSticky = TRUE;
}
else if (gotSticky)
{
for (i = pos - 1; i >= 0; i--)
{
if (parameters[i].type == FORMAT_PARAMETER)
continue;
if ((parameters[i].flags & FLAGS_STICKY) &&
(parameters[i].type == workParameter.type))
{
/* Do not overwrite current qualifiers */
workParameter.flags |= (parameters[i].flags & (unsigned long)~FLAGS_STICKY);
if (workParameter.width == NO_WIDTH)
workParameter.width = parameters[i].width;
if (workParameter.precision == NO_PRECISION)
workParameter.precision = parameters[i].precision;
if (workParameter.base == NO_BASE)
workParameter.base = parameters[i].base;
break;
}
}
}
#endif
if (workParameter.base == NO_BASE)
workParameter.base = BASE_DECIMAL;
offset = workParameter.endOffset;
TrioCopyParameter(&parameters[pos++], &workParameter);
} /* while format characters left */
parameters[pos].type = FORMAT_SENTINEL; /* end parameter array with sentinel */
parameters[pos].beginOffset = offset;
for (num = 0; num <= maxParam; num++)
{
if (usedEntries[num] != 1)
{
if (usedEntries[num] == 0) /* gap detected */
return TRIO_ERROR_RETURN(TRIO_EGAP, num);
else /* double references detected */
return TRIO_ERROR_RETURN(TRIO_EDBLREF, num);
}
i = indices[num];
/*
* FORMAT_PARAMETERS are only present if they must be read,
* so it makes no sense to check the ignore flag (besides,
* the flags variable is not set for that particular type)
*/
if ((parameters[i].type != FORMAT_PARAMETER) && (parameters[i].flags & FLAGS_IGNORE))
continue; /* for all arguments */
/*
* The stack arguments are read according to ANSI C89
* default argument promotions:
*
* char = int
* short = int
* unsigned char = unsigned int
* unsigned short = unsigned int
* float = double
*
* In addition to the ANSI C89 these types are read (the
* default argument promotions of C99 has not been
* considered yet)
*
* long long
* long double
* size_t
* ptrdiff_t
* intmax_t
*/
switch (parameters[i].type)
{
case FORMAT_GROUP:
case FORMAT_STRING:
#if TRIO_FEATURE_WIDECHAR
if (parameters[i].flags & FLAGS_WIDECHAR)
{
parameters[i].data.wstring =
(argfunc == NULL)
? va_arg(arglist, trio_wchar_t*)
: (trio_wchar_t*)(argfunc(argarray, num, TRIO_TYPE_PWCHAR));
}
else
#endif
{
parameters[i].data.string =
(argfunc == NULL) ? va_arg(arglist, char*)
: (char*)(argfunc(argarray, num, TRIO_TYPE_PCHAR));
}
break;
#if TRIO_FEATURE_USER_DEFINED
case FORMAT_USER_DEFINED:
#endif
case FORMAT_POINTER:
case FORMAT_COUNT:
case FORMAT_UNKNOWN:
parameters[i].data.pointer = (argfunc == NULL)
? va_arg(arglist, trio_pointer_t)
: argfunc(argarray, num, TRIO_TYPE_POINTER);
break;
case FORMAT_CHAR:
case FORMAT_INT:
#if TRIO_FEATURE_SCANF
if (TYPE_SCAN == type)
{
if (argfunc == NULL)
parameters[i].data.pointer =
(trio_pointer_t)va_arg(arglist, trio_pointer_t);
else
{
if (parameters[i].type == FORMAT_CHAR)
parameters[i].data.pointer =
(trio_pointer_t)((char*)argfunc(argarray, num, TRIO_TYPE_CHAR));
else if (parameters[i].flags & FLAGS_SHORT)
parameters[i].data.pointer =
(trio_pointer_t)((short*)argfunc(argarray, num, TRIO_TYPE_SHORT));
else
parameters[i].data.pointer =
(trio_pointer_t)((int*)argfunc(argarray, num, TRIO_TYPE_INT));
}
}
else
#endif /* TRIO_FEATURE_SCANF */
{
#if TRIO_FEATURE_VARSIZE || TRIO_FEATURE_FIXED_SIZE
if (parameters[i].flags & (FLAGS_VARSIZE_PARAMETER | FLAGS_FIXED_SIZE))
{
int varsize;
if (parameters[i].flags & FLAGS_VARSIZE_PARAMETER)
{
/*
* Variable sizes are mapped onto the fixed sizes, in
* accordance with integer promotion.
*
* Please note that this may not be portable, as we
* only guess the size, not the layout of the numbers.
* For example, if int is little-endian, and long is
* big-endian, then this will fail.
*/
varsize =
(int)parameters[parameters[i].varsize].data.number.as_unsigned;
}
else
{
/* Used for the I<bits> modifiers */
varsize = parameters[i].varsize;
}
parameters[i].flags &= ~FLAGS_ALL_VARSIZES;
if (varsize <= (int)sizeof(int))
;
else if (varsize <= (int)sizeof(long))
parameters[i].flags |= FLAGS_LONG;
#if TRIO_FEATURE_INTMAX_T
else if (varsize <= (int)sizeof(trio_longlong_t))
parameters[i].flags |= FLAGS_QUAD;
else
parameters[i].flags |= FLAGS_INTMAX_T;
#else
else
parameters[i].flags |= FLAGS_QUAD;
#endif
}
#endif /* TRIO_FEATURE_VARSIZE */
#if TRIO_FEATURE_SIZE_T || TRIO_FEATURE_SIZE_T_UPPER
if (parameters[i].flags & FLAGS_SIZE_T)
parameters[i].data.number.as_unsigned =
(argfunc == NULL)
? (trio_uintmax_t)va_arg(arglist, size_t)
: (trio_uintmax_t)(
*((size_t*)argfunc(argarray, num, TRIO_TYPE_SIZE)));
else
#endif
#if TRIO_FEATURE_PTRDIFF_T
if (parameters[i].flags & FLAGS_PTRDIFF_T)
parameters[i].data.number.as_unsigned =
(argfunc == NULL)
? (trio_uintmax_t)va_arg(arglist, ptrdiff_t)
: (trio_uintmax_t)(
*((ptrdiff_t*)argfunc(argarray, num, TRIO_TYPE_PTRDIFF)));
else
#endif
#if TRIO_FEATURE_INTMAX_T
if (parameters[i].flags & FLAGS_INTMAX_T)
parameters[i].data.number.as_unsigned =
(argfunc == NULL)
? (trio_uintmax_t)va_arg(arglist, trio_intmax_t)
: (trio_uintmax_t)(
*((trio_intmax_t*)argfunc(argarray, num, TRIO_TYPE_UINTMAX)));
else
#endif
if (parameters[i].flags & FLAGS_QUAD)
parameters[i].data.number.as_unsigned =
(argfunc == NULL) ? (trio_uintmax_t)va_arg(arglist, trio_ulonglong_t)
: (trio_uintmax_t)(*((trio_ulonglong_t*)argfunc(
argarray, num, TRIO_TYPE_ULONGLONG)));
else if (parameters[i].flags & FLAGS_LONG)
parameters[i].data.number.as_unsigned =
(argfunc == NULL) ? (trio_uintmax_t)va_arg(arglist, long)
: (trio_uintmax_t)(*(
(long*)argfunc(argarray, num, TRIO_TYPE_LONG)));
else
{
if (argfunc == NULL)
parameters[i].data.number.as_unsigned =
(trio_uintmax_t)va_arg(arglist, int);
else
{
if (parameters[i].type == FORMAT_CHAR)
parameters[i].data.number.as_unsigned = (trio_uintmax_t)(
*((char*)argfunc(argarray, num, TRIO_TYPE_CHAR)));
else if (parameters[i].flags & FLAGS_SHORT)
parameters[i].data.number.as_unsigned = (trio_uintmax_t)(
*((short*)argfunc(argarray, num, TRIO_TYPE_SHORT)));
else
parameters[i].data.number.as_unsigned = (trio_uintmax_t)(
*((int*)argfunc(argarray, num, TRIO_TYPE_INT)));
}
}
}
break;
case FORMAT_PARAMETER:
/*
* The parameter for the user-defined specifier is a pointer,
* whereas the rest (width, precision, base) uses an integer.
*/
if (parameters[i].flags & FLAGS_USER_DEFINED)
parameters[i].data.pointer = (argfunc == NULL)
? va_arg(arglist, trio_pointer_t)
: argfunc(argarray, num, TRIO_TYPE_POINTER);
else
parameters[i].data.number.as_unsigned =
(argfunc == NULL)
? (trio_uintmax_t)va_arg(arglist, int)
: (trio_uintmax_t)(*((int*)argfunc(argarray, num, TRIO_TYPE_INT)));
break;
#if TRIO_FEATURE_FLOAT
case FORMAT_DOUBLE:
#if TRIO_FEATURE_SCANF
if (TYPE_SCAN == type)
{
if (parameters[i].flags & FLAGS_LONGDOUBLE)
parameters[i].data.longdoublePointer =
(argfunc == NULL)
? va_arg(arglist, trio_long_double_t*)
: (trio_long_double_t*)argfunc(argarray, num, TRIO_TYPE_LONGDOUBLE);
else
{
if (parameters[i].flags & FLAGS_LONG)
parameters[i].data.doublePointer =
(argfunc == NULL)
? va_arg(arglist, double*)
: (double*)argfunc(argarray, num, TRIO_TYPE_DOUBLE);
else
parameters[i].data.doublePointer =
(argfunc == NULL)
? (double*)va_arg(arglist, float*)
: (double*)argfunc(argarray, num, TRIO_TYPE_DOUBLE);
}
}
else
#endif /* TRIO_FEATURE_SCANF */
{
if (parameters[i].flags & FLAGS_LONGDOUBLE)
parameters[i].data.longdoubleNumber =
(argfunc == NULL) ? va_arg(arglist, trio_long_double_t)
: (trio_long_double_t)(*((trio_long_double_t*)argfunc(
argarray, num, TRIO_TYPE_LONGDOUBLE)));
else
{
if (argfunc == NULL)
parameters[i].data.longdoubleNumber =
(trio_long_double_t)va_arg(arglist, double);
else
{
if (parameters[i].flags & FLAGS_SHORT)
parameters[i].data.longdoubleNumber = (trio_long_double_t)(
*((float*)argfunc(argarray, num, TRIO_TYPE_FLOAT)));
else
parameters[i].data.longdoubleNumber = (trio_long_double_t)(
*((double*)argfunc(argarray, num, TRIO_TYPE_DOUBLE)));
}
}
}
break;
#endif /* TRIO_FEATURE_FLOAT */
#if TRIO_FEATURE_ERRNO
case FORMAT_ERRNO:
parameters[i].data.errorNumber = save_errno;
break;
#endif
default:
break;
}
} /* for all specifiers */
return num;
}
/*************************************************************************
*
* FORMATTING
*
************************************************************************/
/*************************************************************************
* TrioWriteNumber
*
* Description:
* Output a number.
* The complexity of this function is a result of the complexity
* of the dependencies of the flags.
*/
TRIO_PRIVATE void TrioWriteNumber TRIO_ARGS6((self, number, flags, width, precision, base),
trio_class_t* self, trio_uintmax_t number,
trio_flags_t flags, int width, int precision, int base)
{
BOOLEAN_T isNegative;
BOOLEAN_T isNumberZero;
BOOLEAN_T isPrecisionZero;
BOOLEAN_T ignoreNumber;
char buffer[MAX_CHARS_IN(trio_uintmax_t) * (1 + MAX_LOCALE_SEPARATOR_LENGTH) + 1];
char* bufferend;
char* pointer;
TRIO_CONST char* digits;
int i;
#if TRIO_FEATURE_QUOTE
int length;
char* p;
#endif
int count;
int digitOffset;
assert(VALID(self));
assert(VALID(self->OutStream));
assert(((base >= MIN_BASE) && (base <= MAX_BASE)) || (base == NO_BASE));
digits = (flags & FLAGS_UPPER) ? internalDigitsUpper : internalDigitsLower;
if (base == NO_BASE)
base = BASE_DECIMAL;
isNumberZero = (number == 0);
isPrecisionZero = (precision == 0);
ignoreNumber =
(isNumberZero && isPrecisionZero && !((flags & FLAGS_ALTERNATIVE) && (base == BASE_OCTAL)));
if (flags & FLAGS_UNSIGNED)
{
isNegative = FALSE;
flags &= ~FLAGS_SHOWSIGN;
}
else
{
isNegative = ((trio_intmax_t)number < 0);
if (isNegative)
number = -((trio_intmax_t)number);
}
if (flags & FLAGS_QUAD)
number &= (trio_ulonglong_t)-1;
else if (flags & FLAGS_LONG)
number &= (unsigned long)-1;
else
number &= (unsigned int)-1;
/* Build number */
pointer = bufferend = &buffer[sizeof(buffer) - 1];
*pointer-- = NIL;
for (i = 1; i < (int)sizeof(buffer); i++)
{
digitOffset = number % base;
*pointer-- = digits[digitOffset];
number /= base;
if (number == 0)
break;
#if TRIO_FEATURE_QUOTE
if ((flags & FLAGS_QUOTE) && TrioFollowedBySeparator(i + 1))
{
/*
* We are building the number from the least significant
* to the most significant digit, so we have to copy the
* thousand separator backwards
*/
length = internalThousandSeparatorLength;
if (((int)(pointer - buffer) - length) > 0)
{
p = &internalThousandSeparator[length - 1];
while (length-- > 0)
*pointer-- = *p--;
}
}
#endif
}
if (!ignoreNumber)
{
/* Adjust width */
width -= (bufferend - pointer) - 1;
}
/* Adjust precision */
if (NO_PRECISION != precision)
{
precision -= (bufferend - pointer) - 1;
if (precision < 0)
precision = 0;
flags |= FLAGS_NILPADDING;
}
/* Calculate padding */
count = (!((flags & FLAGS_LEFTADJUST) || (precision == NO_PRECISION))) ? precision : 0;
/* Adjust width further */
if (isNegative || (flags & FLAGS_SHOWSIGN) || (flags & FLAGS_SPACE))
width--;
if ((flags & FLAGS_ALTERNATIVE) && !isNumberZero)
{
switch (base)
{
case BASE_BINARY:
case BASE_HEX:
width -= 2;
break;
case BASE_OCTAL:
if (!(flags & FLAGS_NILPADDING) || (count == 0))
width--;
break;
default:
break;
}
}
/* Output prefixes spaces if needed */
if (!((flags & FLAGS_LEFTADJUST) ||
((flags & FLAGS_NILPADDING) && (precision == NO_PRECISION))))
{
while (width-- > count)
self->OutStream(self, CHAR_ADJUST);
}
/* width has been adjusted for signs and alternatives */
if (isNegative)
self->OutStream(self, '-');
else if (flags & FLAGS_SHOWSIGN)
self->OutStream(self, '+');
else if (flags & FLAGS_SPACE)
self->OutStream(self, ' ');
/* Prefix is not written when the value is zero */
if ((flags & FLAGS_ALTERNATIVE) && !isNumberZero)
{
switch (base)
{
case BASE_BINARY:
self->OutStream(self, '0');
self->OutStream(self, (flags & FLAGS_UPPER) ? 'B' : 'b');
break;
case BASE_OCTAL:
if (!(flags & FLAGS_NILPADDING) || (count == 0))
self->OutStream(self, '0');
break;
case BASE_HEX:
self->OutStream(self, '0');
self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x');
break;
default:
break;
} /* switch base */
}
/* Output prefixed zero padding if needed */
if (flags & FLAGS_NILPADDING)
{
if (precision == NO_PRECISION)
precision = width;
while (precision-- > 0)
{
self->OutStream(self, '0');
width--;
}
}
if (!ignoreNumber)
{
/* Output the number itself */
while (*(++pointer))
{
self->OutStream(self, *pointer);
}
}
/* Output trailing spaces if needed */
if (flags & FLAGS_LEFTADJUST)
{
while (width-- > 0)
self->OutStream(self, CHAR_ADJUST);
}
}
/*************************************************************************
* TrioWriteStringCharacter
*
* Description:
* Output a single character of a string
*/
TRIO_PRIVATE void TrioWriteStringCharacter TRIO_ARGS3((self, ch, flags), trio_class_t* self, int ch,
trio_flags_t flags)
{
if (flags & FLAGS_ALTERNATIVE)
{
if (!isprint(ch))
{
/*
* Non-printable characters are converted to C escapes or
* \number, if no C escape exists.
*/
self->OutStream(self, CHAR_BACKSLASH);
switch (ch)
{
case '\007':
self->OutStream(self, 'a');
break;
case '\b':
self->OutStream(self, 'b');
break;
case '\f':
self->OutStream(self, 'f');
break;
case '\n':
self->OutStream(self, 'n');
break;
case '\r':
self->OutStream(self, 'r');
break;
case '\t':
self->OutStream(self, 't');
break;
case '\v':
self->OutStream(self, 'v');
break;
case '\\':
self->OutStream(self, '\\');
break;
default:
self->OutStream(self, 'x');
TrioWriteNumber(self, (trio_uintmax_t)ch, FLAGS_UNSIGNED | FLAGS_NILPADDING, 2,
2, BASE_HEX);
break;
}
}
else if (ch == CHAR_BACKSLASH)
{
self->OutStream(self, CHAR_BACKSLASH);
self->OutStream(self, CHAR_BACKSLASH);
}
else
{
self->OutStream(self, ch);
}
}
else
{
self->OutStream(self, ch);
}
}
/*************************************************************************
* TrioWriteString
*
* Description:
* Output a string
*/
TRIO_PRIVATE void TrioWriteString TRIO_ARGS5((self, string, flags, width, precision),
trio_class_t* self, TRIO_CONST char* string,
trio_flags_t flags, int width, int precision)
{
int length = 0;
int ch;
assert(VALID(self));
assert(VALID(self->OutStream));
if (string == NULL)
{
string = internalNullString;
length = sizeof(internalNullString) - 1;
#if TRIO_FEATURE_QUOTE
/* Disable quoting for the null pointer */
flags &= (~FLAGS_QUOTE);
#endif
width = 0;
}
else
{
if (precision <= 0)
{
length = trio_length(string);
}
else
{
length = trio_length_max(string, precision);
}
}
if ((NO_PRECISION != precision) && (precision < length))
{
length = precision;
}
width -= length;
#if TRIO_FEATURE_QUOTE
if (flags & FLAGS_QUOTE)
self->OutStream(self, CHAR_QUOTE);
#endif
if (!(flags & FLAGS_LEFTADJUST))
{
while (width-- > 0)
self->OutStream(self, CHAR_ADJUST);
}
while (length-- > 0)
{
/* The ctype parameters must be an unsigned char (or EOF) */
ch = (int)((unsigned char)(*string++));
TrioWriteStringCharacter(self, ch, flags);
}
if (flags & FLAGS_LEFTADJUST)
{
while (width-- > 0)
self->OutStream(self, CHAR_ADJUST);
}
#if TRIO_FEATURE_QUOTE
if (flags & FLAGS_QUOTE)
self->OutStream(self, CHAR_QUOTE);
#endif
}
/*************************************************************************
* TrioWriteWideStringCharacter
*
* Description:
* Output a wide string as a multi-byte sequence
*/
#if TRIO_FEATURE_WIDECHAR
TRIO_PRIVATE int TrioWriteWideStringCharacter TRIO_ARGS4((self, wch, flags, width),
trio_class_t* self, trio_wchar_t wch,
trio_flags_t flags, int width)
{
int size;
int i;
int ch;
char* string;
char buffer[MB_LEN_MAX + 1];
if (width == NO_WIDTH)
width = sizeof(buffer);
size = wctomb(buffer, wch);
if ((size <= 0) || (size > width) || (buffer[0] == NIL))
return 0;
string = buffer;
i = size;
while ((width >= i) && (width-- > 0) && (i-- > 0))
{
/* The ctype parameters must be an unsigned char (or EOF) */
ch = (int)((unsigned char)(*string++));
TrioWriteStringCharacter(self, ch, flags);
}
return size;
}
#endif /* TRIO_FEATURE_WIDECHAR */
/*************************************************************************
* TrioWriteWideString
*
* Description:
* Output a wide character string as a multi-byte string
*/
#if TRIO_FEATURE_WIDECHAR
TRIO_PRIVATE void TrioWriteWideString TRIO_ARGS5((self, wstring, flags, width, precision),
trio_class_t* self,
TRIO_CONST trio_wchar_t* wstring,
trio_flags_t flags, int width, int precision)
{
int length;
int size;
assert(VALID(self));
assert(VALID(self->OutStream));
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
/* Required by TrioWriteWideStringCharacter */
(void)mblen(NULL, 0);
#endif
if (wstring == NULL)
{
TrioWriteString(self, NULL, flags, width, precision);
return;
}
if (NO_PRECISION == precision)
{
length = INT_MAX;
}
else
{
length = precision;
width -= length;
}
#if TRIO_FEATURE_QUOTE
if (flags & FLAGS_QUOTE)
self->OutStream(self, CHAR_QUOTE);
#endif
if (!(flags & FLAGS_LEFTADJUST))
{
while (width-- > 0)
self->OutStream(self, CHAR_ADJUST);
}
while (length > 0)
{
size = TrioWriteWideStringCharacter(self, *wstring++, flags, length);
if (size == 0)
break; /* while */
length -= size;
}
if (flags & FLAGS_LEFTADJUST)
{
while (width-- > 0)
self->OutStream(self, CHAR_ADJUST);
}
#if TRIO_FEATURE_QUOTE
if (flags & FLAGS_QUOTE)
self->OutStream(self, CHAR_QUOTE);
#endif
}
#endif /* TRIO_FEATURE_WIDECHAR */
/*************************************************************************
* TrioWriteDouble
*
* http://wwwold.dkuug.dk/JTC1/SC22/WG14/www/docs/dr_211.htm
*
* "5.2.4.2.2 paragraph #4
*
* The accuracy [...] is implementation defined, as is the accuracy
* of the conversion between floating-point internal representations
* and string representations performed by the libray routine in
* <stdio.h>"
*/
/* FIXME: handle all instances of constant long-double number (L)
* and *l() math functions.
*/
#if TRIO_FEATURE_FLOAT
TRIO_PRIVATE void TrioWriteDouble TRIO_ARGS6((self, number, flags, width, precision, base),
trio_class_t* self, trio_long_double_t number,
trio_flags_t flags, int width, int precision, int base)
{
trio_long_double_t integerNumber;
trio_long_double_t fractionNumber;
trio_long_double_t workNumber;
int integerDigits;
int fractionDigits;
int exponentDigits;
int workDigits;
int baseDigits;
int integerThreshold;
int fractionThreshold;
int expectedWidth;
int exponent = 0;
unsigned int uExponent = 0;
int exponentBase;
trio_long_double_t dblBase;
trio_long_double_t dblFractionBase;
trio_long_double_t integerAdjust;
trio_long_double_t fractionAdjust;
trio_long_double_t workFractionNumber;
trio_long_double_t workFractionAdjust;
int fractionDigitsInspect;
BOOLEAN_T isNegative;
BOOLEAN_T isExponentNegative = FALSE;
BOOLEAN_T requireTwoDigitExponent;
BOOLEAN_T isHex;
TRIO_CONST char* digits;
#if TRIO_FEATURE_QUOTE
char* groupingPointer;
#endif
int i;
int offset;
BOOLEAN_T hasOnlyZeroes;
int leadingFractionZeroes = -1;
register int trailingZeroes;
BOOLEAN_T keepTrailingZeroes;
BOOLEAN_T keepDecimalPoint;
trio_long_double_t epsilon;
BOOLEAN_T adjustNumber = FALSE;
assert(VALID(self));
assert(VALID(self->OutStream));
assert(((base >= MIN_BASE) && (base <= MAX_BASE)) || (base == NO_BASE));
/* Determine sign and look for special quantities */
switch (trio_fpclassify_and_signbit(number, &isNegative))
{
case TRIO_FP_NAN:
TrioWriteString(self, (flags & FLAGS_UPPER) ? NAN_UPPER : NAN_LOWER, flags, width,
precision);
return;
case TRIO_FP_INFINITE:
if (isNegative)
{
/* Negative infinity */
TrioWriteString(self,
(flags & FLAGS_UPPER) ? "-" INFINITE_UPPER : "-" INFINITE_LOWER,
flags, width, precision);
return;
}
else
{
/* Positive infinity */
TrioWriteString(self, (flags & FLAGS_UPPER) ? INFINITE_UPPER : INFINITE_LOWER,
flags, width, precision);
return;
}
default:
/* Finitude */
break;
}
/* Normal numbers */
if (flags & FLAGS_LONGDOUBLE)
{
baseDigits =
(base == 10) ? LDBL_DIG : (int)trio_floor(LDBL_MANT_DIG / TrioLogarithmBase(base));
epsilon = LDBL_EPSILON;
}
else if (flags & FLAGS_SHORT)
{
baseDigits = (base == BASE_DECIMAL)
? FLT_DIG
: (int)trio_floor(FLT_MANT_DIG / TrioLogarithmBase(base));
epsilon = FLT_EPSILON;
}
else
{
baseDigits = (base == BASE_DECIMAL)
? DBL_DIG
: (int)trio_floor(DBL_MANT_DIG / TrioLogarithmBase(base));
epsilon = DBL_EPSILON;
}
digits = (flags & FLAGS_UPPER) ? internalDigitsUpper : internalDigitsLower;
isHex = (base == BASE_HEX);
if (base == NO_BASE)
base = BASE_DECIMAL;
dblBase = (trio_long_double_t)base;
keepTrailingZeroes =
!((flags & FLAGS_ROUNDING) || ((flags & FLAGS_FLOAT_G) && !(flags & FLAGS_ALTERNATIVE)));
#if TRIO_FEATURE_ROUNDING
if (flags & FLAGS_ROUNDING)
{
precision = baseDigits;
}
#endif
if (precision == NO_PRECISION)
{
if (isHex)
{
keepTrailingZeroes = FALSE;
precision = FLT_MANT_DIG;
}
else
{
precision = FLT_DIG;
}
}
if (isNegative)
{
number = -number;
}
if (isHex)
{
flags |= FLAGS_FLOAT_E;
}
reprocess:
if (flags & FLAGS_FLOAT_G)
{
if (precision == 0)
precision = 1;
if ((number < TRIO_SUFFIX_LONG(1.0E-4)) ||
(number >= TrioPower(base, (trio_long_double_t)precision)))
{
/* Use scientific notation */
flags |= FLAGS_FLOAT_E;
}
else if (number < 1.0)
{
/*
* Use normal notation. If the integer part of the number is
* zero, then adjust the precision to include leading fractional
* zeros.
*/
workNumber = TrioLogarithm(number, base);
workNumber = TRIO_FABS(workNumber);
if (workNumber - trio_floor(workNumber) < epsilon)
workNumber--;
leadingFractionZeroes = (int)trio_floor(workNumber);
}
}
if (flags & FLAGS_FLOAT_E)
{
/* Scale the number */
workNumber = TrioLogarithm(number, base);
if (trio_isinf(workNumber) == -1)
{
exponent = 0;
/* Undo setting */
if (flags & FLAGS_FLOAT_G)
flags &= ~FLAGS_FLOAT_E;
}
else
{
exponent = (int)trio_floor(workNumber);
workNumber = number;
/*
* The expression A * 10^-B is equivalent to A / 10^B but the former
* usually gives better accuracy.
*/
workNumber *= TrioPower(dblBase, (trio_long_double_t)-exponent);
if (trio_isinf(workNumber))
{
/*
* Scaling is done it two steps to avoid problems with subnormal
* numbers.
*/
workNumber /= TrioPower(dblBase, (trio_long_double_t)(exponent / 2));
workNumber /= TrioPower(dblBase, (trio_long_double_t)(exponent - (exponent / 2)));
}
number = workNumber;
isExponentNegative = (exponent < 0);
uExponent = (isExponentNegative) ? -exponent : exponent;
if (isHex)
uExponent *= 4; /* log16(2) */
#if TRIO_FEATURE_QUOTE
/* No thousand separators */
flags &= ~FLAGS_QUOTE;
#endif
}
}
integerNumber = trio_floor(number);
fractionNumber = number - integerNumber;
/*
* Truncated number.
*
* Precision is number of significant digits for FLOAT_G and number of
* fractional digits for others.
*/
integerDigits = 1;
if (integerNumber > epsilon)
{
integerDigits += (int)TrioLogarithm(integerNumber, base);
}
fractionDigits = precision;
if (flags & FLAGS_FLOAT_G)
{
if (leadingFractionZeroes > 0)
{
fractionDigits += leadingFractionZeroes;
}
if ((integerNumber > epsilon) || (number <= epsilon))
{
fractionDigits -= integerDigits;
}
}
dblFractionBase = TrioPower(base, fractionDigits);
if (integerNumber < 1.0)
{
workNumber = number * dblFractionBase + TRIO_SUFFIX_LONG(0.5);
if (trio_floor(number * dblFractionBase) != trio_floor(workNumber))
{
adjustNumber = TRUE;
/* Remove a leading fraction zero if fraction is rounded up */
if ((int)TrioLogarithm(number * dblFractionBase, base) !=
(int)TrioLogarithm(workNumber, base))
{
--leadingFractionZeroes;
}
}
workNumber /= dblFractionBase;
}
else
{
workNumber = number + TRIO_SUFFIX_LONG(0.5) / dblFractionBase;
adjustNumber = (trio_floor(number) != trio_floor(workNumber));
}
if (adjustNumber)
{
if ((flags & FLAGS_FLOAT_G) && !(flags & FLAGS_FLOAT_E))
{
/* The adjustment may require a change to scientific notation */
if ((workNumber < TRIO_SUFFIX_LONG(1.0E-4)) ||
(workNumber >= TrioPower(base, (trio_long_double_t)precision)))
{
/* Use scientific notation */
flags |= FLAGS_FLOAT_E;
goto reprocess;
}
}
if (flags & FLAGS_FLOAT_E)
{
workDigits = 1 + TrioLogarithm(trio_floor(workNumber), base);
if (integerDigits == workDigits)
{
/* Adjust if the same number of digits are used */
number += TRIO_SUFFIX_LONG(0.5) / dblFractionBase;
integerNumber = trio_floor(number);
fractionNumber = number - integerNumber;
}
else
{
/* Adjust if number was rounded up one digit (ie. 0.99 to 1.00) */
exponent++;
isExponentNegative = (exponent < 0);
uExponent = (isExponentNegative) ? -exponent : exponent;
if (isHex)
uExponent *= 4; /* log16(2) */
workNumber = (number + TRIO_SUFFIX_LONG(0.5) / dblFractionBase) / dblBase;
integerNumber = trio_floor(workNumber);
fractionNumber = workNumber - integerNumber;
}
}
else
{
if (workNumber > 1.0)
{
/* Adjust if number was rounded up one digit (ie. 99 to 100) */
integerNumber = trio_floor(workNumber);
fractionNumber = 0.0;
integerDigits =
(integerNumber > epsilon) ? 1 + (int)TrioLogarithm(integerNumber, base) : 1;
if (flags & FLAGS_FLOAT_G)
{
if (flags & FLAGS_ALTERNATIVE)
{
fractionDigits = precision;
if ((integerNumber > epsilon) || (number <= epsilon))
{
fractionDigits -= integerDigits;
}
}
else
{
fractionDigits = 0;
}
}
}
else
{
integerNumber = trio_floor(workNumber);
fractionNumber = workNumber - integerNumber;
if (flags & FLAGS_FLOAT_G)
{
if (flags & FLAGS_ALTERNATIVE)
{
fractionDigits = precision;
if (leadingFractionZeroes > 0)
{
fractionDigits += leadingFractionZeroes;
}
if ((integerNumber > epsilon) || (number <= epsilon))
{
fractionDigits -= integerDigits;
}
}
}
}
}
}
/* Estimate accuracy */
integerAdjust = fractionAdjust = TRIO_SUFFIX_LONG(0.5);
#if TRIO_FEATURE_ROUNDING
if (flags & FLAGS_ROUNDING)
{
if (integerDigits > baseDigits)
{
integerThreshold = baseDigits;
fractionDigits = 0;
dblFractionBase = 1.0;
fractionThreshold = 0;
precision = 0; /* Disable decimal-point */
integerAdjust = TrioPower(base, integerDigits - integerThreshold - 1);
fractionAdjust = 0.0;
}
else
{
integerThreshold = integerDigits;
fractionThreshold = fractionDigits - integerThreshold;
fractionAdjust = 1.0;
}
}
else
#endif
{
integerThreshold = INT_MAX;
fractionThreshold = INT_MAX;
}
/*
* Calculate expected width.
* sign + integer part + thousands separators + decimal point
* + fraction + exponent
*/
fractionAdjust /= dblFractionBase;
hasOnlyZeroes = (trio_floor((fractionNumber + fractionAdjust) * dblFractionBase) < epsilon);
keepDecimalPoint = ((flags & FLAGS_ALTERNATIVE) ||
!((precision == 0) || (!keepTrailingZeroes && hasOnlyZeroes)));
expectedWidth = integerDigits + fractionDigits;
if (!keepTrailingZeroes)
{
trailingZeroes = 0;
workFractionNumber = fractionNumber;
workFractionAdjust = fractionAdjust;
fractionDigitsInspect = fractionDigits;
if (integerDigits > integerThreshold)
{
fractionDigitsInspect = 0;
}
else if (fractionThreshold <= fractionDigits)
{
fractionDigitsInspect = fractionThreshold + 1;
}
trailingZeroes = fractionDigits - fractionDigitsInspect;
for (i = 0; i < fractionDigitsInspect; i++)
{
workFractionNumber *= dblBase;
workFractionAdjust *= dblBase;
workNumber = trio_floor(workFractionNumber + workFractionAdjust);
workFractionNumber -= workNumber;
offset = (int)trio_fmod(workNumber, dblBase);
if (offset == 0)
{
trailingZeroes++;
}
else
{
trailingZeroes = 0;
}
}
expectedWidth -= trailingZeroes;
}
if (keepDecimalPoint)
{
expectedWidth += internalDecimalPointLength;
}
#if TRIO_FEATURE_QUOTE
if (flags & FLAGS_QUOTE)
{
expectedWidth += TrioCalcThousandSeparatorLength(integerDigits);
}
#endif
if (isNegative || (flags & FLAGS_SHOWSIGN) || (flags & FLAGS_SPACE))
{
expectedWidth += sizeof("-") - 1;
}
exponentDigits = 0;
if (flags & FLAGS_FLOAT_E)
{
exponentDigits =
(uExponent == 0)
? 1
: (int)trio_ceil(TrioLogarithm((double)(uExponent + 1), (isHex) ? 10 : base));
}
requireTwoDigitExponent = ((base == BASE_DECIMAL) && (exponentDigits == 1));
if (exponentDigits > 0)
{
expectedWidth += exponentDigits;
expectedWidth += (requireTwoDigitExponent ? sizeof("E+0") - 1 : sizeof("E+") - 1);
}
if (isHex)
{
expectedWidth += sizeof("0X") - 1;
}
/* Output prefixing */
if (flags & FLAGS_NILPADDING)
{
/* Leading zeros must be after sign */
if (isNegative)
self->OutStream(self, '-');
else if (flags & FLAGS_SHOWSIGN)
self->OutStream(self, '+');
else if (flags & FLAGS_SPACE)
self->OutStream(self, ' ');
if (isHex)
{
self->OutStream(self, '0');
self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x');
}
if (!(flags & FLAGS_LEFTADJUST))
{
for (i = expectedWidth; i < width; i++)
{
self->OutStream(self, '0');
}
}
}
else
{
/* Leading spaces must be before sign */
if (!(flags & FLAGS_LEFTADJUST))
{
for (i = expectedWidth; i < width; i++)
{
self->OutStream(self, CHAR_ADJUST);
}
}
if (isNegative)
self->OutStream(self, '-');
else if (flags & FLAGS_SHOWSIGN)
self->OutStream(self, '+');
else if (flags & FLAGS_SPACE)
self->OutStream(self, ' ');
if (isHex)
{
self->OutStream(self, '0');
self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x');
}
}
/* Output the integer part and thousand separators */
for (i = 0; i < integerDigits; i++)
{
workNumber =
trio_floor(((integerNumber + integerAdjust) / TrioPower(base, integerDigits - i - 1)));
if (i > integerThreshold)
{
/* Beyond accuracy */
self->OutStream(self, digits[0]);
}
else
{
self->OutStream(self, digits[(int)trio_fmod(workNumber, dblBase)]);
}
#if TRIO_FEATURE_QUOTE
if (((flags & (FLAGS_FLOAT_E | FLAGS_QUOTE)) == FLAGS_QUOTE) &&
TrioFollowedBySeparator(integerDigits - i))
{
for (groupingPointer = internalThousandSeparator; *groupingPointer != NIL;
groupingPointer++)
{
self->OutStream(self, *groupingPointer);
}
}
#endif
}
/* Insert decimal point and build the fraction part */
trailingZeroes = 0;
if (keepDecimalPoint)
{
if (internalDecimalPoint)
{
self->OutStream(self, internalDecimalPoint);
}
else
{
for (i = 0; i < internalDecimalPointLength; i++)
{
self->OutStream(self, internalDecimalPointString[i]);
}
}
}
for (i = 0; i < fractionDigits; i++)
{
if ((integerDigits > integerThreshold) || (i > fractionThreshold))
{
/* Beyond accuracy */
trailingZeroes++;
}
else
{
fractionNumber *= dblBase;
fractionAdjust *= dblBase;
workNumber = trio_floor(fractionNumber + fractionAdjust);
if (workNumber > fractionNumber)
{
/* fractionNumber should never become negative */
fractionNumber = 0.0;
fractionAdjust = 0.0;
}
else
{
fractionNumber -= workNumber;
}
offset = (int)trio_fmod(workNumber, dblBase);
if (offset == 0)
{
trailingZeroes++;
}
else
{
while (trailingZeroes > 0)
{
/* Not trailing zeroes after all */
self->OutStream(self, digits[0]);
trailingZeroes--;
}
self->OutStream(self, digits[offset]);
}
}
}
if (keepTrailingZeroes)
{
while (trailingZeroes > 0)
{
self->OutStream(self, digits[0]);
trailingZeroes--;
}
}
/* Output exponent */
if (exponentDigits > 0)
{
self->OutStream(self, isHex ? ((flags & FLAGS_UPPER) ? 'P' : 'p')
: ((flags & FLAGS_UPPER) ? 'E' : 'e'));
self->OutStream(self, (isExponentNegative) ? '-' : '+');
/* The exponent must contain at least two digits */
if (requireTwoDigitExponent)
self->OutStream(self, '0');
if (isHex)
base = 10;
exponentBase = (int)TrioPower(base, exponentDigits - 1);
for (i = 0; i < exponentDigits; i++)
{
self->OutStream(self, digits[(uExponent / exponentBase) % base]);
exponentBase /= base;
}
}
/* Output trailing spaces */
if (flags & FLAGS_LEFTADJUST)
{
for (i = expectedWidth; i < width; i++)
{
self->OutStream(self, CHAR_ADJUST);
}
}
}
#endif /* TRIO_FEATURE_FLOAT */
/*************************************************************************
* TrioFormatProcess
*
* Description:
* This is the main engine for formatting output
*/
TRIO_PRIVATE int TrioFormatProcess TRIO_ARGS3((data, format, parameters), trio_class_t* data,
TRIO_CONST char* format, trio_parameter_t* parameters)
{
int i;
#if TRIO_FEATURE_ERRNO
TRIO_CONST char* string;
#endif
trio_pointer_t pointer;
trio_flags_t flags;
int width;
int precision;
int base;
int offset;
offset = 0;
i = 0;
for (;;)
{
/* Skip the parameter entries */
while (parameters[i].type == FORMAT_PARAMETER)
i++;
/* Copy non conversion-specifier part of format string */
while (offset < parameters[i].beginOffset)
{
if (CHAR_IDENTIFIER == format[offset] && CHAR_IDENTIFIER == format[offset + 1])
{
data->OutStream(data, CHAR_IDENTIFIER);
offset += 2;
}
else
{
data->OutStream(data, format[offset++]);
}
}
/* Abort if we reached end of format string */
if (parameters[i].type == FORMAT_SENTINEL)
break;
/* Ouput parameter */
flags = parameters[i].flags;
/* Find width */
width = parameters[i].width;
if (flags & FLAGS_WIDTH_PARAMETER)
{
/* Get width from parameter list */
width = (int)parameters[width].data.number.as_signed;
if (width < 0)
{
/*
* A negative width is the same as the - flag and
* a positive width.
*/
flags |= FLAGS_LEFTADJUST;
flags &= ~FLAGS_NILPADDING;
width = -width;
}
}
/* Find precision */
if (flags & FLAGS_PRECISION)
{
precision = parameters[i].precision;
if (flags & FLAGS_PRECISION_PARAMETER)
{
/* Get precision from parameter list */
precision = (int)parameters[precision].data.number.as_signed;
if (precision < 0)
{
/*
* A negative precision is the same as no
* precision
*/
precision = NO_PRECISION;
}
}
}
else
{
precision = NO_PRECISION;
}
/* Find base */
if (NO_BASE != parameters[i].baseSpecifier)
{
/* Base from specifier has priority */
base = parameters[i].baseSpecifier;
}
else if (flags & FLAGS_BASE_PARAMETER)
{
/* Get base from parameter list */
base = parameters[i].base;
base = (int)parameters[base].data.number.as_signed;
}
else
{
/* Use base from format string */
base = parameters[i].base;
}
switch (parameters[i].type)
{
case FORMAT_CHAR:
#if TRIO_FEATURE_QUOTE
if (flags & FLAGS_QUOTE)
data->OutStream(data, CHAR_QUOTE);
#endif
if (!(flags & FLAGS_LEFTADJUST))
{
while (--width > 0)
data->OutStream(data, CHAR_ADJUST);
}
#if TRIO_FEATURE_WIDECHAR
if (flags & FLAGS_WIDECHAR)
{
TrioWriteWideStringCharacter(
data, (trio_wchar_t)parameters[i].data.number.as_signed, flags, NO_WIDTH);
}
else
#endif
{
TrioWriteStringCharacter(data, (int)parameters[i].data.number.as_signed, flags);
}
if (flags & FLAGS_LEFTADJUST)
{
while (--width > 0)
data->OutStream(data, CHAR_ADJUST);
}
#if TRIO_FEATURE_QUOTE
if (flags & FLAGS_QUOTE)
data->OutStream(data, CHAR_QUOTE);
#endif
break; /* FORMAT_CHAR */
case FORMAT_INT:
TrioWriteNumber(data, parameters[i].data.number.as_unsigned, flags, width,
precision, base);
break; /* FORMAT_INT */
#if TRIO_FEATURE_FLOAT
case FORMAT_DOUBLE:
TrioWriteDouble(data, parameters[i].data.longdoubleNumber, flags, width, precision,
base);
break; /* FORMAT_DOUBLE */
#endif
case FORMAT_STRING:
#if TRIO_FEATURE_WIDECHAR
if (flags & FLAGS_WIDECHAR)
{
TrioWriteWideString(data, parameters[i].data.wstring, flags, width, precision);
}
else
#endif
{
TrioWriteString(data, parameters[i].data.string, flags, width, precision);
}
break; /* FORMAT_STRING */
case FORMAT_POINTER:
{
trio_reference_t reference;
reference.data = data;
reference.parameter = &parameters[i];
trio_print_pointer(&reference, parameters[i].data.pointer);
}
break; /* FORMAT_POINTER */
case FORMAT_COUNT:
pointer = parameters[i].data.pointer;
if (NULL != pointer)
{
/*
* C99 paragraph 7.19.6.1.8 says "the number of
* characters written to the output stream so far by
* this call", which is data->actually.committed
*/
#if TRIO_FEATURE_SIZE_T || TRIO_FEATURE_SIZE_T_UPPER
if (flags & FLAGS_SIZE_T)
*(size_t*)pointer = (size_t)data->actually.committed;
else
#endif
#if TRIO_FEATURE_PTRDIFF_T
if (flags & FLAGS_PTRDIFF_T)
*(ptrdiff_t*)pointer = (ptrdiff_t)data->actually.committed;
else
#endif
#if TRIO_FEATURE_INTMAX_T
if (flags & FLAGS_INTMAX_T)
*(trio_intmax_t*)pointer = (trio_intmax_t)data->actually.committed;
else
#endif
if (flags & FLAGS_QUAD)
{
*(trio_ulonglong_t*)pointer = (trio_ulonglong_t)data->actually.committed;
}
else if (flags & FLAGS_LONG)
{
*(long int*)pointer = (long int)data->actually.committed;
}
else if (flags & FLAGS_SHORT)
{
*(short int*)pointer = (short int)data->actually.committed;
}
else
{
*(int*)pointer = (int)data->actually.committed;
}
}
break; /* FORMAT_COUNT */
case FORMAT_PARAMETER:
break; /* FORMAT_PARAMETER */
#if TRIO_FEATURE_ERRNO
case FORMAT_ERRNO:
string = trio_error(parameters[i].data.errorNumber);
if (string)
{
TrioWriteString(data, string, flags, width, precision);
}
else
{
data->OutStream(data, '#');
TrioWriteNumber(data, (trio_uintmax_t)parameters[i].data.errorNumber, flags,
width, precision, BASE_DECIMAL);
}
break; /* FORMAT_ERRNO */
#endif /* TRIO_FEATURE_ERRNO */
#if TRIO_FEATURE_USER_DEFINED
case FORMAT_USER_DEFINED:
{
trio_reference_t reference;
trio_userdef_t* def = NULL;
if (parameters[i].flags & FLAGS_USER_DEFINED_PARAMETER)
{
/* Use handle */
if ((i > 0) || (parameters[i - 1].type == FORMAT_PARAMETER))
def = (trio_userdef_t*)parameters[i - 1].data.pointer;
}
else
{
/* Look up namespace */
def = TrioFindNamespace(parameters[i].user_defined.namespace, NULL);
}
if (def)
{
reference.data = data;
reference.parameter = &parameters[i];
def->callback(&reference);
}
}
break;
#endif /* TRIO_FEATURE_USER_DEFINED */
default:
break;
} /* switch parameter type */
/* Prepare for next */
offset = parameters[i].endOffset;
i++;
}
return data->processed;
}
/*************************************************************************
* TrioFormatRef
*/
#if TRIO_EXTENSION
TRIO_PRIVATE int TrioFormatRef TRIO_ARGS5((reference, format, arglist, argfunc, argarray),
trio_reference_t* reference, TRIO_CONST char* format,
va_list arglist, trio_argfunc_t argfunc,
trio_pointer_t* argarray)
{
int status;
trio_parameter_t parameters[MAX_PARAMETERS];
status = TrioParse(TYPE_PRINT, format, parameters, arglist, argfunc, argarray);
if (status < 0)
return status;
status = TrioFormatProcess(reference->data, format, parameters);
if (reference->data->error != 0)
{
status = reference->data->error;
}
return status;
}
#endif /* TRIO_EXTENSION */
/*************************************************************************
* TrioFormat
*/
TRIO_PRIVATE int TrioFormat TRIO_ARGS7((destination, destinationSize, OutStream, format, arglist,
argfunc, argarray),
trio_pointer_t destination, size_t destinationSize,
void(*OutStream) TRIO_PROTO((trio_class_t*, int)),
TRIO_CONST char* format, va_list arglist,
trio_argfunc_t argfunc, trio_pointer_t* argarray)
{
int status;
trio_class_t data;
trio_parameter_t parameters[MAX_PARAMETERS];
assert(VALID(OutStream));
assert(VALID(format));
memset(&data, 0, sizeof(data));
data.OutStream = OutStream;
data.location = destination;
data.max = destinationSize;
data.error = 0;
#if defined(USE_LOCALE)
if (NULL == internalLocaleValues)
{
TrioSetLocale();
}
#endif
status = TrioParse(TYPE_PRINT, format, parameters, arglist, argfunc, argarray);
if (status < 0)
return status;
status = TrioFormatProcess(&data, format, parameters);
if (data.error != 0)
{
status = data.error;
}
return status;
}
/*************************************************************************
* TrioOutStreamFile
*/
#if TRIO_FEATURE_FILE || TRIO_FEATURE_STDIO
TRIO_PRIVATE void TrioOutStreamFile TRIO_ARGS2((self, output), trio_class_t* self, int output)
{
FILE* file;
assert(VALID(self));
assert(VALID(self->location));
file = (FILE*)self->location;
self->processed++;
if (fputc(output, file) == EOF)
{
self->error = TRIO_ERROR_RETURN(TRIO_EOF, 0);
}
else
{
self->actually.committed++;
}
}
#endif /* TRIO_FEATURE_FILE || TRIO_FEATURE_STDIO */
/*************************************************************************
* TrioOutStreamFileDescriptor
*/
#if TRIO_FEATURE_FD
TRIO_PRIVATE void TrioOutStreamFileDescriptor TRIO_ARGS2((self, output), trio_class_t* self,
int output)
{
int fd;
char ch;
assert(VALID(self));
fd = *((int*)self->location);
ch = (char)output;
self->processed++;
if (write(fd, &ch, sizeof(char)) == -1)
{
self->error = TRIO_ERROR_RETURN(TRIO_ERRNO, 0);
}
else
{
self->actually.committed++;
}
}
#endif /* TRIO_FEATURE_FD */
/*************************************************************************
* TrioOutStreamCustom
*/
#if TRIO_FEATURE_CLOSURE
TRIO_PRIVATE void TrioOutStreamCustom TRIO_ARGS2((self, output), trio_class_t* self, int output)
{
int status;
trio_custom_t* data;
assert(VALID(self));
assert(VALID(self->location));
data = (trio_custom_t*)self->location;
if (data->stream.out)
{
status = (data->stream.out)(data->closure, output);
if (status >= 0)
{
self->actually.committed++;
}
else
{
if (self->error == 0)
{
self->error = TRIO_ERROR_RETURN(TRIO_ECUSTOM, -status);
}
}
}
self->processed++;
}
#endif /* TRIO_FEATURE_CLOSURE */
/*************************************************************************
* TrioOutStreamString
*/
TRIO_PRIVATE void TrioOutStreamString TRIO_ARGS2((self, output), trio_class_t* self, int output)
{
char** buffer;
assert(VALID(self));
assert(VALID(self->location));
buffer = (char**)self->location;
**buffer = (char)output;
(*buffer)++;
self->processed++;
self->actually.committed++;
}
/*************************************************************************
* TrioOutStreamStringMax
*/
TRIO_PRIVATE void TrioOutStreamStringMax TRIO_ARGS2((self, output), trio_class_t* self, int output)
{
char** buffer;
assert(VALID(self));
assert(VALID(self->location));
buffer = (char**)self->location;
if (self->processed < self->max)
{
**buffer = (char)output;
(*buffer)++;
self->actually.committed++;
}
self->processed++;
}
/*************************************************************************
* TrioOutStreamStringDynamic
*/
#if TRIO_FEATURE_DYNAMICSTRING
TRIO_PRIVATE void TrioOutStreamStringDynamic TRIO_ARGS2((self, output), trio_class_t* self,
int output)
{
assert(VALID(self));
assert(VALID(self->location));
if (self->error == 0)
{
trio_xstring_append_char((trio_string_t*)self->location, (char)output);
self->actually.committed++;
}
/* The processed variable must always be increased */
self->processed++;
}
#endif /* TRIO_FEATURE_DYNAMICSTRING */
/*************************************************************************
* TrioArrayGetter
*/
static trio_pointer_t TrioArrayGetter(trio_pointer_t context, int index, int type)
{
/* Utility function for the printfv family */
trio_pointer_t* argarray = (trio_pointer_t*)context;
return argarray[index];
}
/*************************************************************************
*
* Formatted printing functions
*
************************************************************************/
/** @addtogroup Printf
@{
*/
/*************************************************************************
* printf
*/
/**
Print to standard output stream.
@param format Formatting string.
@param ... Arguments.
@return Number of printed characters.
*/
#if TRIO_FEATURE_STDIO
TRIO_PUBLIC int trio_printf TRIO_VARGS2((format, va_alist), TRIO_CONST char* format, TRIO_VA_DECL)
{
int status;
va_list args;
assert(VALID(format));
TRIO_VA_START(args, format);
status = TrioFormat(stdout, 0, TrioOutStreamFile, format, args, NULL, NULL);
TRIO_VA_END(args);
return status;
}
#endif /* TRIO_FEATURE_STDIO */
/**
Print to standard output stream.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
#if TRIO_FEATURE_STDIO
TRIO_PUBLIC int trio_vprintf TRIO_ARGS2((format, args), TRIO_CONST char* format, va_list args)
{
assert(VALID(format));
return TrioFormat(stdout, 0, TrioOutStreamFile, format, args, NULL, NULL);
}
#endif /* TRIO_FEATURE_STDIO */
/**
Print to standard output stream.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
#if TRIO_FEATURE_STDIO
TRIO_PUBLIC int trio_printfv TRIO_ARGS2((format, args), TRIO_CONST char* format,
trio_pointer_t* args)
{
static va_list unused;
assert(VALID(format));
return TrioFormat(stdout, 0, TrioOutStreamFile, format, unused, TrioArrayGetter, args);
}
#endif /* TRIO_FEATURE_STDIO */
/*************************************************************************
* fprintf
*/
/**
Print to file.
@param file File pointer.
@param format Formatting string.
@param ... Arguments.
@return Number of printed characters.
*/
#if TRIO_FEATURE_FILE
TRIO_PUBLIC int trio_fprintf TRIO_VARGS3((file, format, va_alist), FILE* file,
TRIO_CONST char* format, TRIO_VA_DECL)
{
int status;
va_list args;
assert(VALID(file));
assert(VALID(format));
TRIO_VA_START(args, format);
status = TrioFormat(file, 0, TrioOutStreamFile, format, args, NULL, NULL);
TRIO_VA_END(args);
return status;
}
#endif /* TRIO_FEATURE_FILE */
/**
Print to file.
@param file File pointer.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
#if TRIO_FEATURE_FILE
TRIO_PUBLIC int trio_vfprintf TRIO_ARGS3((file, format, args), FILE* file, TRIO_CONST char* format,
va_list args)
{
assert(VALID(file));
assert(VALID(format));
return TrioFormat(file, 0, TrioOutStreamFile, format, args, NULL, NULL);
}
#endif /* TRIO_FEATURE_FILE */
/**
Print to file.
@param file File pointer.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
#if TRIO_FEATURE_FILE
TRIO_PUBLIC int trio_fprintfv TRIO_ARGS3((file, format, args), FILE* file, TRIO_CONST char* format,
trio_pointer_t* args)
{
static va_list unused;
assert(VALID(file));
assert(VALID(format));
return TrioFormat(file, 0, TrioOutStreamFile, format, unused, TrioArrayGetter, args);
}
#endif /* TRIO_FEATURE_FILE */
/*************************************************************************
* dprintf
*/
/**
Print to file descriptor.
@param fd File descriptor.
@param format Formatting string.
@param ... Arguments.
@return Number of printed characters.
*/
#if TRIO_FEATURE_FD
TRIO_PUBLIC int trio_dprintf TRIO_VARGS3((fd, format, va_alist), int fd, TRIO_CONST char* format,
TRIO_VA_DECL)
{
int status;
va_list args;
assert(VALID(format));
TRIO_VA_START(args, format);
status = TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, args, NULL, NULL);
TRIO_VA_END(args);
return status;
}
#endif /* TRIO_FEATURE_FD */
/**
Print to file descriptor.
@param fd File descriptor.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
#if TRIO_FEATURE_FD
TRIO_PUBLIC int trio_vdprintf TRIO_ARGS3((fd, format, args), int fd, TRIO_CONST char* format,
va_list args)
{
assert(VALID(format));
return TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, args, NULL, NULL);
}
#endif /* TRIO_FEATURE_FD */
/**
Print to file descriptor.
@param fd File descriptor.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
#if TRIO_FEATURE_FD
TRIO_PUBLIC int trio_dprintfv TRIO_ARGS3((fd, format, args), int fd, TRIO_CONST char* format,
trio_pointer_t* args)
{
static va_list unused;
assert(VALID(format));
return TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, unused, TrioArrayGetter, args);
}
#endif /* TRIO_FEATURE_FD */
/*************************************************************************
* cprintf
*/
#if TRIO_FEATURE_CLOSURE
TRIO_PUBLIC int trio_cprintf TRIO_VARGS4((stream, closure, format, va_alist),
trio_outstream_t stream, trio_pointer_t closure,
TRIO_CONST char* format, TRIO_VA_DECL)
{
int status;
va_list args;
trio_custom_t data;
assert(VALID(stream));
assert(VALID(format));
TRIO_VA_START(args, format);
data.stream.out = stream;
data.closure = closure;
status = TrioFormat(&data, 0, TrioOutStreamCustom, format, args, NULL, NULL);
TRIO_VA_END(args);
return status;
}
#endif /* TRIO_FEATURE_CLOSURE */
#if TRIO_FEATURE_CLOSURE
TRIO_PUBLIC int trio_vcprintf TRIO_ARGS4((stream, closure, format, args), trio_outstream_t stream,
trio_pointer_t closure, TRIO_CONST char* format,
va_list args)
{
trio_custom_t data;
assert(VALID(stream));
assert(VALID(format));
data.stream.out = stream;
data.closure = closure;
return TrioFormat(&data, 0, TrioOutStreamCustom, format, args, NULL, NULL);
}
#endif /* TRIO_FEATURE_CLOSURE */
#if TRIO_FEATURE_CLOSURE
TRIO_PUBLIC int trio_cprintfv TRIO_ARGS4((stream, closure, format, args), trio_outstream_t stream,
trio_pointer_t closure, TRIO_CONST char* format,
trio_pointer_t* args)
{
static va_list unused;
trio_custom_t data;
assert(VALID(stream));
assert(VALID(format));
data.stream.out = stream;
data.closure = closure;
return TrioFormat(&data, 0, TrioOutStreamCustom, format, unused, TrioArrayGetter, args);
}
#endif /* TRIO_FEATURE_CLOSURE */
#if TRIO_FEATURE_CLOSURE && TRIO_FEATURE_ARGFUNC
TRIO_PUBLIC int trio_cprintff TRIO_ARGS5((stream, closure, format, argfunc, context),
trio_outstream_t stream, trio_pointer_t closure,
TRIO_CONST char* format, trio_argfunc_t argfunc,
trio_pointer_t context)
{
static va_list unused;
trio_custom_t data;
assert(VALID(stream));
assert(VALID(format));
assert(VALID(argfunc));
data.stream.out = stream;
data.closure = closure;
return TrioFormat(&data, 0, TrioOutStreamCustom, format, unused, argfunc,
(trio_pointer_t*)context);
}
#endif /* TRIO_FEATURE_CLOSURE && TRIO_FEATURE_ARGFUNC */
/*************************************************************************
* sprintf
*/
/**
Print to string.
@param buffer Output string.
@param format Formatting string.
@param ... Arguments.
@return Number of printed characters.
*/
TRIO_PUBLIC int trio_sprintf TRIO_VARGS3((buffer, format, va_alist), char* buffer,
TRIO_CONST char* format, TRIO_VA_DECL)
{
int status;
va_list args;
assert(VALID(buffer));
assert(VALID(format));
TRIO_VA_START(args, format);
status = TrioFormat(&buffer, 0, TrioOutStreamString, format, args, NULL, NULL);
*buffer = NIL; /* Terminate with NIL character */
TRIO_VA_END(args);
return status;
}
/**
Print to string.
@param buffer Output string.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
TRIO_PUBLIC int trio_vsprintf TRIO_ARGS3((buffer, format, args), char* buffer,
TRIO_CONST char* format, va_list args)
{
int status;
assert(VALID(buffer));
assert(VALID(format));
status = TrioFormat(&buffer, 0, TrioOutStreamString, format, args, NULL, NULL);
*buffer = NIL;
return status;
}
/**
Print to string.
@param buffer Output string.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
TRIO_PUBLIC int trio_sprintfv TRIO_ARGS3((buffer, format, args), char* buffer,
TRIO_CONST char* format, trio_pointer_t* args)
{
static va_list unused;
int status;
assert(VALID(buffer));
assert(VALID(format));
status = TrioFormat(&buffer, 0, TrioOutStreamString, format, unused, TrioArrayGetter, args);
*buffer = NIL;
return status;
}
/*************************************************************************
* snprintf
*/
/**
Print at most @p max characters to string.
@param buffer Output string.
@param max Maximum number of characters to print.
@param format Formatting string.
@param ... Arguments.
@return Number of printed characters.
*/
TRIO_PUBLIC int trio_snprintf TRIO_VARGS4((buffer, max, format, va_alist), char* buffer, size_t max,
TRIO_CONST char* format, TRIO_VA_DECL)
{
int status;
va_list args;
assert(VALID(buffer) || (max == 0));
assert(VALID(format));
TRIO_VA_START(args, format);
status = TrioFormat(&buffer, max > 0 ? max - 1 : 0, TrioOutStreamStringMax, format, args, NULL,
NULL);
if (max > 0)
*buffer = NIL;
TRIO_VA_END(args);
return status;
}
/**
Print at most @p max characters to string.
@param buffer Output string.
@param max Maximum number of characters to print.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
TRIO_PUBLIC int trio_vsnprintf TRIO_ARGS4((buffer, max, format, args), char* buffer, size_t max,
TRIO_CONST char* format, va_list args)
{
int status;
assert(VALID(buffer) || (max == 0));
assert(VALID(format));
status = TrioFormat(&buffer, max > 0 ? max - 1 : 0, TrioOutStreamStringMax, format, args, NULL,
NULL);
if (max > 0)
*buffer = NIL;
return status;
}
/**
Print at most @p max characters to string.
@param buffer Output string.
@param max Maximum number of characters to print.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
TRIO_PUBLIC int trio_snprintfv TRIO_ARGS4((buffer, max, format, args), char* buffer, size_t max,
TRIO_CONST char* format, trio_pointer_t* args)
{
static va_list unused;
int status;
assert(VALID(buffer) || (max == 0));
assert(VALID(format));
status = TrioFormat(&buffer, max > 0 ? max - 1 : 0, TrioOutStreamStringMax, format, unused,
TrioArrayGetter, args);
if (max > 0)
*buffer = NIL;
return status;
}
/*************************************************************************
* snprintfcat
* Appends the new string to the buffer string overwriting the '\0'
* character at the end of buffer.
*/
#if TRIO_EXTENSION
TRIO_PUBLIC int trio_snprintfcat TRIO_VARGS4((buffer, max, format, va_alist), char* buffer,
size_t max, TRIO_CONST char* format, TRIO_VA_DECL)
{
int status;
va_list args;
size_t buf_len;
TRIO_VA_START(args, format);
assert(VALID(buffer));
assert(VALID(format));
buf_len = trio_length(buffer);
buffer = &buffer[buf_len];
status =
TrioFormat(&buffer, max - 1 - buf_len, TrioOutStreamStringMax, format, args, NULL, NULL);
TRIO_VA_END(args);
*buffer = NIL;
return status;
}
#endif
#if TRIO_EXTENSION
TRIO_PUBLIC int trio_vsnprintfcat TRIO_ARGS4((buffer, max, format, args), char* buffer, size_t max,
TRIO_CONST char* format, va_list args)
{
int status;
size_t buf_len;
assert(VALID(buffer));
assert(VALID(format));
buf_len = trio_length(buffer);
buffer = &buffer[buf_len];
status =
TrioFormat(&buffer, max - 1 - buf_len, TrioOutStreamStringMax, format, args, NULL, NULL);
*buffer = NIL;
return status;
}
#endif
/*************************************************************************
* trio_aprintf
*/
#if TRIO_DEPRECATED && TRIO_FEATURE_DYNAMICSTRING
TRIO_PUBLIC char* trio_aprintf TRIO_VARGS2((format, va_alist), TRIO_CONST char* format,
TRIO_VA_DECL)
{
va_list args;
trio_string_t* info;
char* result = NULL;
assert(VALID(format));
info = trio_xstring_duplicate("");
if (info)
{
TRIO_VA_START(args, format);
(void)TrioFormat(info, 0, TrioOutStreamStringDynamic, format, args, NULL, NULL);
TRIO_VA_END(args);
trio_string_terminate(info);
result = trio_string_extract(info);
trio_string_destroy(info);
}
return result;
}
#endif /* TRIO_DEPRECATED && TRIO_FEATURE_DYNAMICSTRING */
#if TRIO_DEPRECATED && TRIO_FEATURE_DYNAMICSTRING
TRIO_PUBLIC char* trio_vaprintf TRIO_ARGS2((format, args), TRIO_CONST char* format, va_list args)
{
trio_string_t* info;
char* result = NULL;
assert(VALID(format));
info = trio_xstring_duplicate("");
if (info)
{
(void)TrioFormat(info, 0, TrioOutStreamStringDynamic, format, args, NULL, NULL);
trio_string_terminate(info);
result = trio_string_extract(info);
trio_string_destroy(info);
}
return result;
}
#endif /* TRIO_DEPRECATED && TRIO_FEATURE_DYNAMICSTRING */
/**
Allocate and print to string.
The memory allocated and returned by @p result must be freed by the
calling application.
@param result Output string.
@param format Formatting string.
@param ... Arguments.
@return Number of printed characters.
*/
#if TRIO_FEATURE_DYNAMICSTRING
TRIO_PUBLIC int trio_asprintf TRIO_VARGS3((result, format, va_alist), char** result,
TRIO_CONST char* format, TRIO_VA_DECL)
{
va_list args;
int status;
trio_string_t* info;
assert(VALID(format));
*result = NULL;
info = trio_xstring_duplicate("");
if (info == NULL)
{
status = TRIO_ERROR_RETURN(TRIO_ENOMEM, 0);
}
else
{
TRIO_VA_START(args, format);
status = TrioFormat(info, 0, TrioOutStreamStringDynamic, format, args, NULL, NULL);
TRIO_VA_END(args);
if (status >= 0)
{
trio_string_terminate(info);
*result = trio_string_extract(info);
}
trio_string_destroy(info);
}
return status;
}
#endif /* TRIO_FEATURE_DYNAMICSTRING */
/**
Allocate and print to string.
The memory allocated and returned by @p result must be freed by the
calling application.
@param result Output string.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
#if TRIO_FEATURE_DYNAMICSTRING
TRIO_PUBLIC int trio_vasprintf TRIO_ARGS3((result, format, args), char** result,
TRIO_CONST char* format, va_list args)
{
int status;
trio_string_t* info;
assert(VALID(format));
*result = NULL;
info = trio_xstring_duplicate("");
if (info == NULL)
{
status = TRIO_ERROR_RETURN(TRIO_ENOMEM, 0);
}
else
{
status = TrioFormat(info, 0, TrioOutStreamStringDynamic, format, args, NULL, NULL);
if (status >= 0)
{
trio_string_terminate(info);
*result = trio_string_extract(info);
}
trio_string_destroy(info);
}
return status;
}
#endif /* TRIO_FEATURE_DYNAMICSTRING */
/**
Allocate and print to string.
The memory allocated and returned by @p result must be freed by the
calling application.
@param result Output string.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
#if TRIO_FEATURE_DYNAMICSTRING
TRIO_PUBLIC int trio_asprintfv TRIO_ARGS3((result, format, args), char** result,
TRIO_CONST char* format, trio_pointer_t* args)
{
static va_list unused;
int status;
trio_string_t* info;
assert(VALID(format));
*result = NULL;
info = trio_xstring_duplicate("");
if (info == NULL)
{
status = TRIO_ERROR_RETURN(TRIO_ENOMEM, 0);
}
else
{
status =
TrioFormat(info, 0, TrioOutStreamStringDynamic, format, unused, TrioArrayGetter, args);
if (status >= 0)
{
trio_string_terminate(info);
*result = trio_string_extract(info);
}
trio_string_destroy(info);
}
return status;
}
#endif /* TRIO_FEATURE_DYNAMICSTRING */
#if defined(TRIO_DOCUMENTATION)
#include "doc/doc_printf.h"
#endif
/** @} End of Printf documentation module */
/*************************************************************************
*
* CALLBACK
*
************************************************************************/
#if defined(TRIO_DOCUMENTATION)
#include "doc/doc_register.h"
#endif
/**
@addtogroup UserDefined
@{
*/
#if TRIO_FEATURE_USER_DEFINED
/*************************************************************************
* trio_register
*/
/**
Register new user-defined specifier.
@param callback
@param name
@return Handle.
*/
TRIO_PUBLIC trio_pointer_t trio_register TRIO_ARGS2((callback, name), trio_callback_t callback,
TRIO_CONST char* name)
{
trio_userdef_t* def;
trio_userdef_t* prev = NULL;
if (callback == NULL)
return NULL;
if (name)
{
/* Handle built-in namespaces */
if (name[0] == ':')
{
if (trio_equal(name, ":enter"))
{
internalEnterCriticalRegion = callback;
}
else if (trio_equal(name, ":leave"))
{
internalLeaveCriticalRegion = callback;
}
return NULL;
}
/* Bail out if namespace is too long */
if (trio_length_max(name, MAX_USER_NAME) >= MAX_USER_NAME)
return NULL;
/* Bail out if namespace already is registered */
def = TrioFindNamespace(name, &prev);
if (def)
return NULL;
}
def = (trio_userdef_t*)TRIO_MALLOC(sizeof(trio_userdef_t));
if (def)
{
if (internalEnterCriticalRegion)
(void)internalEnterCriticalRegion(NULL);
if (name)
{
/* Link into internal list */
if (prev == NULL)
internalUserDef = def;
else
prev->next = def;
}
/* Initialize */
def->callback = callback;
def->name = (name == NULL) ? NULL : trio_duplicate(name);
def->next = NULL;
if (internalLeaveCriticalRegion)
(void)internalLeaveCriticalRegion(NULL);
}
return (trio_pointer_t)def;
}
/**
Unregister an existing user-defined specifier.
@param handle
*/
void trio_unregister TRIO_ARGS1((handle), trio_pointer_t handle)
{
trio_userdef_t* self = (trio_userdef_t*)handle;
trio_userdef_t* def;
trio_userdef_t* prev = NULL;
assert(VALID(self));
if (self->name)
{
def = TrioFindNamespace(self->name, &prev);
if (def)
{
if (internalEnterCriticalRegion)
(void)internalEnterCriticalRegion(NULL);
if (prev == NULL)
internalUserDef = internalUserDef->next;
else
prev->next = def->next;
if (internalLeaveCriticalRegion)
(void)internalLeaveCriticalRegion(NULL);
}
trio_destroy(self->name);
}
TRIO_FREE(self);
}
/*************************************************************************
* trio_get_format [public]
*/
TRIO_CONST char* trio_get_format TRIO_ARGS1((ref), trio_pointer_t ref)
{
#if TRIO_FEATURE_USER_DEFINED
assert(((trio_reference_t*)ref)->parameter->type == FORMAT_USER_DEFINED);
#endif
return (((trio_reference_t*)ref)->parameter->user_data);
}
/*************************************************************************
* trio_get_argument [public]
*/
trio_pointer_t trio_get_argument TRIO_ARGS1((ref), trio_pointer_t ref)
{
#if TRIO_FEATURE_USER_DEFINED
assert(((trio_reference_t*)ref)->parameter->type == FORMAT_USER_DEFINED);
#endif
return ((trio_reference_t*)ref)->parameter->data.pointer;
}
/*************************************************************************
* trio_get_width / trio_set_width [public]
*/
int trio_get_width TRIO_ARGS1((ref), trio_pointer_t ref)
{
return ((trio_reference_t*)ref)->parameter->width;
}
void trio_set_width TRIO_ARGS2((ref, width), trio_pointer_t ref, int width)
{
((trio_reference_t*)ref)->parameter->width = width;
}
/*************************************************************************
* trio_get_precision / trio_set_precision [public]
*/
int trio_get_precision TRIO_ARGS1((ref), trio_pointer_t ref)
{
return (((trio_reference_t*)ref)->parameter->precision);
}
void trio_set_precision TRIO_ARGS2((ref, precision), trio_pointer_t ref, int precision)
{
((trio_reference_t*)ref)->parameter->precision = precision;
}
/*************************************************************************
* trio_get_base / trio_set_base [public]
*/
int trio_get_base TRIO_ARGS1((ref), trio_pointer_t ref)
{
return (((trio_reference_t*)ref)->parameter->base);
}
void trio_set_base TRIO_ARGS2((ref, base), trio_pointer_t ref, int base)
{
((trio_reference_t*)ref)->parameter->base = base;
}
/*************************************************************************
* trio_get_long / trio_set_long [public]
*/
int trio_get_long TRIO_ARGS1((ref), trio_pointer_t ref)
{
return (((trio_reference_t*)ref)->parameter->flags & FLAGS_LONG) ? TRUE : FALSE;
}
void trio_set_long TRIO_ARGS2((ref, is_long), trio_pointer_t ref, int is_long)
{
if (is_long)
((trio_reference_t*)ref)->parameter->flags |= FLAGS_LONG;
else
((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_LONG;
}
/*************************************************************************
* trio_get_longlong / trio_set_longlong [public]
*/
int trio_get_longlong TRIO_ARGS1((ref), trio_pointer_t ref)
{
return (((trio_reference_t*)ref)->parameter->flags & FLAGS_QUAD) ? TRUE : FALSE;
}
void trio_set_longlong TRIO_ARGS2((ref, is_longlong), trio_pointer_t ref, int is_longlong)
{
if (is_longlong)
((trio_reference_t*)ref)->parameter->flags |= FLAGS_QUAD;
else
((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_QUAD;
}
/*************************************************************************
* trio_get_longdouble / trio_set_longdouble [public]
*/
#if TRIO_FEATURE_FLOAT
int trio_get_longdouble TRIO_ARGS1((ref), trio_pointer_t ref)
{
return (((trio_reference_t*)ref)->parameter->flags & FLAGS_LONGDOUBLE) ? TRUE : FALSE;
}
void trio_set_longdouble TRIO_ARGS2((ref, is_longdouble), trio_pointer_t ref, int is_longdouble)
{
if (is_longdouble)
((trio_reference_t*)ref)->parameter->flags |= FLAGS_LONGDOUBLE;
else
((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_LONGDOUBLE;
}
#endif /* TRIO_FEATURE_FLOAT */
/*************************************************************************
* trio_get_short / trio_set_short [public]
*/
int trio_get_short TRIO_ARGS1((ref), trio_pointer_t ref)
{
return (((trio_reference_t*)ref)->parameter->flags & FLAGS_SHORT) ? TRUE : FALSE;
}
void trio_set_short TRIO_ARGS2((ref, is_short), trio_pointer_t ref, int is_short)
{
if (is_short)
((trio_reference_t*)ref)->parameter->flags |= FLAGS_SHORT;
else
((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_SHORT;
}
/*************************************************************************
* trio_get_shortshort / trio_set_shortshort [public]
*/
int trio_get_shortshort TRIO_ARGS1((ref), trio_pointer_t ref)
{
return (((trio_reference_t*)ref)->parameter->flags & FLAGS_SHORTSHORT) ? TRUE : FALSE;
}
void trio_set_shortshort TRIO_ARGS2((ref, is_shortshort), trio_pointer_t ref, int is_shortshort)
{
if (is_shortshort)
((trio_reference_t*)ref)->parameter->flags |= FLAGS_SHORTSHORT;
else
((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_SHORTSHORT;
}
/*************************************************************************
* trio_get_alternative / trio_set_alternative [public]
*/
int trio_get_alternative TRIO_ARGS1((ref), trio_pointer_t ref)
{
return (((trio_reference_t*)ref)->parameter->flags & FLAGS_ALTERNATIVE) ? TRUE : FALSE;
}
void trio_set_alternative TRIO_ARGS2((ref, is_alternative), trio_pointer_t ref, int is_alternative)
{
if (is_alternative)
((trio_reference_t*)ref)->parameter->flags |= FLAGS_ALTERNATIVE;
else
((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_ALTERNATIVE;
}
/*************************************************************************
* trio_get_alignment / trio_set_alignment [public]
*/
int trio_get_alignment TRIO_ARGS1((ref), trio_pointer_t ref)
{
return (((trio_reference_t*)ref)->parameter->flags & FLAGS_LEFTADJUST) ? TRUE : FALSE;
}
void trio_set_alignment TRIO_ARGS2((ref, is_leftaligned), trio_pointer_t ref, int is_leftaligned)
{
if (is_leftaligned)
((trio_reference_t*)ref)->parameter->flags |= FLAGS_LEFTADJUST;
else
((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_LEFTADJUST;
}
/*************************************************************************
* trio_get_spacing /trio_set_spacing [public]
*/
int trio_get_spacing TRIO_ARGS1((ref), trio_pointer_t ref)
{
return (((trio_reference_t*)ref)->parameter->flags & FLAGS_SPACE) ? TRUE : FALSE;
}
void trio_set_spacing TRIO_ARGS2((ref, is_space), trio_pointer_t ref, int is_space)
{
if (is_space)
((trio_reference_t*)ref)->parameter->flags |= FLAGS_SPACE;
else
((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_SPACE;
}
/*************************************************************************
* trio_get_sign / trio_set_sign [public]
*/
int trio_get_sign TRIO_ARGS1((ref), trio_pointer_t ref)
{
return (((trio_reference_t*)ref)->parameter->flags & FLAGS_SHOWSIGN) ? TRUE : FALSE;
}
void trio_set_sign TRIO_ARGS2((ref, is_sign), trio_pointer_t ref, int is_sign)
{
if (is_sign)
((trio_reference_t*)ref)->parameter->flags |= FLAGS_SHOWSIGN;
else
((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_SHOWSIGN;
}
/*************************************************************************
* trio_get_padding / trio_set_padding [public]
*/
int trio_get_padding TRIO_ARGS1((ref), trio_pointer_t ref)
{
return (((trio_reference_t*)ref)->parameter->flags & FLAGS_NILPADDING) ? TRUE : FALSE;
}
void trio_set_padding TRIO_ARGS2((ref, is_padding), trio_pointer_t ref, int is_padding)
{
if (is_padding)
((trio_reference_t*)ref)->parameter->flags |= FLAGS_NILPADDING;
else
((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_NILPADDING;
}
/*************************************************************************
* trio_get_quote / trio_set_quote [public]
*/
#if TRIO_FEATURE_QUOTE
int trio_get_quote TRIO_ARGS1((ref), trio_pointer_t ref)
{
return (((trio_reference_t*)ref)->parameter->flags & FLAGS_QUOTE) ? TRUE : FALSE;
}
void trio_set_quote TRIO_ARGS2((ref, is_quote), trio_pointer_t ref, int is_quote)
{
if (is_quote)
((trio_reference_t*)ref)->parameter->flags |= FLAGS_QUOTE;
else
((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_QUOTE;
}
#endif /* TRIO_FEATURE_QUOTE */
/*************************************************************************
* trio_get_upper / trio_set_upper [public]
*/
int trio_get_upper TRIO_ARGS1((ref), trio_pointer_t ref)
{
return (((trio_reference_t*)ref)->parameter->flags & FLAGS_UPPER) ? TRUE : FALSE;
}
void trio_set_upper TRIO_ARGS2((ref, is_upper), trio_pointer_t ref, int is_upper)
{
if (is_upper)
((trio_reference_t*)ref)->parameter->flags |= FLAGS_UPPER;
else
((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_UPPER;
}
/*************************************************************************
* trio_get_largest / trio_set_largest [public]
*/
#if TRIO_FEATURE_INTMAX_T
int trio_get_largest TRIO_ARGS1((ref), trio_pointer_t ref)
{
return (((trio_reference_t*)ref)->parameter->flags & FLAGS_INTMAX_T) ? TRUE : FALSE;
}
void trio_set_largest TRIO_ARGS2((ref, is_largest), trio_pointer_t ref, int is_largest)
{
if (is_largest)
((trio_reference_t*)ref)->parameter->flags |= FLAGS_INTMAX_T;
else
((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_INTMAX_T;
}
#endif /* TRIO_FEATURE_INTMAX_T */
/*************************************************************************
* trio_get_ptrdiff / trio_set_ptrdiff [public]
*/
#if TRIO_FEATURE_PTRDIFF_T
int trio_get_ptrdiff TRIO_ARGS1((ref), trio_pointer_t ref)
{
return (((trio_reference_t*)ref)->parameter->flags & FLAGS_PTRDIFF_T) ? TRUE : FALSE;
}
void trio_set_ptrdiff TRIO_ARGS2((ref, is_ptrdiff), trio_pointer_t ref, int is_ptrdiff)
{
if (is_ptrdiff)
((trio_reference_t*)ref)->parameter->flags |= FLAGS_PTRDIFF_T;
else
((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_PTRDIFF_T;
}
#endif /* TRIO_FEATURE_PTRDIFF_T */
/*************************************************************************
* trio_get_size / trio_set_size [public]
*/
#if TRIO_FEATURE_SIZE_T
int trio_get_size TRIO_ARGS1((ref), trio_pointer_t ref)
{
return (((trio_reference_t*)ref)->parameter->flags & FLAGS_SIZE_T) ? TRUE : FALSE;
}
void trio_set_size TRIO_ARGS2((ref, is_size), trio_pointer_t ref, int is_size)
{
if (is_size)
((trio_reference_t*)ref)->parameter->flags |= FLAGS_SIZE_T;
else
((trio_reference_t*)ref)->parameter->flags &= ~FLAGS_SIZE_T;
}
#endif /* TRIO_FEATURE_SIZE_T */
/*************************************************************************
* trio_print_int [public]
*/
void trio_print_int TRIO_ARGS2((ref, number), trio_pointer_t ref, int number)
{
trio_reference_t* self = (trio_reference_t*)ref;
TrioWriteNumber(self->data, (trio_uintmax_t)number, self->parameter->flags,
self->parameter->width, self->parameter->precision, self->parameter->base);
}
/*************************************************************************
* trio_print_uint [public]
*/
void trio_print_uint TRIO_ARGS2((ref, number), trio_pointer_t ref, unsigned int number)
{
trio_reference_t* self = (trio_reference_t*)ref;
TrioWriteNumber(self->data, (trio_uintmax_t)number, self->parameter->flags | FLAGS_UNSIGNED,
self->parameter->width, self->parameter->precision, self->parameter->base);
}
/*************************************************************************
* trio_print_double [public]
*/
#if TRIO_FEATURE_FLOAT
void trio_print_double TRIO_ARGS2((ref, number), trio_pointer_t ref, double number)
{
trio_reference_t* self = (trio_reference_t*)ref;
TrioWriteDouble(self->data, number, self->parameter->flags, self->parameter->width,
self->parameter->precision, self->parameter->base);
}
#endif /* TRIO_FEATURE_FLOAT */
/*************************************************************************
* trio_print_string [public]
*/
void trio_print_string TRIO_ARGS2((ref, string), trio_pointer_t ref, TRIO_CONST char* string)
{
trio_reference_t* self = (trio_reference_t*)ref;
TrioWriteString(self->data, string, self->parameter->flags, self->parameter->width,
self->parameter->precision);
}
/*************************************************************************
* trio_print_ref [public]
*/
int trio_print_ref TRIO_VARGS3((ref, format, va_alist), trio_pointer_t ref, TRIO_CONST char* format,
TRIO_VA_DECL)
{
int status;
va_list arglist;
assert(VALID(format));
TRIO_VA_START(arglist, format);
status = TrioFormatRef((trio_reference_t*)ref, format, arglist, NULL, NULL);
TRIO_VA_END(arglist);
return status;
}
/*************************************************************************
* trio_vprint_ref [public]
*/
int trio_vprint_ref TRIO_ARGS3((ref, format, arglist), trio_pointer_t ref, TRIO_CONST char* format,
va_list arglist)
{
assert(VALID(format));
return TrioFormatRef((trio_reference_t*)ref, format, arglist, NULL, NULL);
}
/*************************************************************************
* trio_printv_ref [public]
*/
int trio_printv_ref TRIO_ARGS3((ref, format, argarray), trio_pointer_t ref, TRIO_CONST char* format,
trio_pointer_t* argarray)
{
static va_list unused;
assert(VALID(format));
return TrioFormatRef((trio_reference_t*)ref, format, unused, TrioArrayGetter, argarray);
}
#endif
/*************************************************************************
* trio_print_pointer [public]
*/
void trio_print_pointer TRIO_ARGS2((ref, pointer), trio_pointer_t ref, trio_pointer_t pointer)
{
trio_reference_t* self = (trio_reference_t*)ref;
trio_flags_t flags;
trio_uintmax_t number;
if (NULL == pointer)
{
TRIO_CONST char* string = internalNullString;
while (*string)
self->data->OutStream(self->data, *string++);
}
else
{
/*
* The subtraction of the null pointer is a workaround
* to avoid a compiler warning. The performance overhead
* is negligible (and likely to be removed by an
* optimizing compiler). The (char *) casting is done
* to please ANSI C++.
*/
number = (trio_uintmax_t)((char*)pointer - (char*)0);
/* Shrink to size of pointer */
number &= (trio_uintmax_t)-1;
flags = self->parameter->flags;
flags |= (FLAGS_UNSIGNED | FLAGS_ALTERNATIVE | FLAGS_NILPADDING);
TrioWriteNumber(self->data, number, flags, POINTER_WIDTH, NO_PRECISION, BASE_HEX);
}
}
/** @} End of UserDefined documentation module */
/*************************************************************************
*
* LOCALES
*
************************************************************************/
/*************************************************************************
* trio_locale_set_decimal_point
*
* Decimal point can only be one character. The input argument is a
* string to enable multibyte characters. At most MB_LEN_MAX characters
* will be used.
*/
#if TRIO_FEATURE_LOCALE
TRIO_PUBLIC void trio_locale_set_decimal_point TRIO_ARGS1((decimalPoint), char* decimalPoint)
{
#if defined(USE_LOCALE)
if (NULL == internalLocaleValues)
{
TrioSetLocale();
}
#endif
internalDecimalPointLength = trio_length(decimalPoint);
if (internalDecimalPointLength == 1)
{
internalDecimalPoint = *decimalPoint;
}
else
{
internalDecimalPoint = NIL;
trio_copy_max(internalDecimalPointString, sizeof(internalDecimalPointString), decimalPoint);
}
}
#endif
/*************************************************************************
* trio_locale_set_thousand_separator
*
* See trio_locale_set_decimal_point
*/
#if TRIO_FEATURE_LOCALE || TRIO_EXTENSION
TRIO_PUBLIC void trio_locale_set_thousand_separator TRIO_ARGS1((thousandSeparator),
char* thousandSeparator)
{
#if defined(USE_LOCALE)
if (NULL == internalLocaleValues)
{
TrioSetLocale();
}
#endif
trio_copy_max(internalThousandSeparator, sizeof(internalThousandSeparator), thousandSeparator);
internalThousandSeparatorLength = trio_length(internalThousandSeparator);
}
#endif
/*************************************************************************
* trio_locale_set_grouping
*
* Array of bytes. Reversed order.
*
* CHAR_MAX : No further grouping
* 0 : Repeat last group for the remaining digits (not necessary
* as C strings are zero-terminated)
* n : Set current group to n
*
* Same order as the grouping attribute in LC_NUMERIC.
*/
#if TRIO_FEATURE_LOCALE || TRIO_EXTENSION
TRIO_PUBLIC void trio_locale_set_grouping TRIO_ARGS1((grouping), char* grouping)
{
#if defined(USE_LOCALE)
if (NULL == internalLocaleValues)
{
TrioSetLocale();
}
#endif
trio_copy_max(internalGrouping, sizeof(internalGrouping), grouping);
}
#endif
/*************************************************************************
*
* SCANNING
*
************************************************************************/
#if TRIO_FEATURE_SCANF
/*************************************************************************
* TrioSkipWhitespaces
*/
TRIO_PRIVATE int TrioSkipWhitespaces TRIO_ARGS1((self), trio_class_t* self)
{
int ch;
ch = self->current;
while (isspace(ch))
{
self->InStream(self, &ch);
}
return ch;
}
/*************************************************************************
* TrioGetCollation
*/
#if TRIO_EXTENSION
TRIO_PRIVATE void TrioGetCollation(TRIO_NOARGS)
{
int i;
int j;
int k;
char first[2];
char second[2];
/* This is computationally expensive */
first[1] = NIL;
second[1] = NIL;
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
{
k = 0;
first[0] = (char)i;
for (j = 0; j < MAX_CHARACTER_CLASS; j++)
{
second[0] = (char)j;
if (trio_equal_locale(first, second))
internalCollationArray[i][k++] = (char)j;
}
internalCollationArray[i][k] = NIL;
}
}
#endif
/*************************************************************************
* TrioGetCharacterClass
*
* FIXME:
* multibyte
*/
TRIO_PRIVATE int TrioGetCharacterClass TRIO_ARGS4((format, offsetPointer, flagsPointer,
characterclass),
TRIO_CONST char* format, int* offsetPointer,
trio_flags_t* flagsPointer, int* characterclass)
{
int offset = *offsetPointer;
int i;
char ch;
char range_begin;
char range_end;
*flagsPointer &= ~FLAGS_EXCLUDE;
if (format[offset] == QUALIFIER_CIRCUMFLEX)
{
*flagsPointer |= FLAGS_EXCLUDE;
offset++;
}
/*
* If the ungroup character is at the beginning of the scanlist,
* it will be part of the class, and a second ungroup character
* must follow to end the group.
*/
if (format[offset] == SPECIFIER_UNGROUP)
{
characterclass[(int)SPECIFIER_UNGROUP]++;
offset++;
}
/*
* Minus is used to specify ranges. To include minus in the class,
* it must be at the beginning of the list
*/
if (format[offset] == QUALIFIER_MINUS)
{
characterclass[(int)QUALIFIER_MINUS]++;
offset++;
}
/* Collect characters */
for (ch = format[offset]; (ch != SPECIFIER_UNGROUP) && (ch != NIL); ch = format[++offset])
{
switch (ch)
{
case QUALIFIER_MINUS: /* Scanlist ranges */
/*
* Both C99 and UNIX98 describes ranges as implementation-
* defined.
*
* We support the following behaviour (although this may
* change as we become wiser)
* - only increasing ranges, ie. [a-b] but not [b-a]
* - transitive ranges, ie. [a-b-c] == [a-c]
* - trailing minus, ie. [a-] is interpreted as an 'a'
* and a '-'
* - duplicates (although we can easily convert these
* into errors)
*/
range_begin = format[offset - 1];
range_end = format[++offset];
if (range_end == SPECIFIER_UNGROUP)
{
/* Trailing minus is included */
characterclass[(int)ch]++;
ch = range_end;
break; /* for */
}
if (range_end == NIL)
return TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
if (range_begin > range_end)
return TRIO_ERROR_RETURN(TRIO_ERANGE, offset);
for (i = (int)range_begin; i <= (int)range_end; i++)
characterclass[i]++;
ch = range_end;
break;
#if TRIO_EXTENSION
case SPECIFIER_GROUP:
switch (format[offset + 1])
{
case QUALIFIER_DOT: /* Collating symbol */
/*
* FIXME: This will be easier to implement when multibyte
* characters have been implemented. Until now, we ignore
* this feature.
*/
for (i = offset + 2;; i++)
{
if (format[i] == NIL)
/* Error in syntax */
return -1;
else if (format[i] == QUALIFIER_DOT)
break; /* for */
}
if (format[++i] != SPECIFIER_UNGROUP)
return -1;
offset = i;
break;
case QUALIFIER_EQUAL: /* Equivalence class expressions */
{
unsigned int j;
unsigned int k;
if (internalCollationUnconverted)
{
/* Lazy evaluation of collation array */
TrioGetCollation();
internalCollationUnconverted = FALSE;
}
for (i = offset + 2;; i++)
{
if (format[i] == NIL)
/* Error in syntax */
return -1;
else if (format[i] == QUALIFIER_EQUAL)
break; /* for */
else
{
/* Mark any equivalent character */
k = (unsigned int)format[i];
for (j = 0; internalCollationArray[k][j] != NIL; j++)
characterclass[(int)internalCollationArray[k][j]]++;
}
}
if (format[++i] != SPECIFIER_UNGROUP)
return -1;
offset = i;
}
break;
case QUALIFIER_COLON: /* Character class expressions */
if (trio_equal_max(CLASS_ALNUM, sizeof(CLASS_ALNUM) - 1, &format[offset]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isalnum(i))
characterclass[i]++;
offset += sizeof(CLASS_ALNUM) - 1;
}
else if (trio_equal_max(CLASS_ALPHA, sizeof(CLASS_ALPHA) - 1,
&format[offset]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isalpha(i))
characterclass[i]++;
offset += sizeof(CLASS_ALPHA) - 1;
}
else if (trio_equal_max(CLASS_CNTRL, sizeof(CLASS_CNTRL) - 1,
&format[offset]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (iscntrl(i))
characterclass[i]++;
offset += sizeof(CLASS_CNTRL) - 1;
}
else if (trio_equal_max(CLASS_DIGIT, sizeof(CLASS_DIGIT) - 1,
&format[offset]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isdigit(i))
characterclass[i]++;
offset += sizeof(CLASS_DIGIT) - 1;
}
else if (trio_equal_max(CLASS_GRAPH, sizeof(CLASS_GRAPH) - 1,
&format[offset]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isgraph(i))
characterclass[i]++;
offset += sizeof(CLASS_GRAPH) - 1;
}
else if (trio_equal_max(CLASS_LOWER, sizeof(CLASS_LOWER) - 1,
&format[offset]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (islower(i))
characterclass[i]++;
offset += sizeof(CLASS_LOWER) - 1;
}
else if (trio_equal_max(CLASS_PRINT, sizeof(CLASS_PRINT) - 1,
&format[offset]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isprint(i))
characterclass[i]++;
offset += sizeof(CLASS_PRINT) - 1;
}
else if (trio_equal_max(CLASS_PUNCT, sizeof(CLASS_PUNCT) - 1,
&format[offset]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (ispunct(i))
characterclass[i]++;
offset += sizeof(CLASS_PUNCT) - 1;
}
else if (trio_equal_max(CLASS_SPACE, sizeof(CLASS_SPACE) - 1,
&format[offset]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isspace(i))
characterclass[i]++;
offset += sizeof(CLASS_SPACE) - 1;
}
else if (trio_equal_max(CLASS_UPPER, sizeof(CLASS_UPPER) - 1,
&format[offset]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isupper(i))
characterclass[i]++;
offset += sizeof(CLASS_UPPER) - 1;
}
else if (trio_equal_max(CLASS_XDIGIT, sizeof(CLASS_XDIGIT) - 1,
&format[offset]))
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isxdigit(i))
characterclass[i]++;
offset += sizeof(CLASS_XDIGIT) - 1;
}
else
{
characterclass[(int)ch]++;
}
break;
default:
characterclass[(int)ch]++;
break;
}
break;
#endif /* TRIO_EXTENSION */
default:
characterclass[(int)ch]++;
break;
}
}
return 0;
}
/*************************************************************************
* TrioReadNumber
*
* We implement our own number conversion in preference of strtol and
* strtoul, because we must handle 'long long' and thousand separators.
*/
TRIO_PRIVATE BOOLEAN_T TrioReadNumber TRIO_ARGS5((self, target, flags, width, base),
trio_class_t* self, trio_uintmax_t* target,
trio_flags_t flags, int width, int base)
{
trio_uintmax_t number = 0;
int digit;
int count;
BOOLEAN_T isNegative = FALSE;
BOOLEAN_T gotNumber = FALSE;
int j;
assert(VALID(self));
assert(VALID(self->InStream));
assert((base >= MIN_BASE && base <= MAX_BASE) || (base == NO_BASE));
if (internalDigitsUnconverted)
{
/* Lazy evaluation of digits array */
memset(internalDigitArray, -1, sizeof(internalDigitArray));
for (j = 0; j < (int)sizeof(internalDigitsLower) - 1; j++)
{
internalDigitArray[(int)internalDigitsLower[j]] = j;
internalDigitArray[(int)internalDigitsUpper[j]] = j;
}
internalDigitsUnconverted = FALSE;
}
TrioSkipWhitespaces(self);
/* Leading sign */
if (self->current == '+')
{
self->InStream(self, NULL);
}
else if (self->current == '-')
{
self->InStream(self, NULL);
isNegative = TRUE;
}
count = self->processed;
if (flags & FLAGS_ALTERNATIVE)
{
switch (base)
{
case NO_BASE:
case BASE_OCTAL:
case BASE_HEX:
case BASE_BINARY:
if (self->current == '0')
{
self->InStream(self, NULL);
if (self->current)
{
if ((base == BASE_HEX) && (trio_to_upper(self->current) == 'X'))
{
self->InStream(self, NULL);
}
else if ((base == BASE_BINARY) && (trio_to_upper(self->current) == 'B'))
{
self->InStream(self, NULL);
}
}
}
else
return FALSE;
break;
default:
break;
}
}
while (((width == NO_WIDTH) || (self->processed - count < width)) &&
(!((self->current == EOF) || isspace(self->current))))
{
if (isascii(self->current))
{
digit = internalDigitArray[self->current];
/* Abort if digit is not allowed in the specified base */
if ((digit == -1) || (digit >= base))
break;
}
#if TRIO_FEATURE_QUOTE
else if (flags & FLAGS_QUOTE)
{
/* Compare with thousands separator */
for (j = 0; internalThousandSeparator[j] && self->current; j++)
{
if (internalThousandSeparator[j] != self->current)
break;
self->InStream(self, NULL);
}
if (internalThousandSeparator[j])
break; /* Mismatch */
else
continue; /* Match */
}
#endif
else
break;
number *= base;
number += digit;
gotNumber = TRUE; /* we need at least one digit */
self->InStream(self, NULL);
}
/* Was anything read at all? */
if (!gotNumber)
return FALSE;
if (target)
*target = (isNegative) ? (trio_uintmax_t)(-((trio_intmax_t)number)) : number;
return TRUE;
}
/*************************************************************************
* TrioReadChar
*/
TRIO_PRIVATE int TrioReadChar TRIO_ARGS4((self, target, flags, width), trio_class_t* self,
char* target, trio_flags_t flags, int width)
{
int i;
char ch;
trio_uintmax_t number;
assert(VALID(self));
assert(VALID(self->InStream));
for (i = 0; (self->current != EOF) && (i < width); i++)
{
ch = (char)self->current;
self->InStream(self, NULL);
if ((flags & FLAGS_ALTERNATIVE) && (ch == CHAR_BACKSLASH))
{
switch (self->current)
{
case '\\':
ch = '\\';
break;
case 'a':
ch = '\007';
break;
case 'b':
ch = '\b';
break;
case 'f':
ch = '\f';
break;
case 'n':
ch = '\n';
break;
case 'r':
ch = '\r';
break;
case 't':
ch = '\t';
break;
case 'v':
ch = '\v';
break;
default:
if (isdigit(self->current))
{
/* Read octal number */
if (!TrioReadNumber(self, &number, 0, 3, BASE_OCTAL))
return 0;
ch = (char)number;
}
else if (trio_to_upper(self->current) == 'X')
{
/* Read hexadecimal number */
self->InStream(self, NULL);
if (!TrioReadNumber(self, &number, 0, 2, BASE_HEX))
return 0;
ch = (char)number;
}
else
{
ch = (char)self->current;
}
break;
}
}
if (target)
target[i] = ch;
}
return i + 1;
}
/*************************************************************************
* TrioReadString
*/
TRIO_PRIVATE BOOLEAN_T TrioReadString TRIO_ARGS4((self, target, flags, width), trio_class_t* self,
char* target, trio_flags_t flags, int width)
{
int i;
assert(VALID(self));
assert(VALID(self->InStream));
TrioSkipWhitespaces(self);
/*
* Continue until end of string is reached, a whitespace is encountered,
* or width is exceeded
*/
for (i = 0; ((width == NO_WIDTH) || (i < width)) &&
(!((self->current == EOF) || isspace(self->current)));
i++)
{
if (TrioReadChar(self, (target ? &target[i] : 0), flags, 1) == 0)
break; /* for */
}
if (target)
target[i] = NIL;
return TRUE;
}
/*************************************************************************
* TrioReadWideChar
*/
#if TRIO_FEATURE_WIDECHAR
TRIO_PRIVATE int TrioReadWideChar TRIO_ARGS4((self, target, flags, width), trio_class_t* self,
trio_wchar_t* target, trio_flags_t flags, int width)
{
int i;
int j;
int size;
int amount = 0;
trio_wchar_t wch;
char buffer[MB_LEN_MAX + 1];
assert(VALID(self));
assert(VALID(self->InStream));
for (i = 0; (self->current != EOF) && (i < width); i++)
{
if (isascii(self->current))
{
if (TrioReadChar(self, buffer, flags, 1) == 0)
return 0;
buffer[1] = NIL;
}
else
{
/*
* Collect a multibyte character, by enlarging buffer until
* it contains a fully legal multibyte character, or the
* buffer is full.
*/
j = 0;
do
{
buffer[j++] = (char)self->current;
buffer[j] = NIL;
self->InStream(self, NULL);
} while ((j < (int)sizeof(buffer)) && (mblen(buffer, (size_t)j) != j));
}
if (target)
{
size = mbtowc(&wch, buffer, sizeof(buffer));
if (size > 0)
target[i] = wch;
}
amount += size;
self->InStream(self, NULL);
}
return amount;
}
#endif /* TRIO_FEATURE_WIDECHAR */
/*************************************************************************
* TrioReadWideString
*/
#if TRIO_FEATURE_WIDECHAR
TRIO_PRIVATE BOOLEAN_T TrioReadWideString TRIO_ARGS4((self, target, flags, width),
trio_class_t* self, trio_wchar_t* target,
trio_flags_t flags, int width)
{
int i;
int size;
assert(VALID(self));
assert(VALID(self->InStream));
TrioSkipWhitespaces(self);
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
/* Required by TrioReadWideChar */
(void)mblen(NULL, 0);
#endif
/*
* Continue until end of string is reached, a whitespace is encountered,
* or width is exceeded
*/
for (i = 0; ((width == NO_WIDTH) || (i < width)) &&
(!((self->current == EOF) || isspace(self->current)));)
{
size = TrioReadWideChar(self, &target[i], flags, 1);
if (size == 0)
break; /* for */
i += size;
}
if (target)
target[i] = WCONST('\0');
return TRUE;
}
#endif /* TRIO_FEATURE_WIDECHAR */
/*************************************************************************
* TrioReadGroup
*
* Reads non-empty character groups.
*
* FIXME: characterclass does not work with multibyte characters
*/
TRIO_PRIVATE BOOLEAN_T TrioReadGroup TRIO_ARGS5((self, target, characterclass, flags, width),
trio_class_t* self, char* target,
int* characterclass, trio_flags_t flags, int width)
{
int ch;
int i;
assert(VALID(self));
assert(VALID(self->InStream));
ch = self->current;
for (i = 0; ((width == NO_WIDTH) || (i < width)) &&
(!((ch == EOF) || (((flags & FLAGS_EXCLUDE) != 0) ^ (characterclass[ch] == 0))));
i++)
{
if (target)
target[i] = (char)ch;
self->InStream(self, &ch);
}
if (i == 0)
return FALSE;
/* Terminate the string if input saved */
if (target)
target[i] = NIL;
return TRUE;
}
/*************************************************************************
* TrioReadDouble
*
* FIXME:
* add long double
* handle base
*/
#if TRIO_FEATURE_FLOAT
TRIO_PRIVATE BOOLEAN_T TrioReadDouble TRIO_ARGS4((self, target, flags, width), trio_class_t* self,
trio_pointer_t target, trio_flags_t flags,
int width)
{
int ch;
char doubleString[512];
int offset = 0;
int start;
#if TRIO_FEATURE_QUOTE
int j;
#endif
BOOLEAN_T isHex = FALSE;
trio_long_double_t infinity;
doubleString[0] = 0;
if ((width == NO_WIDTH) || (width > (int)sizeof(doubleString) - 1))
width = sizeof(doubleString) - 1;
TrioSkipWhitespaces(self);
/*
* Read entire double number from stream. trio_to_double requires
* a string as input, but InStream can be anything, so we have to
* collect all characters.
*/
ch = self->current;
if ((ch == '+') || (ch == '-'))
{
doubleString[offset++] = (char)ch;
self->InStream(self, &ch);
width--;
}
start = offset;
switch (ch)
{
case 'n':
case 'N':
/* Not-a-number */
if (offset != 0)
break;
/* FALLTHROUGH */
case 'i':
case 'I':
/* Infinity */
while (isalpha(ch) && (offset - start < width))
{
doubleString[offset++] = (char)ch;
self->InStream(self, &ch);
}
doubleString[offset] = NIL;
/* Case insensitive string comparison */
if (trio_equal(&doubleString[start], INFINITE_UPPER) ||
trio_equal(&doubleString[start], LONG_INFINITE_UPPER))
{
infinity = ((start == 1) && (doubleString[0] == '-')) ? trio_ninf() : trio_pinf();
if (!target)
return FALSE;
if (flags & FLAGS_LONGDOUBLE)
{
*((trio_long_double_t*)target) = infinity;
}
else if (flags & FLAGS_LONG)
{
*((double*)target) = infinity;
}
else
{
*((float*)target) = infinity;
}
return TRUE;
}
if (trio_equal(doubleString, NAN_UPPER))
{
if (!target)
return FALSE;
/* NaN must not have a preceeding + nor - */
if (flags & FLAGS_LONGDOUBLE)
{
*((trio_long_double_t*)target) = trio_nan();
}
else if (flags & FLAGS_LONG)
{
*((double*)target) = trio_nan();
}
else
{
*((float*)target) = trio_nan();
}
return TRUE;
}
return FALSE;
case '0':
doubleString[offset++] = (char)ch;
self->InStream(self, &ch);
if (trio_to_upper(ch) == 'X')
{
isHex = TRUE;
doubleString[offset++] = (char)ch;
self->InStream(self, &ch);
}
break;
default:
break;
}
while ((ch != EOF) && (offset - start < width))
{
/* Integer part */
if (isHex ? isxdigit(ch) : isdigit(ch))
{
doubleString[offset++] = (char)ch;
self->InStream(self, &ch);
}
#if TRIO_FEATURE_QUOTE
else if (flags & FLAGS_QUOTE)
{
/* Compare with thousands separator */
for (j = 0; internalThousandSeparator[j] && self->current; j++)
{
if (internalThousandSeparator[j] != self->current)
break;
self->InStream(self, &ch);
}
if (internalThousandSeparator[j])
break; /* Mismatch */
else
continue; /* Match */
}
#endif
else
break; /* while */
}
if (ch == '.')
{
/* Decimal part */
doubleString[offset++] = (char)ch;
self->InStream(self, &ch);
while ((isHex ? isxdigit(ch) : isdigit(ch)) && (offset - start < width))
{
doubleString[offset++] = (char)ch;
self->InStream(self, &ch);
}
}
if (isHex ? (trio_to_upper(ch) == 'P') : (trio_to_upper(ch) == 'E'))
{
/* Exponent */
doubleString[offset++] = (char)ch;
self->InStream(self, &ch);
if ((ch == '+') || (ch == '-'))
{
doubleString[offset++] = (char)ch;
self->InStream(self, &ch);
}
while (isdigit(ch) && (offset - start < width))
{
doubleString[offset++] = (char)ch;
self->InStream(self, &ch);
}
}
if ((offset == start) || (*doubleString == NIL))
return FALSE;
doubleString[offset] = 0;
if (flags & FLAGS_LONGDOUBLE)
{
if (!target)
return FALSE;
*((trio_long_double_t*)target) = trio_to_long_double(doubleString, NULL);
}
else if (flags & FLAGS_LONG)
{
if (!target)
return FALSE;
*((double*)target) = trio_to_double(doubleString, NULL);
}
else
{
if (!target)
return FALSE;
*((float*)target) = trio_to_float(doubleString, NULL);
}
return TRUE;
}
#endif /* TRIO_FEATURE_FLOAT */
/*************************************************************************
* TrioReadPointer
*/
TRIO_PRIVATE BOOLEAN_T TrioReadPointer TRIO_ARGS3((self, target, flags), trio_class_t* self,
trio_pointer_t* target, trio_flags_t flags)
{
trio_uintmax_t number;
char buffer[sizeof(internalNullString)];
flags |= (FLAGS_UNSIGNED | FLAGS_ALTERNATIVE | FLAGS_NILPADDING);
if (TrioReadNumber(self, &number, flags, POINTER_WIDTH, BASE_HEX))
{
if (target)
{
#if defined(TRIO_COMPILER_GCC) || defined(TRIO_COMPILER_MIPSPRO)
/*
* The strange assignment of number is a workaround for a compiler
* warning
*/
*target = &((char*)0)[number];
#else
*target = (trio_pointer_t)number;
#endif
}
return TRUE;
}
else if (TrioReadString(self, (flags & FLAGS_IGNORE) ? NULL : buffer, 0,
sizeof(internalNullString) - 1))
{
if (trio_equal_case(buffer, internalNullString))
{
if (target)
*target = NULL;
return TRUE;
}
}
return FALSE;
}
/*************************************************************************
* TrioScanProcess
*/
TRIO_PRIVATE int TrioScanProcess TRIO_ARGS3((data, format, parameters), trio_class_t* data,
TRIO_CONST char* format, trio_parameter_t* parameters)
{
int status;
int assignment;
int ch;
int offset; /* Offset of format string */
int i; /* Offset of current parameter */
trio_flags_t flags;
int width;
int base;
trio_pointer_t pointer;
/* Return on empty format string */
if (format[0] == NIL)
return 0;
status = 0;
assignment = 0;
i = 0;
offset = 0;
data->InStream(data, &ch);
for (;;)
{
/* Skip the parameter entries */
while (parameters[i].type == FORMAT_PARAMETER)
{
assert(i <= MAX_PARAMETERS);
i++;
}
/* Compare non conversion-specifier part of format string */
while (offset < parameters[i].beginOffset)
{
if ((CHAR_IDENTIFIER == format[offset]) && (CHAR_IDENTIFIER == format[offset + 1]))
{
/* Two % in format matches one % in input stream */
if (CHAR_IDENTIFIER == ch)
{
data->InStream(data, &ch);
offset += 2;
continue; /* while format chars left */
}
else
{
status = TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
goto end;
}
}
else /* Not an % identifier */
{
if (isspace((int)format[offset]))
{
/* Whitespaces may match any amount of whitespaces */
ch = TrioSkipWhitespaces(data);
}
else if (ch == format[offset])
{
data->InStream(data, &ch);
}
else
{
status = assignment;
goto end;
}
offset++;
}
}
if (parameters[i].type == FORMAT_SENTINEL)
break;
if ((EOF == ch) && (parameters[i].type != FORMAT_COUNT))
{
status = (assignment > 0) ? assignment : EOF;
goto end;
}
flags = parameters[i].flags;
/* Find width */
width = parameters[i].width;
if (flags & FLAGS_WIDTH_PARAMETER)
{
/* Get width from parameter list */
width = (int)parameters[width].data.number.as_signed;
}
/* Find base */
if (NO_BASE != parameters[i].baseSpecifier)
{
/* Base from specifier has priority */
base = parameters[i].baseSpecifier;
}
else if (flags & FLAGS_BASE_PARAMETER)
{
/* Get base from parameter list */
base = parameters[i].base;
base = (int)parameters[base].data.number.as_signed;
}
else
{
/* Use base from format string */
base = parameters[i].base;
}
switch (parameters[i].type)
{
case FORMAT_INT:
{
trio_uintmax_t number;
if (0 == base)
base = BASE_DECIMAL;
if (!TrioReadNumber(data, &number, flags, width, base))
{
status = assignment;
goto end;
}
if (!(flags & FLAGS_IGNORE))
{
assignment++;
pointer = parameters[i].data.pointer;
#if TRIO_FEATURE_SIZE_T || TRIO_FEATURE_SIZE_T_UPPER
if (flags & FLAGS_SIZE_T)
*(size_t*)pointer = (size_t)number;
else
#endif
#if TRIO_FEATURE_PTRDIFF_T
if (flags & FLAGS_PTRDIFF_T)
*(ptrdiff_t*)pointer = (ptrdiff_t)number;
else
#endif
#if TRIO_FEATURE_INTMAX_T
if (flags & FLAGS_INTMAX_T)
*(trio_intmax_t*)pointer = (trio_intmax_t)number;
else
#endif
if (flags & FLAGS_QUAD)
*(trio_ulonglong_t*)pointer = (trio_ulonglong_t)number;
else if (flags & FLAGS_LONG)
*(long int*)pointer = (long int)number;
else if (flags & FLAGS_SHORT)
*(short int*)pointer = (short int)number;
else
*(int*)pointer = (int)number;
}
}
break; /* FORMAT_INT */
case FORMAT_STRING:
#if TRIO_FEATURE_WIDECHAR
if (flags & FLAGS_WIDECHAR)
{
if (!TrioReadWideString(
data, (flags & FLAGS_IGNORE) ? NULL : parameters[i].data.wstring, flags,
width))
{
status = assignment;
goto end;
}
}
else
#endif
{
if (!TrioReadString(data,
(flags & FLAGS_IGNORE) ? NULL : parameters[i].data.string,
flags, width))
{
status = assignment;
goto end;
}
}
if (!(flags & FLAGS_IGNORE))
assignment++;
break; /* FORMAT_STRING */
#if TRIO_FEATURE_FLOAT
case FORMAT_DOUBLE:
{
if (flags & FLAGS_IGNORE)
{
pointer = NULL;
}
else
{
pointer = (flags & FLAGS_LONGDOUBLE)
? (trio_pointer_t)parameters[i].data.longdoublePointer
: (trio_pointer_t)parameters[i].data.doublePointer;
}
if (!TrioReadDouble(data, pointer, flags, width))
{
status = assignment;
goto end;
}
if (!(flags & FLAGS_IGNORE))
{
assignment++;
}
break; /* FORMAT_DOUBLE */
}
#endif
case FORMAT_GROUP:
{
int characterclass[MAX_CHARACTER_CLASS + 1];
/* Skip over modifiers */
while (format[offset] != SPECIFIER_GROUP)
{
offset++;
}
/* Skip over group specifier */
offset++;
memset(characterclass, 0, sizeof(characterclass));
status = TrioGetCharacterClass(format, &offset, &flags, characterclass);
if (status < 0)
goto end;
if (!TrioReadGroup(data, (flags & FLAGS_IGNORE) ? NULL : parameters[i].data.string,
characterclass, flags, parameters[i].width))
{
status = assignment;
goto end;
}
if (!(flags & FLAGS_IGNORE))
assignment++;
}
break; /* FORMAT_GROUP */
case FORMAT_COUNT:
pointer = parameters[i].data.pointer;
if (NULL != pointer)
{
int count = data->processed;
if (ch != EOF)
count--; /* a character is read, but is not consumed yet */
#if TRIO_FEATURE_SIZE_T || TRIO_FEATURE_SIZE_T_UPPER
if (flags & FLAGS_SIZE_T)
*(size_t*)pointer = (size_t)count;
else
#endif
#if TRIO_FEATURE_PTRDIFF_T
if (flags & FLAGS_PTRDIFF_T)
*(ptrdiff_t*)pointer = (ptrdiff_t)count;
else
#endif
#if TRIO_FEATURE_INTMAX_T
if (flags & FLAGS_INTMAX_T)
*(trio_intmax_t*)pointer = (trio_intmax_t)count;
else
#endif
if (flags & FLAGS_QUAD)
{
*(trio_ulonglong_t*)pointer = (trio_ulonglong_t)count;
}
else if (flags & FLAGS_LONG)
{
*(long int*)pointer = (long int)count;
}
else if (flags & FLAGS_SHORT)
{
*(short int*)pointer = (short int)count;
}
else
{
*(int*)pointer = (int)count;
}
}
break; /* FORMAT_COUNT */
case FORMAT_CHAR:
#if TRIO_FEATURE_WIDECHAR
if (flags & FLAGS_WIDECHAR)
{
if (TrioReadWideChar(data,
(flags & FLAGS_IGNORE) ? NULL : parameters[i].data.wstring,
flags, (width == NO_WIDTH) ? 1 : width) == 0)
{
status = assignment;
goto end;
}
}
else
#endif
{
if (TrioReadChar(data,
(flags & FLAGS_IGNORE) ? NULL : parameters[i].data.string,
flags, (width == NO_WIDTH) ? 1 : width) == 0)
{
status = assignment;
goto end;
}
}
if (!(flags & FLAGS_IGNORE))
assignment++;
break; /* FORMAT_CHAR */
case FORMAT_POINTER:
if (!TrioReadPointer(
data,
(flags & FLAGS_IGNORE) ? NULL : (trio_pointer_t*)parameters[i].data.pointer,
flags))
{
status = assignment;
goto end;
}
if (!(flags & FLAGS_IGNORE))
assignment++;
break; /* FORMAT_POINTER */
case FORMAT_PARAMETER:
break; /* FORMAT_PARAMETER */
default:
status = TRIO_ERROR_RETURN(TRIO_EINVAL, offset);
goto end;
}
ch = data->current;
offset = parameters[i].endOffset;
i++;
}
status = assignment;
end:
if (data->UndoStream)
data->UndoStream(data);
return status;
}
/*************************************************************************
* TrioScan
*/
TRIO_PRIVATE int TrioScan TRIO_ARGS8(
(source, sourceSize, InStream, UndoStream, format, arglist, argfunc, argarray),
trio_pointer_t source, size_t sourceSize, void(*InStream) TRIO_PROTO((trio_class_t*, int*)),
void(*UndoStream) TRIO_PROTO((trio_class_t*)), TRIO_CONST char* format, va_list arglist,
trio_argfunc_t argfunc, trio_pointer_t* argarray)
{
int status;
trio_parameter_t parameters[MAX_PARAMETERS];
trio_class_t data;
assert(VALID(InStream));
assert(VALID(format));
memset(&data, 0, sizeof(data));
data.InStream = InStream;
data.UndoStream = UndoStream;
data.location = (trio_pointer_t)source;
data.max = sourceSize;
data.error = 0;
#if defined(USE_LOCALE)
if (NULL == internalLocaleValues)
{
TrioSetLocale();
}
#endif
status = TrioParse(TYPE_SCAN, format, parameters, arglist, argfunc, argarray);
if (status < 0)
return status;
status = TrioScanProcess(&data, format, parameters);
if (data.error != 0)
{
status = data.error;
}
return status;
}
/*************************************************************************
* TrioInStreamFile
*/
#if TRIO_FEATURE_FILE || TRIO_FEATURE_STDIO
TRIO_PRIVATE void TrioInStreamFile TRIO_ARGS2((self, intPointer), trio_class_t* self,
int* intPointer)
{
FILE* file = (FILE*)self->location;
assert(VALID(self));
assert(VALID(file));
self->actually.cached = 0;
/* The initial value of self->current is zero */
if (self->current == EOF)
{
self->error =
(ferror(file)) ? TRIO_ERROR_RETURN(TRIO_ERRNO, 0) : TRIO_ERROR_RETURN(TRIO_EOF, 0);
}
else
{
self->processed++;
self->actually.cached++;
}
self->current = fgetc(file);
if (VALID(intPointer))
{
*intPointer = self->current;
}
}
#endif /* TRIO_FEATURE_FILE || TRIO_FEATURE_STDIO */
/*************************************************************************
* TrioUndoStreamFile
*/
#if TRIO_FEATURE_FILE || TRIO_FEATURE_STDIO
TRIO_PRIVATE void TrioUndoStreamFile TRIO_ARGS1((self), trio_class_t* self)
{
FILE* file = (FILE*)self->location;
assert(VALID(self));
assert(VALID(file));
if (self->actually.cached > 0)
{
assert(self->actually.cached == 1);
self->current = ungetc(self->current, file);
self->actually.cached = 0;
}
}
#endif /* TRIO_FEATURE_FILE || TRIO_FEATURE_STDIO */
/*************************************************************************
* TrioInStreamFileDescriptor
*/
#if TRIO_FEATURE_FD
TRIO_PRIVATE void TrioInStreamFileDescriptor TRIO_ARGS2((self, intPointer), trio_class_t* self,
int* intPointer)
{
int fd = *((int*)self->location);
int size;
unsigned char input;
assert(VALID(self));
self->actually.cached = 0;
size = read(fd, &input, sizeof(char));
if (size == -1)
{
self->error = TRIO_ERROR_RETURN(TRIO_ERRNO, 0);
self->current = EOF;
}
else
{
self->current = (size == 0) ? EOF : input;
}
if (self->current != EOF)
{
self->actually.cached++;
self->processed++;
}
if (VALID(intPointer))
{
*intPointer = self->current;
}
}
#endif /* TRIO_FEATURE_FD */
/*************************************************************************
* TrioInStreamCustom
*/
#if TRIO_FEATURE_CLOSURE
TRIO_PRIVATE void TrioInStreamCustom TRIO_ARGS2((self, intPointer), trio_class_t* self,
int* intPointer)
{
trio_custom_t* data;
assert(VALID(self));
assert(VALID(self->location));
self->actually.cached = 0;
data = (trio_custom_t*)self->location;
self->current = (data->stream.in == NULL) ? NIL : (data->stream.in)(data->closure);
if (self->current == NIL)
{
self->current = EOF;
}
else
{
self->processed++;
self->actually.cached++;
}
if (VALID(intPointer))
{
*intPointer = self->current;
}
}
#endif /* TRIO_FEATURE_CLOSURE */
/*************************************************************************
* TrioInStreamString
*/
TRIO_PRIVATE void TrioInStreamString TRIO_ARGS2((self, intPointer), trio_class_t* self,
int* intPointer)
{
unsigned char** buffer;
assert(VALID(self));
assert(VALID(self->location));
self->actually.cached = 0;
buffer = (unsigned char**)self->location;
self->current = (*buffer)[0];
if (self->current == NIL)
{
self->current = EOF;
}
else
{
(*buffer)++;
self->processed++;
self->actually.cached++;
}
if (VALID(intPointer))
{
*intPointer = self->current;
}
}
/*************************************************************************
*
* Formatted scanning functions
*
************************************************************************/
#if defined(TRIO_DOCUMENTATION)
#include "doc/doc_scanf.h"
#endif
/** @addtogroup Scanf
@{
*/
/*************************************************************************
* scanf
*/
/**
Scan characters from standard input stream.
@param format Formatting string.
@param ... Arguments.
@return Number of scanned characters.
*/
#if TRIO_FEATURE_STDIO
TRIO_PUBLIC int trio_scanf TRIO_VARGS2((format, va_alist), TRIO_CONST char* format, TRIO_VA_DECL)
{
int status;
va_list args;
assert(VALID(format));
TRIO_VA_START(args, format);
status = TrioScan((trio_pointer_t)stdin, 0, TrioInStreamFile, TrioUndoStreamFile, format, args,
NULL, NULL);
TRIO_VA_END(args);
return status;
}
#endif /* TRIO_FEATURE_STDIO */
/**
Scan characters from standard input stream.
@param format Formatting string.
@param args Arguments.
@return Number of scanned characters.
*/
#if TRIO_FEATURE_STDIO
TRIO_PUBLIC int trio_vscanf TRIO_ARGS2((format, args), TRIO_CONST char* format, va_list args)
{
assert(VALID(format));
return TrioScan((trio_pointer_t)stdin, 0, TrioInStreamFile, TrioUndoStreamFile, format, args,
NULL, NULL);
}
#endif /* TRIO_FEATURE_STDIO */
/**
Scan characters from standard input stream.
@param format Formatting string.
@param args Arguments.
@return Number of scanned characters.
*/
#if TRIO_FEATURE_STDIO
TRIO_PUBLIC int trio_scanfv TRIO_ARGS2((format, args), TRIO_CONST char* format,
trio_pointer_t* args)
{
static va_list unused;
assert(VALID(format));
return TrioScan((trio_pointer_t)stdin, 0, TrioInStreamFile, TrioUndoStreamFile, format, unused,
TrioArrayGetter, args);
}
#endif /* TRIO_FEATURE_STDIO */
/*************************************************************************
* fscanf
*/
/**
Scan characters from file.
@param file File pointer.
@param format Formatting string.
@param ... Arguments.
@return Number of scanned characters.
*/
#if TRIO_FEATURE_FILE
TRIO_PUBLIC int trio_fscanf TRIO_VARGS3((file, format, va_alist), FILE* file,
TRIO_CONST char* format, TRIO_VA_DECL)
{
int status;
va_list args;
assert(VALID(file));
assert(VALID(format));
TRIO_VA_START(args, format);
status = TrioScan((trio_pointer_t)file, 0, TrioInStreamFile, TrioUndoStreamFile, format, args,
NULL, NULL);
TRIO_VA_END(args);
return status;
}
#endif /* TRIO_FEATURE_FILE */
/**
Scan characters from file.
@param file File pointer.
@param format Formatting string.
@param args Arguments.
@return Number of scanned characters.
*/
#if TRIO_FEATURE_FILE
TRIO_PUBLIC int trio_vfscanf TRIO_ARGS3((file, format, args), FILE* file, TRIO_CONST char* format,
va_list args)
{
assert(VALID(file));
assert(VALID(format));
return TrioScan((trio_pointer_t)file, 0, TrioInStreamFile, TrioUndoStreamFile, format, args,
NULL, NULL);
}
#endif /* TRIO_FEATURE_FILE */
/**
Scan characters from file.
@param file File pointer.
@param format Formatting string.
@param args Arguments.
@return Number of scanned characters.
*/
#if TRIO_FEATURE_FILE
TRIO_PUBLIC int trio_fscanfv TRIO_ARGS3((file, format, args), FILE* file, TRIO_CONST char* format,
trio_pointer_t* args)
{
static va_list unused;
assert(VALID(file));
assert(VALID(format));
return TrioScan((trio_pointer_t)file, 0, TrioInStreamFile, TrioUndoStreamFile, format, unused,
TrioArrayGetter, args);
}
#endif /* TRIO_FEATURE_FILE */
/*************************************************************************
* dscanf
*/
/**
Scan characters from file descriptor.
@param fd File descriptor.
@param format Formatting string.
@param ... Arguments.
@return Number of scanned characters.
*/
#if TRIO_FEATURE_FD
TRIO_PUBLIC int trio_dscanf TRIO_VARGS3((fd, format, va_alist), int fd, TRIO_CONST char* format,
TRIO_VA_DECL)
{
int status;
va_list args;
assert(VALID(format));
TRIO_VA_START(args, format);
status = TrioScan((trio_pointer_t)&fd, 0, TrioInStreamFileDescriptor, NULL, format, args, NULL,
NULL);
TRIO_VA_END(args);
return status;
}
#endif /* TRIO_FEATURE_FD */
/**
Scan characters from file descriptor.
@param fd File descriptor.
@param format Formatting string.
@param args Arguments.
@return Number of scanned characters.
*/
#if TRIO_FEATURE_FD
TRIO_PUBLIC int trio_vdscanf TRIO_ARGS3((fd, format, args), int fd, TRIO_CONST char* format,
va_list args)
{
assert(VALID(format));
return TrioScan((trio_pointer_t)&fd, 0, TrioInStreamFileDescriptor, NULL, format, args, NULL,
NULL);
}
#endif /* TRIO_FEATURE_FD */
/**
Scan characters from file descriptor.
@param fd File descriptor.
@param format Formatting string.
@param args Arguments.
@return Number of scanned characters.
*/
#if TRIO_FEATURE_FD
TRIO_PUBLIC int trio_dscanfv TRIO_ARGS3((fd, format, args), int fd, TRIO_CONST char* format,
trio_pointer_t* args)
{
static va_list unused;
assert(VALID(format));
return TrioScan((trio_pointer_t)&fd, 0, TrioInStreamFileDescriptor, NULL, format, unused,
TrioArrayGetter, args);
}
#endif /* TRIO_FEATURE_FD */
/*************************************************************************
* cscanf
*/
#if TRIO_FEATURE_CLOSURE
TRIO_PUBLIC int trio_cscanf TRIO_VARGS4((stream, closure, format, va_alist), trio_instream_t stream,
trio_pointer_t closure, TRIO_CONST char* format,
TRIO_VA_DECL)
{
int status;
va_list args;
trio_custom_t data;
assert(VALID(stream));
assert(VALID(format));
TRIO_VA_START(args, format);
data.stream.in = stream;
data.closure = closure;
status = TrioScan(&data, 0, TrioInStreamCustom, NULL, format, args, NULL, NULL);
TRIO_VA_END(args);
return status;
}
#endif /* TRIO_FEATURE_CLOSURE */
#if TRIO_FEATURE_CLOSURE
TRIO_PUBLIC int trio_vcscanf TRIO_ARGS4((stream, closure, format, args), trio_instream_t stream,
trio_pointer_t closure, TRIO_CONST char* format,
va_list args)
{
trio_custom_t data;
assert(VALID(stream));
assert(VALID(format));
data.stream.in = stream;
data.closure = closure;
return TrioScan(&data, 0, TrioInStreamCustom, NULL, format, args, NULL, NULL);
}
#endif /* TRIO_FEATURE_CLOSURE */
#if TRIO_FEATURE_CLOSURE
TRIO_PUBLIC int trio_cscanfv TRIO_ARGS4((stream, closure, format, args), trio_instream_t stream,
trio_pointer_t closure, TRIO_CONST char* format,
trio_pointer_t* args)
{
static va_list unused;
trio_custom_t data;
assert(VALID(stream));
assert(VALID(format));
data.stream.in = stream;
data.closure = closure;
return TrioScan(&data, 0, TrioInStreamCustom, NULL, format, unused, TrioArrayGetter, args);
}
#endif /* TRIO_FEATURE_CLOSURE */
#if TRIO_FEATURE_CLOSURE && TRIO_FEATURE_ARGFUNC
TRIO_PUBLIC int trio_cscanff TRIO_ARGS5((stream, closure, format, argfunc, context),
trio_instream_t stream, trio_pointer_t closure,
TRIO_CONST char* format, trio_argfunc_t argfunc,
trio_pointer_t context)
{
static va_list unused;
trio_custom_t data;
assert(VALID(stream));
assert(VALID(format));
assert(VALID(argfunc));
data.stream.in = stream;
data.closure = closure;
return TrioScan(&data, 0, TrioInStreamCustom, NULL, format, unused, argfunc,
(trio_pointer_t*)context);
}
#endif /* TRIO_FEATURE_CLOSURE && TRIO_FEATURE_ARGFUNC */
/*************************************************************************
* sscanf
*/
/**
Scan characters from string.
@param buffer Input string.
@param format Formatting string.
@param ... Arguments.
@return Number of scanned characters.
*/
TRIO_PUBLIC int trio_sscanf TRIO_VARGS3((buffer, format, va_alist), TRIO_CONST char* buffer,
TRIO_CONST char* format, TRIO_VA_DECL)
{
int status;
va_list args;
assert(VALID(buffer));
assert(VALID(format));
TRIO_VA_START(args, format);
status =
TrioScan((trio_pointer_t)&buffer, 0, TrioInStreamString, NULL, format, args, NULL, NULL);
TRIO_VA_END(args);
return status;
}
/**
Scan characters from string.
@param buffer Input string.
@param format Formatting string.
@param args Arguments.
@return Number of scanned characters.
*/
TRIO_PUBLIC int trio_vsscanf TRIO_ARGS3((buffer, format, args), TRIO_CONST char* buffer,
TRIO_CONST char* format, va_list args)
{
assert(VALID(buffer));
assert(VALID(format));
return TrioScan((trio_pointer_t)&buffer, 0, TrioInStreamString, NULL, format, args, NULL, NULL);
}
/**
Scan characters from string.
@param buffer Input string.
@param format Formatting string.
@param args Arguments.
@return Number of scanned characters.
*/
TRIO_PUBLIC int trio_sscanfv TRIO_ARGS3((buffer, format, args), TRIO_CONST char* buffer,
TRIO_CONST char* format, trio_pointer_t* args)
{
static va_list unused;
assert(VALID(buffer));
assert(VALID(format));
return TrioScan((trio_pointer_t)&buffer, 0, TrioInStreamString, NULL, format, unused,
TrioArrayGetter, args);
}
#endif /* TRIO_FEATURE_SCANF */
/** @} End of Scanf documentation module */
/*************************************************************************
* trio_strerror
*/
TRIO_PUBLIC TRIO_CONST char* trio_strerror TRIO_ARGS1((errorcode), int errorcode)
{
#if TRIO_FEATURE_STRERR
/* Textual versions of the error codes */
switch (TRIO_ERROR_CODE(errorcode))
{
case TRIO_EOF:
return "End of file";
case TRIO_EINVAL:
return "Invalid argument";
case TRIO_ETOOMANY:
return "Too many arguments";
case TRIO_EDBLREF:
return "Double reference";
case TRIO_EGAP:
return "Reference gap";
case TRIO_ENOMEM:
return "Out of memory";
case TRIO_ERANGE:
return "Invalid range";
case TRIO_ECUSTOM:
return "Custom error";
default:
return "Unknown";
}
#else
return "Unknown";
#endif
}
#ifdef _WIN32
#pragma warning(pop)
#endif