| /************************************************************************* |
| * |
| * $Id$ |
| * |
| * Copyright (C) 1998 Bjorn Reese and Daniel Stenberg. |
| * |
| * Permission to use, copy, modify, and distribute this software for any |
| * purpose with or without fee is hereby granted, provided that the above |
| * copyright notice and this permission notice appear in all copies. |
| * |
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED |
| * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF |
| * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND |
| * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER. |
| * |
| ************************************************************************* |
| * |
| * 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" |
| #include "trionan.h" |
| #if !defined(TRIO_MINIMAL) |
| # include "triostr.h" |
| #endif |
| |
| /************************************************************************** |
| * |
| * Definitions |
| * |
| *************************************************************************/ |
| |
| #include <math.h> |
| #include <limits.h> |
| #include <float.h> |
| |
| #if (defined(__STDC_ISO_10646__) || defined(MB_LEN_MAX) \ |
| || defined(USE_MULTIBYTE) || TRIO_WIDECHAR) \ |
| && !defined(_WIN32_WCE) |
| # define TRIO_COMPILER_SUPPORTS_MULTIBYTE |
| # if !defined(MB_LEN_MAX) |
| # define MB_LEN_MAX 6 |
| # endif |
| #endif |
| |
| #if (defined(TRIO_COMPILER_MSVC) && (_MSC_VER >= 1100)) || defined(TRIO_COMPILER_BCB) |
| # define TRIO_COMPILER_SUPPORTS_MSVC_INT |
| #endif |
| |
| #if defined(_WIN32_WCE) |
| #include <wincecompat.h> |
| #endif |
| |
| /************************************************************************* |
| * Generic definitions |
| */ |
| |
| #if !(defined(DEBUG) || defined(NDEBUG)) |
| # define NDEBUG |
| #endif |
| |
| #include <assert.h> |
| #include <ctype.h> |
| #if !defined(TRIO_COMPILER_SUPPORTS_C99) |
| # define isblank(x) (((x)==32) || ((x)==9)) |
| #endif |
| #if defined(TRIO_COMPILER_ANCIENT) |
| # include <varargs.h> |
| #else |
| # include <stdarg.h> |
| #endif |
| #include <stddef.h> |
| |
| #if defined( HAVE_ERRNO_H ) || defined( __VMS ) |
| #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_ERRORS |
| /* |
| * 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 |
| |
| #ifndef VA_LIST_IS_ARRAY |
| #define TRIO_VA_LIST_PTR va_list * |
| #define TRIO_VA_LIST_ADDR(l) (&(l)) |
| #define TRIO_VA_LIST_DEREF(l) (*(l)) |
| #else |
| #define TRIO_VA_LIST_PTR va_list |
| #define TRIO_VA_LIST_ADDR(l) (l) |
| #define TRIO_VA_LIST_DEREF(l) (l) |
| #endif |
| |
| typedef unsigned long trio_flags_t; |
| |
| |
| /************************************************************************* |
| * Platform specific definitions |
| */ |
| #if defined(TRIO_PLATFORM_UNIX) || defined(TRIO_PLATFORM_OS400) |
| # include <unistd.h> |
| # include <signal.h> |
| # include <locale.h> |
| # define USE_LOCALE |
| #endif /* TRIO_PLATFORM_UNIX */ |
| #if defined(TRIO_PLATFORM_VMS) |
| # include <unistd.h> |
| #endif |
| #if defined(TRIO_PLATFORM_WIN32) |
| # if defined(_WIN32_WCE) |
| # include <wincecompat.h> |
| # else |
| # include <io.h> |
| # define read _read |
| # define write _write |
| # endif |
| #endif /* TRIO_PLATFORM_WIN32 */ |
| |
| #if TRIO_WIDECHAR |
| # if defined(TRIO_COMPILER_SUPPORTS_ISO94) |
| # 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 iswblank(x) isblank(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 |
| # elif defined(TRIO_COMPILER_SUNPRO) |
| # define USE_LONGLONG |
| # elif defined(_LONG_LONG) || defined(_LONGLONG) |
| # define USE_LONGLONG |
| # 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; |
| #elif defined(TRIO_COMPILER_SUPPORTS_MSVC_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 |
| |
| /* Maximal and fixed integer types */ |
| #if defined(TRIO_COMPILER_SUPPORTS_C99) && !defined( __VMS ) |
| # 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; |
| #elif defined(TRIO_COMPILER_SUPPORTS_UNIX98) || defined( __VMS ) |
| # include <inttypes.h> |
| #ifdef __VMS |
| typedef long long int intmax_t; |
| typedef unsigned long long int uintmax_t; |
| #endif |
| 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; |
| #elif defined(TRIO_COMPILER_SUPPORTS_MSVC_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 |
| |
| #if (!(defined(TRIO_COMPILER_SUPPORTS_C99) \ |
| || defined(TRIO_COMPILER_SUPPORTS_UNIX01))) \ |
| && !defined(_WIN32_WCE) |
| # define floorl(x) floor((double)(x)) |
| # define fmodl(x,y) fmod((double)(x),(double)(y)) |
| # define powl(x,y) pow((double)(x),(double)(y)) |
| #endif |
| |
| #define TRIO_FABS(x) (((x) < 0.0) ? -(x) : (x)) |
| |
| /************************************************************************* |
| * Internal Definitions |
| */ |
| |
| #ifndef 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 |
| |
| /* 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) |
| |
| /* 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" |
| |
| #if !defined(HAVE_ISASCII) && !defined(isascii) |
| #ifndef __VMS |
| # define isascii(x) ((unsigned int)(x) < 128) |
| #endif |
| #endif |
| |
| /* Various constants */ |
| enum { |
| TYPE_PRINT = 1, |
| TYPE_SCAN = 2, |
| |
| /* Flags. FLAGS_LAST must be less than ULONG_MAX */ |
| FLAGS_NEW = 0, |
| FLAGS_STICKY = 1, |
| FLAGS_SPACE = 2 * FLAGS_STICKY, |
| FLAGS_SHOWSIGN = 2 * FLAGS_SPACE, |
| FLAGS_LEFTADJUST = 2 * FLAGS_SHOWSIGN, |
| FLAGS_ALTERNATIVE = 2 * FLAGS_LEFTADJUST, |
| FLAGS_SHORT = 2 * FLAGS_ALTERNATIVE, |
| FLAGS_SHORTSHORT = 2 * FLAGS_SHORT, |
| FLAGS_LONG = 2 * FLAGS_SHORTSHORT, |
| FLAGS_QUAD = 2 * FLAGS_LONG, |
| FLAGS_LONGDOUBLE = 2 * FLAGS_QUAD, |
| FLAGS_SIZE_T = 2 * FLAGS_LONGDOUBLE, |
| FLAGS_PTRDIFF_T = 2 * FLAGS_SIZE_T, |
| FLAGS_INTMAX_T = 2 * FLAGS_PTRDIFF_T, |
| FLAGS_NILPADDING = 2 * FLAGS_INTMAX_T, |
| FLAGS_UNSIGNED = 2 * FLAGS_NILPADDING, |
| FLAGS_UPPER = 2 * FLAGS_UNSIGNED, |
| FLAGS_WIDTH = 2 * FLAGS_UPPER, |
| FLAGS_WIDTH_PARAMETER = 2 * FLAGS_WIDTH, |
| FLAGS_PRECISION = 2 * FLAGS_WIDTH_PARAMETER, |
| FLAGS_PRECISION_PARAMETER = 2 * FLAGS_PRECISION, |
| FLAGS_BASE = 2 * FLAGS_PRECISION_PARAMETER, |
| FLAGS_BASE_PARAMETER = 2 * FLAGS_BASE, |
| FLAGS_FLOAT_E = 2 * FLAGS_BASE_PARAMETER, |
| FLAGS_FLOAT_G = 2 * FLAGS_FLOAT_E, |
| FLAGS_QUOTE = 2 * FLAGS_FLOAT_G, |
| FLAGS_WIDECHAR = 2 * FLAGS_QUOTE, |
| FLAGS_ALLOC = 2 * FLAGS_WIDECHAR, |
| FLAGS_IGNORE = 2 * FLAGS_ALLOC, |
| FLAGS_IGNORE_PARAMETER = 2 * FLAGS_IGNORE, |
| FLAGS_VARSIZE_PARAMETER = 2 * FLAGS_IGNORE_PARAMETER, |
| FLAGS_FIXED_SIZE = 2 * FLAGS_VARSIZE_PARAMETER, |
| FLAGS_LAST = FLAGS_FIXED_SIZE, |
| /* Reused flags */ |
| FLAGS_EXCLUDE = FLAGS_SHORT, |
| FLAGS_USER_DEFINED = FLAGS_IGNORE, |
| FLAGS_ROUNDING = FLAGS_INTMAX_T, |
| /* Compounded flags */ |
| FLAGS_ALL_VARSIZES = FLAGS_LONG | FLAGS_QUAD | FLAGS_INTMAX_T | FLAGS_PTRDIFF_T | FLAGS_SIZE_T, |
| FLAGS_ALL_SIZES = FLAGS_ALL_VARSIZES | FLAGS_SHORTSHORT | FLAGS_SHORT, |
| |
| NO_POSITION = -1, |
| NO_WIDTH = 0, |
| NO_PRECISION = -1, |
| NO_SIZE = -1, |
| |
| /* Do not change these */ |
| NO_BASE = -1, |
| MIN_BASE = 2, |
| MAX_BASE = 36, |
| BASE_BINARY = 2, |
| BASE_OCTAL = 8, |
| BASE_DECIMAL = 10, |
| BASE_HEX = 16, |
| |
| /* Maximal number of allowed parameters */ |
| MAX_PARAMETERS = 64, |
| /* Maximal number of characters in class */ |
| MAX_CHARACTER_CLASS = UCHAR_MAX + 1, |
| |
| /* Maximal string lengths for user-defined specifiers */ |
| MAX_USER_NAME = 64, |
| MAX_USER_DATA = 256, |
| |
| /* Maximal length of locale separator strings */ |
| MAX_LOCALE_SEPARATOR_LENGTH = MB_LEN_MAX, |
| /* Maximal number of integers in grouping */ |
| MAX_LOCALE_GROUPS = 64, |
| |
| /* Initial size of asprintf buffer */ |
| DYNAMIC_START_SIZE = 32 |
| }; |
| |
| #define NO_GROUPING ((int)CHAR_MAX) |
| |
| /* Fundamental formatting parameter types */ |
| #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 |
| #if TRIO_GNU |
| # define FORMAT_ERRNO 9 |
| #endif |
| #if TRIO_EXTENSION |
| # define FORMAT_USER_DEFINED 10 |
| #endif |
| |
| /* Character constants */ |
| #define CHAR_IDENTIFIER '%' |
| #define CHAR_BACKSLASH '\\' |
| #define CHAR_QUOTE '\"' |
| #define CHAR_ADJUST ' ' |
| |
| /* 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:]" |
| |
| /* |
| * 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' |
| #define SPECIFIER_FLOAT_E 'e' |
| #define SPECIFIER_FLOAT_E_UPPER 'E' |
| #define SPECIFIER_FLOAT_F 'f' |
| #define SPECIFIER_FLOAT_F_UPPER 'F' |
| #define SPECIFIER_FLOAT_G 'g' |
| #define SPECIFIER_FLOAT_G_UPPER 'G' |
| #define SPECIFIER_POINTER 'p' |
| #define SPECIFIER_GROUP '[' |
| #define SPECIFIER_UNGROUP ']' |
| #define SPECIFIER_COUNT 'n' |
| #if TRIO_UNIX98 |
| # define SPECIFIER_CHAR_UPPER 'C' |
| # define SPECIFIER_STRING_UPPER 'S' |
| #endif |
| #if TRIO_C99 |
| # define SPECIFIER_HEXFLOAT 'a' |
| # define SPECIFIER_HEXFLOAT_UPPER 'A' |
| #endif |
| #if TRIO_GNU |
| # define SPECIFIER_ERRNO 'm' |
| #endif |
| #if TRIO_EXTENSION |
| # define SPECIFIER_BINARY 'b' |
| # define SPECIFIER_BINARY_UPPER 'B' |
| # define SPECIFIER_USER_DEFINED_BEGIN '<' |
| # define SPECIFIER_USER_DEFINED_END '>' |
| # define SPECIFIER_USER_DEFINED_SEPARATOR ':' |
| #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 */ |
| #if TRIO_C99 |
| # define QUALIFIER_SIZE_T 'z' |
| # define QUALIFIER_PTRDIFF_T 't' |
| # define QUALIFIER_INTMAX_T 'j' |
| #endif |
| #if TRIO_BSD || TRIO_GNU |
| # define QUALIFIER_QUAD 'q' |
| #endif |
| #if TRIO_GNU |
| # define QUALIFIER_SIZE_T_UPPER 'Z' |
| #endif |
| #if TRIO_MISC |
| # define QUALIFIER_WIDECHAR 'w' |
| #endif |
| #if TRIO_MICROSOFT |
| # define QUALIFIER_FIXED_SIZE 'I' |
| #endif |
| #if TRIO_EXTENSION |
| # define QUALIFIER_QUOTE '\'' |
| # define QUALIFIER_STICKY '!' |
| # define QUALIFIER_VARSIZE '&' /* This should remain undocumented */ |
| # define QUALIFIER_PARAM '@' /* Experimental */ |
| # define QUALIFIER_COLON ':' /* For scanlists */ |
| # define QUALIFIER_EQUAL '=' /* For scanlists */ |
| # define QUALIFIER_ROUNDING_UPPER 'R' |
| #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; |
| /* The size for the variable size qualifier */ |
| int varsize; |
| /* The marker of the end of the specifier */ |
| int indexAfterSpecifier; |
| /* The data from the argument list */ |
| union { |
| char *string; |
| #if TRIO_WIDECHAR |
| trio_wchar_t *wstring; |
| #endif |
| trio_pointer_t pointer; |
| union { |
| trio_intmax_t as_signed; |
| trio_uintmax_t as_unsigned; |
| } number; |
| double doubleNumber; |
| double *doublePointer; |
| trio_long_double_t longdoubleNumber; |
| trio_long_double_t *longdoublePointer; |
| int errorNumber; |
| } data; |
| /* For the user-defined specifier */ |
| char user_name[MAX_USER_NAME]; |
| char user_data[MAX_USER_DATA]; |
| } 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 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; |
| /* |
| * The number of characters that are actually written/read. |
| * Processed and committed will only differ for the *nprintf |
| * and *nscanf functions. |
| */ |
| int committed; |
| /* |
| * The upper limit of characters that may be written/read. |
| */ |
| int max; |
| /* |
| * 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; |
| |
| /* 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; |
| |
| /************************************************************************* |
| * |
| * Internal Variables |
| * |
| *************************************************************************/ |
| |
| static TRIO_CONST char rcsid[] = "@(#)$Id$"; |
| |
| /* |
| * Need this to workaround a parser bug in HP C/iX compiler that fails |
| * to resolves macro definitions that includes type 'long double', |
| * e.g: va_arg(arg_ptr, long double) |
| */ |
| #if defined(TRIO_PLATFORM_MPEIX) |
| static TRIO_CONST trio_long_double_t ___dummy_long_double = 0; |
| #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 (.)" |
| */ |
| static int internalDecimalPointLength = 1; |
| static int internalThousandSeparatorLength = 1; |
| static char internalDecimalPoint = '.'; |
| static char internalDecimalPointString[MAX_LOCALE_SEPARATOR_LENGTH + 1] = "."; |
| static char internalThousandSeparator[MAX_LOCALE_SEPARATOR_LENGTH + 1] = ","; |
| static char internalGrouping[MAX_LOCALE_GROUPS] = { (char)NO_GROUPING }; |
| |
| static TRIO_CONST char internalDigitsLower[] = "0123456789abcdefghijklmnopqrstuvwxyz"; |
| static TRIO_CONST char internalDigitsUpper[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; |
| static BOOLEAN_T internalDigitsUnconverted = TRUE; |
| static int internalDigitArray[128]; |
| #if TRIO_EXTENSION |
| static BOOLEAN_T internalCollationUnconverted = TRUE; |
| static char internalCollationArray[MAX_CHARACTER_CLASS][MAX_CHARACTER_CLASS]; |
| #endif |
| |
| #if TRIO_EXTENSION |
| 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_MINIMAL) |
| # define TRIO_STRING_PUBLIC static |
| # include "triostr.c" |
| #endif /* defined(TRIO_MINIMAL) */ |
| |
| /************************************************************************* |
| * 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_LONG_UPPER: |
| case QUALIFIER_CIRCUMFLEX: |
| #if defined(QUALIFIER_SIZE_T) |
| case QUALIFIER_SIZE_T: |
| #endif |
| #if defined(QUALIFIER_PTRDIFF_T) |
| case QUALIFIER_PTRDIFF_T: |
| #endif |
| #if defined(QUALIFIER_INTMAX_T) |
| case QUALIFIER_INTMAX_T: |
| #endif |
| #if defined(QUALIFIER_QUAD) |
| case QUALIFIER_QUAD: |
| #endif |
| #if defined(QUALIFIER_SIZE_T_UPPER) |
| case QUALIFIER_SIZE_T_UPPER: |
| #endif |
| #if defined(QUALIFIER_WIDECHAR) |
| case QUALIFIER_WIDECHAR: |
| #endif |
| #if defined(QUALIFIER_QUOTE) |
| case QUALIFIER_QUOTE: |
| #endif |
| #if defined(QUALIFIER_STICKY) |
| case QUALIFIER_STICKY: |
| #endif |
| #if defined(QUALIFIER_VARSIZE) |
| case QUALIFIER_VARSIZE: |
| #endif |
| #if defined(QUALIFIER_PARAM) |
| case QUALIFIER_PARAM: |
| #endif |
| #if defined(QUALIFIER_FIXED_SIZE) |
| case QUALIFIER_FIXED_SIZE: |
| #endif |
| #if defined(QUALIFIER_ROUNDING_UPPER) |
| case QUALIFIER_ROUNDING_UPPER: |
| #endif |
| return TRUE; |
| default: |
| return FALSE; |
| } |
| } |
| |
| /************************************************************************* |
| * 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 ((internalLocaleValues->thousands_sep) && |
| (internalLocaleValues->thousands_sep[0] != NIL)) |
| { |
| trio_copy_max(internalThousandSeparator, |
| sizeof(internalThousandSeparator), |
| internalLocaleValues->thousands_sep); |
| internalThousandSeparatorLength = trio_length(internalThousandSeparator); |
| } |
| if ((internalLocaleValues->grouping) && |
| (internalLocaleValues->grouping[0] != NIL)) |
| { |
| trio_copy_max(internalGrouping, |
| sizeof(internalGrouping), |
| internalLocaleValues->grouping); |
| } |
| } |
| } |
| #endif /* defined(USE_LOCALE) */ |
| |
| TRIO_PRIVATE int |
| TrioCalcThousandSeparatorLength |
| TRIO_ARGS1((digits), |
| int digits) |
| { |
| #if TRIO_EXTENSION |
| int count = 0; |
| int step = NO_GROUPING; |
| char *groupingPointer = internalGrouping; |
| |
| while (digits > 0) |
| { |
| if (*groupingPointer == CHAR_MAX) |
| { |
| /* Disable grouping */ |
| break; /* while */ |
| } |
| else if (*groupingPointer == 0) |
| { |
| /* Repeat last group */ |
| if (step == NO_GROUPING) |
| { |
| /* Error in locale */ |
| break; /* while */ |
| } |
| } |
| else |
| { |
| step = *groupingPointer++; |
| } |
| if (digits > step) |
| count += internalThousandSeparatorLength; |
| digits -= step; |
| } |
| return count; |
| #else |
| return 0; |
| #endif |
| } |
| |
| TRIO_PRIVATE BOOLEAN_T |
| TrioFollowedBySeparator |
| TRIO_ARGS1((position), |
| int position) |
| { |
| #if TRIO_EXTENSION |
| int step = 0; |
| char *groupingPointer = internalGrouping; |
| |
| position--; |
| if (position == 0) |
| return FALSE; |
| while (position > 0) |
| { |
| if (*groupingPointer == CHAR_MAX) |
| { |
| /* Disable grouping */ |
| break; /* while */ |
| } |
| else if (*groupingPointer != 0) |
| { |
| step = *groupingPointer++; |
| } |
| if (step == 0) |
| break; |
| position -= step; |
| } |
| return (position == 0); |
| #else |
| return FALSE; |
| #endif |
| } |
| |
| /************************************************************************* |
| * TrioGetPosition |
| * |
| * Get the %n$ position. |
| */ |
| TRIO_PRIVATE int |
| TrioGetPosition |
| TRIO_ARGS2((format, indexPointer), |
| TRIO_CONST char *format, |
| int *indexPointer) |
| { |
| #if TRIO_UNIX98 |
| char *tmpformat; |
| int number = 0; |
| int index = *indexPointer; |
| |
| number = (int)trio_to_long(&format[index], &tmpformat, BASE_DECIMAL); |
| index = (int)(tmpformat - format); |
| if ((number != 0) && (QUALIFIER_POSITION == format[index++])) |
| { |
| *indexPointer = index; |
| /* |
| * number is decreased by 1, because n$ starts from 1, whereas |
| * the array it is indexing starts from 0. |
| */ |
| return number - 1; |
| } |
| #endif |
| return NO_POSITION; |
| } |
| |
| #if TRIO_EXTENSION |
| /************************************************************************* |
| * TrioFindNamespace |
| * |
| * Find registered user-defined specifier. |
| * The prev argument is used for optimization only. |
| */ |
| 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. |
| */ |
| 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 = powl((trio_long_double_t)number, |
| (trio_long_double_t)exponent); |
| break; |
| } |
| } |
| else |
| { |
| return powl((trio_long_double_t)number, (trio_long_double_t)exponent); |
| } |
| return result; |
| } |
| |
| /************************************************************************* |
| * TrioLogarithm |
| */ |
| TRIO_PRIVATE double |
| TrioLogarithm |
| TRIO_ARGS2((number, base), |
| double number, |
| int base) |
| { |
| double result; |
| |
| if (number <= 0.0) |
| { |
| /* xlC crashes on log(0) */ |
| result = (number == 0.0) ? trio_ninf() : trio_nan(); |
| } |
| else |
| { |
| if (base == 10) |
| { |
| result = log10(number); |
| } |
| else |
| { |
| result = log10(number) / log10((double)base); |
| } |
| } |
| return result; |
| } |
| |
| /************************************************************************* |
| * TrioLogarithmBase |
| */ |
| 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); |
| } |
| } |
| |
| /************************************************************************* |
| * TrioParse |
| * |
| * Description: |
| * Parse the format string |
| */ |
| TRIO_PRIVATE int |
| TrioParse |
| TRIO_ARGS5((type, format, parameters, arglist, argarray), |
| int type, |
| TRIO_CONST char *format, |
| trio_parameter_t *parameters, |
| TRIO_VA_LIST_PTR arglist, |
| trio_pointer_t *argarray) |
| { |
| /* Count the number of times a parameter is referenced */ |
| unsigned short usedEntries[MAX_PARAMETERS]; |
| /* Parameter counters */ |
| int parameterPosition; |
| int currentParam; |
| int maxParam = -1; |
| /* Utility variables */ |
| trio_flags_t flags; |
| int width; |
| int precision; |
| int varsize; |
| int base; |
| int index; /* Index into formatting string */ |
| int dots; /* Count number of dots in modifier part */ |
| BOOLEAN_T positional; /* Does the specifier have a positional? */ |
| BOOLEAN_T gotSticky = FALSE; /* Are there any sticky modifiers at all? */ |
| /* |
| * indices specifies the order in which the parameters must be |
| * read from the va_args (this is necessary to handle positionals) |
| */ |
| int indices[MAX_PARAMETERS]; |
| int pos = 0; |
| /* Various variables */ |
| char ch; |
| #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) |
| int charlen; |
| #endif |
| int save_errno; |
| int i = -1; |
| int num; |
| char *tmpformat; |
| |
| /* One and only one of arglist and argarray must be used */ |
| assert((arglist != NULL) ^ (argarray != NULL)); |
| |
| /* |
| * The 'parameters' array is not initialized, but we need to |
| * know which entries we have used. |
| */ |
| memset(usedEntries, 0, sizeof(usedEntries)); |
| |
| save_errno = errno; |
| index = 0; |
| parameterPosition = 0; |
| #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) |
| (void)mblen(NULL, 0); |
| #endif |
| |
| while (format[index]) |
| { |
| #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) |
| if (! isascii(format[index])) |
| { |
| /* |
| * Multibyte characters cannot be legal specifiers or |
| * modifiers, so we skip over them. |
| */ |
| charlen = mblen(&format[index], MB_LEN_MAX); |
| index += (charlen > 0) ? charlen : 1; |
| continue; /* while */ |
| } |
| #endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */ |
| if (CHAR_IDENTIFIER == format[index++]) |
| { |
| if (CHAR_IDENTIFIER == format[index]) |
| { |
| index++; |
| continue; /* while */ |
| } |
| |
| flags = FLAGS_NEW; |
| dots = 0; |
| currentParam = TrioGetPosition(format, &index); |
| positional = (NO_POSITION != currentParam); |
| if (!positional) |
| { |
| /* We have no positional, get the next counter */ |
| currentParam = parameterPosition; |
| } |
| if(currentParam >= MAX_PARAMETERS) |
| { |
| /* Bail out completely to make the error more obvious */ |
| return TRIO_ERROR_RETURN(TRIO_ETOOMANY, index); |
| } |
| |
| if (currentParam > maxParam) |
| maxParam = currentParam; |
| |
| /* Default values */ |
| width = NO_WIDTH; |
| precision = NO_PRECISION; |
| base = NO_BASE; |
| varsize = NO_SIZE; |
| |
| while (TrioIsQualifier(format[index])) |
| { |
| ch = format[index++]; |
| |
| switch (ch) |
| { |
| case QUALIFIER_SPACE: |
| flags |= FLAGS_SPACE; |
| break; |
| |
| case QUALIFIER_PLUS: |
| flags |= FLAGS_SHOWSIGN; |
| break; |
| |
| case QUALIFIER_MINUS: |
| flags |= FLAGS_LEFTADJUST; |
| flags &= ~FLAGS_NILPADDING; |
| break; |
| |
| case QUALIFIER_ALTERNATIVE: |
| flags |= FLAGS_ALTERNATIVE; |
| break; |
| |
| case QUALIFIER_DOT: |
| if (dots == 0) /* Precision */ |
| { |
| dots++; |
| |
| /* Skip if no precision */ |
| if (QUALIFIER_DOT == format[index]) |
| break; |
| |
| /* After the first dot we have the precision */ |
| flags |= FLAGS_PRECISION; |
| if ((QUALIFIER_STAR == format[index]) |
| #if defined(QUALIFIER_PARAM) |
| || (QUALIFIER_PARAM == format[index]) |
| #endif |
| ) |
| { |
| index++; |
| flags |= FLAGS_PRECISION_PARAMETER; |
| |
| precision = TrioGetPosition(format, &index); |
| if (precision == NO_POSITION) |
| { |
| parameterPosition++; |
| if (positional) |
| precision = parameterPosition; |
| else |
| { |
| precision = currentParam; |
| currentParam = precision + 1; |
| } |
| } |
| else |
| { |
| if (! positional) |
| currentParam = precision + 1; |
| if (width > maxParam) |
| maxParam = precision; |
| } |
| if (currentParam > maxParam) |
| maxParam = currentParam; |
| } |
| else |
| { |
| precision = trio_to_long(&format[index], |
| &tmpformat, |
| BASE_DECIMAL); |
| index = (int)(tmpformat - format); |
| } |
| } |
| else if (dots == 1) /* Base */ |
| { |
| dots++; |
| |
| /* After the second dot we have the base */ |
| flags |= FLAGS_BASE; |
| if ((QUALIFIER_STAR == format[index]) |
| #if defined(QUALIFIER_PARAM) |
| || (QUALIFIER_PARAM == format[index]) |
| #endif |
| ) |
| { |
| index++; |
| flags |= FLAGS_BASE_PARAMETER; |
| base = TrioGetPosition(format, &index); |
| if (base == NO_POSITION) |
| { |
| parameterPosition++; |
| if (positional) |
| base = parameterPosition; |
| else |
| { |
| base = currentParam; |
| currentParam = base + 1; |
| } |
| } |
| else |
| { |
| if (! positional) |
| currentParam = base + 1; |
| if (base > maxParam) |
| maxParam = base; |
| } |
| if (currentParam > maxParam) |
| maxParam = currentParam; |
| } |
| else |
| { |
| base = trio_to_long(&format[index], |
| &tmpformat, |
| BASE_DECIMAL); |
| if (base > MAX_BASE) |
| return TRIO_ERROR_RETURN(TRIO_EINVAL, index); |
| index = (int)(tmpformat - format); |
| } |
| } |
| else |
| { |
| return TRIO_ERROR_RETURN(TRIO_EINVAL, index); |
| } |
| break; /* QUALIFIER_DOT */ |
| |
| #if defined(QUALIFIER_PARAM) |
| case QUALIFIER_PARAM: |
| type = TYPE_PRINT; |
| /* FALLTHROUGH */ |
| #endif |
| case QUALIFIER_STAR: |
| /* This has different meanings for print and scan */ |
| if (TYPE_PRINT == type) |
| { |
| /* Read with from parameter */ |
| flags |= (FLAGS_WIDTH | FLAGS_WIDTH_PARAMETER); |
| width = TrioGetPosition(format, &index); |
| if (width == NO_POSITION) |
| { |
| parameterPosition++; |
| if (positional) |
| width = parameterPosition; |
| else |
| { |
| width = currentParam; |
| currentParam = width + 1; |
| } |
| } |
| else |
| { |
| if (! positional) |
| currentParam = width + 1; |
| if (width > maxParam) |
| maxParam = width; |
| } |
| if (currentParam > maxParam) |
| maxParam = currentParam; |
| } |
| else |
| { |
| /* Scan, but do not store result */ |
| flags |= FLAGS_IGNORE; |
| } |
| |
| break; /* QUALIFIER_STAR */ |
| |
| case '0': |
| if (! (flags & FLAGS_LEFTADJUST)) |
| flags |= FLAGS_NILPADDING; |
| /* FALLTHROUGH */ |
| case '1': case '2': case '3': case '4': |
| case '5': case '6': case '7': case '8': case '9': |
| flags |= FLAGS_WIDTH; |
| /* &format[index - 1] is used to "rewind" the read |
| * character from format |
| */ |
| width = trio_to_long(&format[index - 1], |
| &tmpformat, |
| BASE_DECIMAL); |
| index = (int)(tmpformat - format); |
| break; |
| |
| case QUALIFIER_SHORT: |
| if (flags & FLAGS_SHORTSHORT) |
| return TRIO_ERROR_RETURN(TRIO_EINVAL, index); |
| else if (flags & FLAGS_SHORT) |
| flags |= FLAGS_SHORTSHORT; |
| else |
| flags |= FLAGS_SHORT; |
| break; |
| |
| case QUALIFIER_LONG: |
| if (flags & FLAGS_QUAD) |
| return TRIO_ERROR_RETURN(TRIO_EINVAL, index); |
| else if (flags & FLAGS_LONG) |
| flags |= FLAGS_QUAD; |
| else |
| flags |= FLAGS_LONG; |
| break; |
| |
| case QUALIFIER_LONG_UPPER: |
| flags |= FLAGS_LONGDOUBLE; |
| break; |
| |
| #if defined(QUALIFIER_SIZE_T) |
| case QUALIFIER_SIZE_T: |
| flags |= FLAGS_SIZE_T; |
| /* Modify flags for later truncation of number */ |
| if (sizeof(size_t) == sizeof(trio_ulonglong_t)) |
| flags |= FLAGS_QUAD; |
| else if (sizeof(size_t) == sizeof(long)) |
| flags |= FLAGS_LONG; |
| break; |
| #endif |
| |
| #if defined(QUALIFIER_PTRDIFF_T) |
| case QUALIFIER_PTRDIFF_T: |
| flags |= FLAGS_PTRDIFF_T; |
| if (sizeof(ptrdiff_t) == sizeof(trio_ulonglong_t)) |
| flags |= FLAGS_QUAD; |
| else if (sizeof(ptrdiff_t) == sizeof(long)) |
| flags |= FLAGS_LONG; |
| break; |
| #endif |
| |
| #if defined(QUALIFIER_INTMAX_T) |
| case QUALIFIER_INTMAX_T: |
| flags |= FLAGS_INTMAX_T; |
| if (sizeof(trio_intmax_t) == sizeof(trio_ulonglong_t)) |
| flags |= FLAGS_QUAD; |
| else if (sizeof(trio_intmax_t) == sizeof(long)) |
| flags |= FLAGS_LONG; |
| break; |
| #endif |
| |
| #if defined(QUALIFIER_QUAD) |
| case QUALIFIER_QUAD: |
| flags |= FLAGS_QUAD; |
| break; |
| #endif |
| |
| #if defined(QUALIFIER_FIXED_SIZE) |
| case QUALIFIER_FIXED_SIZE: |
| if (flags & FLAGS_FIXED_SIZE) |
| return TRIO_ERROR_RETURN(TRIO_EINVAL, index); |
| |
| if (flags & (FLAGS_ALL_SIZES | FLAGS_LONGDOUBLE | |
| FLAGS_WIDECHAR | FLAGS_VARSIZE_PARAMETER)) |
| return TRIO_ERROR_RETURN(TRIO_EINVAL, index); |
| |
| if ((format[index] == '6') && |
| (format[index + 1] == '4')) |
| { |
| varsize = sizeof(trio_int64_t); |
| index += 2; |
| } |
| else if ((format[index] == '3') && |
| (format[index + 1] == '2')) |
| { |
| varsize = sizeof(trio_int32_t); |
| index += 2; |
| } |
| else if ((format[index] == '1') && |
| (format[index + 1] == '6')) |
| { |
| varsize = sizeof(trio_int16_t); |
| index += 2; |
| } |
| else if (format[index] == '8') |
| { |
| varsize = sizeof(trio_int8_t); |
| index++; |
| } |
| else |
| return TRIO_ERROR_RETURN(TRIO_EINVAL, index); |
| |
| flags |= FLAGS_FIXED_SIZE; |
| break; |
| #endif |
| |
| #if defined(QUALIFIER_WIDECHAR) |
| case QUALIFIER_WIDECHAR: |
| flags |= FLAGS_WIDECHAR; |
| break; |
| #endif |
| |
| #if defined(QUALIFIER_SIZE_T_UPPER) |
| case QUALIFIER_SIZE_T_UPPER: |
| break; |
| #endif |
| |
| #if defined(QUALIFIER_QUOTE) |
| case QUALIFIER_QUOTE: |
| flags |= FLAGS_QUOTE; |
| break; |
| #endif |
| |
| #if defined(QUALIFIER_STICKY) |
| case QUALIFIER_STICKY: |
| flags |= FLAGS_STICKY; |
| gotSticky = TRUE; |
| break; |
| #endif |
| |
| #if defined(QUALIFIER_VARSIZE) |
| case QUALIFIER_VARSIZE: |
| flags |= FLAGS_VARSIZE_PARAMETER; |
| parameterPosition++; |
| if (positional) |
| varsize = parameterPosition; |
| else |
| { |
| varsize = currentParam; |
| currentParam = varsize + 1; |
| } |
| if (currentParam > maxParam) |
| maxParam = currentParam; |
| break; |
| #endif |
| |
| #if defined(QUALIFIER_ROUNDING_UPPER) |
| case QUALIFIER_ROUNDING_UPPER: |
| flags |= FLAGS_ROUNDING; |
| break; |
| #endif |
| |
| default: |
| /* Bail out completely to make the error more obvious */ |
| return TRIO_ERROR_RETURN(TRIO_EINVAL, index); |
| } |
| } /* while qualifier */ |
| |
| /* |
| * Parameters only need the type and value. The value is |
| * read later. |
| */ |
| if (flags & FLAGS_WIDTH_PARAMETER) |
| { |
| usedEntries[width] += 1; |
| parameters[pos].type = FORMAT_PARAMETER; |
| parameters[pos].flags = 0; |
| indices[width] = pos; |
| width = pos++; |
| } |
| if (flags & FLAGS_PRECISION_PARAMETER) |
| { |
| usedEntries[precision] += 1; |
| parameters[pos].type = FORMAT_PARAMETER; |
| parameters[pos].flags = 0; |
| indices[precision] = pos; |
| precision = pos++; |
| } |
| if (flags & FLAGS_BASE_PARAMETER) |
| { |
| usedEntries[base] += 1; |
| parameters[pos].type = FORMAT_PARAMETER; |
| parameters[pos].flags = 0; |
| indices[base] = pos; |
| base = pos++; |
| } |
| if (flags & FLAGS_VARSIZE_PARAMETER) |
| { |
| usedEntries[varsize] += 1; |
| parameters[pos].type = FORMAT_PARAMETER; |
| parameters[pos].flags = 0; |
| indices[varsize] = pos; |
| varsize = pos++; |
| } |
| |
| indices[currentParam] = pos; |
| |
| switch (format[index++]) |
| { |
| #if defined(SPECIFIER_CHAR_UPPER) |
| case SPECIFIER_CHAR_UPPER: |
| flags |= FLAGS_WIDECHAR; |
| /* FALLTHROUGH */ |
| #endif |
| case SPECIFIER_CHAR: |
| if (flags & FLAGS_LONG) |
| flags |= FLAGS_WIDECHAR; |
| else if (flags & FLAGS_SHORT) |
| flags &= ~FLAGS_WIDECHAR; |
| parameters[pos].type = FORMAT_CHAR; |
| break; |
| |
| #if defined(SPECIFIER_STRING_UPPER) |
| case SPECIFIER_STRING_UPPER: |
| flags |= FLAGS_WIDECHAR; |
| /* FALLTHROUGH */ |
| #endif |
| case SPECIFIER_STRING: |
| if (flags & FLAGS_LONG) |
| flags |= FLAGS_WIDECHAR; |
| else if (flags & FLAGS_SHORT) |
| flags &= ~FLAGS_WIDECHAR; |
| parameters[pos].type = FORMAT_STRING; |
| break; |
| |
| case SPECIFIER_GROUP: |
| if (TYPE_SCAN == type) |
| { |
| int depth = 1; |
| parameters[pos].type = FORMAT_GROUP; |
| if (format[index] == QUALIFIER_CIRCUMFLEX) |
| index++; |
| if (format[index] == SPECIFIER_UNGROUP) |
| index++; |
| if (format[index] == QUALIFIER_MINUS) |
| index++; |
| /* Skip nested brackets */ |
| while (format[index] != NIL) |
| { |
| if (format[index] == SPECIFIER_GROUP) |
| { |
| depth++; |
| } |
| else if (format[index] == SPECIFIER_UNGROUP) |
| { |
| if (--depth <= 0) |
| { |
| index++; |
| break; |
| } |
| } |
| index++; |
| } |
| } |
| break; |
| |
| case SPECIFIER_INTEGER: |
| parameters[pos].type = FORMAT_INT; |
| break; |
| |
| case SPECIFIER_UNSIGNED: |
| flags |= FLAGS_UNSIGNED; |
| parameters[pos].type = FORMAT_INT; |
| break; |
| |
| case SPECIFIER_DECIMAL: |
| /* Disable base modifier */ |
| flags &= ~FLAGS_BASE_PARAMETER; |
| base = BASE_DECIMAL; |
| parameters[pos].type = FORMAT_INT; |
| break; |
| |
| case SPECIFIER_OCTAL: |
| flags |= FLAGS_UNSIGNED; |
| flags &= ~FLAGS_BASE_PARAMETER; |
| base = BASE_OCTAL; |
| parameters[pos].type = FORMAT_INT; |
| break; |
| |
| #if defined(SPECIFIER_BINARY) |
| case SPECIFIER_BINARY_UPPER: |
| flags |= FLAGS_UPPER; |
| /* FALLTHROUGH */ |
| case SPECIFIER_BINARY: |
| flags |= FLAGS_NILPADDING; |
| flags &= ~FLAGS_BASE_PARAMETER; |
| base = BASE_BINARY; |
| parameters[pos].type = FORMAT_INT; |
| break; |
| #endif |
| |
| case SPECIFIER_HEX_UPPER: |
| flags |= FLAGS_UPPER; |
| /* FALLTHROUGH */ |
| case SPECIFIER_HEX: |
| flags |= FLAGS_UNSIGNED; |
| flags &= ~FLAGS_BASE_PARAMETER; |
| base = BASE_HEX; |
| parameters[pos].type = FORMAT_INT; |
| break; |
| |
| case SPECIFIER_FLOAT_E_UPPER: |
| flags |= FLAGS_UPPER; |
| /* FALLTHROUGH */ |
| case SPECIFIER_FLOAT_E: |
| flags |= FLAGS_FLOAT_E; |
| parameters[pos].type = FORMAT_DOUBLE; |
| break; |
| |
| case SPECIFIER_FLOAT_G_UPPER: |
| flags |= FLAGS_UPPER; |
| /* FALLTHROUGH */ |
| case SPECIFIER_FLOAT_G: |
| flags |= FLAGS_FLOAT_G; |
| parameters[pos].type = FORMAT_DOUBLE; |
| break; |
| |
| case SPECIFIER_FLOAT_F_UPPER: |
| flags |= FLAGS_UPPER; |
| /* FALLTHROUGH */ |
| case SPECIFIER_FLOAT_F: |
| parameters[pos].type = FORMAT_DOUBLE; |
| break; |
| |
| case SPECIFIER_POINTER: |
| if (sizeof(trio_pointer_t) == sizeof(trio_ulonglong_t)) |
| flags |= FLAGS_QUAD; |
| else if (sizeof(trio_pointer_t) == sizeof(long)) |
| flags |= FLAGS_LONG; |
| parameters[pos].type = FORMAT_POINTER; |
| break; |
| |
| case SPECIFIER_COUNT: |
| parameters[pos].type = FORMAT_COUNT; |
| break; |
| |
| #if defined(SPECIFIER_HEXFLOAT) |
| # if defined(SPECIFIER_HEXFLOAT_UPPER) |
| case SPECIFIER_HEXFLOAT_UPPER: |
| flags |= FLAGS_UPPER; |
| /* FALLTHROUGH */ |
| # endif |
| case SPECIFIER_HEXFLOAT: |
| base = BASE_HEX; |
| parameters[pos].type = FORMAT_DOUBLE; |
| break; |
| #endif |
| |
| #if defined(FORMAT_ERRNO) |
| case SPECIFIER_ERRNO: |
| parameters[pos].type = FORMAT_ERRNO; |
| break; |
| #endif |
| |
| #if defined(SPECIFIER_USER_DEFINED_BEGIN) |
| case SPECIFIER_USER_DEFINED_BEGIN: |
| { |
| unsigned int max; |
| int without_namespace = TRUE; |
| |
| parameters[pos].type = FORMAT_USER_DEFINED; |
| parameters[pos].user_name[0] = NIL; |
| tmpformat = (char *)&format[index]; |
| |
| while ((ch = format[index])) |
| { |
| index++; |
| if (ch == SPECIFIER_USER_DEFINED_END) |
| { |
| if (without_namespace) |
| { |
| /* We must get the handle first */ |
| parameters[pos].type = FORMAT_PARAMETER; |
| parameters[pos].indexAfterSpecifier = index; |
| parameters[pos].flags = FLAGS_USER_DEFINED; |
| /* Adjust parameters for insertion of new one */ |
| pos++; |
| usedEntries[currentParam] += 1; |
| parameters[pos].type = FORMAT_USER_DEFINED; |
| currentParam++; |
| indices[currentParam] = pos; |
| if (currentParam > maxParam) |
| maxParam = currentParam; |
| } |
| /* Copy the user data */ |
| max = (unsigned int)(&format[index] - tmpformat); |
| if (max > MAX_USER_DATA) |
| max = MAX_USER_DATA; |
| trio_copy_max(parameters[pos].user_data, |
| max, |
| tmpformat); |
| break; /* while */ |
| } |
| if (ch == SPECIFIER_USER_DEFINED_SEPARATOR) |
| { |
| without_namespace = FALSE; |
| /* Copy the namespace for later looking-up */ |
| max = (int)(&format[index] - tmpformat); |
| if (max > MAX_USER_NAME) |
| max = MAX_USER_NAME; |
| trio_copy_max(parameters[pos].user_name, |
| max, |
| tmpformat); |
| tmpformat = (char *)&format[index]; |
| } |
| } |
| if (ch != SPECIFIER_USER_DEFINED_END) |
| return TRIO_ERROR_RETURN(TRIO_EINVAL, index); |
| } |
| break; |
| #endif /* defined(SPECIFIER_USER_DEFINED_BEGIN) */ |
| |
| default: |
| /* Bail out completely to make the error more obvious */ |
| return TRIO_ERROR_RETURN(TRIO_EINVAL, index); |
| } |
| |
| /* Count the number of times this entry has been used */ |
| usedEntries[currentParam] += 1; |
| |
| /* Find last sticky parameters */ |
| if (gotSticky && !(flags & FLAGS_STICKY)) |
| { |
| for (i = pos - 1; i >= 0; i--) |
| { |
| if (parameters[i].type == FORMAT_PARAMETER) |
| continue; |
| if ((parameters[i].flags & FLAGS_STICKY) && |
| (parameters[i].type == parameters[pos].type)) |
| { |
| /* Do not overwrite current qualifiers */ |
| flags |= (parameters[i].flags & (unsigned long)~FLAGS_STICKY); |
| if (width == NO_WIDTH) |
| width = parameters[i].width; |
| if (precision == NO_PRECISION) |
| precision = parameters[i].precision; |
| if (base == NO_BASE) |
| base = parameters[i].base; |
| break; |
| } |
| } |
| } |
| |
| parameters[pos].indexAfterSpecifier = index; |
| parameters[pos].flags = flags; |
| parameters[pos].width = width; |
| parameters[pos].precision = precision; |
| parameters[pos].base = (base == NO_BASE) ? BASE_DECIMAL : base; |
| parameters[pos].varsize = varsize; |
| pos++; |
| |
| if (! positional) |
| parameterPosition++; |
| |
| } /* if identifier */ |
| |
| } /* while format characters left */ |
| |
| for (num = 0; num <= maxParam; num++) |
| { |
| if (usedEntries[num] != 1) |
| { |
| if (usedEntries[num] == 0) /* gap detected */ |
| return TRIO_ERROR_RETURN(TRIO_EGAP, num); |
| else /* double references detected */ |
| return TRIO_ERROR_RETURN(TRIO_EDBLREF, num); |
| } |
| |
| i = indices[num]; |
| |
| /* |
| * FORMAT_PARAMETERS are only present if they must be read, |
| * so it makes no sense to check the ignore flag (besides, |
| * the flags variable is not set for that particular type) |
| */ |
| if ((parameters[i].type != FORMAT_PARAMETER) && |
| (parameters[i].flags & FLAGS_IGNORE)) |
| continue; /* for all arguments */ |
| |
| /* |
| * The stack arguments are read according to ANSI C89 |
| * default argument promotions: |
| * |
| * char = int |
| * short = int |
| * unsigned char = unsigned int |
| * unsigned short = unsigned int |
| * float = double |
| * |
| * In addition to the ANSI C89 these types are read (the |
| * default argument promotions of C99 has not been |
| * considered yet) |
| * |
| * long long |
| * long double |
| * size_t |
| * ptrdiff_t |
| * intmax_t |
| */ |
| switch (parameters[i].type) |
| { |
| case FORMAT_GROUP: |
| case FORMAT_STRING: |
| #if TRIO_WIDECHAR |
| if (flags & FLAGS_WIDECHAR) |
| { |
| parameters[i].data.wstring = (argarray == NULL) |
| ? va_arg(TRIO_VA_LIST_DEREF(arglist), trio_wchar_t *) |
| : (trio_wchar_t *)(argarray[num]); |
| } |
| else |
| #endif |
| { |
| parameters[i].data.string = (argarray == NULL) |
| ? va_arg(TRIO_VA_LIST_DEREF(arglist), char *) |
| : (char *)(argarray[num]); |
| } |
| break; |
| |
| #if defined(FORMAT_USER_DEFINED) |
| case FORMAT_USER_DEFINED: |
| #endif |
| case FORMAT_POINTER: |
| case FORMAT_COUNT: |
| case FORMAT_UNKNOWN: |
| parameters[i].data.pointer = (argarray == NULL) |
| ? va_arg(TRIO_VA_LIST_DEREF(arglist), trio_pointer_t ) |
| : argarray[num]; |
| break; |
| |
| case FORMAT_CHAR: |
| case FORMAT_INT: |
| if (TYPE_SCAN == type) |
| { |
| if (argarray == NULL) |
| parameters[i].data.pointer = |
| (trio_pointer_t)va_arg(TRIO_VA_LIST_DEREF(arglist), trio_pointer_t); |
| else |
| { |
| if (parameters[i].type == FORMAT_CHAR) |
| parameters[i].data.pointer = |
| (trio_pointer_t)((char *)argarray[num]); |
| else if (parameters[i].flags & FLAGS_SHORT) |
| parameters[i].data.pointer = |
| (trio_pointer_t)((short *)argarray[num]); |
| else |
| parameters[i].data.pointer = |
| (trio_pointer_t)((int *)argarray[num]); |
| } |
| } |
| else |
| { |
| #if defined(QUALIFIER_VARSIZE) || defined(QUALIFIER_FIXED_SIZE) |
| if (parameters[i].flags |
| & (FLAGS_VARSIZE_PARAMETER | FLAGS_FIXED_SIZE)) |
| { |
| if (parameters[i].flags & FLAGS_VARSIZE_PARAMETER) |
| { |
| /* |
| * Variable sizes are mapped onto the fixed sizes, in |
| * accordance with integer promotion. |
| * |
| * Please note that this may not be portable, as we |
| * only guess the size, not the layout of the numbers. |
| * For example, if int is little-endian, and long is |
| * big-endian, then this will fail. |
| */ |
| varsize = (int)parameters[parameters[i].varsize].data.number.as_unsigned; |
| } |
| else |
| { |
| /* Used for the I<bits> modifiers */ |
| varsize = parameters[i].varsize; |
| } |
| parameters[i].flags &= ~FLAGS_ALL_VARSIZES; |
| |
| if (varsize <= (int)sizeof(int)) |
| ; |
| else if (varsize <= (int)sizeof(long)) |
| parameters[i].flags |= FLAGS_LONG; |
| #if defined(QUALIFIER_INTMAX_T) |
| else if (varsize <= (int)sizeof(trio_longlong_t)) |
| parameters[i].flags |= FLAGS_QUAD; |
| else |
| parameters[i].flags |= FLAGS_INTMAX_T; |
| #else |
| else |
| parameters[i].flags |= FLAGS_QUAD; |
| #endif |
| } |
| #endif /* defined(QUALIFIER_VARSIZE) */ |
| #if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER) |
| if (parameters[i].flags & FLAGS_SIZE_T) |
| parameters[i].data.number.as_unsigned = (argarray == NULL) |
| ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), size_t) |
| : (trio_uintmax_t)(*((size_t *)argarray[num])); |
| else |
| #endif |
| #if defined(QUALIFIER_PTRDIFF_T) |
| if (parameters[i].flags & FLAGS_PTRDIFF_T) |
| parameters[i].data.number.as_unsigned = (argarray == NULL) |
| ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), ptrdiff_t) |
| : (trio_uintmax_t)(*((ptrdiff_t *)argarray[num])); |
| else |
| #endif |
| #if defined(QUALIFIER_INTMAX_T) |
| if (parameters[i].flags & FLAGS_INTMAX_T) |
| parameters[i].data.number.as_unsigned = (argarray == NULL) |
| ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), trio_intmax_t) |
| : (trio_uintmax_t)(*((trio_intmax_t *)argarray[num])); |
| else |
| #endif |
| if (parameters[i].flags & FLAGS_QUAD) |
| parameters[i].data.number.as_unsigned = (argarray == NULL) |
| ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), trio_ulonglong_t) |
| : (trio_uintmax_t)(*((trio_ulonglong_t *)argarray[num])); |
| else if (parameters[i].flags & FLAGS_LONG) |
| parameters[i].data.number.as_unsigned = (argarray == NULL) |
| ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), long) |
| : (trio_uintmax_t)(*((long *)argarray[num])); |
| else |
| { |
| if (argarray == NULL) |
| parameters[i].data.number.as_unsigned = (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), int); |
| else |
| { |
| if (parameters[i].type == FORMAT_CHAR) |
| parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((char *)argarray[num])); |
| else if (parameters[i].flags & FLAGS_SHORT) |
| parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((short *)argarray[num])); |
| else |
| parameters[i].data.number.as_unsigned = (trio_uintmax_t)(*((int *)argarray[num])); |
| } |
| } |
| } |
| break; |
| |
| case FORMAT_PARAMETER: |
| /* |
| * The parameter for the user-defined specifier is a pointer, |
| * whereas the rest (width, precision, base) uses an integer. |
| */ |
| if (parameters[i].flags & FLAGS_USER_DEFINED) |
| parameters[i].data.pointer = (argarray == NULL) |
| ? va_arg(TRIO_VA_LIST_DEREF(arglist), trio_pointer_t ) |
| : argarray[num]; |
| else |
| parameters[i].data.number.as_unsigned = (argarray == NULL) |
| ? (trio_uintmax_t)va_arg(TRIO_VA_LIST_DEREF(arglist), int) |
| : (trio_uintmax_t)(*((int *)argarray[num])); |
| break; |
| |
| case FORMAT_DOUBLE: |
| if (TYPE_SCAN == type) |
| { |
| if (parameters[i].flags & FLAGS_LONGDOUBLE) |
| parameters[i].data.longdoublePointer = (argarray == NULL) |
| ? va_arg(TRIO_VA_LIST_DEREF(arglist), trio_long_double_t *) |
| : (trio_long_double_t *)argarray[num]; |
| else |
| { |
| if (parameters[i].flags & FLAGS_LONG) |
| parameters[i].data.doublePointer = (argarray == NULL) |
| ? va_arg(TRIO_VA_LIST_DEREF(arglist), double *) |
| : (double *)argarray[num]; |
| else |
| parameters[i].data.doublePointer = (argarray == NULL) |
| ? (double *)va_arg(TRIO_VA_LIST_DEREF(arglist), float *) |
| : (double *)((float *)argarray[num]); |
| } |
| } |
| else |
| { |
| if (parameters[i].flags & FLAGS_LONGDOUBLE) |
| parameters[i].data.longdoubleNumber = (argarray == NULL) |
| ? va_arg(TRIO_VA_LIST_DEREF(arglist), trio_long_double_t) |
| : (trio_long_double_t)(*((trio_long_double_t *)argarray[num])); |
| else |
| { |
| if (argarray == NULL) |
| parameters[i].data.longdoubleNumber = |
| (trio_long_double_t)va_arg(TRIO_VA_LIST_DEREF(arglist), double); |
| else |
| { |
| if (parameters[i].flags & FLAGS_SHORT) |
| parameters[i].data.longdoubleNumber = |
| (trio_long_double_t)(*((float *)argarray[num])); |
| else |
| parameters[i].data.longdoubleNumber = |
| (trio_long_double_t)(*((double *)argarray[num])); |
| } |
| } |
| } |
| break; |
| |
| #if defined(FORMAT_ERRNO) |
| case FORMAT_ERRNO: |
| parameters[i].data.errorNumber = save_errno; |
| break; |
| #endif |
| |
| default: |
| break; |
| } |
| } /* for all specifiers */ |
| return num; |
| } |
| |
| |
| /************************************************************************* |
| * |
| * 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; |
| int length; |
| char *p; |
| int count; |
| |
| 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++) |
| { |
| *pointer-- = digits[number % base]; |
| number /= base; |
| if (number == 0) |
| break; |
| |
| 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--; |
| } |
| } |
| } |
| |
| if (! ignoreNumber) |
| { |
| /* Adjust width */ |
| width -= (bufferend - pointer) - 1; |
| } |
| |
| /* Adjust precision */ |
| if (NO_PRECISION != precision) |
| { |
| precision -= (bufferend - pointer) - 1; |
| if (precision < 0) |
| precision = 0; |
| flags |= FLAGS_NILPADDING; |
| } |
| |
| /* Calculate padding */ |
| count = (! ((flags & FLAGS_LEFTADJUST) || (precision == NO_PRECISION))) |
| ? precision |
| : 0; |
| |
| /* Adjust width further */ |
| if (isNegative || (flags & FLAGS_SHOWSIGN) || (flags & FLAGS_SPACE)) |
| width--; |
| if ((flags & FLAGS_ALTERNATIVE) && !isNumberZero) |
| { |
| switch (base) |
| { |
| case BASE_BINARY: |
| case BASE_HEX: |
| width -= 2; |
| break; |
| case BASE_OCTAL: |
| if (!(flags & FLAGS_NILPADDING) || (count == 0)) |
| width--; |
| break; |
| default: |
| break; |
| } |
| } |
| |
| /* Output prefixes spaces if needed */ |
| if (! ((flags & FLAGS_LEFTADJUST) || |
| ((flags & FLAGS_NILPADDING) && (precision == NO_PRECISION)))) |
| { |
| while (width-- > count) |
| self->OutStream(self, CHAR_ADJUST); |
| } |
| |
| /* width has been adjusted for signs and alternatives */ |
| if (isNegative) |
| self->OutStream(self, '-'); |
| else if (flags & FLAGS_SHOWSIGN) |
| self->OutStream(self, '+'); |
| else if (flags & FLAGS_SPACE) |
| self->OutStream(self, ' '); |
| |
| /* Prefix is not written when the value is zero */ |
| if ((flags & FLAGS_ALTERNATIVE) && !isNumberZero) |
| { |
| switch (base) |
| { |
| case BASE_BINARY: |
| self->OutStream(self, '0'); |
| self->OutStream(self, (flags & FLAGS_UPPER) ? 'B' : 'b'); |
| break; |
| |
| case BASE_OCTAL: |
| if (!(flags & FLAGS_NILPADDING) || (count == 0)) |
| self->OutStream(self, '0'); |
| break; |
| |
| case BASE_HEX: |
| self->OutStream(self, '0'); |
| self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x'); |
| break; |
| |
| default: |
| break; |
| } /* switch base */ |
| } |
| |
| /* Output prefixed zero padding if needed */ |
| if (flags & FLAGS_NILPADDING) |
| { |
| if (precision == NO_PRECISION) |
| precision = width; |
| while (precision-- > 0) |
| { |
| self->OutStream(self, '0'); |
| width--; |
| } |
| } |
| |
| if (! ignoreNumber) |
| { |
| /* Output the number itself */ |
| while (*(++pointer)) |
| { |
| self->OutStream(self, *pointer); |
| } |
| } |
| |
| /* Output trailing spaces if needed */ |
| if (flags & FLAGS_LEFTADJUST) |
| { |
| while (width-- > 0) |
| self->OutStream(self, CHAR_ADJUST); |
| } |
| } |
| |
| /************************************************************************* |
| * TrioWriteStringCharacter |
| * |
| * Description: |
| * Output a single character of a string |
| */ |
| TRIO_PRIVATE void |
| TrioWriteStringCharacter |
| TRIO_ARGS3((self, ch, flags), |
| trio_class_t *self, |
| int ch, |
| trio_flags_t flags) |
| { |
| if (flags & FLAGS_ALTERNATIVE) |
| { |
| if (! isprint(ch)) |
| { |
| /* |
| * Non-printable characters are converted to C escapes or |
| * \number, if no C escape exists. |
| */ |
| self->OutStream(self, CHAR_BACKSLASH); |
| switch (ch) |
| { |
| case '\007': self->OutStream(self, 'a'); break; |
| case '\b': self->OutStream(self, 'b'); break; |
| case '\f': self->OutStream(self, 'f'); break; |
| case '\n': self->OutStream(self, 'n'); break; |
| case '\r': self->OutStream(self, 'r'); break; |
| case '\t': self->OutStream(self, 't'); break; |
| case '\v': self->OutStream(self, 'v'); break; |
| case '\\': self->OutStream(self, '\\'); break; |
| default: |
| self->OutStream(self, 'x'); |
| TrioWriteNumber(self, (trio_uintmax_t)ch, |
| FLAGS_UNSIGNED | FLAGS_NILPADDING, |
| 2, 2, BASE_HEX); |
| break; |
| } |
| } |
| else if (ch == CHAR_BACKSLASH) |
| { |
| self->OutStream(self, CHAR_BACKSLASH); |
| self->OutStream(self, CHAR_BACKSLASH); |
| } |
| else |
| { |
| self->OutStream(self, ch); |
| } |
| } |
| else |
| { |
| self->OutStream(self, ch); |
| } |
| } |
| |
| /************************************************************************* |
| * TrioWriteString |
| * |
| * Description: |
| * Output a string |
| */ |
| TRIO_PRIVATE void |
| TrioWriteString |
| TRIO_ARGS5((self, string, flags, width, precision), |
| trio_class_t *self, |
| TRIO_CONST char *string, |
| trio_flags_t flags, |
| int width, |
| int precision) |
| { |
| int length; |
| int ch; |
| |
| assert(VALID(self)); |
| assert(VALID(self->OutStream)); |
| |
| if (string == NULL) |
| { |
| string = internalNullString; |
| length = sizeof(internalNullString) - 1; |
| /* Disable quoting for the null pointer */ |
| flags &= (~FLAGS_QUOTE); |
| width = 0; |
| } |
| else |
| { |
| length = trio_length(string); |
| } |
| if ((NO_PRECISION != precision) && |
| (precision < length)) |
| { |
| length = precision; |
| } |
| width -= length; |
| |
| if (flags & FLAGS_QUOTE) |
| self->OutStream(self, CHAR_QUOTE); |
| |
| if (! (flags & FLAGS_LEFTADJUST)) |
| { |
| while (width-- > 0) |
| self->OutStream(self, CHAR_ADJUST); |
| } |
| |
| while (length-- > 0) |
| { |
| /* The ctype parameters must be an unsigned char (or EOF) */ |
| ch = (int)((unsigned char)(*string++)); |
| TrioWriteStringCharacter(self, ch, flags); |
| } |
| |
| if (flags & FLAGS_LEFTADJUST) |
| { |
| while (width-- > 0) |
| self->OutStream(self, CHAR_ADJUST); |
| } |
| if (flags & FLAGS_QUOTE) |
| self->OutStream(self, CHAR_QUOTE); |
| } |
| |
| /************************************************************************* |
| * TrioWriteWideStringCharacter |
| * |
| * Description: |
| * Output a wide string as a multi-byte sequence |
| */ |
| #if TRIO_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_WIDECHAR */ |
| |
| /************************************************************************* |
| * TrioWriteWideString |
| * |
| * Description: |
| * Output a wide character string as a multi-byte string |
| */ |
| #if TRIO_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) |
| (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 (flags & FLAGS_QUOTE) |
| self->OutStream(self, CHAR_QUOTE); |
| |
| 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 (flags & FLAGS_QUOTE) |
| self->OutStream(self, CHAR_QUOTE); |
| } |
| #endif /* TRIO_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. |
| */ |
| 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 baseDigits; |
| int integerThreshold; |
| int fractionThreshold; |
| int expectedWidth; |
| int exponent = 0; |
| unsigned int uExponent = 0; |
| int exponentBase; |
| trio_long_double_t dblBase; |
| trio_long_double_t dblIntegerBase; |
| trio_long_double_t dblFractionBase; |
| trio_long_double_t integerAdjust; |
| trio_long_double_t fractionAdjust; |
| BOOLEAN_T isNegative; |
| BOOLEAN_T isExponentNegative = FALSE; |
| BOOLEAN_T requireTwoDigitExponent; |
| BOOLEAN_T isHex; |
| TRIO_CONST char *digits; |
| char *groupingPointer; |
| int i; |
| int index; |
| BOOLEAN_T hasOnlyZeroes; |
| int zeroes = 0; |
| register int trailingZeroes; |
| BOOLEAN_T keepTrailingZeroes; |
| BOOLEAN_T keepDecimalPoint; |
| trio_long_double_t epsilon; |
| |
| assert(VALID(self)); |
| assert(VALID(self->OutStream)); |
| assert(((base >= MIN_BASE) && (base <= MAX_BASE)) || (base == NO_BASE)); |
| |
| /* Determine sign and look for special quantities */ |
| switch (trio_fpclassify_and_signbit(number, &isNegative)) |
| { |
| case TRIO_FP_NAN: |
| TrioWriteString(self, |
| (flags & FLAGS_UPPER) |
| ? NAN_UPPER |
| : NAN_LOWER, |
| flags, width, precision); |
| return; |
| |
| case TRIO_FP_INFINITE: |
| if (isNegative) |
| { |
| /* Negative infinity */ |
| TrioWriteString(self, |
| (flags & FLAGS_UPPER) |
| ? "-" INFINITE_UPPER |
| : "-" INFINITE_LOWER, |
| flags, width, precision); |
| return; |
| } |
| else |
| { |
| /* Positive infinity */ |
| TrioWriteString(self, |
| (flags & FLAGS_UPPER) |
| ? INFINITE_UPPER |
| : INFINITE_LOWER, |
| flags, width, precision); |
| return; |
| } |
| |
| default: |
| /* Finitude */ |
| break; |
| } |
| |
| /* Normal numbers */ |
| if (flags & FLAGS_LONGDOUBLE) |
| { |
| baseDigits = (base == 10) |
| ? LDBL_DIG |
| : (int)floor(LDBL_MANT_DIG / TrioLogarithmBase(base)); |
| epsilon = LDBL_EPSILON; |
| } |
| else if (flags & FLAGS_SHORT) |
| { |
| baseDigits = (base == BASE_DECIMAL) |
| ? FLT_DIG |
| : (int)floor(FLT_MANT_DIG / TrioLogarithmBase(base)); |
| epsilon = FLT_EPSILON; |
| } |
| else |
| { |
| baseDigits = (base == BASE_DECIMAL) |
| ? DBL_DIG |
| : (int)floor(DBL_MANT_DIG / TrioLogarithmBase(base)); |
| epsilon = DBL_EPSILON; |
| } |
| |
| digits = (flags & FLAGS_UPPER) ? internalDigitsUpper : internalDigitsLower; |
| isHex = (base == BASE_HEX); |
| if (base == NO_BASE) |
| base = BASE_DECIMAL; |
| dblBase = (trio_long_double_t)base; |
| keepTrailingZeroes = !( (flags & FLAGS_ROUNDING) || |
| ( (flags & FLAGS_FLOAT_G) && |
| !(flags & FLAGS_ALTERNATIVE) ) ); |
| |
| if (flags & FLAGS_ROUNDING) |
| precision = baseDigits; |
| |
| if (precision == NO_PRECISION) |
| { |
| if (isHex) |
| { |
| keepTrailingZeroes = FALSE; |
| precision = FLT_MANT_DIG; |
| } |
| else |
| { |
| precision = FLT_DIG; |
| } |
| } |
| |
| if (isNegative) |
| number = -number; |
| |
| if (isHex) |
| flags |= FLAGS_FLOAT_E; |
| |
| if (flags & FLAGS_FLOAT_G) |
| { |
| if (precision == 0) |
| precision = 1; |
| |
| if ((number < 1.0E-4) || (number > powl(base, |
| (trio_long_double_t)precision))) |
| { |
| /* Use scientific notation */ |
| flags |= FLAGS_FLOAT_E; |
| } |
| else if (number < 1.0) |
| { |
| /* |
| * Use normal notation. If the integer part of the number is |
| * zero, then adjust the precision to include leading fractional |
| * zeros. |
| */ |
| workNumber = TrioLogarithm(number, base); |
| workNumber = TRIO_FABS(workNumber); |
| if (workNumber - floorl(workNumber) < 0.001) |
| workNumber--; |
| zeroes = (int)floorl(workNumber); |
| } |
| } |
| |
| if (flags & FLAGS_FLOAT_E) |
| { |
| /* Scale the number */ |
| workNumber = TrioLogarithm(number, base); |
| if (trio_isinf(workNumber) == -1) |
| { |
| exponent = 0; |
| /* Undo setting */ |
| if (flags & FLAGS_FLOAT_G) |
| flags &= ~FLAGS_FLOAT_E; |
| } |
| else |
| { |
| exponent = (int)floorl(workNumber); |
| number /= powl(dblBase, (trio_long_double_t)exponent); |
| isExponentNegative = (exponent < 0); |
| uExponent = (isExponentNegative) ? -exponent : exponent; |
| if (isHex) |
| uExponent *= 4; /* log16(2) */ |
| /* No thousand separators */ |
| flags &= ~FLAGS_QUOTE; |
| } |
| } |
| |
| integerNumber = floorl(number); |
| fractionNumber = number - integerNumber; |
| |
| /* |
| * Truncated number. |
| * |
| * Precision is number of significant digits for FLOAT_G |
| * and number of fractional digits for others. |
| */ |
| integerDigits = (integerNumber > epsilon) |
| ? 1 + (int)TrioLogarithm(integerNumber, base) |
| : 1; |
| fractionDigits = ((flags & FLAGS_FLOAT_G) && (zeroes == 0)) |
| ? precision - integerDigits |
| : zeroes + precision; |
| |
| dblFractionBase = TrioPower(base, fractionDigits); |
| |
| workNumber = number + 0.5 / dblFractionBase; |
| if (floorl(number) != floorl(workNumber)) |
| { |
| if (flags & FLAGS_FLOAT_E) |
| { |
| /* Adjust if number was rounded up one digit (ie. 0.99 to 1.00) */ |
| exponent++; |
| isExponentNegative = (exponent < 0); |
| uExponent = (isExponentNegative) ? -exponent : exponent; |
| if (isHex) |
| uExponent *= 4; /* log16(2) */ |
| workNumber = (number + 0.5 / dblFractionBase) / dblBase; |
| integerNumber = floorl(workNumber); |
| fractionNumber = workNumber - integerNumber; |
| } |
| else |
| { |
| /* Adjust if number was rounded up one digit (ie. 99 to 100) */ |
| integerNumber = floorl(number + 0.5); |
| fractionNumber = 0.0; |
| integerDigits = (integerNumber > epsilon) |
| ? 1 + (int)TrioLogarithm(integerNumber, base) |
| : 1; |
| } |
| } |
| |
| /* Estimate accuracy */ |
| integerAdjust = fractionAdjust = 0.5; |
| if (flags & FLAGS_ROUNDING) |
| { |
| if (integerDigits > baseDigits) |
| { |
| integerThreshold = baseDigits; |
| fractionDigits = 0; |
| dblFractionBase = 1.0; |
| fractionThreshold = 0; |
| precision = 0; /* Disable decimal-point */ |
| integerAdjust = TrioPower(base, integerDigits - integerThreshold - 1); |
| fractionAdjust = 0.0; |
| } |
| else |
| { |
| integerThreshold = integerDigits; |
| fractionThreshold = fractionDigits - integerThreshold; |
| fractionAdjust = 1.0; |
| } |
| } |
| else |
| { |
| integerThreshold = INT_MAX; |
| fractionThreshold = INT_MAX; |
| } |
| |
| /* |
| * Calculate expected width. |
| * sign + integer part + thousands separators + decimal point |
| * + fraction + exponent |
| */ |
| fractionAdjust /= dblFractionBase; |
| hasOnlyZeroes = (floorl((fractionNumber + fractionAdjust) * dblFractionBase) < epsilon); |
| keepDecimalPoint = ( (flags & FLAGS_ALTERNATIVE) || |
| !((precision == 0) || |
| (!keepTrailingZeroes && hasOnlyZeroes)) ); |
| if (flags & FLAGS_FLOAT_E) |
| { |
| exponentDigits = (uExponent == 0) |
| ? 1 |
| : (int)ceil(TrioLogarithm((double)(uExponent + 1), |
| (isHex) ? 10.0 : base)); |
| } |
| else |
| exponentDigits = 0; |
| requireTwoDigitExponent = ((base == BASE_DECIMAL) && (exponentDigits == 1)); |
| |
| expectedWidth = integerDigits + fractionDigits |
| + (keepDecimalPoint |
| ? internalDecimalPointLength |
| : 0) |
| + ((flags & FLAGS_QUOTE) |
| ? TrioCalcThousandSeparatorLength(integerDigits) |
| : 0); |
| if (isNegative || (flags & FLAGS_SHOWSIGN) || (flags & FLAGS_SPACE)) |
| expectedWidth += sizeof("-") - 1; |
| if (exponentDigits > 0) |
| expectedWidth += exponentDigits + |
| ((requireTwoDigitExponent ? sizeof("E+0") : sizeof("E+")) - 1); |
| if (isHex) |
| expectedWidth += sizeof("0X") - 1; |
| |
| /* Output prefixing */ |
| if (flags & FLAGS_NILPADDING) |
| { |
| /* Leading zeros must be after sign */ |
| if (isNegative) |
| self->OutStream(self, '-'); |
| else if (flags & FLAGS_SHOWSIGN) |
| self->OutStream(self, '+'); |
| else if (flags & FLAGS_SPACE) |
| self->OutStream(self, ' '); |
| if (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 */ |
| dblIntegerBase = 1.0 / TrioPower(base, integerDigits - 1); |
| for (i = 0; i < integerDigits; i++) |
| { |
| workNumber = floorl(((integerNumber + integerAdjust) * dblIntegerBase)); |
| if (i > integerThreshold) |
| { |
| /* Beyond accuracy */ |
| self->OutStream(self, digits[0]); |
| } |
| else |
| { |
| self->OutStream(self, digits[(int)fmodl(workNumber, dblBase)]); |
| } |
| dblIntegerBase *= dblBase; |
| |
| if (((flags & (FLAGS_FLOAT_E | FLAGS_QUOTE)) == FLAGS_QUOTE) |
| && TrioFollowedBySeparator(integerDigits - i)) |
| { |
| for (groupingPointer = internalThousandSeparator; |
| *groupingPointer != NIL; |
| groupingPointer++) |
| { |
| self->OutStream(self, *groupingPointer); |
| } |
| } |
| } |
| |
| /* 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 = floorl(fractionNumber + fractionAdjust); |
| fractionNumber -= workNumber; |
| index = (int)fmodl(workNumber, dblBase); |
| if (index == 0) |
| { |
| trailingZeroes++; |
| } |
| else |
| { |
| while (trailingZeroes > 0) |
| { |
| /* Not trailing zeroes after all */ |
| self->OutStream(self, digits[0]); |
| trailingZeroes--; |
| } |
| self->OutStream(self, digits[index]); |
| } |
| } |
| } |
| |
| 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.0; |
| 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); |
| } |
| } |
| } |
| |
| /************************************************************************* |
| * 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) |
| { |
| #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) |
| int charlen; |
| #endif |
| int i; |
| TRIO_CONST char *string; |
| trio_pointer_t pointer; |
| trio_flags_t flags; |
| int width; |
| int precision; |
| int base; |
| int index; |
| |
| index = 0; |
| i = 0; |
| #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) |
| (void)mblen(NULL, 0); |
| #endif |
| |
| while (format[index]) |
| { |
| #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) |
| if (! isascii(format[index])) |
| { |
| charlen = mblen(&format[index], MB_LEN_MAX); |
| /* |
| * Only valid multibyte characters are handled here. Invalid |
| * multibyte characters (charlen == -1) are handled as normal |
| * characters. |
| */ |
| if (charlen != -1) |
| { |
| while (charlen-- > 0) |
| { |
| data->OutStream(data, format[index++]); |
| } |
| continue; /* while characters left in formatting string */ |
| } |
| } |
| #endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */ |
| if (CHAR_IDENTIFIER == format[index]) |
| { |
| if (CHAR_IDENTIFIER == format[index + 1]) |
| { |
| data->OutStream(data, CHAR_IDENTIFIER); |
| index += 2; |
| } |
| else |
| { |
| /* Skip the parameter entries */ |
| while (parameters[i].type == FORMAT_PARAMETER) |
| i++; |
| |
| flags = parameters[i].flags; |
| |
| /* Find width */ |
| width = parameters[i].width; |
| if (flags & FLAGS_WIDTH_PARAMETER) |
| { |
| /* Get width from parameter list */ |
| width = (int)parameters[width].data.number.as_signed; |
| if (width < 0) |
| { |
| /* |
| * A negative width is the same as the - flag and |
| * a positive width. |
| */ |
| flags |= FLAGS_LEFTADJUST; |
| flags &= ~FLAGS_NILPADDING; |
| width = -width; |
| } |
| } |
| |
| /* Find precision */ |
| if (flags & FLAGS_PRECISION) |
| { |
| precision = parameters[i].precision; |
| if (flags & FLAGS_PRECISION_PARAMETER) |
| { |
| /* Get precision from parameter list */ |
| precision = (int)parameters[precision].data.number.as_signed; |
| if (precision < 0) |
| { |
| /* |
| * A negative precision is the same as no |
| * precision |
| */ |
| precision = NO_PRECISION; |
| } |
| } |
| } |
| else |
| { |
| precision = NO_PRECISION; |
| } |
| |
| /* Find base */ |
| base = parameters[i].base; |
| if (flags & FLAGS_BASE_PARAMETER) |
| { |
| /* Get base from parameter list */ |
| base = (int)parameters[base].data.number.as_signed; |
| } |
| |
| switch (parameters[i].type) |
| { |
| case FORMAT_CHAR: |
| if (flags & FLAGS_QUOTE) |
| data->OutStream(data, CHAR_QUOTE); |
| if (! (flags & FLAGS_LEFTADJUST)) |
| { |
| while (--width > 0) |
| data->OutStream(data, CHAR_ADJUST); |
| } |
| #if TRIO_WIDECHAR |
| if (flags & FLAGS_WIDECHAR) |
| { |
| TrioWriteWideStringCharacter(data, |
| (trio_wchar_t)parameters[i].data.number.as_signed, |
| flags, |
| NO_WIDTH); |
| } |
| else |
| #endif |
| { |
| TrioWriteStringCharacter(data, |
| (int)parameters[i].data.number.as_signed, |
| flags); |
| } |
| |
| if (flags & FLAGS_LEFTADJUST) |
| { |
| while(--width > 0) |
| data->OutStream(data, CHAR_ADJUST); |
| } |
| if (flags & FLAGS_QUOTE) |
| data->OutStream(data, CHAR_QUOTE); |
| |
| break; /* FORMAT_CHAR */ |
| |
| case FORMAT_INT: |
| TrioWriteNumber(data, |
| parameters[i].data.number.as_unsigned, |
| flags, |
| width, |
| precision, |
| base); |
| |
| break; /* FORMAT_INT */ |
| |
| case FORMAT_DOUBLE: |
| TrioWriteDouble(data, |
| parameters[i].data.longdoubleNumber, |
| flags, |
| width, |
| precision, |
| base); |
| break; /* FORMAT_DOUBLE */ |
| |
| case FORMAT_STRING: |
| #if TRIO_WIDECHAR |
| if (flags & FLAGS_WIDECHAR) |
| { |
| TrioWriteWideString(data, |
| parameters[i].data.wstring, |
| flags, |
| width, |
| precision); |
| } |
| else |
| #endif |
| { |
| TrioWriteString(data, |
| parameters[i].data.string, |
| flags, |
| width, |
| precision); |
| } |
| break; /* FORMAT_STRING */ |
| |
| case FORMAT_POINTER: |
| { |
| trio_reference_t reference; |
| |
| reference.data = data; |
| reference.parameter = ¶meters[i]; |
| trio_print_pointer(&reference, parameters[i].data.pointer); |
| } |
| break; /* FORMAT_POINTER */ |
| |
| case FORMAT_COUNT: |
| pointer = parameters[i].data.pointer; |
| if (NULL != pointer) |
| { |
| /* |
| * C99 paragraph 7.19.6.1.8 says "the number of |
| * characters written to the output stream so far by |
| * this call", which is data->committed |
| */ |
| #if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER) |
| if (flags & FLAGS_SIZE_T) |
| *(size_t *)pointer = (size_t)data->committed; |
| else |
| #endif |
| #if defined(QUALIFIER_PTRDIFF_T) |
| if (flags & FLAGS_PTRDIFF_T) |
| *(ptrdiff_t *)pointer = (ptrdiff_t)data->committed; |
| else |
| #endif |
| #if defined(QUALIFIER_INTMAX_T) |
| if (flags & FLAGS_INTMAX_T) |
| *(trio_intmax_t *)pointer = (trio_intmax_t)data->committed; |
| else |
| #endif |
| if (flags & FLAGS_QUAD) |
| { |
| *(trio_ulonglong_t *)pointer = (trio_ulonglong_t)data->committed; |
| } |
| else if (flags & FLAGS_LONG) |
| { |
| *(long int *)pointer = (long int)data->committed; |
| } |
| else if (flags & FLAGS_SHORT) |
| { |
| *(short int *)pointer = (short int)data->committed; |
| } |
| else |
| { |
| *(int *)pointer = (int)data->committed; |
| } |
| } |
| break; /* FORMAT_COUNT */ |
| |
| case FORMAT_PARAMETER: |
| break; /* FORMAT_PARAMETER */ |
| |
| #if defined(FORMAT_ERRNO) |
| case FORMAT_ERRNO: |
| string = trio_error(parameters[i].data.errorNumber); |
| if (string) |
| { |
| TrioWriteString(data, |
| string, |
| flags, |
| width, |
| precision); |
| } |
| else |
| { |
| data->OutStream(data, '#'); |
| TrioWriteNumber(data, |
| (trio_uintmax_t)parameters[i].data.errorNumber, |
| flags, |
| width, |
| precision, |
| BASE_DECIMAL); |
| } |
| break; /* FORMAT_ERRNO */ |
| #endif /* defined(FORMAT_ERRNO) */ |
| |
| #if defined(FORMAT_USER_DEFINED) |
| case FORMAT_USER_DEFINED: |
| { |
| trio_reference_t reference; |
| trio_userdef_t *def = NULL; |
| |
| if (parameters[i].user_name[0] == NIL) |
| { |
| /* Use handle */ |
| if ((i > 0) || |
| (parameters[i - 1].type == FORMAT_PARAMETER)) |
| def = (trio_userdef_t *)parameters[i - 1].data.pointer; |
| } |
| else |
| { |
| /* Look up namespace */ |
| def = TrioFindNamespace(parameters[i].user_name, NULL); |
| } |
| if (def) { |
| reference.data = data; |
| reference.parameter = ¶meters[i]; |
| def->callback(&reference); |
| } |
| } |
| break; |
| #endif /* defined(FORMAT_USER_DEFINED) */ |
| |
| default: |
| break; |
| } /* switch parameter type */ |
| |
| /* Prepare for next */ |
| index = parameters[i].indexAfterSpecifier; |
| i++; |
| } |
| } |
| else /* not identifier */ |
| { |
| data->OutStream(data, format[index++]); |
| } |
| } |
| return data->processed; |
| } |
| |
| /************************************************************************* |
| * TrioFormatRef |
| */ |
| TRIO_PRIVATE int |
| TrioFormatRef |
| TRIO_ARGS4((reference, format, arglist, argarray), |
| trio_reference_t *reference, |
| TRIO_CONST char *format, |
| TRIO_VA_LIST_PTR arglist, |
| trio_pointer_t *argarray) |
| { |
| int status; |
| trio_parameter_t parameters[MAX_PARAMETERS]; |
| |
| status = TrioParse(TYPE_PRINT, format, parameters, arglist, argarray); |
| if (status < 0) |
| return status; |
| |
| status = TrioFormatProcess(reference->data, format, parameters); |
| if (reference->data->error != 0) |
| { |
| status = reference->data->error; |
| } |
| return status; |
| } |
| |
| /************************************************************************* |
| * TrioFormat |
| */ |
| TRIO_PRIVATE int |
| TrioFormat |
| TRIO_ARGS6((destination, destinationSize, OutStream, format, arglist, argarray), |
| trio_pointer_t destination, |
| size_t destinationSize, |
| void (*OutStream) TRIO_PROTO((trio_class_t *, int)), |
| TRIO_CONST char *format, |
| TRIO_VA_LIST_PTR arglist, |
| trio_pointer_t *argarray) |
| { |
| int status; |
| trio_class_t data; |
| trio_parameter_t parameters[MAX_PARAMETERS]; |
| |
| assert(VALID(OutStream)); |
| assert(VALID(format)); |
| |
| memset(&data, 0, sizeof(data)); |
| data.OutStream = OutStream; |
| data.location = destination; |
| data.max = destinationSize; |
| data.error = 0; |
| |
| #if defined(USE_LOCALE) |
| if (NULL == internalLocaleValues) |
| { |
| TrioSetLocale(); |
| } |
| #endif |
| |
| status = TrioParse(TYPE_PRINT, format, parameters, arglist, argarray); |
| if (status < 0) |
| return status; |
| |
| status = TrioFormatProcess(&data, format, parameters); |
| if (data.error != 0) |
| { |
| status = data.error; |
| } |
| return status; |
| } |
| |
| /************************************************************************* |
| * TrioOutStreamFile |
| */ |
| 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->committed++; |
| } |
| } |
| |
| /************************************************************************* |
| * TrioOutStreamFileDescriptor |
| */ |
| 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->committed++; |
| } |
| } |
| |
| /************************************************************************* |
| * TrioOutStreamCustom |
| */ |
| 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->committed++; |
| } |
| else |
| { |
| if (self->error == 0) |
| { |
| self->error = TRIO_ERROR_RETURN(TRIO_ECUSTOM, -status); |
| } |
| } |
| } |
| self->processed++; |
| } |
| |
| /************************************************************************* |
| * 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->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->committed++; |
| } |
| self->processed++; |
| } |
| |
| /************************************************************************* |
| * TrioOutStreamStringDynamic |
| */ |
| 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->committed++; |
| } |
| /* The processed variable must always be increased */ |
| self->processed++; |
| } |
| |
| /************************************************************************* |
| * |
| * Formatted printing functions |
| * |
| ************************************************************************/ |
| |
| #if defined(TRIO_DOCUMENTATION) |
| # include "doc/doc_printf.h" |
| #endif |
| /** @addtogroup Printf |
| @{ |
| */ |
| |
| /************************************************************************* |
| * printf |
| */ |
| |
| /** |
| Print to standard output stream. |
| |
| @param format Formatting string. |
| @param ... Arguments. |
| @return Number of printed characters. |
| */ |
| 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, TRIO_VA_LIST_ADDR(args), NULL); |
| TRIO_VA_END(args); |
| return status; |
| } |
| |
| /** |
| Print to standard output stream. |
| |
| @param format Formatting string. |
| @param args Arguments. |
| @return Number of printed characters. |
| */ |
| 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, TRIO_VA_LIST_ADDR(args), NULL); |
| } |
| |
| /** |
| Print to standard output stream. |
| |
| @param format Formatting string. |
| @param args Arguments. |
| @return Number of printed characters. |
| */ |
| TRIO_PUBLIC int |
| trio_printfv |
| TRIO_ARGS2((format, args), |
| TRIO_CONST char *format, |
| trio_pointer_t * args) |
| { |
| assert(VALID(format)); |
| |
| return TrioFormat(stdout, 0, TrioOutStreamFile, format, NULL, args); |
| } |
| |
| /************************************************************************* |
| * fprintf |
| */ |
| |
| /** |
| Print to file. |
| |
| @param file File pointer. |
| @param format Formatting string. |
| @param ... Arguments. |
| @return Number of printed characters. |
| */ |
| 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, TRIO_VA_LIST_ADDR(args), NULL); |
| TRIO_VA_END(args); |
| return status; |
| } |
| |
| /** |
| Print to file. |
| |
| @param file File pointer. |
| @param format Formatting string. |
| @param args Arguments. |
| @return Number of printed characters. |
| */ |
| 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, TRIO_VA_LIST_ADDR(args), NULL); |
| } |
| |
| /** |
| Print to file. |
| |
| @param file File pointer. |
| @param format Formatting string. |
| @param args Arguments. |
| @return Number of printed characters. |
| */ |
| TRIO_PUBLIC int |
| trio_fprintfv |
| TRIO_ARGS3((file, format, args), |
| FILE *file, |
| TRIO_CONST char *format, |
| trio_pointer_t * args) |
| { |
| assert(VALID(file)); |
| assert(VALID(format)); |
| |
| return TrioFormat(file, 0, TrioOutStreamFile, format, NULL, args); |
| } |
| |
| /************************************************************************* |
| * dprintf |
| */ |
| |
| /** |
| Print to file descriptor. |
| |
| @param fd File descriptor. |
| @param format Formatting string. |
| @param ... Arguments. |
| @return Number of printed characters. |
| */ |
| 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, TRIO_VA_LIST_ADDR(args), NULL); |
| TRIO_VA_END(args); |
| return status; |
| } |
| |
| /** |
| Print to file descriptor. |
| |
| @param fd File descriptor. |
| @param format Formatting string. |
| @param args Arguments. |
| @return Number of printed characters. |
| */ |
| TRIO_PUBLIC int |
| trio_vdprintf |
| TRIO_ARGS3((fd, format, args), |
| int fd, |
| TRIO_CONST char *format, |
| va_list args) |
| { |
| assert(VALID(format)); |
| |
| return TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, TRIO_VA_LIST_ADDR(args), NULL); |
| } |
| |
| /** |
| Print to file descriptor. |
| |
| @param fd File descriptor. |
| @param format Formatting string. |
| @param args Arguments. |
| @return Number of printed characters. |
| */ |
| TRIO_PUBLIC int |
| trio_dprintfv |
| TRIO_ARGS3((fd, format, args), |
| int fd, |
| TRIO_CONST char *format, |
| trio_pointer_t *args) |
| { |
| assert(VALID(format)); |
| |
| return TrioFormat(&fd, 0, TrioOutStreamFileDescriptor, format, NULL, args); |
| } |
| |
| /************************************************************************* |
| * cprintf |
| */ |
| 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, TRIO_VA_LIST_ADDR(args), NULL); |
| TRIO_VA_END(args); |
| return status; |
| } |
| |
| 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, TRIO_VA_LIST_ADDR(args), NULL); |
| } |
| |
| TRIO_PUBLIC int |
| trio_cprintfv |
| TRIO_ARGS4((stream, closure, format, args), |
| trio_outstream_t stream, |
| trio_pointer_t closure, |
| TRIO_CONST char *format, |
| void **args) |
| { |
| trio_custom_t data; |
| |
| assert(VALID(stream)); |
| assert(VALID(format)); |
| |
| data.stream.out = stream; |
| data.closure = closure; |
| return TrioFormat(&data, 0, TrioOutStreamCustom, format, NULL, args); |
| } |
| |
| /************************************************************************* |
| * 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, TRIO_VA_LIST_ADDR(args), 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, TRIO_VA_LIST_ADDR(args), 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) |
| { |
| int status; |
| |
| assert(VALID(buffer)); |
| assert(VALID(format)); |
| |
| status = TrioFormat(&buffer, 0, TrioOutStreamString, format, NULL, 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)); |
| assert(VALID(format)); |
| |
| TRIO_VA_START(args, format); |
| status = TrioFormat(&buffer, max > 0 ? max - 1 : 0, |
| TrioOutStreamStringMax, format, TRIO_VA_LIST_ADDR(args), 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)); |
| assert(VALID(format)); |
| |
| status = TrioFormat(&buffer, max > 0 ? max - 1 : 0, |
| TrioOutStreamStringMax, format, TRIO_VA_LIST_ADDR(args), 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) |
| { |
| int status; |
| |
| assert(VALID(buffer)); |
| assert(VALID(format)); |
| |
| status = TrioFormat(&buffer, max > 0 ? max - 1 : 0, |
| TrioOutStreamStringMax, format, NULL, 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. |
| */ |
| 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, TRIO_VA_LIST_ADDR(args), NULL); |
| TRIO_VA_END(args); |
| *buffer = NIL; |
| return status; |
| } |
| |
| 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, TRIO_VA_LIST_ADDR(args), NULL); |
| *buffer = NIL; |
| return status; |
| } |
| |
| /************************************************************************* |
| * trio_aprintf |
| */ |
| |
| /* Deprecated */ |
| 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, TRIO_VA_LIST_ADDR(args), NULL); |
| TRIO_VA_END(args); |
| |
| trio_string_terminate(info); |
| result = trio_string_extract(info); |
| trio_string_destroy(info); |
| } |
| return result; |
| } |
| |
| /* Deprecated */ |
| 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, TRIO_VA_LIST_ADDR(args), NULL); |
| trio_string_terminate(info); |
| result = trio_string_extract(info); |
| trio_string_destroy(info); |
| } |
| return result; |
| } |
| |
| 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, TRIO_VA_LIST_ADDR(args), NULL); |
| TRIO_VA_END(args); |
| if (status >= 0) |
| { |
| trio_string_terminate(info); |
| *result = trio_string_extract(info); |
| } |
| trio_string_destroy(info); |
| } |
| return status; |
| } |
| |
| 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, TRIO_VA_LIST_ADDR(args), NULL); |
| if (status >= 0) |
| { |
| trio_string_terminate(info); |
| *result = trio_string_extract(info); |
| } |
| trio_string_destroy(info); |
| } |
| return status; |
| } |
| |
| /** @} End of Printf documentation module */ |
| |
| /************************************************************************* |
| * |
| * CALLBACK |
| * |
| ************************************************************************/ |
| |
| #if defined(TRIO_DOCUMENTATION) |
| # include "doc/doc_register.h" |
| #endif |
| /** |
| @addtogroup UserDefined |
| @{ |
| */ |
| |
| #if TRIO_EXTENSION |
| |
| /************************************************************************* |
| * trio_register |
| */ |
| |
| /** |
| Register new user-defined specifier. |
| |
| @param callback |
| @param name |
| @return Handle. |
| */ |
| TRIO_PUBLIC trio_pointer_t |
| trio_register |
| TRIO_ARGS2((callback, name), |
| trio_callback_t callback, |
| TRIO_CONST char *name) |
| { |
| trio_userdef_t *def; |
| trio_userdef_t *prev = NULL; |
| |
| if (callback == NULL) |
| return NULL; |
| |
| if (name) |
| { |
| /* Handle built-in namespaces */ |
| if (name[0] == ':') |
| { |
| if (trio_equal(name, ":enter")) |
| { |
| internalEnterCriticalRegion = callback; |
| } |
| else if (trio_equal(name, ":leave")) |
| { |
| internalLeaveCriticalRegion = callback; |
| } |
| return NULL; |
| } |
| |
| /* Bail out if namespace is too long */ |
| if (trio_length(name) >= MAX_USER_NAME) |
| return NULL; |
| |
| /* Bail out if namespace already is registered */ |
| def = TrioFindNamespace(name, &prev); |
| if (def) |
| return NULL; |
| } |
| |
| def = (trio_userdef_t *)TRIO_MALLOC(sizeof(trio_userdef_t)); |
| if (def) |
| { |
| if (internalEnterCriticalRegion) |
| (void)internalEnterCriticalRegion(NULL); |
| |
| if (name) |
| { |
| /* Link into internal list */ |
| if (prev == NULL) |
| internalUserDef = def; |
| else |
| prev->next = def; |
| } |
| /* Initialize */ |
| def->callback = callback; |
| def->name = (name == NULL) |
| ? NULL |
| : trio_duplicate(name); |
| def->next = NULL; |
| |
| if (internalLeaveCriticalRegion) |
| (void)internalLeaveCriticalRegion(NULL); |
| } |
| return (trio_pointer_t)def; |
| } |
| |
| /** |
| Unregister an existing user-defined specifier. |
| |
| @param handle |
| */ |
| void |
| trio_unregister |
| TRIO_ARGS1((handle), |
| trio_pointer_t handle) |
| { |
| trio_userdef_t *self = (trio_userdef_t *)handle; |
| trio_userdef_t *def; |
| trio_userdef_t *prev = NULL; |
| |
| assert(VALID(self)); |
| |
| if (self->name) |
| { |
| def = TrioFindNamespace(self->name, &prev); |
| if (def) |
| { |
| if (internalEnterCriticalRegion) |
| (void)internalEnterCriticalRegion(NULL); |
| |
| if (prev == NULL) |
| internalUserDef = NULL; |
| 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 defined(FORMAT_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 defined(FORMAT_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] |
| */ |
| 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; |
| } |
| |
| /************************************************************************* |
| * 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] |
| */ |
| 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; |
| } |
| |
| /************************************************************************* |
| * 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_C99 |
| 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_get_ptrdiff / trio_set_ptrdiff [public] |
| */ |
| 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; |
| } |
| |
| /************************************************************************* |
| * trio_get_size / trio_set_size [public] |
| */ |
| #if TRIO_C99 |
| 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_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] |
| */ |
| 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); |
| } |
| |
| /************************************************************************* |
| * trio_print_string [public] |
| */ |
| void |
| trio_print_string |
| TRIO_ARGS2((ref, string), |
| trio_pointer_t ref, |
| 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, TRIO_VA_LIST_ADDR(arglist), 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, TRIO_VA_LIST_ADDR(arglist), 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) |
| { |
| assert(VALID(format)); |
| |
| return TrioFormatRef((trio_reference_t *)ref, format, NULL, argarray); |
| } |
| |
| #endif /* TRIO_EXTENSION */ |
| |
| /************************************************************************* |
| * 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. |
| */ |
| 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); |
| } |
| } |
| |
| /************************************************************************* |
| * trio_locale_set_thousand_separator |
| * |
| * See trio_locale_set_decimal_point |
| */ |
| 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); |
| } |
| |
| /************************************************************************* |
| * 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. |
| */ |
| 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); |
| } |
| |
| |
| /************************************************************************* |
| * |
| * SCANNING |
| * |
| ************************************************************************/ |
| |
| /************************************************************************* |
| * 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, indexPointer, flagsPointer, characterclass), |
| TRIO_CONST char *format, |
| int *indexPointer, |
| trio_flags_t *flagsPointer, |
| int *characterclass) |
| { |
| int index = *indexPointer; |
| int i; |
| char ch; |
| char range_begin; |
| char range_end; |
| |
| *flagsPointer &= ~FLAGS_EXCLUDE; |
| |
| if (format[index] == QUALIFIER_CIRCUMFLEX) |
| { |
| *flagsPointer |= FLAGS_EXCLUDE; |
| index++; |
| } |
| /* |
| * If the ungroup character is at the beginning of the scanlist, |
| * it will be part of the class, and a second ungroup character |
| * must follow to end the group. |
| */ |
| if (format[index] == SPECIFIER_UNGROUP) |
| { |
| characterclass[(int)SPECIFIER_UNGROUP]++; |
| index++; |
| } |
| /* |
| * Minus is used to specify ranges. To include minus in the class, |
| * it must be at the beginning of the list |
| */ |
| if (format[index] == QUALIFIER_MINUS) |
| { |
| characterclass[(int)QUALIFIER_MINUS]++; |
| index++; |
| } |
| /* Collect characters */ |
| for (ch = format[index]; |
| (ch != SPECIFIER_UNGROUP) && (ch != NIL); |
| ch = format[++index]) |
| { |
| switch (ch) |
| { |
| case QUALIFIER_MINUS: /* Scanlist ranges */ |
| |
| /* |
| * Both C99 and UNIX98 describes ranges as implementation- |
| * defined. |
| * |
| * We support the following behaviour (although this may |
| * change as we become wiser) |
| * - only increasing ranges, ie. [a-b] but not [b-a] |
| * - transitive ranges, ie. [a-b-c] == [a-c] |
| * - trailing minus, ie. [a-] is interpreted as an 'a' |
| * and a '-' |
| * - duplicates (although we can easily convert these |
| * into errors) |
| */ |
| range_begin = format[index - 1]; |
| range_end = format[++index]; |
| if (range_end == SPECIFIER_UNGROUP) |
| { |
| /* Trailing minus is included */ |
| characterclass[(int)ch]++; |
| ch = range_end; |
| break; /* for */ |
| } |
| if (range_end == NIL) |
| return TRIO_ERROR_RETURN(TRIO_EINVAL, index); |
| if (range_begin > range_end) |
| return TRIO_ERROR_RETURN(TRIO_ERANGE, index); |
| |
| for (i = (int)range_begin; i <= (int)range_end; i++) |
| characterclass[i]++; |
| |
| ch = range_end; |
| break; |
| |
| #if TRIO_EXTENSION |
| |
| case SPECIFIER_GROUP: |
| |
| switch (format[index + 1]) |
| { |
| case QUALIFIER_DOT: /* Collating symbol */ |
| /* |
| * FIXME: This will be easier to implement when multibyte |
| * characters have been implemented. Until now, we ignore |
| * this feature. |
| */ |
| for (i = index + 2; ; i++) |
| { |
| if (format[i] == NIL) |
| /* Error in syntax */ |
| return -1; |
| else if (format[i] == QUALIFIER_DOT) |
| break; /* for */ |
| } |
| if (format[++i] != SPECIFIER_UNGROUP) |
| return -1; |
| |
| index = i; |
| break; |
| |
| case QUALIFIER_EQUAL: /* Equivalence class expressions */ |
| { |
| unsigned int j; |
| unsigned int k; |
| |
| if (internalCollationUnconverted) |
| { |
| /* Lazy evaluation of collation array */ |
| TrioGetCollation(); |
| internalCollationUnconverted = FALSE; |
| } |
| for (i = index + 2; ; i++) |
| { |
| if (format[i] == NIL) |
| /* Error in syntax */ |
| return -1; |
| else if (format[i] == QUALIFIER_EQUAL) |
| break; /* for */ |
| else |
| { |
| /* Mark any equivalent character */ |
| k = (unsigned int)format[i]; |
| for (j = 0; internalCollationArray[k][j] != NIL; j++) |
| characterclass[(int)internalCollationArray[k][j]]++; |
| } |
| } |
| if (format[++i] != SPECIFIER_UNGROUP) |
| return -1; |
| |
| index = i; |
| } |
| break; |
| |
| case QUALIFIER_COLON: /* Character class expressions */ |
| |
| if (trio_equal_max(CLASS_ALNUM, sizeof(CLASS_ALNUM) - 1, |
| &format[index])) |
| { |
| for (i = 0; i < MAX_CHARACTER_CLASS; i++) |
| if (isalnum(i)) |
| characterclass[i]++; |
| index += sizeof(CLASS_ALNUM) - 1; |
| } |
| else if (trio_equal_max(CLASS_ALPHA, sizeof(CLASS_ALPHA) - 1, |
| &format[index])) |
| { |
| for (i = 0; i < MAX_CHARACTER_CLASS; i++) |
| if (isalpha(i)) |
| characterclass[i]++; |
| index += sizeof(CLASS_ALPHA) - 1; |
| } |
| else if (trio_equal_max(CLASS_CNTRL, sizeof(CLASS_CNTRL) - 1, |
| &format[index])) |
| { |
| for (i = 0; i < MAX_CHARACTER_CLASS; i++) |
| if (iscntrl(i)) |
| characterclass[i]++; |
| index += sizeof(CLASS_CNTRL) - 1; |
| } |
| else if (trio_equal_max(CLASS_DIGIT, sizeof(CLASS_DIGIT) - 1, |
| &format[index])) |
| { |
| for (i = 0; i < MAX_CHARACTER_CLASS; i++) |
| if (isdigit(i)) |
| characterclass[i]++; |
| index += sizeof(CLASS_DIGIT) - 1; |
| } |
| else if (trio_equal_max(CLASS_GRAPH, sizeof(CLASS_GRAPH) - 1, |
| &format[index])) |
| { |
| for (i = 0; i < MAX_CHARACTER_CLASS; i++) |
| if (isgraph(i)) |
| characterclass[i]++; |
| index += sizeof(CLASS_GRAPH) - 1; |
| } |
| else if (trio_equal_max(CLASS_LOWER, sizeof(CLASS_LOWER) - 1, |
| &format[index])) |
| { |
| for (i = 0; i < MAX_CHARACTER_CLASS; i++) |
| if (islower(i)) |
| characterclass[i]++; |
| index += sizeof(CLASS_LOWER) - 1; |
| } |
| else if (trio_equal_max(CLASS_PRINT, sizeof(CLASS_PRINT) - 1, |
| &format[index])) |
| { |
| for (i = 0; i < MAX_CHARACTER_CLASS; i++) |
| if (isprint(i)) |
| characterclass[i]++; |
| index += sizeof(CLASS_PRINT) - 1; |
| } |
| else if (trio_equal_max(CLASS_PUNCT, sizeof(CLASS_PUNCT) - 1, |
| &format[index])) |
| { |
| for (i = 0; i < MAX_CHARACTER_CLASS; i++) |
| if (ispunct(i)) |
| characterclass[i]++; |
| index += sizeof(CLASS_PUNCT) - 1; |
| } |
| else if (trio_equal_max(CLASS_SPACE, sizeof(CLASS_SPACE) - 1, |
| &format[index])) |
| { |
| for (i = 0; i < MAX_CHARACTER_CLASS; i++) |
| if (isspace(i)) |
| characterclass[i]++; |
| index += sizeof(CLASS_SPACE) - 1; |
| } |
| else if (trio_equal_max(CLASS_UPPER, sizeof(CLASS_UPPER) - 1, |
| &format[index])) |
| { |
| for (i = 0; i < MAX_CHARACTER_CLASS; i++) |
| if (isupper(i)) |
| characterclass[i]++; |
| index += sizeof(CLASS_UPPER) - 1; |
| } |
| else if (trio_equal_max(CLASS_XDIGIT, sizeof(CLASS_XDIGIT) - 1, |
| &format[index])) |
| { |
| for (i = 0; i < MAX_CHARACTER_CLASS; i++) |
| if (isxdigit(i)) |
| characterclass[i]++; |
| index += sizeof(CLASS_XDIGIT) - 1; |
| } |
| else |
| { |
| characterclass[(int)ch]++; |
| } |
| break; |
| |
| default: |
| characterclass[(int)ch]++; |
| break; |
| } |
| break; |
| |
| #endif /* TRIO_EXTENSION */ |
| |
| default: |
| characterclass[(int)ch]++; |
| break; |
| } |
| } |
| return 0; |
| } |
| |
| /************************************************************************* |
| * 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); |
| |
| if (!(flags & FLAGS_UNSIGNED)) |
| { |
| /* Leading sign */ |
| if (self->current == '+') |
| { |
| self->InStream(self, NULL); |
| } |
| else if (self->current == '-') |
| { |
| self->InStream(self, NULL); |
| isNegative = TRUE; |
| } |
| } |
| |
| count = self->processed; |
| |
| if (flags & FLAGS_ALTERNATIVE) |
| { |
| switch (base) |
| { |
| case NO_BASE: |
| case BASE_OCTAL: |
| case BASE_HEX: |
| case BASE_BINARY: |
| if (self->current == '0') |
| { |
| self->InStream(self, NULL); |
| if (self->current) |
| { |
| if ((base == BASE_HEX) && |
| (trio_to_upper(self->current) == 'X')) |
| { |
| self->InStream(self, NULL); |
| } |
| else if ((base == BASE_BINARY) && |
| (trio_to_upper(self->current) == 'B')) |
| { |
| self->InStream(self, NULL); |
| } |
| } |
| } |
| else |
| return FALSE; |
| break; |
| default: |
| break; |
| } |
| } |
| |
| while (((width == NO_WIDTH) || (self->processed - count < width)) && |
| (! ((self->current == EOF) || isspace(self->current)))) |
| { |
| if (isascii(self->current)) |
| { |
| digit = internalDigitArray[self->current]; |
| /* Abort if digit is not allowed in the specified base */ |
| if ((digit == -1) || (digit >= base)) |
| break; |
| } |
| else if (flags & FLAGS_QUOTE) |
| { |
| /* Compare with thousands separator */ |
| for (j = 0; internalThousandSeparator[j] && self->current; j++) |
| { |
| if (internalThousandSeparator[j] != self->current) |
| break; |
| |
| self->InStream(self, NULL); |
| } |
| if (internalThousandSeparator[j]) |
| break; /* Mismatch */ |
| else |
| continue; /* Match */ |
| } |
| else |
| break; |
| |
| number *= base; |
| number += digit; |
| gotNumber = TRUE; /* we need at least one digit */ |
| |
| self->InStream(self, NULL); |
| } |
| |
| /* Was anything read at all? */ |
| if (!gotNumber) |
| return FALSE; |
| |
| if (target) |
| *target = (isNegative) ? -((trio_intmax_t)number) : number; |
| return TRUE; |
| } |
| |
| /************************************************************************* |
| * 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_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_WIDECHAR */ |
| |
| /************************************************************************* |
| * TrioReadWideString |
| */ |
| #if TRIO_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) |
| (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_WIDECHAR */ |
| |
| /************************************************************************* |
| * TrioReadGroup |
| * |
| * 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 (target) |
| target[i] = NIL; |
| return TRUE; |
| } |
| |
| /************************************************************************* |
| * TrioReadDouble |
| * |
| * FIXME: |
| * add long double |
| * handle base |
| */ |
| 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 index = 0; |
| int start; |
| int j; |
| BOOLEAN_T isHex = FALSE; |
| |
| doubleString[0] = 0; |
| |
| if ((width == NO_WIDTH) || (width > (int)sizeof(doubleString) - 1)) |
| width = sizeof(doubleString) - 1; |
| |
| TrioSkipWhitespaces(self); |
| |
| /* |
| * Read entire double number from stream. trio_to_double requires |
| * a string as input, but InStream can be anything, so we have to |
| * collect all characters. |
| */ |
| ch = self->current; |
| if ((ch == '+') || (ch == '-')) |
| { |
| doubleString[index++] = (char)ch; |
| self->InStream(self, &ch); |
| width--; |
| } |
| |
| start = index; |
| switch (ch) |
| { |
| case 'n': |
| case 'N': |
| /* Not-a-number */ |
| if (index != 0) |
| break; |
| /* FALLTHROUGH */ |
| case 'i': |
| case 'I': |
| /* Infinity */ |
| while (isalpha(ch) && (index - start < width)) |
| { |
| doubleString[index++] = (char)ch; |
| self->InStream(self, &ch); |
| } |
| doubleString[index] = NIL; |
| |
| /* Case insensitive string comparison */ |
| if (trio_equal(&doubleString[start], INFINITE_UPPER) || |
| trio_equal(&doubleString[start], LONG_INFINITE_UPPER)) |
| { |
| if (flags & FLAGS_LONGDOUBLE) |
| { |
| if ((start == 1) && (doubleString[0] == '-')) |
| { |
| *((trio_long_double_t *)target) = trio_ninf(); |
| } |
| else |
| { |
| *((trio_long_double_t *)target) = trio_pinf(); |
| } |
| } |
| else |
| { |
| if ((start == 1) && (doubleString[0] == '-')) |
| { |
| *((double *)target) = trio_ninf(); |
| } |
| else |
| { |
| *((double *)target) = trio_pinf(); |
| } |
| } |
| return TRUE; |
| } |
| if (trio_equal(doubleString, NAN_UPPER)) |
| { |
| /* NaN must not have a preceeding + nor - */ |
| if (flags & FLAGS_LONGDOUBLE) |
| { |
| *((trio_long_double_t *)target) = trio_nan(); |
| } |
| else |
| { |
| *((double *)target) = trio_nan(); |
| } |
| return TRUE; |
| } |
| return FALSE; |
| |
| case '0': |
| doubleString[index++] = (char)ch; |
| self->InStream(self, &ch); |
| if (trio_to_upper(ch) == 'X') |
| { |
| isHex = TRUE; |
| doubleString[index++] = (char)ch; |
| self->InStream(self, &ch); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| while ((ch != EOF) && (index - start < width)) |
| { |
| /* Integer part */ |
| if (isHex ? isxdigit(ch) : isdigit(ch)) |
| { |
| doubleString[index++] = (char)ch; |
| self->InStream(self, &ch); |
| } |
| else if (flags & FLAGS_QUOTE) |
| { |
| /* Compare with thousands separator */ |
| for (j = 0; internalThousandSeparator[j] && self->current; j++) |
| { |
| if (internalThousandSeparator[j] != self->current) |
| break; |
| |
| self->InStream(self, &ch); |
| } |
| if (internalThousandSeparator[j]) |
| break; /* Mismatch */ |
| else |
| continue; /* Match */ |
| } |
| else |
| break; /* while */ |
| } |
| if (ch == '.') |
| { |
| /* Decimal part */ |
| doubleString[index++] = (char)ch; |
| self->InStream(self, &ch); |
| while ((isHex ? isxdigit(ch) : isdigit(ch)) && |
| (index - start < width)) |
| { |
| doubleString[index++] = (char)ch; |
| self->InStream(self, &ch); |
| } |
| if (isHex ? (trio_to_upper(ch) == 'P') : (trio_to_upper(ch) == 'E')) |
| { |
| /* Exponent */ |
| doubleString[index++] = (char)ch; |
| self->InStream(self, &ch); |
| if ((ch == '+') || (ch == '-')) |
| { |
| doubleString[index++] = (char)ch; |
| self->InStream(self, &ch); |
| } |
| while (isdigit(ch) && (index - start < width)) |
| { |
| doubleString[index++] = (char)ch; |
| self->InStream(self, &ch); |
| } |
| } |
| } |
| |
| if ((index == start) || (*doubleString == NIL)) |
| return FALSE; |
| |
| doubleString[index] = 0; |
| |
| if (flags & FLAGS_LONGDOUBLE) |
| { |
| *((trio_long_double_t *)target) = trio_to_long_double(doubleString, NULL); |
| } |
| else |
| { |
| *((double *)target) = trio_to_double(doubleString, NULL); |
| } |
| return TRUE; |
| } |
| |
| /************************************************************************* |
| * 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)) |
| { |
| /* |
| * The strange assignment of number is a workaround for a compiler |
| * warning |
| */ |
| if (target) |
| *target = (char *)0 + number; |
| return TRUE; |
| } |
| else if (TrioReadString(self, |
| (flags & FLAGS_IGNORE) |
| ? NULL |
| : buffer, |
| 0, |
| sizeof(internalNullString) - 1)) |
| { |
| if (trio_equal_case(buffer, internalNullString)) |
| { |
| if (target) |
| *target = NULL; |
| return TRUE; |
| } |
| } |
| return FALSE; |
| } |
| |
| /************************************************************************* |
| * TrioScanProcess |
| */ |
| TRIO_PRIVATE int |
| TrioScanProcess |
| TRIO_ARGS3((data, format, parameters), |
| trio_class_t *data, |
| TRIO_CONST char *format, |
| trio_parameter_t *parameters) |
| { |
| #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) |
| int charlen; |
| int cnt; |
| #endif |
| int assignment; |
| int ch; |
| int index; /* Index of format string */ |
| int i; /* Index of current parameter */ |
| trio_flags_t flags; |
| int width; |
| int base; |
| trio_pointer_t pointer; |
| |
| assignment = 0; |
| i = 0; |
| index = 0; |
| data->InStream(data, &ch); |
| |
| #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) |
| (void)mblen(NULL, 0); |
| #endif |
| |
| while (format[index]) |
| { |
| #if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE) |
| if (! isascii(format[index])) |
| { |
| charlen = mblen(&format[index], MB_LEN_MAX); |
| if (charlen != -1) |
| { |
| /* Compare multibyte characters in format string */ |
| for (cnt = 0; cnt < charlen - 1; cnt++) |
| { |
| if (ch != format[index + cnt]) |
| { |
| return TRIO_ERROR_RETURN(TRIO_EINVAL, index); |
| } |
| data->InStream(data, &ch); |
| } |
| continue; /* while characters left in formatting string */ |
| } |
| } |
| #endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */ |
| |
| if ((EOF == ch) && (parameters[i].type != FORMAT_COUNT)) |
| { |
| return (assignment > 0) ? assignment : EOF; |
| } |
| |
| if (CHAR_IDENTIFIER == format[index]) |
| { |
| if (CHAR_IDENTIFIER == format[index + 1]) |
| { |
| /* Two % in format matches one % in input stream */ |
| if (CHAR_IDENTIFIER == ch) |
| { |
| data->InStream(data, &ch); |
| index += 2; |
| continue; /* while format chars left */ |
| } |
| else |
| return TRIO_ERROR_RETURN(TRIO_EINVAL, index); |
| } |
| |
| /* Skip the parameter entries */ |
| while (parameters[i].type == FORMAT_PARAMETER) |
| i++; |
| |
| flags = parameters[i].flags; |
| /* Find width */ |
| width = parameters[i].width; |
| if (flags & FLAGS_WIDTH_PARAMETER) |
| { |
| /* Get width from parameter list */ |
| width = (int)parameters[width].data.number.as_signed; |
| } |
| /* Find base */ |
| base = parameters[i].base; |
| if (flags & FLAGS_BASE_PARAMETER) |
| { |
| /* Get base from parameter list */ |
| base = (int)parameters[base].data.number.as_signed; |
| } |
| |
| switch (parameters[i].type) |
| { |
| case FORMAT_INT: |
| { |
| trio_uintmax_t number; |
| |
| if (0 == base) |
| base = BASE_DECIMAL; |
| |
| if (!TrioReadNumber(data, |
| &number, |
| flags, |
| width, |
| base)) |
| return assignment; |
| |
| if (!(flags & FLAGS_IGNORE)) |
| { |
| assignment++; |
| |
| pointer = parameters[i].data.pointer; |
| #if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER) |
| if (flags & FLAGS_SIZE_T) |
| *(size_t *)pointer = (size_t)number; |
| else |
| #endif |
| #if defined(QUALIFIER_PTRDIFF_T) |
| if (flags & FLAGS_PTRDIFF_T) |
| *(ptrdiff_t *)pointer = (ptrdiff_t)number; |
| else |
| #endif |
| #if defined(QUALIFIER_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_WIDECHAR |
| if (flags & FLAGS_WIDECHAR) |
| { |
| if (!TrioReadWideString(data, |
| (flags & FLAGS_IGNORE) |
| ? NULL |
| : parameters[i].data.wstring, |
| flags, |
| width)) |
| return assignment; |
| } |
| else |
| #endif |
| { |
| if (!TrioReadString(data, |
| (flags & FLAGS_IGNORE) |
| ? NULL |
| : parameters[i].data.string, |
| flags, |
| width)) |
| return assignment; |
| } |
| if (!(flags & FLAGS_IGNORE)) |
| assignment++; |
| break; /* FORMAT_STRING */ |
| |
| case FORMAT_DOUBLE: |
| { |
| trio_pointer_t pointer; |
| |
| 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)) |
| { |
| return assignment; |
| } |
| if (!(flags & FLAGS_IGNORE)) |
| { |
| assignment++; |
| } |
| break; /* FORMAT_DOUBLE */ |
| } |
| case FORMAT_GROUP: |
| { |
| int characterclass[MAX_CHARACTER_CLASS + 1]; |
| int rc; |
| |
| /* Skip over modifiers */ |
| while (format[index] != SPECIFIER_GROUP) |
| { |
| index++; |
| } |
| /* Skip over group specifier */ |
| index++; |
| |
| memset(characterclass, 0, sizeof(characterclass)); |
| rc = TrioGetCharacterClass(format, |
| &index, |
| &flags, |
| characterclass); |
| if (rc < 0) |
| return rc; |
| |
| if (!TrioReadGroup(data, |
| (flags & FLAGS_IGNORE) |
| ? NULL |
| : parameters[i].data.string, |
| characterclass, |
| flags, |
| parameters[i].width)) |
| return assignment; |
| if (!(flags & FLAGS_IGNORE)) |
| assignment++; |
| } |
| break; /* FORMAT_GROUP */ |
| |
| case FORMAT_COUNT: |
| pointer = parameters[i].data.pointer; |
| if (NULL != pointer) |
| { |
| int count = data->committed; |
| if (ch != EOF) |
| count--; /* a character is read, but is not consumed yet */ |
| #if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER) |
| if (flags & FLAGS_SIZE_T) |
| *(size_t *)pointer = (size_t)count; |
| else |
| #endif |
| #if defined(QUALIFIER_PTRDIFF_T) |
| if (flags & FLAGS_PTRDIFF_T) |
| *(ptrdiff_t *)pointer = (ptrdiff_t)count; |
| else |
| #endif |
| #if defined(QUALIFIER_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_WIDECHAR |
| if (flags & FLAGS_WIDECHAR) |
| { |
| if (TrioReadWideChar(data, |
| (flags & FLAGS_IGNORE) |
| ? NULL |
| : parameters[i].data.wstring, |
| flags, |
| (width == NO_WIDTH) ? 1 : width) == 0) |
| return assignment; |
| } |
| else |
| #endif |
| { |
| if (TrioReadChar(data, |
| (flags & FLAGS_IGNORE) |
| ? NULL |
| : parameters[i].data.string, |
| flags, |
| (width == NO_WIDTH) ? 1 : width) == 0) |
| return assignment; |
| } |
| 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)) |
| return assignment; |
| if (!(flags & FLAGS_IGNORE)) |
| assignment++; |
| break; /* FORMAT_POINTER */ |
| |
| case FORMAT_PARAMETER: |
| break; /* FORMAT_PARAMETER */ |
| |
| default: |
| return TRIO_ERROR_RETURN(TRIO_EINVAL, index); |
| } |
| ch = data->current; |
| index = parameters[i].indexAfterSpecifier; |
| i++; |
| } |
| else /* Not an % identifier */ |
| { |
| if (isspace((int)format[index])) |
| { |
| /* Whitespaces may match any amount of whitespaces */ |
| ch = TrioSkipWhitespaces(data); |
| } |
| else if (ch == format[index]) |
| { |
| data->InStream(data, &ch); |
| } |
| else |
| return assignment; |
| |
| index++; |
| } |
| } |
| return assignment; |
| } |
| |
| /************************************************************************* |
| * TrioScan |
| */ |
| TRIO_PRIVATE int |
| TrioScan |
| TRIO_ARGS6((source, sourceSize, InStream, format, arglist, argarray), |
| trio_pointer_t source, |
| size_t sourceSize, |
| void (*InStream) TRIO_PROTO((trio_class_t *, int *)), |
| TRIO_CONST char *format, |
| TRIO_VA_LIST_PTR arglist, |
| trio_pointer_t *argarray) |
| { |
| int status; |
| trio_parameter_t parameters[MAX_PARAMETERS]; |
| trio_class_t data; |
| |
| assert(VALID(InStream)); |
| assert(VALID(format)); |
| |
| memset(&data, 0, sizeof(data)); |
| data.InStream = InStream; |
| data.location = (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, argarray); |
| if (status < 0) |
| return status; |
| |
| status = TrioScanProcess(&data, format, parameters); |
| if (data.error != 0) |
| { |
| status = data.error; |
| } |
| return status; |
| } |
| |
| /************************************************************************* |
| * TrioInStreamFile |
| */ |
| TRIO_PRIVATE void |
| TrioInStreamFile |
| TRIO_ARGS2((self, intPointer), |
| trio_class_t *self, |
| int *intPointer) |
| { |
| FILE *file; |
| |
| assert(VALID(self)); |
| assert(VALID(self->location)); |
| assert(VALID(file)); |
| |
| file = (FILE *)self->location; |
| |
| self->current = fgetc(file); |
| if (self->current == EOF) |
| { |
| self->error = (ferror(file)) |
| ? TRIO_ERROR_RETURN(TRIO_ERRNO, 0) |
| : TRIO_ERROR_RETURN(TRIO_EOF, 0); |
| } |
| else |
| { |
| self->processed++; |
| self->committed++; |
| } |
| |
| if (VALID(intPointer)) |
| { |
| *intPointer = self->current; |
| } |
| } |
| |
| /************************************************************************* |
| * TrioInStreamFileDescriptor |
| */ |
| TRIO_PRIVATE void |
| TrioInStreamFileDescriptor |
| TRIO_ARGS2((self, intPointer), |
| trio_class_t *self, |
| int *intPointer) |
| { |
| int fd; |
| int size; |
| unsigned char input; |
| |
| assert(VALID(self)); |
| assert(VALID(self->location)); |
| |
| fd = *((int *)self->location); |
| |
| 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->committed++; |
| self->processed++; |
| } |
| |
| if (VALID(intPointer)) |
| { |
| *intPointer = self->current; |
| } |
| } |
| |
| /************************************************************************* |
| * TrioInStreamCustom |
| */ |
| 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)); |
| |
| 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->committed++; |
| } |
| |
| if (VALID(intPointer)) |
| { |
| *intPointer = self->current; |
| } |
| } |
| |
| /************************************************************************* |
| * 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)); |
| |
| buffer = (unsigned char **)self->location; |
| self->current = (*buffer)[0]; |
| if (self->current == NIL) |
| { |
| self->current = EOF; |
| } |
| else |
| { |
| (*buffer)++; |
| self->processed++; |
| self->committed++; |
| } |
| |
| 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. |
| */ |
| 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, |
| format, TRIO_VA_LIST_ADDR(args), NULL); |
| TRIO_VA_END(args); |
| return status; |
| } |
| |
| 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, |
| format, TRIO_VA_LIST_ADDR(args), NULL); |
| } |
| |
| TRIO_PUBLIC int |
| trio_scanfv |
| TRIO_ARGS2((format, args), |
| TRIO_CONST char *format, |
| trio_pointer_t *args) |
| { |
| assert(VALID(format)); |
| |
| return TrioScan((trio_pointer_t)stdin, 0, |
| TrioInStreamFile, |
| format, NULL, args); |
| } |
| |
| /************************************************************************* |
| * fscanf |
| */ |
| 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, |
| format, TRIO_VA_LIST_ADDR(args), NULL); |
| TRIO_VA_END(args); |
| return status; |
| } |
| |
| 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, |
| format, TRIO_VA_LIST_ADDR(args), NULL); |
| } |
| |
| TRIO_PUBLIC int |
| trio_fscanfv |
| TRIO_ARGS3((file, format, args), |
| FILE *file, |
| TRIO_CONST char *format, |
| trio_pointer_t *args) |
| { |
| assert(VALID(file)); |
| assert(VALID(format)); |
| |
| return TrioScan((trio_pointer_t)file, 0, |
| TrioInStreamFile, |
| format, NULL, args); |
| } |
| |
| /************************************************************************* |
| * dscanf |
| */ |
| 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, |
| format, TRIO_VA_LIST_ADDR(args), NULL); |
| TRIO_VA_END(args); |
| return status; |
| } |
| |
| 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, |
| format, TRIO_VA_LIST_ADDR(args), NULL); |
| } |
| |
| TRIO_PUBLIC int |
| trio_dscanfv |
| TRIO_ARGS3((fd, format, args), |
| int fd, |
| TRIO_CONST char *format, |
| trio_pointer_t *args) |
| { |
| assert(VALID(format)); |
| |
| return TrioScan((trio_pointer_t)&fd, 0, |
| TrioInStreamFileDescriptor, |
| format, NULL, args); |
| } |
| |
| /************************************************************************* |
| * cscanf |
| */ |
| 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, format, TRIO_VA_LIST_ADDR(args), NULL); |
| TRIO_VA_END(args); |
| return status; |
| } |
| |
| 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, format, TRIO_VA_LIST_ADDR(args), NULL); |
| } |
| |
| TRIO_PUBLIC int |
| trio_cscanfv |
| TRIO_ARGS4((stream, closure, format, args), |
| trio_instream_t stream, |
| trio_pointer_t closure, |
| TRIO_CONST char *format, |
| trio_pointer_t *args) |
| { |
| trio_custom_t data; |
| |
| assert(VALID(stream)); |
| assert(VALID(format)); |
| |
| data.stream.in = stream; |
| data.closure = closure; |
| return TrioScan(&data, 0, TrioInStreamCustom, format, NULL, args); |
| } |
| |
| /************************************************************************* |
| * sscanf |
| */ |
| 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, |
| format, TRIO_VA_LIST_ADDR(args), NULL); |
| TRIO_VA_END(args); |
| return status; |
| } |
| |
| 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, |
| format, TRIO_VA_LIST_ADDR(args), NULL); |
| } |
| |
| TRIO_PUBLIC int |
| trio_sscanfv |
| TRIO_ARGS3((buffer, format, args), |
| TRIO_CONST char *buffer, |
| TRIO_CONST char *format, |
| trio_pointer_t *args) |
| { |
| assert(VALID(buffer)); |
| assert(VALID(format)); |
| |
| return TrioScan((trio_pointer_t)&buffer, 0, |
| TrioInStreamString, |
| format, NULL, args); |
| } |
| |
| /** @} End of Scanf documentation module */ |
| |
| /************************************************************************* |
| * trio_strerror |
| */ |
| TRIO_PUBLIC TRIO_CONST char * |
| trio_strerror |
| TRIO_ARGS1((errorcode), |
| int errorcode) |
| { |
| /* 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"; |
| } |
| } |
