| /************************************************************************* |
| * |
| * $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. |
| * |
| ************************************************************************* |
| * |
| * 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. |
| * |
| ************************************************************************/ |
| |
| /* DV for libxml */ |
| #include "xmlversion.h" |
| #ifdef WITH_TRIO |
| #include "config.h" |
| /* |
| * DV changes applied |
| * excluded all unused interfaces, renamed them without the trio prefix |
| */ |
| |
| /* |
| * FIXME: |
| * - Scan is probably too permissive about its modifiers. |
| * - Width for floating-point numbers (does it make sense?) |
| * - Add hex-float to TrioReadDouble |
| * - C escapes in %#[] ? |
| * - Multibyte characters (done for format parsing, except scan groups) |
| * - Widechar |
| * - Complex numbers? (C99 _Complex) |
| * - Boolean values? (C99 _Bool) |
| * - C99 NaN(n-char-sequence) missing |
| * - 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'. |
| */ |
| |
| static const char rcsid[] = "@(#)$Id$"; |
| |
| #if defined(__STDC__) && (__STDC_VERSION__ >= 199901L) |
| # define TRIO_C99 /* FIXME: C99 support has not been properly tested */ |
| #endif |
| #define TRIO_BSD |
| #define TRIO_GNU |
| #define TRIO_MISC |
| #define TRIO_UNIX98 |
| #define TRIO_EXTENSION |
| #define TRIO_ERRORS |
| |
| #if defined(unix) || defined(__xlC__) /* AIX xlC workaround */ |
| # define PLATFORM_UNIX |
| #elif defined(AMIGA) && defined(__GNUC__) |
| # define PLATFORM_UNIX |
| #endif |
| |
| /************************************************************************* |
| * Include files |
| */ |
| |
| |
| #include "trio.h" |
| #include "strio.h" |
| #include <ctype.h> |
| #include <math.h> |
| #include <limits.h> |
| #include <float.h> |
| #include <stdarg.h> |
| #include <errno.h> |
| #if defined(TRIO_C99) |
| # include <stdint.h> |
| #endif |
| #if defined(PLATFORM_UNIX) |
| # include <unistd.h> |
| # include <locale.h> |
| # define USE_LOCALE |
| #endif |
| #ifndef DEBUG |
| # define NDEBUG |
| #endif |
| #include <assert.h> |
| |
| /************************************************************************* |
| * Generic definitions |
| */ |
| |
| #ifndef NULL |
| # define NULL 0 |
| #endif |
| #define NIL ((char)0) |
| #ifdef __cplusplus |
| # undef TRUE |
| # undef FALSE |
| # define TRUE true |
| # define FALSE false |
| # define BOOLEAN_T bool |
| #else |
| # ifndef FALSE |
| # define FALSE (1 == 0) |
| # define TRUE (! FALSE) |
| # endif |
| # define BOOLEAN_T int |
| #endif |
| |
| /* mincore() can be used for debugging purposes */ |
| #define VALID(x) (NULL != (x)) |
| |
| /* Encode the error code and the position. This is decoded |
| * with TRIO_ERROR_CODE and TRIO_ERROR_POSITION. |
| */ |
| #if defined(TRIO_ERRORS) |
| # define TRIO_ERROR_RETURN(x,y) (- ((x) + ((y) << 8))) |
| #else |
| # define TRIO_ERROR_RETURN(x,y) (-1) |
| #endif |
| |
| /************************************************************************* |
| * Internal definitions |
| */ |
| |
| #if defined(__STDC_ISO_10646__) || defined(MB_LEN_MAX) |
| # define USE_MULTIBYTE |
| #endif |
| |
| #if !defined(USE_LONGLONG) |
| # if defined(__GNUC__) && !defined(__STRICT_ANSI__) |
| # define USE_LONGLONG |
| # elif defined(__SUNPRO_C) |
| # define USE_LONGLONG |
| # elif defined(_LONG_LONG) || defined(_LONGLONG) |
| # define USE_LONGLONG |
| # endif |
| #endif |
| |
| /* The extra long numbers */ |
| #if defined(USE_LONGLONG) |
| # define LONGLONG long long |
| # define ULONGLONG unsigned long long |
| #else |
| # define LONGLONG long |
| # define ULONGLONG unsigned long |
| #endif |
| |
| /* The longest possible integer */ |
| #if defined(TRIO_C99) |
| # define LONGEST uintmax_t |
| # define SLONGEST intmax_t |
| #else |
| # define LONGEST ULONGLONG |
| # define SLONGEST LONGLONG |
| #endif |
| |
| /* The maximal number of digits are for base 2 */ |
| #define MAX_CHARS_IN(x) (sizeof(x) * CHAR_BIT + 1) |
| /* The width of a pointer. The number of bits in a hex digit is 4 */ |
| #define POINTER_WIDTH ((sizeof("0x") - 1) + sizeof(void *) * CHAR_BIT / 4) |
| |
| /* Infinite and Not-A-Number for floating-point */ |
| #if defined(HUGE_VAL) |
| # define USE_INFINITE |
| # if defined(TRIO_C99) |
| # define IS_INFINITE(x) isinf(x) |
| # else |
| # define IS_INFINITE(x) (((x)==HUGE_VAL) ? 1 : (((x)==-HUGE_VAL) ? -1 : 0)) |
| # endif |
| # define INFINITE_LOWER "inf" |
| # define INFINITE_UPPER "INF" |
| # define LONG_INFINITE_LOWER "infinite" |
| # define LONG_INFINITE_UPPER "INFINITE" |
| #endif |
| #if defined(NAN) |
| # define USE_NAN |
| # define IS_NAN(x) isnan(x) |
| # define NAN_LOWER "nan" |
| # define NAN_UPPER "NAN" |
| #endif |
| |
| /* Various constants */ |
| enum { |
| TYPE_PRINT = 1, |
| TYPE_SCAN = 2, |
| |
| /* Flags. Use maximum 32 */ |
| 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_SIZE_PARAMETER = 2 * FLAGS_IGNORE_PARAMETER, |
| /* Reused flags */ |
| FLAGS_EXCLUDE = FLAGS_SHORT, |
| /* Compounded flags */ |
| FLAGS_ALL_SIZES = FLAGS_LONG | FLAGS_QUAD | FLAGS_INTMAX_T | FLAGS_PTRDIFF_T | FLAGS_SIZE_T, |
| |
| NO_POSITION = -1, |
| NO_WIDTH = 0, |
| NO_PRECISION = -1, |
| NO_SIZE = -1, |
| |
| NO_BASE = -1, |
| MIN_BASE = 2, |
| MAX_BASE = 36, |
| BASE_BINARY = 2, |
| BASE_OCTAL = 8, |
| BASE_DECIMAL = 10, |
| BASE_HEX = 16, |
| |
| /* Maximal number of allowed parameters */ |
| MAX_PARAMETERS = 64, |
| /* Maximal number of characters in class */ |
| MAX_CHARACTER_CLASS = UCHAR_MAX, |
| |
| /* Maximal length of locale separator strings */ |
| MAX_LOCALE_SEPARATOR_LENGTH = 64, |
| /* Maximal number of integers in grouping */ |
| MAX_LOCALE_GROUPS = 64 |
| }; |
| |
| #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 defined(TRIO_GNU) |
| # define FORMAT_ERRNO 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_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 |
| * |
| * 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 defined(TRIO_UNIX98) |
| # define SPECIFIER_CHAR_UPPER 'C' |
| # define SPECIFIER_STRING_UPPER 'S' |
| #endif |
| #if defined(TRIO_C99) |
| # define SPECIFIER_HEXFLOAT 'a' |
| # define SPECIFIER_HEXFLOAT_UPPER 'A' |
| #endif |
| #if defined(TRIO_GNU) |
| # define SPECIFIER_ERRNO 'm' |
| #endif |
| #if defined(TRIO_EXTENSION) |
| # define SPECIFIER_BINARY 'b' |
| # define SPECIFIER_BINARY_UPPER 'B' |
| #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) |
| * |
| * Extensions: |
| * NB: Some of these have been deprecated. |
| * <alloc> = GNU 'a' qualifier |
| * <base=n> = sets base to 'n' (int) |
| * <fill=c> = fill with 'c' (char) |
| * <quote> = quote string |
| */ |
| #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 '^' |
| #if defined(TRIO_C99) |
| # define QUALIFIER_SIZE_T 'z' |
| # define QUALIFIER_PTRDIFF_T 't' |
| # define QUALIFIER_INTMAX_T 'j' |
| #endif |
| #if defined(TRIO_BSD) || defined(TRIO_GNU) |
| # define QUALIFIER_QUAD 'q' |
| #endif |
| #if defined(TRIO_GNU) |
| # define QUALIFIER_SIZE_T_UPPER 'Z' |
| #endif |
| #if defined(TRIO_MISC) |
| # define QUALIFIER_WIDECHAR 'w' |
| #endif |
| #if defined(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_EXTENSIONBEGIN '<' |
| # define QUALIFIER_EXTENSIONEND '>' |
| # define QUALIFIER_EXTENSIONSEPARATOR ',' |
| # define QUALIFIER_EXTENSIONVALUE '=' |
| #endif |
| |
| /* Internal structure for parameters */ |
| typedef struct { |
| int type; |
| int flags; |
| int width; |
| size_t precision; |
| int base; |
| int varsize; |
| int indexAfterSpecifier; |
| union { |
| char *string; |
| void *pointer; |
| union { |
| SLONGEST asSigned; |
| LONGEST asUnsigned; |
| } number; |
| double doubleNumber; |
| double *doublePointer; |
| long double longdoubleNumber; |
| long double *longdoublePointer; |
| int errorNumber; |
| } data; |
| } parameter_T; |
| |
| /* Internal structure */ |
| typedef struct _trio_T { |
| void *location; |
| void (*OutStream)(struct _trio_T *, int); |
| void (*InStream)(struct _trio_T *, int *); |
| /* The number of characters that would have been written/read if |
| * there had been sufficient space. |
| */ |
| size_t processed; |
| /* The number of characters that are actually written/read. |
| * Processed and committed with only differ for the *nprintf |
| * and *nscanf functions. |
| */ |
| size_t committed; |
| size_t max; |
| unsigned int current; |
| } trio_T; |
| |
| |
| /************************************************************************* |
| * Package scope variables |
| */ |
| |
| #if defined(PLATFORM_UNIX) |
| extern int errno; |
| #endif |
| |
| #if defined(USE_LOCALE) |
| static struct lconv *globalLocaleValues = NULL; |
| #endif |
| /* UNIX98 says "in a locale where the radix character is not defined, |
| * the radix character defaults to a period (.)" |
| */ |
| static char globalDecimalPoint[MAX_LOCALE_SEPARATOR_LENGTH] = "."; |
| static char globalThousandSeparator[MAX_LOCALE_SEPARATOR_LENGTH] = ","; |
| static char globalGrouping[MAX_LOCALE_GROUPS] = { (char)NO_GROUPING }; |
| |
| static const char globalDigitsLower[] = "0123456789abcdefghijklmnopqrstuvwxyz"; |
| static const char globalDigitsUpper[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; |
| static BOOLEAN_T globalDigitsUnconverted = TRUE; |
| static int globalDigitArray[128]; |
| |
| static const char null[] = "(nil)"; |
| |
| static const char extensionFill[] = "fill"; |
| static const size_t extensionFillSize = sizeof(extensionFill) - 1; |
| static const char extensionAlloc[] = "alloc"; |
| static const size_t extensionAllocSize = sizeof(extensionAlloc) - 1; |
| static const char extensionBase[] = "base"; |
| static const size_t extensionBaseSize = sizeof(extensionBase) - 1; |
| static const char extensionQuote[] = "quote"; |
| static const size_t extensionQuoteSize = sizeof(extensionQuote) - 1; |
| |
| |
| /************************************************************************* |
| * TrioIsQualifier [private] |
| * |
| * Description: |
| * Remember to add all new qualifiers to this function. |
| * QUALIFIER_POSITION must not be added. |
| */ |
| static BOOLEAN_T |
| TrioIsQualifier(const char ch) |
| { |
| /* QUALIFIER_POSITION is not included */ |
| switch (ch) |
| { |
| 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_EXTENSIONBEGIN) |
| case QUALIFIER_EXTENSIONBEGIN: |
| #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 |
| return TRUE; |
| default: |
| return FALSE; |
| } |
| } |
| |
| /************************************************************************* |
| * TrioSetLocale [private] |
| */ |
| static void |
| TrioSetLocale() |
| { |
| #if defined(USE_LOCALE) |
| globalLocaleValues = (struct lconv *)localeconv(); |
| if (StrLength(globalLocaleValues->decimal_point) > 0) |
| { |
| StrCopyMax(globalDecimalPoint, |
| sizeof(globalDecimalPoint), |
| globalLocaleValues->decimal_point); |
| } |
| if (StrLength(globalLocaleValues->thousands_sep) > 0) |
| { |
| StrCopyMax(globalThousandSeparator, |
| sizeof(globalThousandSeparator), |
| globalLocaleValues->thousands_sep); |
| } |
| if (StrLength(globalLocaleValues->grouping) > 0) |
| { |
| StrCopyMax(globalGrouping, |
| sizeof(globalGrouping), |
| globalLocaleValues->grouping); |
| } |
| #endif |
| } |
| |
| /************************************************************************* |
| * TrioGetPosition [private] |
| * |
| * Get the %n$ position. |
| */ |
| static int |
| TrioGetPosition(const char *format, int *indexPointer) |
| { |
| char *tmpformat; |
| int number = 0; |
| int index = *indexPointer; |
| |
| number = (int)StrToLong(&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; |
| } |
| return NO_POSITION; |
| } |
| |
| /************************************************************************* |
| * TrioPreprocess [private] |
| * |
| * Description: |
| * Parse the format string |
| */ |
| static int |
| TrioPreprocess(int type, |
| const char *format, |
| parameter_T *parameters, |
| va_list arglist) |
| { |
| #if defined(TRIO_ERRORS) |
| /* Count the number of times a parameter is referenced */ |
| unsigned short usedEntries[MAX_PARAMETERS]; |
| #endif |
| /* Parameter counters */ |
| int parameterPosition; |
| int currentParam; |
| int maxParam = -1; |
| BOOLEAN_T insideExtension; /* Are we inside an <> extension? */ |
| /* Utility variables */ |
| int 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 got_sticky = 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; |
| int charlen; |
| int i = -1; |
| int num; |
| int work; |
| char *tmpformat; |
| |
| |
| #if defined(TRIO_ERRORS) |
| /* The 'parameters' array is not initialized, but we need to |
| * know which entries we have used. |
| */ |
| memset(usedEntries, 0, sizeof(usedEntries)); |
| #endif |
| |
| index = 0; |
| parameterPosition = 0; |
| #if defined(USE_MULTIBYTE) |
| mblen(NULL, 0); |
| #endif |
| |
| while (format[index]) |
| { |
| #if defined(USE_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 |
| if (CHAR_IDENTIFIER == format[index++]) |
| { |
| if (CHAR_IDENTIFIER == format[index]) |
| { |
| index++; |
| continue; /* while */ |
| } |
| |
| flags = FLAGS_NEW; |
| insideExtension = FALSE; |
| 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]) |
| || insideExtension) |
| { |
| ch = format[index++]; |
| |
| #if defined(TRIO_EXTENSION) |
| if (insideExtension) |
| { |
| if (QUALIFIER_EXTENSIONSEPARATOR == ch) |
| { |
| ch = QUALIFIER_EXTENSIONBEGIN; |
| } |
| else |
| { |
| insideExtension = FALSE; |
| } |
| } |
| if (QUALIFIER_EXTENSIONBEGIN == ch) |
| { |
| /* Parse extended format */ |
| insideExtension = TRUE; |
| work = index; |
| |
| switch (format[work]) |
| { |
| case 'a': |
| /* <alloc> */ |
| if (StrEqualMax(extensionAlloc, extensionAllocSize, |
| &format[work])) |
| { |
| flags |= FLAGS_ALLOC; |
| work += extensionAllocSize; |
| } |
| break; |
| |
| case 'b': |
| /* <base=c> */ |
| if (StrEqualMax(extensionBase, extensionBaseSize, |
| &format[work])) |
| { |
| work += extensionBaseSize; |
| if (QUALIFIER_EXTENSIONVALUE == format[work]) |
| { |
| work++; |
| base = StrToLong(&format[work], &tmpformat, BASE_DECIMAL); |
| work += (int)(tmpformat - &format[work]); |
| if ((base < MIN_BASE) || (base > MAX_BASE)) |
| return TRIO_ERROR_RETURN(TRIO_EINVAL, index); |
| } |
| } |
| break; |
| |
| #if 0 |
| /* Deprecated */ |
| case 'f': |
| if (StrEqualMax(extensionFill, extensionFillSize, |
| &format[work])) |
| { |
| work += extensionFillSize; |
| if (QUALIFIER_EXTENSIONVALUE == format[work]) |
| { |
| work++; |
| adjust = format[work++]; |
| } |
| } |
| #endif |
| case 'q': |
| /* <quote> */ |
| if (StrEqualMax(extensionQuote, extensionQuoteSize, |
| &format[work])) |
| { |
| flags |= FLAGS_QUOTE; |
| work += extensionQuoteSize; |
| #if 0 |
| /* Deprecated */ |
| if (QUALIFIER_EXTENSIONVALUE == format[work]) |
| { |
| work++; |
| quote = format[work++]; |
| } |
| #endif |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| if (QUALIFIER_EXTENSIONEND == work[format]) |
| { |
| insideExtension = FALSE; |
| index = ++work; |
| } |
| } |
| #endif /* defined(TRIO_EXTENSION) */ |
| |
| switch (ch) |
| { |
| #if defined(TRIO_EXTENSION) |
| case QUALIFIER_EXTENSIONBEGIN: |
| case QUALIFIER_EXTENSIONSEPARATOR: |
| /* Everything is fine, but ignore */ |
| break; |
| #endif |
| 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]) || |
| (QUALIFIER_PARAM == format[index])) |
| { |
| 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 = StrToLong(&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]) || |
| (QUALIFIER_PARAM == format[index])) |
| { |
| 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 = StrToLong(&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 */ |
| |
| case QUALIFIER_PARAM: |
| type = TYPE_PRINT; |
| /* FALLTHROUGH */ |
| 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 = StrToLong(&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(ULONGLONG)) |
| 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(ULONGLONG)) |
| 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(intmax_t) == sizeof(ULONGLONG)) |
| flags |= FLAGS_QUAD; |
| else if (sizeof(intmax_t) == sizeof(long)) |
| flags |= FLAGS_LONG; |
| break; |
| #endif |
| |
| #if defined(QUALIFIER_QUAD) |
| case QUALIFIER_QUAD: |
| flags |= FLAGS_QUAD; |
| 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; |
| got_sticky = TRUE; |
| break; |
| #endif |
| |
| #if defined(QUALIFIER_VARSIZE) |
| case QUALIFIER_VARSIZE: |
| flags |= FLAGS_SIZE_PARAMETER; |
| parameterPosition++; |
| if (positional) |
| varsize = parameterPosition; |
| else |
| { |
| varsize = currentParam; |
| currentParam = varsize + 1; |
| } |
| if (currentParam > maxParam) |
| maxParam = currentParam; |
| 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) |
| { |
| #if defined(TRIO_ERRORS) |
| usedEntries[width] += 1; |
| #endif |
| parameters[pos].type = FORMAT_PARAMETER; |
| indices[width] = pos; |
| width = pos++; |
| } |
| if (flags & FLAGS_PRECISION_PARAMETER) |
| { |
| #if defined(TRIO_ERRORS) |
| usedEntries[precision] += 1; |
| #endif |
| parameters[pos].type = FORMAT_PARAMETER; |
| indices[precision] = pos; |
| precision = pos++; |
| } |
| if (flags & FLAGS_BASE_PARAMETER) |
| { |
| #if defined(TRIO_ERRORS) |
| usedEntries[base] += 1; |
| #endif |
| parameters[pos].type = FORMAT_PARAMETER; |
| indices[base] = pos; |
| base = pos++; |
| } |
| if (flags & FLAGS_SIZE_PARAMETER) |
| { |
| #if defined(TRIO_ERRORS) |
| usedEntries[varsize] += 1; |
| #endif |
| parameters[pos].type = FORMAT_PARAMETER; |
| indices[varsize] = pos; |
| varsize = pos++; |
| } |
| |
| indices[currentParam] = pos; |
| |
| switch (format[index++]) |
| { |
| #if defined(SPECIFIER_CHAR_UPPER) |
| case SPECIFIER_CHAR_UPPER: |
| flags |= FLAGS_LONG; |
| /* FALLTHROUGH */ |
| #endif |
| case SPECIFIER_CHAR: |
| parameters[pos].type = FORMAT_CHAR; |
| break; |
| |
| #if defined(SPECIFIER_STRING_UPPER) |
| case SPECIFIER_STRING_UPPER: |
| flags |= FLAGS_LONG; |
| /* FALLTHROUGH */ |
| #endif |
| case SPECIFIER_STRING: |
| parameters[pos].type = FORMAT_STRING; |
| break; |
| |
| case SPECIFIER_GROUP: |
| if (TYPE_SCAN == type) |
| { |
| parameters[pos].type = FORMAT_GROUP; |
| while (format[index]) |
| { |
| if (format[index++] == SPECIFIER_UNGROUP) |
| break; /* while */ |
| } |
| } |
| 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_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: |
| 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 |
| |
| default: |
| /* Bail out completely to make the error more obvious */ |
| return TRIO_ERROR_RETURN(TRIO_EINVAL, index); |
| } |
| |
| #if defined(TRIO_ERRORS) |
| /* Count the number of times this entry has been used */ |
| usedEntries[currentParam] += 1; |
| #endif |
| |
| /* Find last sticky parameters */ |
| if (got_sticky && !(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 & ~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 defined(TRIO_ERRORS) |
| 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); |
| } |
| #endif |
| |
| 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: |
| parameters[i].data.string = va_arg(arglist, char *); |
| break; |
| |
| case FORMAT_POINTER: |
| case FORMAT_COUNT: |
| case FORMAT_UNKNOWN: |
| parameters[i].data.pointer = va_arg(arglist, void *); |
| break; |
| |
| case FORMAT_CHAR: |
| case FORMAT_INT: |
| if (TYPE_SCAN == type) |
| { |
| parameters[i].data.pointer = (LONGEST *)va_arg(arglist, void *); |
| } |
| else |
| { |
| #if defined(QUALIFIER_VARSIZE) |
| if (parameters[i].flags & FLAGS_SIZE_PARAMETER) |
| { |
| /* Variable sizes are mapped onto the fixed sizes, |
| * in accordance with integer promotion. |
| */ |
| parameters[i].flags &= ~FLAGS_ALL_SIZES; |
| varsize = (int)parameters[parameters[i].varsize].data.number.asUnsigned; |
| 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(LONGLONG)) |
| parameters[i].flags |= FLAGS_QUAD; |
| else |
| parameters[i].flags |= FLAGS_INTMAX_T; |
| #else |
| else |
| parameters[i].flags |= FLAGS_QUAD; |
| #endif |
| } |
| #endif |
| #if defined(QUALIFIER_SIZE_T) || defined(QUALIFIER_SIZE_T_UPPER) |
| if (parameters[i].flags & FLAGS_SIZE_T) |
| parameters[i].data.number.asUnsigned = (LONGEST)va_arg(arglist, size_t); |
| else |
| #endif |
| #if defined(QUALIFIER_PTRDIFF_T) |
| if (parameters[i].flags & FLAGS_PTRDIFF_T) |
| parameters[i].data.number.asUnsigned = (LONGEST)va_arg(arglist, ptrdiff_t); |
| else |
| #endif |
| #if defined(QUALIFIER_INTMAX_T) |
| if (parameters[i].flags & FLAGS_INTMAX_T) |
| parameters[i].data.number.asUnsigned = (LONGEST)va_arg(arglist, intmax_t); |
| else |
| #endif |
| if (parameters[i].flags & FLAGS_QUAD) |
| parameters[i].data.number.asUnsigned = (LONGEST)va_arg(arglist, ULONGLONG); |
| else if (parameters[i].flags & FLAGS_LONG) |
| parameters[i].data.number.asUnsigned = (LONGEST)va_arg(arglist, long); |
| else |
| parameters[i].data.number.asUnsigned = (LONGEST)va_arg(arglist, int); |
| } |
| break; |
| |
| case FORMAT_PARAMETER: |
| parameters[i].data.number.asUnsigned = (LONGEST)va_arg(arglist, int); |
| break; |
| |
| case FORMAT_DOUBLE: |
| if (TYPE_SCAN == type) |
| { |
| if (parameters[i].flags & FLAGS_LONG) |
| parameters[i].data.longdoublePointer = va_arg(arglist, long double *); |
| else |
| parameters[i].data.doublePointer = va_arg(arglist, double *); |
| } |
| else |
| { |
| if (parameters[i].flags & FLAGS_LONG) |
| parameters[i].data.longdoubleNumber = va_arg(arglist, long double); |
| else |
| parameters[i].data.longdoubleNumber = (long double)va_arg(arglist, double); |
| } |
| break; |
| |
| #if defined(FORMAT_ERRNO) |
| case FORMAT_ERRNO: |
| parameters[i].data.errorNumber = errno; |
| break; |
| #endif |
| |
| default: |
| break; |
| } |
| } /* for all specifiers */ |
| return num; |
| } |
| |
| |
| /************************************************************************* |
| * |
| * FORMATTING |
| * |
| ************************************************************************/ |
| |
| |
| /************************************************************************* |
| * TrioWriteNumber [private] |
| * |
| * Description: |
| * Output a number. |
| * The complexity of this function is a result of the complexity |
| * of the dependencies of the flags. |
| */ |
| static void |
| TrioWriteNumber(trio_T *self, |
| LONGEST number, |
| int flags, |
| int width, |
| int precision, |
| int base) |
| { |
| BOOLEAN_T isNegative; |
| char buffer[MAX_CHARS_IN(LONGEST) |
| * MAX_LOCALE_SEPARATOR_LENGTH |
| * MAX_LOCALE_GROUPS]; |
| char *bufferend; |
| char *pointer; |
| const char *digits; |
| int i; |
| int length; |
| char *p; |
| int charsPerThousand; |
| int groupingIndex; |
| int count; |
| |
| assert(VALID(self)); |
| assert(VALID(self->OutStream)); |
| assert((base >= MIN_BASE && base <= MAX_BASE) || (base == NO_BASE)); |
| |
| digits = (flags & FLAGS_UPPER) ? globalDigitsUpper : globalDigitsLower; |
| |
| if (flags & FLAGS_UNSIGNED) |
| isNegative = FALSE; |
| else if ((isNegative = (((SLONGEST)number) < 0))) |
| number = -number; |
| |
| if (flags & FLAGS_QUAD) |
| number &= (ULONGLONG)-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; |
| charsPerThousand = (int)globalGrouping[0]; |
| groupingIndex = 1; |
| for (i = 1; i < (int)sizeof(buffer); i++) |
| { |
| *pointer-- = digits[number % base]; |
| number /= base; |
| if (number == 0) |
| break; |
| |
| if ((flags & FLAGS_QUOTE) |
| && (charsPerThousand != NO_GROUPING) |
| && (i % charsPerThousand == 0)) |
| { |
| /* |
| * We are building the number from the least significant |
| * to the most significant digit, so we have to copy the |
| * thousand separator backwards |
| */ |
| length = StrLength(globalThousandSeparator); |
| if (((int)(pointer - buffer) - length) > 0) |
| { |
| p = &globalThousandSeparator[length - 1]; |
| while (length-- > 0) |
| *pointer-- = *p--; |
| } |
| |
| /* Advance to next grouping number */ |
| switch (globalGrouping[groupingIndex]) |
| { |
| case CHAR_MAX: /* Disable grouping */ |
| charsPerThousand = NO_GROUPING; |
| break; |
| case 0: /* Repeat last group */ |
| break; |
| default: |
| charsPerThousand = (int)globalGrouping[groupingIndex++]; |
| break; |
| } |
| } |
| } |
| |
| /* Adjust width */ |
| width -= (bufferend - pointer) - 1; |
| |
| /* Adjust precision */ |
| if (NO_PRECISION != precision) |
| { |
| precision -= (bufferend - pointer) - 1; |
| if (precision < 0) |
| precision = 0; |
| flags |= FLAGS_NILPADDING; |
| } |
| |
| /* Adjust width further */ |
| if (isNegative || (flags & FLAGS_SHOWSIGN) || (flags & FLAGS_SPACE)) |
| width--; |
| if (flags & FLAGS_ALTERNATIVE) |
| { |
| 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) || |
| ((flags & FLAGS_NILPADDING) && (precision == NO_PRECISION)))) |
| { |
| count = (precision == NO_PRECISION) ? 0 : 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, ' '); |
| |
| if (flags & FLAGS_ALTERNATIVE) |
| { |
| switch (base) |
| { |
| case BASE_BINARY: |
| self->OutStream(self, '0'); |
| self->OutStream(self, (flags & FLAGS_UPPER) ? 'B' : 'b'); |
| break; |
| |
| case BASE_OCTAL: |
| 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--; |
| } |
| } |
| |
| /* 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); |
| } |
| } |
| |
| /************************************************************************* |
| * TrioWriteString [private] |
| * |
| * Description: |
| * Output a string |
| */ |
| static void |
| TrioWriteString(trio_T *self, |
| const char *string, |
| int flags, |
| int width, |
| int precision) |
| { |
| int length; |
| int ch; |
| |
| assert(VALID(self)); |
| assert(VALID(self->OutStream)); |
| |
| if (string == NULL) |
| { |
| string = null; |
| length = sizeof(null) - 1; |
| /* Disable quoting for the null pointer */ |
| flags &= (~FLAGS_QUOTE); |
| width = 0; |
| } |
| else |
| { |
| length = StrLength(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 = (unsigned char)(*string++); |
| if (flags & FLAGS_ALTERNATIVE) |
| { |
| if (! (isprint(ch) || isspace(ch))) |
| { |
| /* Non-printable characters are converted to C escapes or |
| * \number, if no C escape exists. |
| */ |
| self->OutStream(self, CHAR_BACKSLASH); |
| switch (ch) |
| { |
| case '\a': /* alert */ |
| self->OutStream(self, 'a'); |
| break; |
| case '\b': /* backspace */ |
| self->OutStream(self, 'b'); |
| break; |
| case '\f': /* formfeed */ |
| self->OutStream(self, 'f'); |
| break; |
| case '\n': /* newline */ |
| self->OutStream(self, 'n'); |
| break; |
| case '\r': /* carriage return */ |
| self->OutStream(self, 'r'); |
| break; |
| case '\t': /* horizontal tab */ |
| self->OutStream(self, 't'); |
| break; |
| case '\v': /* vertical tab */ |
| self->OutStream(self, 'v'); |
| break; |
| case '\\': /* backslash */ |
| self->OutStream(self, '\\'); |
| break; |
| default: /* the rest */ |
| self->OutStream(self, 'x'); |
| TrioWriteNumber(self, (ULONGLONG)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); |
| } |
| } |
| |
| if (flags & FLAGS_LEFTADJUST) |
| { |
| while (width-- > 0) |
| self->OutStream(self, CHAR_ADJUST); |
| } |
| if (flags & FLAGS_QUOTE) |
| self->OutStream(self, CHAR_QUOTE); |
| } |
| |
| /************************************************************************* |
| * TrioWriteDouble [private] |
| */ |
| static void |
| TrioWriteDouble(trio_T *self, |
| long double longdoubleNumber, |
| int flags, |
| int width, |
| int precision, |
| int base) |
| { |
| int charsPerThousand; |
| int length; |
| double number; |
| double precisionPower; |
| double workNumber; |
| int integerDigits; |
| int fractionDigits; |
| int exponentDigits; |
| int visibleDigits; |
| int expectedWidth; |
| int exponent; |
| unsigned int uExponent; |
| double dblBase; |
| BOOLEAN_T isNegative; |
| BOOLEAN_T isExponentNegative = FALSE; |
| BOOLEAN_T isHex; |
| const char *digits; |
| char numberBuffer[MAX_CHARS_IN(double) |
| * MAX_LOCALE_SEPARATOR_LENGTH |
| * MAX_LOCALE_GROUPS]; |
| char *numberPointer; |
| char exponentBuffer[MAX_CHARS_IN(double)]; |
| char *exponentPointer; |
| int groupingIndex; |
| char *work; |
| int i; |
| BOOLEAN_T onlyzero; |
| |
| assert(VALID(self)); |
| assert(VALID(self->OutStream)); |
| assert(base == BASE_DECIMAL || base == BASE_HEX); |
| |
| number = (double)longdoubleNumber; |
| |
| #if defined(USE_INFINITE) |
| /* Handle infinite numbers and non-a-number first */ |
| switch (IS_INFINITE(number)) |
| { |
| case 1: |
| TrioWriteString(self, |
| (flags & FLAGS_UPPER) |
| ? INFINITE_UPPER |
| : INFINITE_LOWER, |
| flags, width, precision); |
| return; |
| |
| case -1: |
| TrioWriteString(self, |
| (flags & FLAGS_UPPER) |
| ? "-" INFINITE_UPPER |
| : "-" INFINITE_LOWER, |
| flags, width, precision); |
| return; |
| |
| default: |
| break; |
| } |
| #endif |
| #if defined(USE_NAN) |
| if (IS_NAN(number)) |
| { |
| TrioWriteString(self, |
| (flags & FLAGS_UPPER) |
| ? NAN_UPPER |
| : NAN_LOWER, |
| 0, 0, 0, 0, 0); |
| return; |
| } |
| #endif |
| |
| /* Normal numbers */ |
| digits = (flags & FLAGS_UPPER) ? globalDigitsUpper : globalDigitsLower; |
| isHex = (base == BASE_HEX); |
| dblBase = (double)base; |
| |
| if (precision == NO_PRECISION) |
| precision = FLT_DIG; |
| precisionPower = pow(10.0, (double)precision); |
| |
| isNegative = (number < 0.0); |
| if (isNegative) |
| number = -number; |
| |
| if ((flags & FLAGS_FLOAT_G) || isHex) |
| { |
| if ((number < 1.0e-4) || (number > precisionPower)) |
| flags |= FLAGS_FLOAT_E; |
| #if defined(TRIO_UNIX98) |
| if (precision == 0) |
| precision = 1; |
| #endif |
| } |
| |
| if (flags & FLAGS_FLOAT_E) |
| { |
| /* Scale the number */ |
| workNumber = log10(number); |
| if (workNumber == -HUGE_VAL) |
| { |
| exponent = 0; |
| /* Undo setting */ |
| if (flags & FLAGS_FLOAT_G) |
| flags &= ~FLAGS_FLOAT_E; |
| } |
| else |
| { |
| exponent = (int)floor(workNumber); |
| number /= pow(10.0, (double)exponent); |
| isExponentNegative = (exponent < 0); |
| uExponent = (isExponentNegative) ? -exponent : exponent; |
| /* No thousand separators */ |
| flags &= ~FLAGS_QUOTE; |
| } |
| } |
| |
| /* |
| * Truncated number. |
| * |
| * precision is number of significant digits for FLOAT_G |
| * and number of fractional digits for others |
| */ |
| integerDigits = (number > DBL_EPSILON) |
| ? 1 + (int)log10(floor(number)) |
| : 1; |
| fractionDigits = (flags & FLAGS_FLOAT_G) |
| ? precision - integerDigits |
| : precision; |
| number = floor(0.5 + number * pow(10.0, (double)fractionDigits)); |
| if ((int)log10(number) + 1 > integerDigits + fractionDigits) |
| { |
| /* Adjust if number was rounded up one digit (ie. 99 to 100) */ |
| integerDigits++; |
| } |
| visibleDigits = integerDigits + fractionDigits; |
| |
| /* Build the fraction part */ |
| numberPointer = &numberBuffer[sizeof(numberBuffer) - 1]; |
| *numberPointer = NIL; |
| onlyzero = TRUE; |
| for (i = 0; i < fractionDigits; i++) |
| { |
| *(--numberPointer) = digits[(int)fmod(number, dblBase)]; |
| number = floor(number / dblBase); |
| |
| /* Prune trailing zeroes */ |
| if (numberPointer[0] != digits[0]) |
| onlyzero = FALSE; |
| else if (onlyzero && (numberPointer[0] == digits[0])) |
| numberPointer++; |
| } |
| |
| /* Insert decimal point */ |
| if ((flags & FLAGS_ALTERNATIVE) || ((fractionDigits > 0) && !onlyzero)) |
| { |
| i = StrLength(globalDecimalPoint); |
| while (i> 0) |
| { |
| *(--numberPointer) = globalDecimalPoint[--i]; |
| } |
| } |
| /* Insert the integer part and thousand separators */ |
| charsPerThousand = (int)globalGrouping[0]; |
| groupingIndex = 1; |
| for (i = 1; i < integerDigits + 1; i++) |
| { |
| *(--numberPointer) = digits[(int)fmod(number, dblBase)]; |
| number = floor(number / dblBase); |
| if (number < DBL_EPSILON) |
| break; |
| |
| if ((i > 0) |
| && ((flags & (FLAGS_FLOAT_E | FLAGS_QUOTE)) == FLAGS_QUOTE) |
| && (charsPerThousand != NO_GROUPING) |
| && (i % charsPerThousand == 0)) |
| { |
| /* |
| * We are building the number from the least significant |
| * to the most significant digit, so we have to copy the |
| * thousand separator backwards |
| */ |
| length = StrLength(globalThousandSeparator); |
| integerDigits += length; |
| if (((int)(numberPointer - numberBuffer) - length) > 0) |
| { |
| work = &globalThousandSeparator[length - 1]; |
| while (length-- > 0) |
| *(--numberPointer) = *work--; |
| } |
| |
| /* Advance to next grouping number */ |
| if (charsPerThousand != NO_GROUPING) |
| { |
| switch (globalGrouping[groupingIndex]) |
| { |
| case CHAR_MAX: /* Disable grouping */ |
| charsPerThousand = NO_GROUPING; |
| break; |
| case 0: /* Repeat last group */ |
| break; |
| default: |
| charsPerThousand = (int)globalGrouping[groupingIndex++]; |
| break; |
| } |
| } |
| } |
| } |
| |
| /* Build the exponent */ |
| exponentDigits = 0; |
| if (flags & FLAGS_FLOAT_E) |
| { |
| exponentPointer = &exponentBuffer[sizeof(exponentBuffer) - 1]; |
| *exponentPointer-- = NIL; |
| do { |
| *exponentPointer-- = digits[uExponent % base]; |
| uExponent /= base; |
| exponentDigits++; |
| } while (uExponent); |
| } |
| |
| /* Calculate expected width. |
| * sign + integer part + thousands separators + decimal point |
| * + fraction + exponent |
| */ |
| expectedWidth = StrLength(numberPointer); |
| if (isNegative || (flags & FLAGS_SHOWSIGN)) |
| expectedWidth += sizeof("-") - 1; |
| if (exponentDigits > 0) |
| expectedWidth += exponentDigits + sizeof("E+") - 1; |
| if (isExponentNegative) |
| expectedWidth += sizeof('-') - 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, '+'); |
| 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, '+'); |
| if (isHex) |
| { |
| self->OutStream(self, '0'); |
| self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x'); |
| } |
| } |
| /* Output number */ |
| for (i = 0; numberPointer[i]; i++) |
| { |
| self->OutStream(self, numberPointer[i]); |
| } |
| /* Output exponent */ |
| if (exponentDigits > 0) |
| { |
| self->OutStream(self, |
| isHex |
| ? ((flags & FLAGS_UPPER) ? 'P' : 'p') |
| : ((flags & FLAGS_UPPER) ? 'E' : 'e')); |
| self->OutStream(self, (isExponentNegative) ? '-' : '+'); |
| for (i = 0; i < exponentDigits; i++) |
| { |
| self->OutStream(self, exponentPointer[i + 1]); |
| } |
| } |
| /* Output trailing spaces */ |
| if (flags & FLAGS_LEFTADJUST) |
| { |
| for (i = expectedWidth; i < width; i++) |
| { |
| self->OutStream(self, CHAR_ADJUST); |
| } |
| } |
| } |
| |
| /************************************************************************* |
| * TrioFormat [private] |
| * |
| * Description: |
| * This is the main engine for formatting output |
| */ |
| static int |
| TrioFormat(void *destination, |
| size_t destinationSize, |
| void (*OutStream)(trio_T *, int), |
| const char *format, |
| va_list args) |
| { |
| #if defined(USE_MULTIBYTE) |
| int charlen; |
| #endif |
| int status; |
| parameter_T parameters[MAX_PARAMETERS]; |
| trio_T internalData; |
| trio_T *data; |
| int i; |
| const char *string; |
| void *pointer; |
| int flags; |
| int width; |
| int precision; |
| int base; |
| int index; |
| ULONGLONG number; |
| |
| assert(VALID(OutStream)); |
| assert(VALID(format)); |
| assert(VALID(args)); |
| |
| /* memset(¶meters, 0, sizeof(parameters)); */ |
| memset(&internalData, 0, sizeof(internalData)); |
| data = &internalData; |
| data->OutStream = OutStream; |
| data->location = destination; |
| data->max = destinationSize; |
| |
| #if defined(USE_LOCALE) |
| if (NULL == globalLocaleValues) |
| { |
| TrioSetLocale(); |
| } |
| #endif |
| |
| status = TrioPreprocess(TYPE_PRINT, format, parameters, args); |
| if (status < 0) |
| return status; |
| |
| index = 0; |
| i = 0; |
| #if defined(USE_MULTIBYTE) |
| mblen(NULL, 0); |
| #endif |
| |
| while (format[index]) |
| { |
| #if defined(USE_MULTIBYTE) |
| if (! isascii(format[index])) |
| { |
| charlen = mblen(&format[index], MB_LEN_MAX); |
| while (charlen-- > 0) |
| { |
| OutStream(data, format[index++]); |
| } |
| continue; /* while */ |
| } |
| #endif |
| if (CHAR_IDENTIFIER == format[index]) |
| { |
| if (CHAR_IDENTIFIER == format[index + 1]) |
| { |
| 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.asSigned; |
| } |
| |
| /* 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.asSigned; |
| } |
| } |
| 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.asSigned; |
| } |
| |
| switch (parameters[i].type) |
| { |
| case FORMAT_CHAR: |
| if (flags & FLAGS_QUOTE) |
| OutStream(data, CHAR_QUOTE); |
| if (! (flags & FLAGS_LEFTADJUST)) |
| { |
| while (--width > 0) |
| OutStream(data, CHAR_ADJUST); |
| } |
| |
| OutStream(data, (char)parameters[i].data.number.asSigned); |
| |
| if (flags & FLAGS_LEFTADJUST) |
| { |
| while(--width > 0) |
| OutStream(data, CHAR_ADJUST); |
| } |
| if (flags & FLAGS_QUOTE) |
| OutStream(data, CHAR_QUOTE); |
| |
| break; /* FORMAT_CHAR */ |
| |
| case FORMAT_INT: |
| if (base == NO_BASE) |
| base = BASE_DECIMAL; |
| |
| TrioWriteNumber(data, |
| parameters[i].data.number.asUnsigned, |
| 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: |
| TrioWriteString(data, |
| parameters[i].data.string, |
| flags, |
| width, |
| precision); |
| break; /* FORMAT_STRING */ |
| |
| case FORMAT_POINTER: |
| pointer = parameters[i].data.pointer; |
| if (NULL == pointer) |
| { |
| string = null; |
| while (*string) |
| OutStream(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 |
| * optimising compiler). The (char *) casting is done |
| * to please ANSI C++. |
| */ |
| number = (ULONGLONG)((char *)parameters[i].data.pointer |
| - (char *)0); |
| /* Shrink to size of pointer */ |
| number &= (ULONGLONG)-1; |
| flags |= (FLAGS_UNSIGNED | FLAGS_ALTERNATIVE | |
| FLAGS_NILPADDING); |
| TrioWriteNumber(data, |
| number, |
| flags, |
| POINTER_WIDTH, |
| precision, |
| BASE_HEX); |
| } |
| 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) |
| *(intmax_t *)pointer = (intmax_t)data->committed; |
| else |
| #endif |
| if (flags & FLAGS_QUAD) |
| { |
| *(ULONGLONG int *)pointer = (ULONGLONG)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 = StrError(parameters[i].data.errorNumber); |
| if (string) |
| { |
| TrioWriteString(data, |
| string, |
| flags, |
| width, |
| precision); |
| } |
| else |
| { |
| OutStream(data, '#'); |
| TrioWriteNumber(data, |
| (LONGEST)parameters[i].data.errorNumber, |
| flags, |
| width, |
| precision, |
| BASE_DECIMAL); |
| } |
| break; /* FORMAT_ERRNO */ |
| #endif |
| |
| default: |
| break; |
| } /* switch parameter type */ |
| |
| /* Prepare for next */ |
| index = parameters[i].indexAfterSpecifier; |
| i++; |
| } |
| } |
| else /* not identifier */ |
| { |
| OutStream(data, format[index++]); |
| } |
| } |
| |
| return data->processed; |
| } |
| |
| /************************************************************************* |
| * TrioOutStreamFile [private] |
| */ |
| static void |
| TrioOutStreamFile(trio_T *self, int output) |
| { |
| FILE *file = (FILE *)self->location; |
| |
| assert(VALID(self)); |
| assert(VALID(file)); |
| |
| self->processed++; |
| self->committed++; |
| (void)fputc(output, file); |
| } |
| |
| /************************************************************************* |
| * TrioOutStreamFileDescriptor [private] |
| */ |
| static void |
| TrioOutStreamFileDescriptor(trio_T *self, int output) |
| { |
| int fd = *((int *)self->location); |
| char ch; |
| |
| assert(VALID(self)); |
| |
| ch = (char)output; |
| (void)write(fd, &ch, sizeof(char)); |
| self->processed++; |
| self->committed++; |
| } |
| |
| /************************************************************************* |
| * TrioOutStreamString [private] |
| */ |
| static void |
| TrioOutStreamString(trio_T *self, int output) |
| { |
| char **buffer = (char **)self->location; |
| |
| assert(VALID(self)); |
| assert(VALID(buffer)); |
| |
| **buffer = (char)output; |
| (*buffer)++; |
| self->processed++; |
| self->committed++; |
| } |
| |
| /************************************************************************* |
| * TrioOutStreamStringMax [private] |
| */ |
| static void |
| TrioOutStreamStringMax(trio_T *self, int output) |
| { |
| char **buffer; |
| |
| assert(VALID(self)); |
| buffer = (char **)self->location; |
| assert(VALID(buffer)); |
| |
| if (self->processed < self->max) |
| { |
| **buffer = (char)output; |
| (*buffer)++; |
| self->committed++; |
| } |
| self->processed++; |
| } |
| |
| /************************************************************************* |
| * TrioOutStreamStringDynamic [private] |
| */ |
| #define DYNAMIC_START_SIZE 32 |
| struct dynamicBuffer { |
| char *buffer; |
| size_t length; |
| size_t allocated; |
| }; |
| |
| static void |
| TrioOutStreamStringDynamic(trio_T *self, int output) |
| { |
| struct dynamicBuffer *infop; |
| |
| assert(VALID(self)); |
| assert(VALID(self->location)); |
| |
| infop = (struct dynamicBuffer *)self->location; |
| |
| if (infop->buffer == NULL) |
| { |
| /* Start with a reasonable size */ |
| infop->buffer = (char *)malloc(DYNAMIC_START_SIZE); |
| if (infop->buffer == NULL) |
| return; /* fail */ |
| |
| infop->allocated = DYNAMIC_START_SIZE; |
| self->processed = 0; |
| self->committed = 0; |
| } |
| else if (self->committed + sizeof(NIL) >= infop->allocated) |
| { |
| char *newptr; |
| |
| /* Allocate increasing chunks */ |
| newptr = (char *)realloc(infop->buffer, infop->allocated * 2); |
| |
| if (newptr == NULL) |
| return; |
| |
| infop->buffer = newptr; |
| infop->allocated *= 2; |
| } |
| |
| infop->buffer[self->committed] = output; |
| self->committed++; |
| self->processed++; |
| |
| infop->length = self->committed; |
| } |
| |
| #ifndef HAVE_PRINTF |
| /************************************************************************* |
| * trio_printf |
| */ |
| int |
| printf(const char *format, ...) |
| { |
| int status; |
| va_list args; |
| |
| assert(VALID(format)); |
| |
| va_start(args, format); |
| status = TrioFormat(stdout, 0, TrioOutStreamFile, format, args); |
| va_end(args); |
| return status; |
| } |
| #endif |
| |
| #ifndef HAVE_FPRINTF |
| /************************************************************************* |
| * trio_fprintf |
| */ |
| int |
| fprintf(FILE *file, const char *format, ...) |
| { |
| int status; |
| va_list args; |
| |
| assert(VALID(file)); |
| assert(VALID(format)); |
| |
| va_start(args, format); |
| status = TrioFormat(file, 0, TrioOutStreamFile, format, args); |
| va_end(args); |
| return status; |
| } |
| #endif |
| |
| #ifndef HAVE_VFPRINTF |
| /************************************************************************* |
| * trio_vfprintf |
| */ |
| int |
| vfprintf(FILE *file, const char *format, va_list args) |
| { |
| assert(VALID(file)); |
| assert(VALID(format)); |
| assert(VALID(args)); |
| |
| return TrioFormat(file, 0, TrioOutStreamFile, format, args); |
| } |
| #endif |
| |
| #ifndef HAVE_SPRINTF |
| /************************************************************************* |
| * trio_sprintf |
| */ |
| int |
| sprintf(char *buffer, const char *format, ...) |
| { |
| int status; |
| va_list args; |
| |
| assert(VALID(buffer)); |
| assert(VALID(format)); |
| |
| va_start(args, format); |
| status = TrioFormat(&buffer, 0, TrioOutStreamString, format, args); |
| *buffer = NIL; /* Terminate with NIL character */ |
| va_end(args); |
| return status; |
| } |
| #endif |
| |
| #ifndef HAVE_VSPRINTF |
| /************************************************************************* |
| * trio_vsprintf |
| */ |
| int |
| vsprintf(char *buffer, const char *format, va_list args) |
| { |
| int status; |
| |
| assert(VALID(buffer)); |
| assert(VALID(format)); |
| assert(VALID(args)); |
| |
| status = TrioFormat(&buffer, 0, TrioOutStreamString, format, args); |
| *buffer = NIL; |
| return status; |
| } |
| #endif |
| |
| #ifndef HAVE_SNPRINTF |
| /************************************************************************* |
| * trio_snprintf |
| */ |
| int |
| snprintf(char *buffer, size_t bufferSize, const char *format, ...) |
| { |
| int status; |
| va_list args; |
| |
| assert(VALID(buffer)); |
| assert(VALID(format)); |
| |
| va_start(args, format); |
| status = TrioFormat(&buffer, bufferSize > 0 ? bufferSize - 1 : 0, |
| TrioOutStreamStringMax, format, args); |
| if (bufferSize > 0) |
| *buffer = NIL; |
| va_end(args); |
| return status; |
| } |
| #endif |
| |
| #ifndef HAVE_VSNPRINTF |
| /************************************************************************* |
| * trio_vsnprintf |
| */ |
| int |
| vsnprintf(char *buffer, size_t bufferSize, const char *format, |
| va_list args) |
| { |
| int status; |
| |
| assert(VALID(buffer)); |
| assert(VALID(format)); |
| assert(VALID(args)); |
| |
| status = TrioFormat(&buffer, bufferSize > 0 ? bufferSize - 1 : 0, |
| TrioOutStreamStringMax, format, args); |
| if (bufferSize > 0) |
| *buffer = NIL; |
| return status; |
| } |
| #endif |
| |
| /************************************************************************* |
| * |
| * SCANNING |
| * |
| ************************************************************************/ |
| |
| /* DV for libxml */ |
| #ifndef HAVE_SSCANF |
| |
| /************************************************************************* |
| * TrioSkipWhitespaces [private] |
| */ |
| static int |
| TrioSkipWhitespaces(trio_T *self) |
| { |
| int ch; |
| |
| ch = self->current; |
| while (isspace(ch)) |
| { |
| self->InStream(self, &ch); |
| } |
| return ch; |
| } |
| |
| /************************************************************************* |
| * TrioGetCharacterClass [private] |
| * |
| * FIXME: |
| * multibyte |
| */ |
| static int |
| TrioGetCharacterClass(const char *format, |
| int *indexPointer, |
| int *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; |
| |
| case QUALIFIER_COLON: /* Character class expressions */ |
| |
| if (StrEqualMax(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 (StrEqualMax(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 (StrEqualMax(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 (StrEqualMax(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 (StrEqualMax(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 (StrEqualMax(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 (StrEqualMax(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 (StrEqualMax(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 (StrEqualMax(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 (StrEqualMax(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 (StrEqualMax(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; |
| } |
| } |
| return 0; |
| } |
| |
| /************************************************************************* |
| * TrioReadNumber [private] |
| * |
| * We implement our own number conversion in preference of strtol and |
| * strtoul, because we must handle 'long long' and thousand separators. |
| */ |
| static BOOLEAN_T |
| TrioReadNumber(trio_T *self, LONGEST *target, int flags, int width, int base) |
| { |
| LONGEST number = 0; |
| int digit; |
| int count; |
| BOOLEAN_T isNegative = FALSE; |
| int j; |
| |
| assert(VALID(self)); |
| assert(VALID(self->InStream)); |
| assert((base >= MIN_BASE && base <= MAX_BASE) || (base == NO_BASE)); |
| |
| 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) && |
| (toupper(self->current) == 'X')) |
| { |
| self->InStream(self, NULL); |
| } |
| else if ((base == BASE_BINARY) && |
| (toupper(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 = globalDigitArray[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; globalThousandSeparator[j] && self->current; j++) |
| { |
| if (globalThousandSeparator[j] != self->current) |
| break; |
| |
| self->InStream(self, NULL); |
| } |
| if (globalThousandSeparator[j]) |
| break; /* Mismatch */ |
| else |
| continue; /* Match */ |
| } |
| else |
| break; |
| |
| number *= base; |
| number += digit; |
| |
| self->InStream(self, NULL); |
| } |
| |
| /* Was anything read at all? */ |
| if (self->processed == count) |
| return FALSE; |
| |
| if (target) |
| *target = (isNegative) ? -number : number; |
| return TRUE; |
| } |
| |
| /************************************************************************* |
| * TrioReadChar [private] |
| */ |
| static BOOLEAN_T |
| TrioReadChar(trio_T *self, char *target, int width) |
| { |
| int i; |
| |
| assert(VALID(self)); |
| assert(VALID(self->InStream)); |
| |
| for (i = 0; |
| (self->current != EOF) && (i < width); |
| i++) |
| { |
| if (target) |
| target[i] = self->current; |
| self->InStream(self, NULL); |
| } |
| return TRUE; |
| } |
| |
| /************************************************************************* |
| * TrioReadString [private] |
| */ |
| static BOOLEAN_T |
| TrioReadString(trio_T *self, char *target, int flags, int width) |
| { |
| int i; |
| char ch; |
| LONGEST number; |
| |
| 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++) |
| { |
| ch = self->current; |
| if ((flags & FLAGS_ALTERNATIVE) && (ch == CHAR_BACKSLASH)) |
| { |
| self->InStream(self, NULL); |
| switch (self->current) |
| { |
| case 'a': |
| ch = '\a'; |
| 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; |
| case '\\': |
| ch = '\\'; |
| break; |
| default: |
| if (isdigit(self->current)) |
| { |
| /* Read octal number */ |
| if (!TrioReadNumber(self, &number, 0, 3, BASE_OCTAL)) |
| return FALSE; |
| ch = (char)number; |
| } |
| else if (toupper(self->current) == 'X') |
| { |
| /* Read hexadecimal number */ |
| self->InStream(self, NULL); |
| if (!TrioReadNumber(self, &number, 0, 2, BASE_HEX)) |
| return FALSE; |
| ch = (char)number; |
| } |
| else |
| { |
| ch = self->current; |
| } |
| break; |
| } |
| } |
| if (target) |
| target[i] = ch; |
| self->InStream(self, NULL); |
| } |
| if (target) |
| target[i] = NIL; |
| return TRUE; |
| } |
| |
| /************************************************************************* |
| * TrioReadGroup [private] |
| * |
| * FIXME: characterclass does not work with multibyte characters |
| */ |
| static BOOLEAN_T |
| TrioReadGroup(trio_T *self, |
| char *target, |
| int *characterclass, |
| int flags, |
| int width) |
| { |
| unsigned 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 [private] |
| * |
| * FIXME: |
| * add hex-float format |
| * add long double |
| */ |
| static BOOLEAN_T |
| TrioReadDouble(trio_T *self, |
| double *target, |
| int flags, |
| int width) |
| { |
| int ch; |
| char doubleString[512] = ""; |
| int index = 0; |
| int start; |
| |
| if ((width == NO_WIDTH) || (width > sizeof(doubleString) - 1)) |
| width = sizeof(doubleString) - 1; |
| |
| TrioSkipWhitespaces(self); |
| |
| /* Read entire double number from stream. StrToDouble 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++] = ch; |
| self->InStream(self, &ch); |
| width--; |
| } |
| |
| start = index; |
| #if defined(USE_INFINITE) || defined(USE_NAN) |
| switch (ch) |
| { |
| #if defined(USE_NAN) |
| case 'n': |
| case 'N': |
| /* Not-a-number */ |
| if (index != 0) |
| break; |
| /* FALLTHROUGH */ |
| #endif |
| case 'i': |
| case 'I': |
| /* Infinity */ |
| while (isalpha(ch) && (index - start < width)) |
| { |
| doubleString[index++] = ch; |
| self->InStream(self, &ch); |
| } |
| doubleString[index] = NIL; |
| |
| #if defined(USE_INFINITE) |
| /* Case insensitive string comparison */ |
| if (StrEqual(&doubleString[start], INFINITE_UPPER) || |
| StrEqual(&doubleString[start], LONG_INFINITE_UPPER)) |
| { |
| *target = ((start == 1 && doubleString[0] == '-')) |
| ? -HUGE_VAL |
| : HUGE_VAL; |
| return TRUE; |
| } |
| #endif |
| #if defined(USE_NAN) |
| if (StrEqual(doubleString, NAN_LOWER)) |
| { |
| /* NaN must not have a preceeding + nor - */ |
| *target = NAN; |
| return TRUE; |
| } |
| #endif |
| return FALSE; |
| |
| default: |
| break; |
| } |
| #endif |
| |
| while (isdigit(ch) && (index - start < width)) |
| { |
| /* Integer part */ |
| doubleString[index++] = ch; |
| self->InStream(self, &ch); |
| } |
| if (ch == '.') |
| { |
| /* Decimal part */ |
| doubleString[index++] = ch; |
| self->InStream(self, &ch); |
| while (isdigit(ch) && (index - start < width)) |
| { |
| doubleString[index++] = ch; |
| self->InStream(self, &ch); |
| } |
| if ((ch == 'e') || (ch == 'E')) |
| { |
| /* Exponent */ |
| doubleString[index++] = ch; |
| self->InStream(self, &ch); |
| if ((ch == '+') || (ch == '-')) |
| { |
| doubleString[index++] = ch; |
| self->InStream(self, &ch); |
| } |
| while (isdigit(ch) && (index - start < width)) |
| { |
| doubleString[index++] = ch; |
| self->InStream(self, &ch); |
| } |
| } |
| } |
| |
| if ((index == start) || (*doubleString == NIL)) |
| return FALSE; |
| |
| if (flags & FLAGS_LONGDOUBLE) |
| /* *longdoublePointer = StrToLongDouble()*/; |
| else |
| { |
| *target = StrToDouble(doubleString, NULL); |
| } |
| return TRUE; |
| } |
| |
| /************************************************************************* |
| * TrioReadPointer [private] |
| */ |
| static BOOLEAN_T |
| TrioReadPointer(trio_T *self, void **target, int flags) |
| { |
| LONGEST number; |
| char buffer[sizeof(null)]; |
| |
| flags |= (FLAGS_UNSIGNED | FLAGS_ALTERNATIVE | FLAGS_NILPADDING); |
| |
| if (TrioReadNumber(self, |
| &number, |
| flags, |
| POINTER_WIDTH, |
| BASE_HEX)) |
| { |
| /* The addition is a workaround for a compiler warning */ |
| if (target) |
| *target = (void *)0 + number; |
| return TRUE; |
| } |
| else if (TrioReadString(self, |
| (flags & FLAGS_IGNORE) |
| ? NULL |
| : buffer, |
| 0, |
| sizeof(null) - 1)) |
| { |
| if (StrEqualCase(buffer, null)) |
| { |
| if (target) |
| *target = NULL; |
| return TRUE; |
| } |
| } |
| return FALSE; |
| } |
| |
| /************************************************************************* |
| * TrioScan [private] |
| */ |
| static int |
| TrioScan(void *source, |
| size_t sourceSize, |
| void (*InStream)(trio_T *, int *), |
| const char *format, |
| va_list args) |
| { |
| #if defined(USE_MULTIBYTE) |
| int charlen; |
| #endif |
| int status; |
| int assignment; |
| parameter_T parameters[MAX_PARAMETERS]; |
| trio_T internalData; |
| trio_T *data; |
| int ch; |
| int cnt; |
| int index; /* Index of format string */ |
| int i; /* Index of current parameter */ |
| int flags; |
| int width; |
| int base; |
| void *pointer; |
| |
| assert(VALID(InStream)); |
| assert(VALID(format)); |
| assert(VALID(args)); |
| |
| memset(&internalData, 0, sizeof(internalData)); |
| data = &internalData; |
| data->InStream = InStream; |
| data->location = source; |
| data->max = sourceSize; |
| |
| #if defined(USE_LOCALE) |
| if (NULL == globalLocaleValues) |
| { |
| TrioSetLocale(); |
| } |
| #endif |
| if (globalDigitsUnconverted) |
| { |
| memset(globalDigitArray, -1, sizeof(globalDigitArray)); |
| for (i = 0; i < sizeof(globalDigitsLower) - 1; i++) |
| { |
| globalDigitArray[(int)globalDigitsLower[i]] = i; |
| globalDigitArray[(int)globalDigitsUpper[i]] = i; |
| } |
| globalDigitsUnconverted = FALSE; |
| } |
| |
| status = TrioPreprocess(TYPE_SCAN, format, parameters, args); |
| if (status < 0) |
| return status; |
| |
| assignment = 0; |
| i = 0; |
| index = 0; |
| data->InStream(data, &ch); |
| |
| #if defined(USE_MULTIBYTE) |
| mblen(NULL, 0); |
| #endif |
| |
| while (format[index]) |
| { |
| #if defined(USE_MULTIBYTE) |
| if (! isascii(format[index])) |
| { |
| charlen = mblen(&format[index], MB_LEN_MAX); |
| /* 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 */ |
| } |
| #endif |
| if (EOF == ch) |
| return 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.asSigned; |
| } |
| /* Find base */ |
| base = parameters[i].base; |
| if (flags & FLAGS_BASE_PARAMETER) |
| { |
| /* Get base from parameter list */ |
| base = (int)parameters[base].data.number.asSigned; |
| } |
| |
| switch (parameters[i].type) |
| { |
| case FORMAT_INT: |
| { |
| LONGEST number; |
| |
| if (0 == base) |
| base = BASE_DECIMAL; |
| |
| if (!TrioReadNumber(data, |
| &number, |
| flags, |
| width, |
| base)) |
| return assignment; |
| assignment++; |
| |
| if (!(flags & FLAGS_IGNORE)) |
| { |
| 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) |
| *(intmax_t *)pointer = (intmax_t)number; |
| else |
| #endif |
| if (flags & FLAGS_QUAD) |
| *(ULONGLONG int *)pointer = (ULONGLONG)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 (!TrioReadString(data, |
| (flags & FLAGS_IGNORE) |
| ? NULL |
| : parameters[i].data.string, |
| flags, |
| width)) |
| return assignment; |
| assignment++; |
| break; /* FORMAT_STRING */ |
| |
| case FORMAT_DOUBLE: |
| if (!TrioReadDouble(data, |
| (flags & FLAGS_IGNORE) |
| ? NULL |
| : parameters[i].data.doublePointer, |
| flags, |
| width)) |
| return assignment; |
| assignment++; |
| break; /* FORMAT_DOUBLE */ |
| |
| case FORMAT_GROUP: |
| { |
| int characterclass[MAX_CHARACTER_CLASS + 1]; |
| int rc; |
| |
| index += 2; |
| 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; |
| assignment++; |
| } |
| break; /* FORMAT_GROUP */ |
| |
| case FORMAT_COUNT: |
| pointer = parameters[i].data.pointer; |
| if (NULL != pointer) |
| { |
| #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) |
| *(intmax_t *)pointer = (intmax_t)data->committed; |
| else |
| #endif |
| if (flags & FLAGS_QUAD) |
| { |
| *(ULONGLONG int *)pointer = (ULONGLONG)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_CHAR: |
| if (!TrioReadChar(data, |
| (flags & FLAGS_IGNORE) |
| ? NULL |
| : parameters[i].data.string, |
| (width == NO_WIDTH) ? 1 : width)) |
| return assignment; |
| assignment++; |
| break; /* FORMAT_CHAR */ |
| |
| case FORMAT_POINTER: |
| if (!TrioReadPointer(data, |
| (flags & FLAGS_IGNORE) |
| ? NULL |
| : parameters[i].data.pointer, |
| flags)) |
| return assignment; |
| 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 TRIO_ERROR_RETURN(TRIO_EINVAL, index); |
| |
| index++; |
| } |
| } |
| return assignment; |
| } |
| |
| /************************************************************************* |
| * TrioInStreamFile [private] |
| */ |
| static void |
| TrioInStreamFile(trio_T *self, int *intPointer) |
| { |
| FILE *file = (FILE *)self->location; |
| |
| assert(VALID(self)); |
| assert(VALID(file)); |
| |
| self->current = fgetc(file); |
| self->processed++; |
| self->committed++; |
| |
| if (VALID(intPointer)) |
| { |
| *intPointer = self->current; |
| } |
| } |
| |
| /************************************************************************* |
| * TrioInStreamFileDescriptor [private] |
| */ |
| static void |
| TrioInStreamFileDescriptor(trio_T *self, int *intPointer) |
| { |
| int fd = *((int *)self->location); |
| int size; |
| unsigned char input; |
| |
| assert(VALID(self)); |
| |
| size = read(fd, &input, sizeof(char)); |
| self->current = (size == 0) ? EOF : input; |
| self->processed++; |
| self->committed++; |
| |
| if (VALID(intPointer)) |
| { |
| *intPointer = self->current; |
| } |
| } |
| |
| /************************************************************************* |
| * TrioInStreamString [private] |
| */ |
| static void |
| TrioInStreamString(trio_T *self, int *intPointer) |
| { |
| unsigned char **buffer; |
| |
| assert(VALID(self)); |
| assert(VALID(self->InStream)); |
| assert(VALID(self->location)); |
| |
| buffer = (unsigned char **)self->location; |
| self->current = (*buffer)[0]; |
| if (self->current == NIL) |
| self->current = EOF; |
| (*buffer)++; |
| self->processed++; |
| self->committed++; |
| |
| if (VALID(intPointer)) |
| { |
| *intPointer = self->current; |
| } |
| } |
| |
| /************************************************************************* |
| * trio_sscanf |
| */ |
| int |
| sscanf(const char *buffer, const char *format, ...) |
| { |
| int status; |
| va_list args; |
| |
| assert(VALID(buffer)); |
| assert(VALID(format)); |
| |
| va_start(args, format); |
| status = TrioScan(&buffer, 0, TrioInStreamString, format, args); |
| va_end(args); |
| return status; |
| } |
| |
| /* DV for libxml */ |
| #endif /* !HAVE_SSCANF */ |
| #endif /* WITH_TRIO */ |