trio.c revision 38ae7e4efe803ea78b6499cd05a394db32623e41
/*************************************************************************
*
* $Id: trio.c 3600 2007-04-17 12:44:58Z veillard $
*
* 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
* 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
# define TRIO_COMPILER_SUPPORTS_MSVC_INT
#endif
#if defined(_WIN32_WCE)
#include <wincecompat.h>
#endif
/*************************************************************************
* Generic definitions
*/
# define NDEBUG
#endif
#include <assert.h>
#include <ctype.h>
#if !defined(TRIO_COMPILER_SUPPORTS_C99)
#endif
#if defined(TRIO_COMPILER_ANCIENT)
# include <varargs.h>
#else
# include <stdarg.h>
#endif
#include <stddef.h>
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#ifndef NULL
# define NULL 0
#endif
#define NIL ((char)0)
#ifndef FALSE
# define FALSE (1 == 0)
#endif
#define BOOLEAN_T int
/* mincore() can be used for debugging purposes */
#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
typedef unsigned long trio_flags_t;
/*************************************************************************
* Platform specific definitions
*/
#if defined(TRIO_PLATFORM_UNIX)
# 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>
# 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
# 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
# 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)
# 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)
# include <inttypes.h>
typedef intmax_t trio_intmax_t;
typedef uintmax_t trio_uintmax_t;
typedef int8_t trio_int8_t;
typedef int16_t trio_int16_t;
typedef int32_t trio_int32_t;
typedef int64_t trio_int64_t;
#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)
#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)
# 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 */
/* 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"
/* Various constants */
enum {
TYPE_PRINT = 1,
TYPE_SCAN = 2,
/* Flags. FLAGS_LAST must be less than ULONG_MAX */
FLAGS_NEW = 0,
FLAGS_STICKY = 1,
/* Reused flags */
/* Compounded flags */
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 */
/* Maximal string lengths for user-defined specifiers */
MAX_USER_NAME = 64,
MAX_USER_DATA = 256,
/* Maximal length of locale separator strings */
/* 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
*
* 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 '*'
#if TRIO_C99
# define QUALIFIER_SIZE_T 'z'
# define QUALIFIER_PTRDIFF_T 't'
# define QUALIFIER_INTMAX_T 'j'
#endif
# 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_ROUNDING_UPPER 'R'
#endif
/*************************************************************************
*
* Internal Structures
*
*************************************************************************/
/* Parameters */
typedef struct {
/* An indication of which entry in the data union is used */
int type;
/* The 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
#endif
union {
} number;
double doubleNumber;
double *doublePointer;
int errorNumber;
} data;
/* For the user-defined specifier */
char user_name[MAX_USER_NAME];
char user_data[MAX_USER_DATA];
/* Container for customized functions */
typedef struct {
union {
} stream;
/* General trio "class" */
typedef struct _trio_class_t {
/*
* The function to write characters to a stream.
*/
/*
* The function to read characters from a stream.
*/
/*
* The current location in the stream.
*/
/*
* The character currently being processed.
*/
int current;
/*
* if there had been sufficient space.
*/
int processed;
/*
* Processed and committed will only differ for the *nprintf
* and *nscanf functions.
*/
int committed;
/*
*/
int max;
/*
* The last output error that was detected.
*/
int error;
} trio_class_t;
/* References (for user-defined callbacks) */
typedef struct _trio_reference_t {
/* Registered entries (for user-defined callbacks) */
typedef struct _trio_userdef_t {
struct _trio_userdef_t *next;
char *name;
/*************************************************************************
*
* Internal Variables
*
*************************************************************************/
/*
* to resolves macro definitions that includes type 'long double',
* e.g: va_arg(arg_ptr, long double)
*/
#if defined(TRIO_PLATFORM_MPEIX)
#endif
#if defined(USE_LOCALE)
#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 int internalDigitArray[128];
#if TRIO_EXTENSION
#endif
#if TRIO_EXTENSION
#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_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
{
if (internalLocaleValues)
{
if ((internalLocaleValues->decimal_point) &&
{
if (internalDecimalPointLength == 1)
{
}
else
{
sizeof(internalDecimalPointString),
}
}
if ((internalLocaleValues->thousands_sep) &&
{
sizeof(internalThousandSeparator),
}
if ((internalLocaleValues->grouping) &&
{
sizeof(internalGrouping),
}
}
}
#endif /* defined(USE_LOCALE) */
TRIO_PRIVATE int
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++;
}
}
return count;
#else
return 0;
#endif
}
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;
}
return (position == 0);
#else
return FALSE;
#endif
}
/*************************************************************************
* TrioGetPosition
*
* Get the %n$ position.
*/
TRIO_PRIVATE int
TRIO_CONST char *format,
int *indexPointer)
{
#if TRIO_UNIX98
char *tmpformat;
int number = 0;
int index = *indexPointer;
{
*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_CONST char *name,
{
(void)internalEnterCriticalRegion(NULL);
{
/* Case-sensitive string comparison */
break;
if (prev)
}
(void)internalLeaveCriticalRegion(NULL);
return def;
}
#endif
/*************************************************************************
* TrioPower
*
* Description:
* Calculate pow(base, exponent), where number and exponent are integers.
*/
int number,
int exponent)
{
if (number == 10)
{
switch (exponent)
{
/* Speed up calculation of common cases */
case 0:
break;
case 1:
break;
case 2:
break;
case 3:
break;
case 4:
break;
case 5:
break;
case 6:
break;
case 7:
break;
case 8:
break;
case 9:
break;
default:
break;
}
}
else
{
}
return result;
}
/*************************************************************************
* TrioLogarithm
*/
TRIO_PRIVATE double
double number,
int base)
{
double result;
if (number <= 0.0)
{
/* xlC crashes on log(0) */
}
else
{
if (base == 10)
{
}
else
{
}
}
return result;
}
/*************************************************************************
* TrioLogarithmBase
*/
TRIO_PRIVATE double
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;
}
}
/*************************************************************************
* TrioParse
*
* Description:
* Parse the format string
*/
TRIO_PRIVATE int
int type,
TRIO_CONST char *format,
{
/* 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 */
int width;
int precision;
int varsize;
int base;
int index; /* Index into formatting string */
int dots; /* Count number of dots in modifier part */
/*
* 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 */
/*
* The 'parameters' array is not initialized, but we need to
* know which entries we have used.
*/
save_errno = errno;
index = 0;
parameterPosition = 0;
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
#endif
{
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
{
/*
* Multibyte characters cannot be legal specifiers or
* modifiers, so we skip over them.
*/
continue; /* while */
}
#endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */
{
{
index++;
continue; /* while */
}
dots = 0;
if (!positional)
{
/* We have no positional, get the next counter */
}
if(currentParam >= MAX_PARAMETERS)
{
/* Bail out completely to make the error more obvious */
}
if (currentParam > maxParam)
/* Default values */
{
switch (ch)
{
case QUALIFIER_SPACE:
flags |= FLAGS_SPACE;
break;
case QUALIFIER_PLUS:
flags |= FLAGS_SHOWSIGN;
break;
case QUALIFIER_MINUS:
flags &= ~FLAGS_NILPADDING;
break;
case QUALIFIER_ALTERNATIVE:
break;
case QUALIFIER_DOT:
if (dots == 0) /* Precision */
{
dots++;
/* Skip if no precision */
break;
/* After the first dot we have the precision */
flags |= FLAGS_PRECISION;
#if defined(QUALIFIER_PARAM)
#endif
)
{
index++;
if (precision == NO_POSITION)
{
if (positional)
else
{
}
}
else
{
if (! positional)
}
if (currentParam > maxParam)
}
else
{
}
}
{
dots++;
/* After the second dot we have the base */
flags |= FLAGS_BASE;
#if defined(QUALIFIER_PARAM)
#endif
)
{
index++;
if (base == NO_POSITION)
{
if (positional)
else
{
base = currentParam;
}
}
else
{
if (! positional)
}
if (currentParam > maxParam)
}
else
{
}
}
else
{
}
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 */
if (width == NO_POSITION)
{
if (positional)
else
{
}
}
else
{
if (! positional)
}
if (currentParam > maxParam)
}
else
{
/* Scan, but do not store result */
flags |= FLAGS_IGNORE;
}
break; /* QUALIFIER_STAR */
case '0':
if (! (flags & FLAGS_LEFTADJUST))
/* 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
*/
break;
case QUALIFIER_SHORT:
if (flags & FLAGS_SHORTSHORT)
else if (flags & FLAGS_SHORT)
else
flags |= FLAGS_SHORT;
break;
case QUALIFIER_LONG:
if (flags & FLAGS_QUAD)
else if (flags & FLAGS_LONG)
flags |= FLAGS_QUAD;
else
flags |= FLAGS_LONG;
break;
case QUALIFIER_LONG_UPPER:
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)
{
varsize = sizeof(trio_int64_t);
index += 2;
}
{
varsize = sizeof(trio_int32_t);
index += 2;
}
{
varsize = sizeof(trio_int16_t);
index += 2;
}
{
varsize = sizeof(trio_int8_t);
index++;
}
else
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;
break;
#endif
#if defined(QUALIFIER_VARSIZE)
case QUALIFIER_VARSIZE:
if (positional)
else
{
}
if (currentParam > maxParam)
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 */
}
} /* while qualifier */
/*
* Parameters only need the type and value. The value is
* read later.
*/
if (flags & FLAGS_WIDTH_PARAMETER)
{
}
if (flags & FLAGS_PRECISION_PARAMETER)
{
}
if (flags & FLAGS_BASE_PARAMETER)
{
}
if (flags & FLAGS_VARSIZE_PARAMETER)
{
}
{
#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;
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;
break;
case SPECIFIER_GROUP:
{
int depth = 1;
index++;
index++;
index++;
/* Skip nested brackets */
{
{
depth++;
}
{
if (--depth <= 0)
{
index++;
break;
}
}
index++;
}
}
break;
case SPECIFIER_INTEGER:
break;
case SPECIFIER_UNSIGNED:
flags |= FLAGS_UNSIGNED;
break;
case SPECIFIER_DECIMAL:
/* Disable base modifier */
base = BASE_DECIMAL;
break;
case SPECIFIER_OCTAL:
flags |= FLAGS_UNSIGNED;
base = BASE_OCTAL;
break;
#if defined(SPECIFIER_BINARY)
case SPECIFIER_BINARY_UPPER:
flags |= FLAGS_UPPER;
/* FALLTHROUGH */
case SPECIFIER_BINARY:
base = BASE_BINARY;
break;
#endif
case SPECIFIER_HEX_UPPER:
flags |= FLAGS_UPPER;
/* FALLTHROUGH */
case SPECIFIER_HEX:
flags |= FLAGS_UNSIGNED;
break;
case SPECIFIER_FLOAT_E_UPPER:
flags |= FLAGS_UPPER;
/* FALLTHROUGH */
case SPECIFIER_FLOAT_E:
flags |= FLAGS_FLOAT_E;
break;
case SPECIFIER_FLOAT_G_UPPER:
flags |= FLAGS_UPPER;
/* FALLTHROUGH */
case SPECIFIER_FLOAT_G:
flags |= FLAGS_FLOAT_G;
break;
case SPECIFIER_FLOAT_F_UPPER:
flags |= FLAGS_UPPER;
/* FALLTHROUGH */
case SPECIFIER_FLOAT_F:
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;
break;
case SPECIFIER_COUNT:
break;
#if defined(SPECIFIER_HEXFLOAT)
# if defined(SPECIFIER_HEXFLOAT_UPPER)
case SPECIFIER_HEXFLOAT_UPPER:
flags |= FLAGS_UPPER;
/* FALLTHROUGH */
# endif
case SPECIFIER_HEXFLOAT:
break;
#endif
#if defined(FORMAT_ERRNO)
case SPECIFIER_ERRNO:
break;
#endif
#if defined(SPECIFIER_USER_DEFINED_BEGIN)
{
unsigned int max;
int without_namespace = TRUE;
{
index++;
if (ch == SPECIFIER_USER_DEFINED_END)
{
if (without_namespace)
{
/* We must get the handle first */
/* Adjust parameters for insertion of new one */
pos++;
currentParam++;
if (currentParam > maxParam)
}
/* Copy the user data */
if (max > MAX_USER_DATA)
max = MAX_USER_DATA;
max,
break; /* while */
}
if (ch == SPECIFIER_USER_DEFINED_SEPARATOR)
{
/* Copy the namespace for later looking-up */
if (max > MAX_USER_NAME)
max = MAX_USER_NAME;
max,
}
}
if (ch != SPECIFIER_USER_DEFINED_END)
}
break;
#endif /* defined(SPECIFIER_USER_DEFINED_BEGIN) */
default:
/* Bail out completely to make the error more obvious */
}
/* Count the number of times this entry has been used */
/* Find last sticky parameters */
{
for (i = pos - 1; i >= 0; i--)
{
continue;
{
/* Do not overwrite current qualifiers */
if (precision == NO_PRECISION)
break;
}
}
}
pos++;
if (! positional)
} /* if identifier */
} /* while format characters left */
{
{
else /* double references detected */
}
/*
* 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)
*/
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)
{
}
else
#endif
{
}
break;
#if defined(FORMAT_USER_DEFINED)
case FORMAT_USER_DEFINED:
#endif
case FORMAT_POINTER:
case FORMAT_COUNT:
case FORMAT_UNKNOWN:
break;
case FORMAT_CHAR:
case FORMAT_INT:
{
else
{
else
}
}
else
{
#if defined(QUALIFIER_VARSIZE) || defined(QUALIFIER_FIXED_SIZE)
if (parameters[i].flags
{
{
/*
* 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.
*/
}
else
{
/* Used for the I<bits> modifiers */
}
if (varsize <= (int)sizeof(int))
;
else if (varsize <= (int)sizeof(long))
#if defined(QUALIFIER_INTMAX_T)
else if (varsize <= (int)sizeof(trio_longlong_t))
else
#else
else
#endif
}
#endif /* defined(QUALIFIER_VARSIZE) */
#if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER)
else
#endif
#if defined(QUALIFIER_PTRDIFF_T)
else
#endif
#if defined(QUALIFIER_INTMAX_T)
else
#endif
else
{
else
{
else
}
}
}
break;
case FORMAT_PARAMETER:
/*
* The parameter for the user-defined specifier is a pointer,
* whereas the rest (width, precision, base) uses an integer.
*/
else
break;
case FORMAT_DOUBLE:
{
else
{
else
}
}
else
{
else
{
else
{
else
}
}
}
break;
#if defined(FORMAT_ERRNO)
case FORMAT_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
int width,
int precision,
int base)
{
char *bufferend;
char *pointer;
TRIO_CONST char *digits;
int i;
int length;
char *p;
int count;
base = BASE_DECIMAL;
isNumberZero = (number == 0);
isPrecisionZero = (precision == 0);
if (flags & FLAGS_UNSIGNED)
{
isNegative = FALSE;
flags &= ~FLAGS_SHOWSIGN;
}
else
{
if (isNegative)
}
if (flags & FLAGS_QUAD)
else if (flags & FLAGS_LONG)
number &= (unsigned long)-1;
else
number &= (unsigned int)-1;
/* Build number */
for (i = 1; i < (int)sizeof(buffer); i++)
{
if (number == 0)
break;
{
/*
* We are building the number from the least significant
* to the most significant digit, so we have to copy the
* thousand separator backwards
*/
{
while (length-- > 0)
*pointer-- = *p--;
}
}
}
if (! ignoreNumber)
{
/* Adjust width */
}
/* Adjust precision */
if (NO_PRECISION != precision)
{
if (precision < 0)
precision = 0;
}
/* Calculate padding */
: 0;
/* Adjust width further */
width--;
{
switch (base)
{
case BASE_BINARY:
case BASE_HEX:
width -= 2;
break;
case BASE_OCTAL:
width--;
break;
default:
break;
}
}
/* Output prefixes spaces if needed */
if (! ((flags & FLAGS_LEFTADJUST) ||
{
}
/* width has been adjusted for signs and alternatives */
if (isNegative)
else if (flags & FLAGS_SHOWSIGN)
else if (flags & FLAGS_SPACE)
/* Prefix is not written when the value is zero */
{
switch (base)
{
case BASE_BINARY:
break;
case BASE_OCTAL:
break;
case BASE_HEX:
break;
default:
break;
} /* switch base */
}
/* Output prefixed zero padding if needed */
if (flags & FLAGS_NILPADDING)
{
if (precision == NO_PRECISION)
while (precision-- > 0)
{
width--;
}
}
if (! ignoreNumber)
{
/* Output the number itself */
while (*(++pointer))
{
}
}
/* Output trailing spaces if needed */
if (flags & FLAGS_LEFTADJUST)
{
while (width-- > 0)
}
}
/*************************************************************************
* TrioWriteStringCharacter
*
* Description:
* Output a single character of a string
*/
TRIO_PRIVATE void
int ch,
{
if (flags & FLAGS_ALTERNATIVE)
{
{
/*
* Non-printable characters are converted to C escapes or
* \number, if no C escape exists.
*/
switch (ch)
{
default:
break;
}
}
else if (ch == CHAR_BACKSLASH)
{
}
else
{
}
}
else
{
}
}
/*************************************************************************
* TrioWriteString
*
* Description:
* Output a string
*/
TRIO_PRIVATE void
TRIO_CONST char *string,
int width,
int precision)
{
int length;
int ch;
{
/* Disable quoting for the null pointer */
flags &= (~FLAGS_QUOTE);
width = 0;
}
else
{
}
if ((NO_PRECISION != precision) &&
{
}
if (flags & FLAGS_QUOTE)
if (! (flags & FLAGS_LEFTADJUST))
{
while (width-- > 0)
}
while (length-- > 0)
{
/* The ctype parameters must be an unsigned char (or EOF) */
}
if (flags & FLAGS_LEFTADJUST)
{
while (width-- > 0)
}
if (flags & FLAGS_QUOTE)
}
/*************************************************************************
* TrioWriteWideStringCharacter
*
* Description:
* Output a wide string as a multi-byte sequence
*/
#if TRIO_WIDECHAR
TRIO_PRIVATE int
int width)
{
int size;
int i;
int ch;
char *string;
return 0;
i = size;
{
/* The ctype parameters must be an unsigned char (or EOF) */
}
return size;
}
#endif /* TRIO_WIDECHAR */
/*************************************************************************
* TrioWriteWideString
*
* Description:
* Output a wide character string as a multi-byte string
*/
#if TRIO_WIDECHAR
TRIO_PRIVATE void
int width,
int precision)
{
int length;
int size;
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
#endif
{
return;
}
if (NO_PRECISION == precision)
{
}
else
{
}
if (flags & FLAGS_QUOTE)
if (! (flags & FLAGS_LEFTADJUST))
{
while (width-- > 0)
}
while (length > 0)
{
if (size == 0)
break; /* while */
}
if (flags & FLAGS_LEFTADJUST)
{
while (width-- > 0)
}
if (flags & FLAGS_QUOTE)
}
#endif /* TRIO_WIDECHAR */
/*************************************************************************
* TrioWriteDouble
*
*
* "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
int width,
int precision,
int base)
{
int integerDigits;
int fractionDigits;
int exponentDigits;
int baseDigits;
int integerThreshold;
int fractionThreshold;
int expectedWidth;
int exponent = 0;
unsigned int uExponent = 0;
int exponentBase;
TRIO_CONST char *digits;
char *groupingPointer;
int i;
int index;
int zeroes = 0;
register int trailingZeroes;
/* Determine sign and look for special quantities */
{
case TRIO_FP_NAN:
(flags & FLAGS_UPPER)
: NAN_LOWER,
return;
case TRIO_FP_INFINITE:
if (isNegative)
{
/* Negative infinity */
(flags & FLAGS_UPPER)
? "-" INFINITE_UPPER
: "-" INFINITE_LOWER,
return;
}
else
{
/* Positive infinity */
(flags & FLAGS_UPPER)
return;
}
default:
/* Finitude */
break;
}
/* Normal numbers */
if (flags & FLAGS_LONGDOUBLE)
{
? LDBL_DIG
}
else if (flags & FLAGS_SHORT)
{
? FLT_DIG
}
else
{
? DBL_DIG
}
base = BASE_DECIMAL;
( (flags & FLAGS_FLOAT_G) &&
!(flags & FLAGS_ALTERNATIVE) ) );
if (flags & FLAGS_ROUNDING)
if (precision == NO_PRECISION)
{
if (isHex)
{
}
else
{
}
}
if (isNegative)
if (isHex)
flags |= FLAGS_FLOAT_E;
if (flags & FLAGS_FLOAT_G)
{
if (precision == 0)
precision = 1;
{
/* 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--;
}
}
if (flags & FLAGS_FLOAT_E)
{
/* Scale the number */
{
exponent = 0;
/* Undo setting */
if (flags & FLAGS_FLOAT_G)
flags &= ~FLAGS_FLOAT_E;
}
else
{
isExponentNegative = (exponent < 0);
if (isHex)
/* No thousand separators */
flags &= ~FLAGS_QUOTE;
}
}
/*
* Truncated number.
*
* Precision is number of significant digits for FLOAT_G
* and number of fractional digits for others.
*/
: 1;
{
if (flags & FLAGS_FLOAT_E)
{
/* Adjust if number was rounded up one digit (ie. 0.99 to 1.00) */
exponent++;
isExponentNegative = (exponent < 0);
if (isHex)
}
else
{
/* Adjust if number was rounded up one digit (ie. 99 to 100) */
fractionNumber = 0.0;
: 1;
}
}
/* Estimate accuracy */
if (flags & FLAGS_ROUNDING)
{
if (integerDigits > baseDigits)
{
fractionDigits = 0;
dblFractionBase = 1.0;
fractionThreshold = 0;
precision = 0; /* Disable decimal-point */
fractionAdjust = 0.0;
}
else
{
fractionAdjust = 1.0;
}
}
else
{
}
/*
* Calculate expected width.
* sign + integer part + thousands separators + decimal point
* + fraction + exponent
*/
!((precision == 0) ||
(!keepTrailingZeroes && hasOnlyZeroes)) );
if (flags & FLAGS_FLOAT_E)
{
exponentDigits = (uExponent == 0)
? 1
}
else
exponentDigits = 0;
: 0)
+ ((flags & FLAGS_QUOTE)
: 0);
if (exponentDigits > 0)
if (isHex)
/* Output prefixing */
if (flags & FLAGS_NILPADDING)
{
/* Leading zeros must be after sign */
if (isNegative)
else if (flags & FLAGS_SHOWSIGN)
else if (flags & FLAGS_SPACE)
if (isHex)
{
}
if (!(flags & FLAGS_LEFTADJUST))
{
for (i = expectedWidth; i < width; i++)
{
}
}
}
else
{
/* Leading spaces must be before sign */
if (!(flags & FLAGS_LEFTADJUST))
{
for (i = expectedWidth; i < width; i++)
{
}
}
if (isNegative)
else if (flags & FLAGS_SHOWSIGN)
else if (flags & FLAGS_SPACE)
if (isHex)
{
}
}
/* Output the integer part and thousand separators */
for (i = 0; i < integerDigits; i++)
{
if (i > integerThreshold)
{
/* Beyond accuracy */
}
else
{
}
&& TrioFollowedBySeparator(integerDigits - i))
{
*groupingPointer != NIL;
{
}
}
}
/* Insert decimal point and build the fraction part */
trailingZeroes = 0;
if (keepDecimalPoint)
{
if (internalDecimalPoint)
{
}
else
{
for (i = 0; i < internalDecimalPointLength; i++)
{
}
}
}
for (i = 0; i < fractionDigits; i++)
{
{
/* Beyond accuracy */
}
else
{
if (index == 0)
{
}
else
{
while (trailingZeroes > 0)
{
/* Not trailing zeroes after all */
}
}
}
}
if (keepTrailingZeroes)
{
while (trailingZeroes > 0)
{
}
}
/* Output exponent */
if (exponentDigits > 0)
{
/* The exponent must contain at least two digits */
if (isHex)
base = 10.0;
for (i = 0; i < exponentDigits; i++)
{
exponentBase /= base;
}
}
/* Output trailing spaces */
if (flags & FLAGS_LEFTADJUST)
{
for (i = expectedWidth; i < width; i++)
{
}
}
}
/*************************************************************************
* TrioFormatProcess
*
* Description:
* This is the main engine for formatting output
*/
TRIO_PRIVATE int
TRIO_CONST char *format,
{
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
int charlen;
#endif
int i;
TRIO_CONST char *string;
int width;
int precision;
int base;
int index;
index = 0;
i = 0;
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
#endif
{
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
{
/*
* Only valid multibyte characters are handled here. Invalid
* multibyte characters (charlen == -1) are handled as normal
* characters.
*/
if (charlen != -1)
{
while (charlen-- > 0)
{
}
continue; /* while characters left in formatting string */
}
}
#endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */
{
{
index += 2;
}
else
{
/* Skip the parameter entries */
i++;
/* Find width */
if (flags & FLAGS_WIDTH_PARAMETER)
{
/* Get width from parameter list */
if (width < 0)
{
/*
* A negative width is the same as the - flag and
* a positive width.
*/
flags &= ~FLAGS_NILPADDING;
}
}
/* Find precision */
if (flags & FLAGS_PRECISION)
{
if (flags & FLAGS_PRECISION_PARAMETER)
{
/* Get precision from parameter list */
if (precision < 0)
{
/*
* A negative precision is the same as no
* precision
*/
}
}
}
else
{
}
/* Find base */
if (flags & FLAGS_BASE_PARAMETER)
{
/* Get base from parameter list */
}
switch (parameters[i].type)
{
case FORMAT_CHAR:
if (flags & FLAGS_QUOTE)
if (! (flags & FLAGS_LEFTADJUST))
{
while (--width > 0)
}
#if TRIO_WIDECHAR
if (flags & FLAGS_WIDECHAR)
{
NO_WIDTH);
}
else
#endif
{
flags);
}
if (flags & FLAGS_LEFTADJUST)
{
while(--width > 0)
}
if (flags & FLAGS_QUOTE)
break; /* FORMAT_CHAR */
case FORMAT_INT:
base);
break; /* FORMAT_INT */
case FORMAT_DOUBLE:
base);
break; /* FORMAT_DOUBLE */
case FORMAT_STRING:
#if TRIO_WIDECHAR
if (flags & FLAGS_WIDECHAR)
{
}
else
#endif
{
}
break; /* FORMAT_STRING */
case FORMAT_POINTER:
{
}
break; /* FORMAT_POINTER */
case FORMAT_COUNT:
{
/*
* 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)
else
#endif
#if defined(QUALIFIER_PTRDIFF_T)
if (flags & FLAGS_PTRDIFF_T)
else
#endif
#if defined(QUALIFIER_INTMAX_T)
if (flags & FLAGS_INTMAX_T)
else
#endif
if (flags & FLAGS_QUAD)
{
}
else if (flags & FLAGS_LONG)
{
}
else if (flags & FLAGS_SHORT)
{
}
else
{
}
}
break; /* FORMAT_COUNT */
case FORMAT_PARAMETER:
break; /* FORMAT_PARAMETER */
#if defined(FORMAT_ERRNO)
case FORMAT_ERRNO:
if (string)
{
}
else
{
}
break; /* FORMAT_ERRNO */
#endif /* defined(FORMAT_ERRNO) */
#if defined(FORMAT_USER_DEFINED)
case FORMAT_USER_DEFINED:
{
{
/* Use handle */
if ((i > 0) ||
}
else
{
/* Look up namespace */
}
if (def) {
}
}
break;
#endif /* defined(FORMAT_USER_DEFINED) */
default:
break;
} /* switch parameter type */
/* Prepare for next */
i++;
}
}
else /* not identifier */
{
}
}
}
/*************************************************************************
* TrioFormatRef
*/
TRIO_PRIVATE int
TRIO_CONST char *format,
{
int status;
if (status < 0)
return status;
{
}
return status;
}
/*************************************************************************
* TrioFormat
*/
TRIO_PRIVATE int
TRIO_CONST char *format,
{
int status;
#if defined(USE_LOCALE)
if (NULL == internalLocaleValues)
{
}
#endif
if (status < 0)
return status;
{
}
return status;
}
/*************************************************************************
* TrioOutStreamFile
*/
TRIO_PRIVATE void
int output)
{
{
}
else
{
}
}
/*************************************************************************
* TrioOutStreamFileDescriptor
*/
TRIO_PRIVATE void
int output)
{
int fd;
char ch;
{
}
else
{
}
}
/*************************************************************************
* TrioOutStreamCustom
*/
TRIO_PRIVATE void
int output)
{
int status;
{
if (status >= 0)
{
}
else
{
{
}
}
}
}
/*************************************************************************
* TrioOutStreamString
*/
TRIO_PRIVATE void
int output)
{
char **buffer;
(*buffer)++;
}
/*************************************************************************
* TrioOutStreamStringMax
*/
TRIO_PRIVATE void
int output)
{
char **buffer;
{
(*buffer)++;
}
}
/*************************************************************************
* TrioOutStreamStringDynamic
*/
TRIO_PRIVATE void
int output)
{
{
(char)output);
}
/* The processed variable must always be increased */
}
/*************************************************************************
*
* 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_CONST char *format,
{
int status;
return status;
}
/**
Print to standard output stream.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
TRIO_PUBLIC int
TRIO_CONST char *format,
{
}
/**
Print to standard output stream.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
TRIO_PUBLIC int
TRIO_CONST char *format,
{
}
/*************************************************************************
* fprintf
*/
/**
Print to file.
@param file File pointer.
@param format Formatting string.
@param ... Arguments.
@return Number of printed characters.
*/
TRIO_PUBLIC int
TRIO_CONST char *format,
{
int status;
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_CONST char *format,
{
}
/**
Print to file.
@param file File pointer.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
TRIO_PUBLIC int
TRIO_CONST char *format,
{
}
/*************************************************************************
* dprintf
*/
/**
Print to file descriptor.
@param fd File descriptor.
@param format Formatting string.
@param ... Arguments.
@return Number of printed characters.
*/
TRIO_PUBLIC int
int fd,
TRIO_CONST char *format,
{
int status;
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
int fd,
TRIO_CONST char *format,
{
}
/**
Print to file descriptor.
@param fd File descriptor.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
TRIO_PUBLIC int
int fd,
TRIO_CONST char *format,
{
}
/*************************************************************************
* cprintf
*/
TRIO_PUBLIC int
TRIO_CONST char *format,
{
int status;
return status;
}
TRIO_PUBLIC int
TRIO_CONST char *format,
{
}
TRIO_PUBLIC int
TRIO_CONST char *format,
void **args)
{
}
/*************************************************************************
* sprintf
*/
/**
Print to string.
@param buffer Output string.
@param format Formatting string.
@param ... Arguments.
@return Number of printed characters.
*/
TRIO_PUBLIC int
char *buffer,
TRIO_CONST char *format,
{
int status;
return status;
}
/**
Print to string.
@param buffer Output string.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
TRIO_PUBLIC int
char *buffer,
TRIO_CONST char *format,
{
int status;
return status;
}
/**
Print to string.
@param buffer Output string.
@param format Formatting string.
@param args Arguments.
@return Number of printed characters.
*/
TRIO_PUBLIC int
char *buffer,
TRIO_CONST char *format,
{
int status;
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
char *buffer,
TRIO_CONST char *format,
{
int status;
if (max > 0)
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
char *buffer,
TRIO_CONST char *format,
{
int status;
if (max > 0)
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
char *buffer,
TRIO_CONST char *format,
{
int status;
if (max > 0)
return status;
}
/*************************************************************************
* snprintfcat
* Appends the new string to the buffer string overwriting the '\0'
* character at the end of buffer.
*/
TRIO_PUBLIC int
char *buffer,
TRIO_CONST char *format,
{
int status;
return status;
}
TRIO_PUBLIC int
char *buffer,
TRIO_CONST char *format,
{
int status;
return status;
}
/*************************************************************************
* trio_aprintf
*/
/* Deprecated */
TRIO_PUBLIC char *
TRIO_CONST char *format,
{
if (info)
{
}
return result;
}
/* Deprecated */
TRIO_PUBLIC char *
TRIO_CONST char *format,
{
if (info)
{
}
return result;
}
TRIO_PUBLIC int
char **result,
TRIO_CONST char *format,
{
int status;
{
}
else
{
if (status >= 0)
{
}
}
return status;
}
TRIO_PUBLIC int
char **result,
TRIO_CONST char *format,
{
int status;
{
}
else
{
if (status >= 0)
{
}
}
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_CONST char *name)
{
return NULL;
if (name)
{
/* Handle built-in namespaces */
if (name[0] == ':')
{
{
}
{
}
return NULL;
}
/* Bail out if namespace is too long */
return NULL;
/* Bail out if namespace already is registered */
if (def)
return NULL;
}
if (def)
{
(void)internalEnterCriticalRegion(NULL);
if (name)
{
/* Link into internal list */
else
}
/* Initialize */
? NULL
: trio_duplicate(name);
(void)internalLeaveCriticalRegion(NULL);
}
return (trio_pointer_t)def;
}
/**
Unregister an existing user-defined specifier.
@param handle
*/
void
TRIO_ARGS1((handle),
{
{
if (def)
{
(void)internalEnterCriticalRegion(NULL);
else
(void)internalLeaveCriticalRegion(NULL);
}
}
}
/*************************************************************************
* trio_get_format [public]
*/
TRIO_CONST char *
TRIO_ARGS1((ref),
{
#if defined(FORMAT_USER_DEFINED)
#endif
}
/*************************************************************************
* trio_get_argument [public]
*/
TRIO_ARGS1((ref),
{
#if defined(FORMAT_USER_DEFINED)
#endif
}
/*************************************************************************
* trio_get_width / trio_set_width [public]
*/
int
TRIO_ARGS1((ref),
{
}
void
int width)
{
}
/*************************************************************************
* trio_get_precision / trio_set_precision [public]
*/
int
TRIO_ARGS1((ref),
{
}
void
int precision)
{
}
/*************************************************************************
* trio_get_base / trio_set_base [public]
*/
int
TRIO_ARGS1((ref),
{
}
void
int base)
{
}
/*************************************************************************
* trio_get_long / trio_set_long [public]
*/
int
TRIO_ARGS1((ref),
{
? TRUE
: FALSE;
}
void
int is_long)
{
if (is_long)
else
}
/*************************************************************************
* trio_get_longlong / trio_set_longlong [public]
*/
int
TRIO_ARGS1((ref),
{
? TRUE
: FALSE;
}
void
int is_longlong)
{
if (is_longlong)
else
}
/*************************************************************************
* trio_get_longdouble / trio_set_longdouble [public]
*/
int
TRIO_ARGS1((ref),
{
? TRUE
: FALSE;
}
void
int is_longdouble)
{
if (is_longdouble)
else
}
/*************************************************************************
* trio_get_short / trio_set_short [public]
*/
int
TRIO_ARGS1((ref),
{
? TRUE
: FALSE;
}
void
int is_short)
{
if (is_short)
else
}
/*************************************************************************
* trio_get_shortshort / trio_set_shortshort [public]
*/
int
TRIO_ARGS1((ref),
{
? TRUE
: FALSE;
}
void
int is_shortshort)
{
if (is_shortshort)
else
}
/*************************************************************************
* trio_get_alternative / trio_set_alternative [public]
*/
int
TRIO_ARGS1((ref),
{
? TRUE
: FALSE;
}
void
int is_alternative)
{
if (is_alternative)
else
}
/*************************************************************************
* trio_get_alignment / trio_set_alignment [public]
*/
int
TRIO_ARGS1((ref),
{
? TRUE
: FALSE;
}
void
int is_leftaligned)
{
if (is_leftaligned)
else
}
/*************************************************************************
* trio_get_spacing /trio_set_spacing [public]
*/
int
TRIO_ARGS1((ref),
{
? TRUE
: FALSE;
}
void
int is_space)
{
if (is_space)
else
}
/*************************************************************************
* trio_get_sign / trio_set_sign [public]
*/
int
TRIO_ARGS1((ref),
{
? TRUE
: FALSE;
}
void
int is_sign)
{
if (is_sign)
else
}
/*************************************************************************
* trio_get_padding / trio_set_padding [public]
*/
int
TRIO_ARGS1((ref),
{
? TRUE
: FALSE;
}
void
int is_padding)
{
if (is_padding)
else
}
/*************************************************************************
* trio_get_quote / trio_set_quote [public]
*/
int
TRIO_ARGS1((ref),
{
? TRUE
: FALSE;
}
void
int is_quote)
{
if (is_quote)
else
}
/*************************************************************************
* trio_get_upper / trio_set_upper [public]
*/
int
TRIO_ARGS1((ref),
{
? TRUE
: FALSE;
}
void
int is_upper)
{
if (is_upper)
else
}
/*************************************************************************
* trio_get_largest / trio_set_largest [public]
*/
#if TRIO_C99
int
TRIO_ARGS1((ref),
{
? TRUE
: FALSE;
}
void
int is_largest)
{
if (is_largest)
else
}
#endif
/*************************************************************************
* trio_get_ptrdiff / trio_set_ptrdiff [public]
*/
int
TRIO_ARGS1((ref),
{
? TRUE
: FALSE;
}
void
int is_ptrdiff)
{
if (is_ptrdiff)
else
}
/*************************************************************************
* trio_get_size / trio_set_size [public]
*/
#if TRIO_C99
int
TRIO_ARGS1((ref),
{
? TRUE
: FALSE;
}
void
int is_size)
{
if (is_size)
else
}
#endif
/*************************************************************************
* trio_print_int [public]
*/
void
int number)
{
}
/*************************************************************************
* trio_print_uint [public]
*/
void
unsigned int number)
{
}
/*************************************************************************
* trio_print_double [public]
*/
void
double number)
{
}
/*************************************************************************
* trio_print_string [public]
*/
void
char *string)
{
}
/*************************************************************************
* trio_print_ref [public]
*/
int
TRIO_CONST char *format,
{
int status;
return status;
}
/*************************************************************************
* trio_vprint_ref [public]
*/
int
TRIO_CONST char *format,
{
}
/*************************************************************************
* trio_printv_ref [public]
*/
int
TRIO_CONST char *format,
{
}
#endif /* TRIO_EXTENSION */
/*************************************************************************
* trio_print_pointer [public]
*/
void
{
{
while (*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++.
*/
/* Shrink to size of pointer */
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
char *decimalPoint)
{
#if defined(USE_LOCALE)
if (NULL == internalLocaleValues)
{
}
#endif
if (internalDecimalPointLength == 1)
{
}
else
{
sizeof(internalDecimalPointString),
}
}
/*************************************************************************
* trio_locale_set_thousand_separator
*
* See trio_locale_set_decimal_point
*/
TRIO_PUBLIC void
char *thousandSeparator)
{
#if defined(USE_LOCALE)
if (NULL == internalLocaleValues)
{
}
#endif
sizeof(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
char *grouping)
{
#if defined(USE_LOCALE)
if (NULL == internalLocaleValues)
{
}
#endif
sizeof(internalGrouping),
grouping);
}
/*************************************************************************
*
* SCANNING
*
************************************************************************/
/*************************************************************************
* TrioSkipWhitespaces
*/
TRIO_PRIVATE int
TRIO_ARGS1((self),
{
int ch;
{
}
return ch;
}
/*************************************************************************
* TrioGetCollation
*/
#if TRIO_EXTENSION
TRIO_PRIVATE void
{
int i;
int j;
int k;
char first[2];
char second[2];
/* This is computationally expensive */
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;
internalCollationArray[i][k++] = (char)j;
}
internalCollationArray[i][k] = NIL;
}
}
#endif
/*************************************************************************
* TrioGetCharacterClass
*
* FIXME:
* multibyte
*/
TRIO_PRIVATE int
TRIO_CONST char *format,
int *indexPointer,
int *characterclass)
{
int index = *indexPointer;
int i;
char ch;
char range_begin;
char range_end;
*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.
*/
{
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
*/
{
characterclass[(int)QUALIFIER_MINUS]++;
index++;
}
/* Collect characters */
{
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)
*/
if (range_end == SPECIFIER_UNGROUP)
{
/* Trailing minus is included */
characterclass[(int)ch]++;
break; /* for */
}
if (range_begin > range_end)
for (i = (int)range_begin; i <= (int)range_end; i++)
characterclass[i]++;
break;
#if TRIO_EXTENSION
case SPECIFIER_GROUP:
{
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++)
{
/* 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;
{
/* Lazy evaluation of collation array */
}
for (i = index + 2; ; i++)
{
/* 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 */
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isalnum(i))
characterclass[i]++;
}
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isalpha(i))
characterclass[i]++;
}
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (iscntrl(i))
characterclass[i]++;
}
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isdigit(i))
characterclass[i]++;
}
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isgraph(i))
characterclass[i]++;
}
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (islower(i))
characterclass[i]++;
}
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isprint(i))
characterclass[i]++;
}
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (ispunct(i))
characterclass[i]++;
}
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isspace(i))
characterclass[i]++;
}
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isupper(i))
characterclass[i]++;
}
{
for (i = 0; i < MAX_CHARACTER_CLASS; i++)
if (isxdigit(i))
characterclass[i]++;
}
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.
*/
int width,
int base)
{
trio_uintmax_t number = 0;
int digit;
int count;
int j;
{
/* Lazy evaluation of digits array */
for (j = 0; j < (int)sizeof(internalDigitsLower) - 1; j++)
{
internalDigitArray[(int)internalDigitsLower[j]] = j;
internalDigitArray[(int)internalDigitsUpper[j]] = j;
}
}
if (!(flags & FLAGS_UNSIGNED))
{
/* Leading sign */
{
}
{
isNegative = TRUE;
}
}
if (flags & FLAGS_ALTERNATIVE)
{
switch (base)
{
case NO_BASE:
case BASE_OCTAL:
case BASE_HEX:
case BASE_BINARY:
{
{
{
}
else if ((base == BASE_BINARY) &&
{
}
}
}
else
return FALSE;
break;
default:
break;
}
}
{
{
/* Abort if digit is not allowed in the specified base */
break;
}
else if (flags & FLAGS_QUOTE)
{
/* Compare with thousands separator */
{
break;
}
if (internalThousandSeparator[j])
break; /* Mismatch */
else
continue; /* Match */
}
else
break;
}
/* Was anything read at all? */
if (!gotNumber)
return FALSE;
if (target)
return TRUE;
}
/*************************************************************************
* TrioReadChar
*/
TRIO_PRIVATE int
char *target,
int width)
{
int i;
char ch;
for (i = 0;
i++)
{
{
{
default:
{
/* Read octal number */
return 0;
}
{
/* Read hexadecimal number */
return 0;
}
else
{
}
break;
}
}
if (target)
}
return i + 1;
}
/*************************************************************************
* TrioReadString
*/
char *target,
int width)
{
int i;
/*
* Continue until end of string is reached, a whitespace is encountered,
* or width is exceeded
*/
for (i = 0;
i++)
{
break; /* for */
}
if (target)
return TRUE;
}
/*************************************************************************
* TrioReadWideChar
*/
#if TRIO_WIDECHAR
TRIO_PRIVATE int
int width)
{
int i;
int j;
int size;
int amount = 0;
for (i = 0;
i++)
{
{
return 0;
}
else
{
/*
* Collect a multibyte character, by enlarging buffer until
* it contains a fully legal multibyte character, or the
* buffer is full.
*/
j = 0;
do
{
}
}
if (target)
{
if (size > 0)
}
}
return amount;
}
#endif /* TRIO_WIDECHAR */
/*************************************************************************
* TrioReadWideString
*/
#if TRIO_WIDECHAR
int width)
{
int i;
int size;
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
#endif
/*
* Continue until end of string is reached, a whitespace is encountered,
* or width is exceeded
*/
for (i = 0;
)
{
if (size == 0)
break; /* for */
i += size;
}
if (target)
return TRUE;
}
#endif /* TRIO_WIDECHAR */
/*************************************************************************
* TrioReadGroup
*
* FIXME: characterclass does not work with multibyte characters
*/
char *target,
int *characterclass,
int width)
{
int ch;
int i;
for (i = 0;
i++)
{
if (target)
}
if (target)
return TRUE;
}
/*************************************************************************
* TrioReadDouble
*
* FIXME:
* add long double
* handle base
*/
int width)
{
int ch;
char doubleString[512];
int index = 0;
int start;
int j;
doubleString[0] = 0;
/*
* 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.
*/
{
width--;
}
switch (ch)
{
case 'n':
case 'N':
/* Not-a-number */
if (index != 0)
break;
/* FALLTHROUGH */
case 'i':
case 'I':
/* Infinity */
{
}
/* Case insensitive string comparison */
{
if (flags & FLAGS_LONGDOUBLE)
{
{
}
else
{
}
}
else
{
{
}
else
{
}
}
return TRUE;
}
{
/* NaN must not have a preceeding + nor - */
if (flags & FLAGS_LONGDOUBLE)
{
}
else
{
}
return TRUE;
}
return FALSE;
case '0':
{
}
break;
default:
break;
}
{
/* Integer part */
{
}
else if (flags & FLAGS_QUOTE)
{
/* Compare with thousands separator */
{
break;
}
if (internalThousandSeparator[j])
break; /* Mismatch */
else
continue; /* Match */
}
else
break; /* while */
}
if (ch == '.')
{
/* Decimal part */
{
}
{
/* Exponent */
{
}
{
}
}
}
return FALSE;
doubleString[index] = 0;
if (flags & FLAGS_LONGDOUBLE)
{
}
else
{
}
return TRUE;
}
/*************************************************************************
* TrioReadPointer
*/
{
char buffer[sizeof(internalNullString)];
if (TrioReadNumber(self,
&number,
BASE_HEX))
{
/*
* The strange assignment of number is a workaround for a compiler
* warning
*/
if (target)
return TRUE;
}
else if (TrioReadString(self,
(flags & FLAGS_IGNORE)
? NULL
: buffer,
0,
sizeof(internalNullString) - 1))
{
{
if (target)
return TRUE;
}
}
return FALSE;
}
/*************************************************************************
* TrioScanProcess
*/
TRIO_PRIVATE int
TRIO_CONST char *format,
{
#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 */
int width;
int base;
assignment = 0;
i = 0;
index = 0;
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
#endif
{
#if defined(TRIO_COMPILER_SUPPORTS_MULTIBYTE)
{
if (charlen != -1)
{
/* Compare multibyte characters in format string */
{
{
}
}
continue; /* while characters left in formatting string */
}
}
#endif /* TRIO_COMPILER_SUPPORTS_MULTIBYTE */
{
}
{
{
/* Two % in format matches one % in input stream */
if (CHAR_IDENTIFIER == ch)
{
index += 2;
continue; /* while format chars left */
}
else
}
/* Skip the parameter entries */
i++;
/* Find width */
if (flags & FLAGS_WIDTH_PARAMETER)
{
/* Get width from parameter list */
}
/* Find base */
if (flags & FLAGS_BASE_PARAMETER)
{
/* Get base from parameter list */
}
switch (parameters[i].type)
{
case FORMAT_INT:
{
if (0 == base)
base = BASE_DECIMAL;
if (!TrioReadNumber(data,
&number,
base))
return assignment;
if (!(flags & FLAGS_IGNORE))
{
assignment++;
#if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER)
if (flags & FLAGS_SIZE_T)
else
#endif
#if defined(QUALIFIER_PTRDIFF_T)
if (flags & FLAGS_PTRDIFF_T)
else
#endif
#if defined(QUALIFIER_INTMAX_T)
if (flags & FLAGS_INTMAX_T)
else
#endif
if (flags & FLAGS_QUAD)
else if (flags & FLAGS_LONG)
else if (flags & FLAGS_SHORT)
else
}
}
break; /* FORMAT_INT */
case FORMAT_STRING:
#if TRIO_WIDECHAR
if (flags & FLAGS_WIDECHAR)
{
if (!TrioReadWideString(data,
(flags & FLAGS_IGNORE)
? NULL
width))
return assignment;
}
else
#endif
{
if (!TrioReadString(data,
(flags & FLAGS_IGNORE)
? NULL
width))
return assignment;
}
if (!(flags & FLAGS_IGNORE))
assignment++;
break; /* FORMAT_STRING */
case FORMAT_DOUBLE:
{
if (flags & FLAGS_IGNORE)
{
}
else
{
}
{
return assignment;
}
if (!(flags & FLAGS_IGNORE))
{
assignment++;
}
break; /* FORMAT_DOUBLE */
}
case FORMAT_GROUP:
{
int rc;
/* Skip over modifiers */
{
index++;
}
/* Skip over group specifier */
index++;
&index,
&flags,
if (rc < 0)
return rc;
if (!TrioReadGroup(data,
(flags & FLAGS_IGNORE)
? NULL
parameters[i].width))
return assignment;
if (!(flags & FLAGS_IGNORE))
assignment++;
}
break; /* FORMAT_GROUP */
case FORMAT_COUNT:
{
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)
else
#endif
#if defined(QUALIFIER_PTRDIFF_T)
if (flags & FLAGS_PTRDIFF_T)
else
#endif
#if defined(QUALIFIER_INTMAX_T)
if (flags & FLAGS_INTMAX_T)
else
#endif
if (flags & FLAGS_QUAD)
{
}
else if (flags & FLAGS_LONG)
{
}
else if (flags & FLAGS_SHORT)
{
}
else
{
}
}
break; /* FORMAT_COUNT */
case FORMAT_CHAR:
#if TRIO_WIDECHAR
if (flags & FLAGS_WIDECHAR)
{
if (TrioReadWideChar(data,
(flags & FLAGS_IGNORE)
? NULL
return assignment;
}
else
#endif
{
if (TrioReadChar(data,
(flags & FLAGS_IGNORE)
? NULL
return assignment;
}
if (!(flags & FLAGS_IGNORE))
assignment++;
break; /* FORMAT_CHAR */
case FORMAT_POINTER:
if (!TrioReadPointer(data,
(flags & FLAGS_IGNORE)
? NULL
flags))
return assignment;
if (!(flags & FLAGS_IGNORE))
assignment++;
break; /* FORMAT_POINTER */
case FORMAT_PARAMETER:
break; /* FORMAT_PARAMETER */
default:
}
i++;
}
else /* Not an % identifier */
{
{
/* Whitespaces may match any amount of whitespaces */
}
{
}
else
return assignment;
index++;
}
}
return assignment;
}
/*************************************************************************
* TrioScan
*/
TRIO_PRIVATE int
TRIO_CONST char *format,
{
int status;
#if defined(USE_LOCALE)
if (NULL == internalLocaleValues)
{
}
#endif
if (status < 0)
return status;
{
}
return status;
}
/*************************************************************************
* TrioInStreamFile
*/
TRIO_PRIVATE void
int *intPointer)
{
{
? TRIO_ERROR_RETURN(TRIO_ERRNO, 0)
: TRIO_ERROR_RETURN(TRIO_EOF, 0);
}
else
{
}
if (VALID(intPointer))
{
}
}
/*************************************************************************
* TrioInStreamFileDescriptor
*/
TRIO_PRIVATE void
int *intPointer)
{
int size;
unsigned char input;
if (size == -1)
{
}
else
{
}
{
}
if (VALID(intPointer))
{
}
}
/*************************************************************************
* TrioInStreamCustom
*/
TRIO_PRIVATE void
int *intPointer)
{
? NIL
{
}
else
{
}
if (VALID(intPointer))
{
}
}
/*************************************************************************
* TrioInStreamString
*/
TRIO_PRIVATE void
int *intPointer)
{
unsigned char **buffer;
{
}
else
{
(*buffer)++;
}
if (VALID(intPointer))
{
}
}
/*************************************************************************
*
* 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_CONST char *format,
{
int status;
return status;
}
TRIO_PUBLIC int
TRIO_CONST char *format,
{
}
TRIO_PUBLIC int
TRIO_CONST char *format,
{
}
/*************************************************************************
* fscanf
*/
TRIO_PUBLIC int
TRIO_CONST char *format,
{
int status;
return status;
}
TRIO_PUBLIC int
TRIO_CONST char *format,
{
}
TRIO_PUBLIC int
TRIO_CONST char *format,
{
}
/*************************************************************************
* dscanf
*/
TRIO_PUBLIC int
int fd,
TRIO_CONST char *format,
{
int status;
return status;
}
TRIO_PUBLIC int
int fd,
TRIO_CONST char *format,
{
}
TRIO_PUBLIC int
int fd,
TRIO_CONST char *format,
{
}
/*************************************************************************
* cscanf
*/
TRIO_PUBLIC int
TRIO_CONST char *format,
{
int status;
return status;
}
TRIO_PUBLIC int
TRIO_CONST char *format,
{
}
TRIO_PUBLIC int
TRIO_CONST char *format,
{
}
/*************************************************************************
* sscanf
*/
TRIO_PUBLIC int
TRIO_CONST char *buffer,
TRIO_CONST char *format,
{
int status;
return status;
}
TRIO_PUBLIC int
TRIO_CONST char *buffer,
TRIO_CONST char *format,
{
}
TRIO_PUBLIC int
TRIO_CONST char *buffer,
TRIO_CONST char *format,
{
}
/** @} End of Scanf documentation module */
/*************************************************************************
* trio_strerror
*/
TRIO_PUBLIC TRIO_CONST char *
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";
}
}