mirror of
https://github.com/reactos/reactos.git
synced 2025-08-06 20:13:04 +00:00
1033 lines
27 KiB
C
1033 lines
27 KiB
C
/*
|
|
* COPYRIGHT: GNU GPL, see COPYING in the top level directory
|
|
* PROJECT: ReactOS crt library
|
|
* FILE: lib/sdk/crt/printf/streamout.c
|
|
* PURPOSE: Implementation of streamout
|
|
* PROGRAMMERS: Timo Kreuzer
|
|
* Katayama Hirofumi MZ
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include <tchar.h>
|
|
#include <strings.h>
|
|
#include <math.h>
|
|
#include <float.h>
|
|
#include <limits.h>
|
|
#include <minmax.h>
|
|
|
|
#if DBG && defined(_MSC_VER)
|
|
#define assert(x) if (!(x)) __int2c()
|
|
#else
|
|
#define assert(x)
|
|
#endif
|
|
|
|
#ifdef _UNICODE
|
|
# define streamout wstreamout
|
|
# define format_float format_floatw
|
|
#endif
|
|
|
|
#define MB_CUR_MAX 10
|
|
#define BUFFER_SIZE (32 + 17)
|
|
|
|
int mbtowc(wchar_t *wchar, const char *mbchar, size_t count);
|
|
int wctomb(char *mbchar, wchar_t wchar);
|
|
|
|
typedef struct _STRING
|
|
{
|
|
unsigned short Length;
|
|
unsigned short MaximumLength;
|
|
void *Buffer;
|
|
} STRING;
|
|
|
|
enum
|
|
{
|
|
/* Formatting flags */
|
|
FLAG_ALIGN_LEFT = 0x01,
|
|
FLAG_FORCE_SIGN = 0x02,
|
|
FLAG_FORCE_SIGNSP = 0x04,
|
|
FLAG_PAD_ZERO = 0x08,
|
|
FLAG_SPECIAL = 0x10,
|
|
|
|
/* Data format flags */
|
|
FLAG_SHORT = 0x100,
|
|
FLAG_LONG = 0x200,
|
|
FLAG_WIDECHAR = FLAG_LONG,
|
|
FLAG_INT64 = 0x400,
|
|
#ifdef _WIN64
|
|
FLAG_INTPTR = FLAG_INT64,
|
|
#else
|
|
FLAG_INTPTR = 0,
|
|
#endif
|
|
FLAG_LONGDOUBLE = 0x800,
|
|
};
|
|
|
|
#define va_arg_f(argptr, flags) \
|
|
(flags & FLAG_INT64) ? va_arg(argptr, __int64) : \
|
|
(flags & FLAG_SHORT) ? (short)va_arg(argptr, int) : \
|
|
va_arg(argptr, int)
|
|
|
|
#define va_arg_fu(argptr, flags) \
|
|
(flags & FLAG_INT64) ? va_arg(argptr, unsigned __int64) : \
|
|
(flags & FLAG_SHORT) ? (unsigned short)va_arg(argptr, int) : \
|
|
va_arg(argptr, unsigned int)
|
|
|
|
#define round(x) floor((x) + 0.5)
|
|
|
|
static
|
|
int
|
|
streamout_char(FILE *stream, int chr)
|
|
{
|
|
#if !defined(_USER32_WSPRINTF)
|
|
if ((stream->_flag & _IOSTRG) && (stream->_base == NULL))
|
|
return 1;
|
|
#endif
|
|
#if defined(_USER32_WSPRINTF) || defined(_LIBCNT_)
|
|
/* Check if the buffer is full */
|
|
if (stream->_cnt < sizeof(TCHAR))
|
|
return 0;
|
|
|
|
*(TCHAR*)stream->_ptr = chr;
|
|
stream->_ptr += sizeof(TCHAR);
|
|
stream->_cnt -= sizeof(TCHAR);
|
|
|
|
return 1;
|
|
#else
|
|
return _fputtc((TCHAR)chr, stream) != _TEOF;
|
|
#endif
|
|
}
|
|
|
|
static
|
|
int
|
|
streamout_astring(FILE *stream, const char *string, size_t count)
|
|
{
|
|
TCHAR chr;
|
|
int written = 0;
|
|
|
|
#if !defined(_USER32_WSPRINTF)
|
|
if ((stream->_flag & _IOSTRG) && (stream->_base == NULL))
|
|
return (int)count;
|
|
#endif
|
|
|
|
while (count--)
|
|
{
|
|
#ifdef _UNICODE
|
|
int len;
|
|
if ((len = mbtowc(&chr, string, MB_CUR_MAX)) < 1) break;
|
|
string += len;
|
|
#else
|
|
chr = *string++;
|
|
#endif
|
|
if (streamout_char(stream, chr) == 0) return -1;
|
|
written++;
|
|
}
|
|
|
|
return written;
|
|
}
|
|
|
|
static
|
|
int
|
|
streamout_wstring(FILE *stream, const wchar_t *string, size_t count)
|
|
{
|
|
wchar_t chr;
|
|
int written = 0;
|
|
|
|
#if defined(_UNICODE) && !defined(_USER32_WSPRINTF)
|
|
if ((stream->_flag & _IOSTRG) && (stream->_base == NULL))
|
|
return (int)count;
|
|
#endif
|
|
|
|
while (count--)
|
|
{
|
|
#ifndef _UNICODE
|
|
char mbchar[MB_CUR_MAX], *ptr = mbchar;
|
|
int mblen;
|
|
|
|
mblen = wctomb(mbchar, *string++);
|
|
if (mblen <= 0) return written;
|
|
|
|
while (chr = *ptr++, mblen--)
|
|
#else
|
|
chr = *string++;
|
|
#endif
|
|
{
|
|
if (streamout_char(stream, chr) == 0) return -1;
|
|
written++;
|
|
}
|
|
}
|
|
|
|
return written;
|
|
}
|
|
|
|
#ifdef _UNICODE
|
|
#define streamout_string streamout_wstring
|
|
#else
|
|
#define streamout_string streamout_astring
|
|
#endif
|
|
|
|
#ifndef _USER32_WSPRINTF
|
|
|
|
// Base 2 exponent divided by 8 is base 16 exponent
|
|
#define DBL_MAX_16_EXP (DBL_MAX_EXP / 8)
|
|
|
|
// A double has 52 fraction bits, which is 14 hex digits
|
|
#define DBL_DIG_HEX 14
|
|
|
|
#define DBL_MAX_DIGITS_10 17
|
|
#define DBL_MAX_DIGITS_16 14
|
|
|
|
static
|
|
int
|
|
get_exponent(double fpval, int base)
|
|
{
|
|
int exponent;
|
|
|
|
if (fpval == 0.)
|
|
{
|
|
exponent = 0;
|
|
}
|
|
else if (base == 10)
|
|
{
|
|
exponent = (int)floor(log10(fpval));
|
|
assert(exponent <= DBL_MAX_10_EXP);
|
|
}
|
|
else
|
|
{
|
|
unsigned __int64 fp_bits = *(unsigned __int64*)&fpval;
|
|
int exponent2 = (int)((fp_bits >> 52) & 0x7ff);
|
|
exponent2 -= 1023;
|
|
exponent = (int)(exponent2 / 8);
|
|
assert(exponent <= DBL_MAX_16_EXP);
|
|
}
|
|
|
|
return exponent;
|
|
}
|
|
|
|
static
|
|
int
|
|
get_dbl_digits(
|
|
unsigned char digit_buffer[DBL_MAX_DIGITS_10],
|
|
double fpval,
|
|
int base,
|
|
int exponent,
|
|
int *pnum_digits)
|
|
{
|
|
int num_digits = *pnum_digits;
|
|
|
|
/* Only base 10 (dec) and 16 (hex) are valid */
|
|
assert((base == 10) || (base == 16));
|
|
|
|
/* fpval must be positive! */
|
|
assert(fpval >= 0.);
|
|
|
|
/* Must fit into the buffer */
|
|
assert(num_digits <= DBL_MAX_DIGITS_10);
|
|
|
|
/* Calculate the maximum divisor */
|
|
double divisor = pow(10.0, exponent);
|
|
|
|
/* Calculate the digits */
|
|
double remainder = fpval;
|
|
for (int i = 0; i < num_digits; i++)
|
|
{
|
|
int digit = (int)(remainder / divisor);
|
|
digit_buffer[i] = digit;
|
|
remainder -= digit * divisor;
|
|
divisor /= 10.0;
|
|
}
|
|
|
|
/* Round up */
|
|
int trailing_digit = (int)(remainder / divisor);
|
|
if (trailing_digit >= 5)
|
|
{
|
|
int carry = 1;
|
|
for (int i = num_digits - 1; i >= 0; i--)
|
|
{
|
|
digit_buffer[i] += carry;
|
|
if (digit_buffer[i] == 10)
|
|
{
|
|
digit_buffer[i] = 0;
|
|
carry = 1;
|
|
}
|
|
else
|
|
{
|
|
carry = 0;
|
|
}
|
|
}
|
|
|
|
/* If we carried over the first digit, we need to shift the digits */
|
|
if (carry)
|
|
{
|
|
assert(num_digits < DBL_MAX_DIGITS_10);
|
|
for (int i = num_digits; i > 0; i--)
|
|
{
|
|
digit_buffer[i] = digit_buffer[i - 1];
|
|
}
|
|
digit_buffer[0] = 1;
|
|
exponent++;
|
|
num_digits++;
|
|
}
|
|
}
|
|
|
|
/* Strip trailing zeroes */
|
|
while ((num_digits > 0) && (digit_buffer[num_digits - 1] == 0))
|
|
{
|
|
num_digits--;
|
|
}
|
|
|
|
*pnum_digits = num_digits;
|
|
|
|
return exponent;
|
|
}
|
|
|
|
static
|
|
int
|
|
stramout_dbl_digits(
|
|
FILE* stream,
|
|
const TCHAR* dig_chars,
|
|
const char * inv_str,
|
|
unsigned int flags,
|
|
const unsigned char dig_buffer[DBL_MAX_DIGITS_10],
|
|
int num_real_digits,
|
|
int num_int_digits,
|
|
int num_frac_digits,
|
|
int first_real_digit,
|
|
char use_frac_padding)
|
|
{
|
|
int current_digit = 0;
|
|
|
|
/* Check if we need to insert a virtual 0 */
|
|
if (first_real_digit > 0)
|
|
{
|
|
/* This can only happen when exponent < 0 */
|
|
assert(num_int_digits == 1);
|
|
|
|
/* Output virtual 0 integer digit */
|
|
streamout_char(stream, dig_chars[0]);
|
|
current_digit++;
|
|
}
|
|
else
|
|
{
|
|
const int num_real_int_digits = min(num_int_digits, num_real_digits);
|
|
current_digit += num_real_int_digits;
|
|
for (int i = 0; i < num_real_int_digits; i++)
|
|
{
|
|
streamout_char(stream, dig_chars[dig_buffer[i]]);
|
|
}
|
|
|
|
/* Output optional right 0 padding */
|
|
const int right_padding = num_int_digits - num_real_int_digits;
|
|
current_digit += max(right_padding, 0);
|
|
for (int i = 0; i < right_padding; i++)
|
|
{
|
|
streamout_char(stream, '0');
|
|
}
|
|
}
|
|
|
|
/* We print the dot when there are fraction digits or the # flag was used */
|
|
if ((num_frac_digits > 0) || ((flags & FLAG_SPECIAL) != 0))
|
|
{
|
|
streamout_char(stream, '.');
|
|
}
|
|
|
|
/* Only output fraction digits, if precision is > 0 */
|
|
if (num_frac_digits > 0)
|
|
{
|
|
int num_real_frac_digits = num_real_digits - num_int_digits;
|
|
|
|
/* Check for invalid numbers */
|
|
if (inv_str != 0)
|
|
{
|
|
const int inv_str_len = (int)strlen(inv_str);
|
|
num_real_frac_digits = min(inv_str_len, num_frac_digits);
|
|
for (int i = 0; i < num_real_frac_digits; i++)
|
|
{
|
|
streamout_char(stream, inv_str[i]);
|
|
current_digit++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Output optional 0 chars before real digits begin */
|
|
const int left_padding = first_real_digit - current_digit;
|
|
current_digit += max(left_padding, 0);
|
|
for (int i = 0; i < left_padding; i++)
|
|
{
|
|
streamout_char(stream, '0');
|
|
}
|
|
|
|
/* Output remaining real digits */
|
|
const int start_digit = current_digit - first_real_digit;
|
|
for (int i = start_digit; i < num_real_digits; i++)
|
|
{
|
|
streamout_char(stream, dig_chars[dig_buffer[i]]);
|
|
current_digit++;
|
|
}
|
|
}
|
|
|
|
/* Pad right with '0' for additional precision */
|
|
if (use_frac_padding)
|
|
{
|
|
const int right_padding = num_frac_digits + num_int_digits - current_digit;
|
|
for (int i = 0; i < right_padding; i++)
|
|
{
|
|
streamout_char(stream, '0');
|
|
current_digit++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Return the number of written characters */
|
|
return current_digit + (num_frac_digits > 0);
|
|
}
|
|
|
|
static
|
|
int
|
|
#ifdef _LIBCNT_
|
|
/* Due to restrictions in kernel mode regarding the use of floating point,
|
|
we prevent it from being inlined */
|
|
__declspec(noinline)
|
|
#endif
|
|
streamout_double(
|
|
FILE* stream,
|
|
char format,
|
|
unsigned __int64 fp_bits,
|
|
unsigned int flags,
|
|
int width,
|
|
int precision)
|
|
{
|
|
const char use_frac_padding = (format != 'g');// || use_exp;
|
|
static const char _qnan[] = "#QNAN";
|
|
static const char _snan[] = "#SNAN";
|
|
static const char _ind[] = "#IND";
|
|
static const char _infinity[] = "#INF";
|
|
const char* inv_str = 0;
|
|
static const TCHAR dig_chars_l[] = _T("0123456789abcdefp0x");
|
|
static const TCHAR dig_chars_u[] = _T("0123456789ABCDEFP0X");
|
|
const TCHAR* dig_chars = dig_chars_l;
|
|
unsigned char dig_buffer[DBL_MAX_DIGITS_10];
|
|
int base = 10;
|
|
int use_exp_format = 0;
|
|
char sign_char = 0;
|
|
int exponent;
|
|
int rounded_exponent;
|
|
int width_exp;
|
|
int num_int_digits;
|
|
int num_frac_digits;
|
|
int first_real_digit;
|
|
int num_digits;
|
|
|
|
/* Convert to an actual double */
|
|
double fpval = *(double*)&fp_bits;
|
|
|
|
/* Check for upper case digits to use */
|
|
if ((format == 'E') || (format == 'F') || (format == 'G') || (format == 'A'))
|
|
{
|
|
dig_chars = dig_chars_u;
|
|
format = format - 'A' + 'a';
|
|
}
|
|
|
|
/* Check for base 16 (hex) */
|
|
if (format == 'a')
|
|
{
|
|
base = 16;
|
|
}
|
|
|
|
/* Check for default precision */
|
|
if (precision < 0) precision = 6;
|
|
|
|
/* Get sign and normalize fpval to absolute */
|
|
if (fp_bits & 0x8000000000000000ULL)
|
|
{
|
|
sign_char = '-';
|
|
fpval = -fpval;
|
|
}
|
|
else if (flags & FLAG_FORCE_SIGN)
|
|
{
|
|
sign_char = '+';
|
|
}
|
|
else if (flags & FLAG_FORCE_SIGNSP)
|
|
{
|
|
sign_char = ' ';
|
|
}
|
|
|
|
const int width_sign = (sign_char != 0) ? 1 : 0;
|
|
|
|
/* Handle NAN / INF */
|
|
if (_isnan(fpval))
|
|
{
|
|
if (fp_bits == 0xFFF8000000000000ULL)
|
|
{
|
|
inv_str = _ind;
|
|
}
|
|
else if (fp_bits & 0x0008000000000000ULL)
|
|
{
|
|
inv_str = _qnan;
|
|
}
|
|
else
|
|
{
|
|
inv_str = _snan;
|
|
}
|
|
fpval = 1.;
|
|
}
|
|
else if (!_finite(fpval))
|
|
{
|
|
inv_str = _infinity;
|
|
fpval = 1.;
|
|
}
|
|
|
|
/* Calculate the exponent (i.e. digits before decimal point) */
|
|
exponent = get_exponent(fpval, base);
|
|
|
|
retry:
|
|
|
|
/* Check whether to ise the exponent format */
|
|
if (format == 'g')
|
|
{
|
|
use_exp_format = ((exponent < -4) || (exponent >= precision));
|
|
}
|
|
else if (format == 'f')
|
|
{
|
|
use_exp_format = 0;
|
|
}
|
|
else
|
|
{
|
|
use_exp_format = 1;
|
|
}
|
|
|
|
/* Check for explicit exponent format */
|
|
if (use_exp_format)
|
|
{
|
|
width_exp = 5;
|
|
|
|
/* One digit before the decimal point */
|
|
num_int_digits = 1;
|
|
|
|
/* Precision includes the integer digit */
|
|
first_real_digit = 0;
|
|
}
|
|
else
|
|
{
|
|
width_exp = 0;
|
|
|
|
/* Integer digits based on exponent, at least 1 */
|
|
num_int_digits = max(exponent + 1, 1);
|
|
|
|
/* First real digit based on exponent */
|
|
first_real_digit = max(-exponent, 0);
|
|
}
|
|
|
|
if (format == 'g')
|
|
{
|
|
num_frac_digits = max(precision - num_int_digits, 0);
|
|
}
|
|
else
|
|
{
|
|
/* Precision is the number of fractional digits */
|
|
num_frac_digits = precision;
|
|
}
|
|
|
|
num_digits = num_int_digits + num_frac_digits;
|
|
|
|
/* Get max number of actual digits */
|
|
const int max_real_digits = (base == 16) ? DBL_MAX_DIGITS_16 : DBL_MAX_DIGITS_10;
|
|
|
|
/* Calculate the number of real digits to return */
|
|
int num_real_digits = min(num_digits - first_real_digit, max_real_digits);
|
|
|
|
/* Get the digits (0 based) */
|
|
rounded_exponent = get_dbl_digits(dig_buffer, fpval, base, exponent, &num_real_digits);
|
|
|
|
/* If the expoent changed due to rounding, we need to try again */
|
|
if (rounded_exponent != exponent)
|
|
{
|
|
assert(rounded_exponent > exponent);
|
|
exponent = rounded_exponent;
|
|
goto retry;
|
|
}
|
|
|
|
/* Special handling for special numbers */
|
|
if (inv_str != NULL)
|
|
{
|
|
num_real_digits = (int)strlen(inv_str) + 1;
|
|
}
|
|
|
|
/* In the g format we need to handle stripped trailing zeroes */
|
|
if ((format == 'g'))
|
|
{
|
|
int max_digits = first_real_digit + num_real_digits;
|
|
num_frac_digits = max(max_digits - num_int_digits, 0);
|
|
num_digits = num_int_digits + num_frac_digits;
|
|
}
|
|
|
|
/* Calculate widths */
|
|
int width_dot = ((num_frac_digits > 0) || (flags & FLAG_SPECIAL)) ? 1 : 0;
|
|
int width_of_number = width_sign + num_digits + width_dot + width_exp;
|
|
|
|
/* Output left space padding */
|
|
if (((flags & FLAG_ALIGN_LEFT) == 0) &&
|
|
((flags & FLAG_PAD_ZERO) == 0) &&
|
|
(width > width_of_number))
|
|
{
|
|
const int padding = width - width_of_number;
|
|
for (int i = 0; i < padding; i++)
|
|
{
|
|
streamout_char(stream, ' ');
|
|
}
|
|
}
|
|
|
|
/* Output sign */
|
|
if (sign_char != 0)
|
|
{
|
|
streamout_char(stream, sign_char);
|
|
}
|
|
|
|
/* Output hex prefix */
|
|
if (format == 'a')
|
|
{
|
|
streamout_string(stream, &dig_chars[0x11], 2);
|
|
}
|
|
|
|
/* Output left 0 padding */
|
|
if (((flags & FLAG_ALIGN_LEFT) == 0) &&
|
|
((flags & FLAG_PAD_ZERO) != 0) &&
|
|
(width > width_of_number))
|
|
{
|
|
const int padding = width - width_of_number;
|
|
for (int i = 0; i < padding; i++)
|
|
{
|
|
streamout_char(stream, '0');
|
|
}
|
|
}
|
|
|
|
/* Output the digits */
|
|
stramout_dbl_digits(
|
|
stream,
|
|
dig_chars,
|
|
inv_str,
|
|
flags,
|
|
dig_buffer,
|
|
num_real_digits,
|
|
num_int_digits,
|
|
num_frac_digits,
|
|
first_real_digit,
|
|
use_frac_padding);
|
|
|
|
/* Output the exponent */
|
|
if (use_exp_format)
|
|
{
|
|
streamout_char(stream, format == 'a' ? dig_chars[0x10] : dig_chars[0xe]);
|
|
streamout_char(stream, (exponent >= 0) ? '+' : '-');
|
|
exponent = (exponent < 0) ? -exponent : exponent;
|
|
assert(exponent < 1000);
|
|
streamout_char(stream, dig_chars[exponent / 100]);
|
|
exponent %= 100;
|
|
streamout_char(stream, dig_chars[exponent / 10]);
|
|
exponent %= 10;
|
|
streamout_char(stream, dig_chars[exponent]);
|
|
}
|
|
|
|
/* Output right padding */
|
|
if (((flags & FLAG_ALIGN_LEFT) != 0) &&
|
|
(width > width_of_number))
|
|
{
|
|
const int padding = width - width_of_number;
|
|
for (int i = 0; i < padding; i++)
|
|
{
|
|
streamout_char(stream, ' ');
|
|
}
|
|
}
|
|
|
|
return max(width, width_of_number);
|
|
}
|
|
|
|
#endif // _USER32_WSPRINTF
|
|
|
|
#ifdef _USER32_WSPRINTF
|
|
# define USE_MULTISIZE 0
|
|
#else
|
|
# define USE_MULTISIZE 1
|
|
#endif
|
|
|
|
int
|
|
__cdecl
|
|
streamout(FILE *stream, const TCHAR *format, va_list argptr)
|
|
{
|
|
static const TCHAR digits_l[] = _T("0123456789abcdef0x");
|
|
static const TCHAR digits_u[] = _T("0123456789ABCDEF0X");
|
|
static const char *_nullstring = "(null)";
|
|
TCHAR buffer[BUFFER_SIZE + 1];
|
|
TCHAR chr, *string;
|
|
STRING *nt_string;
|
|
const TCHAR *digits, *prefix;
|
|
int base, fieldwidth, precision, padding, rpadding = 0;
|
|
size_t prefixlen, len;
|
|
int written = 1, written_all = 0;
|
|
unsigned int flags;
|
|
unsigned __int64 val64;
|
|
|
|
buffer[BUFFER_SIZE] = '\0';
|
|
|
|
while (written >= 0)
|
|
{
|
|
chr = *format++;
|
|
|
|
/* Check for end of format string */
|
|
if (chr == _T('\0')) break;
|
|
|
|
/* Check for 'normal' character or double % */
|
|
if ((chr != _T('%')) ||
|
|
(chr = *format++) == _T('%'))
|
|
{
|
|
/* Write the character to the stream */
|
|
if ((written = streamout_char(stream, chr)) == 0) return -1;
|
|
written_all += written;
|
|
continue;
|
|
}
|
|
|
|
/* Handle flags */
|
|
flags = 0;
|
|
while (1)
|
|
{
|
|
if (chr == _T('-')) flags |= FLAG_ALIGN_LEFT;
|
|
else if (chr == _T('+')) flags |= FLAG_FORCE_SIGN;
|
|
else if (chr == _T(' ')) flags |= FLAG_FORCE_SIGNSP;
|
|
else if (chr == _T('0')) flags |= FLAG_PAD_ZERO;
|
|
else if (chr == _T('#')) flags |= FLAG_SPECIAL;
|
|
else break;
|
|
chr = *format++;
|
|
}
|
|
|
|
/* Handle field width modifier */
|
|
if (chr == _T('*'))
|
|
{
|
|
#ifdef _USER32_WSPRINTF
|
|
if ((written = streamout_char(stream, chr)) == 0) return -1;
|
|
written_all += written;
|
|
continue;
|
|
#else
|
|
fieldwidth = va_arg(argptr, int);
|
|
if (fieldwidth < 0)
|
|
{
|
|
flags |= FLAG_ALIGN_LEFT;
|
|
fieldwidth = -fieldwidth;
|
|
}
|
|
chr = *format++;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
fieldwidth = 0;
|
|
while (chr >= _T('0') && chr <= _T('9'))
|
|
{
|
|
fieldwidth = fieldwidth * 10 + (chr - _T('0'));
|
|
chr = *format++;
|
|
}
|
|
}
|
|
|
|
/* Handle precision modifier */
|
|
if (chr == '.')
|
|
{
|
|
chr = *format++;
|
|
|
|
if (chr == _T('*'))
|
|
{
|
|
#ifdef _USER32_WSPRINTF
|
|
if ((written = streamout_char(stream, chr)) == 0) return -1;
|
|
written_all += written;
|
|
continue;
|
|
#else
|
|
precision = va_arg(argptr, int);
|
|
chr = *format++;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
precision = 0;
|
|
while (chr >= _T('0') && chr <= _T('9'))
|
|
{
|
|
precision = precision * 10 + (chr - _T('0'));
|
|
chr = *format++;
|
|
}
|
|
}
|
|
}
|
|
else precision = -1;
|
|
|
|
/* Handle argument size prefix */
|
|
do
|
|
{
|
|
if (chr == _T('h')) flags |= FLAG_SHORT;
|
|
else if (chr == _T('w')) flags |= FLAG_WIDECHAR;
|
|
else if (chr == _T('L')) flags |= 0; // FIXME: long double
|
|
else if (chr == _T('F')) flags |= 0; // FIXME: what is that?
|
|
else if (chr == _T('z') && *format && strchr("udxXion", *format))
|
|
{
|
|
flags |= FLAG_INTPTR;
|
|
}
|
|
else if (chr == _T('l'))
|
|
{
|
|
/* Check if this is the 2nd 'l' in a row */
|
|
if (format[-2] == 'l') flags |= FLAG_INT64;
|
|
else flags |= FLAG_LONG;
|
|
}
|
|
else if (chr == _T('I'))
|
|
{
|
|
if (format[0] == _T('3') && format[1] == _T('2'))
|
|
{
|
|
format += 2;
|
|
}
|
|
else if (format[0] == _T('6') && format[1] == _T('4'))
|
|
{
|
|
format += 2;
|
|
flags |= FLAG_INT64;
|
|
}
|
|
else if (format[0] == _T('x') || format[0] == _T('X') ||
|
|
format[0] == _T('d') || format[0] == _T('i') ||
|
|
format[0] == _T('u') || format[0] == _T('o'))
|
|
{
|
|
flags |= FLAG_INTPTR;
|
|
}
|
|
else break;
|
|
}
|
|
else break;
|
|
chr = *format++;
|
|
}
|
|
while (USE_MULTISIZE);
|
|
|
|
/* Handle the format specifier */
|
|
digits = digits_l;
|
|
string = &buffer[BUFFER_SIZE];
|
|
base = 10;
|
|
prefix = 0;
|
|
switch (chr)
|
|
{
|
|
case _T('n'):
|
|
if (flags & FLAG_INT64)
|
|
*va_arg(argptr, __int64*) = written_all;
|
|
else if (flags & FLAG_SHORT)
|
|
*va_arg(argptr, short*) = written_all;
|
|
else
|
|
*va_arg(argptr, int*) = written_all;
|
|
continue;
|
|
|
|
case _T('C'):
|
|
#ifndef _UNICODE
|
|
if (!(flags & FLAG_SHORT)) flags |= FLAG_WIDECHAR;
|
|
#endif
|
|
goto case_char;
|
|
|
|
case _T('c'):
|
|
#ifdef _UNICODE
|
|
if (!(flags & FLAG_SHORT)) flags |= FLAG_WIDECHAR;
|
|
#endif
|
|
case_char:
|
|
string = buffer;
|
|
len = 1;
|
|
if (flags & FLAG_WIDECHAR)
|
|
{
|
|
((wchar_t*)string)[0] = va_arg(argptr, int);
|
|
((wchar_t*)string)[1] = _T('\0');
|
|
}
|
|
else
|
|
{
|
|
((char*)string)[0] = va_arg(argptr, int);
|
|
((char*)string)[1] = _T('\0');
|
|
}
|
|
break;
|
|
|
|
case _T('Z'):
|
|
nt_string = va_arg(argptr, void*);
|
|
if (nt_string && (string = nt_string->Buffer))
|
|
{
|
|
len = nt_string->Length;
|
|
if (flags & FLAG_WIDECHAR) len /= sizeof(wchar_t);
|
|
break;
|
|
}
|
|
string = 0;
|
|
goto case_string;
|
|
|
|
case _T('S'):
|
|
string = va_arg(argptr, void*);
|
|
#ifndef _UNICODE
|
|
if (!(flags & FLAG_SHORT)) flags |= FLAG_WIDECHAR;
|
|
#endif
|
|
goto case_string;
|
|
|
|
case _T('s'):
|
|
string = va_arg(argptr, void*);
|
|
#ifdef _UNICODE
|
|
if (!(flags & FLAG_SHORT)) flags |= FLAG_WIDECHAR;
|
|
#endif
|
|
|
|
case_string:
|
|
if (!string)
|
|
{
|
|
string = (TCHAR*)_nullstring;
|
|
flags &= ~FLAG_WIDECHAR;
|
|
}
|
|
|
|
if (flags & FLAG_WIDECHAR)
|
|
len = wcsnlen((wchar_t*)string, (unsigned)precision);
|
|
else
|
|
len = strnlen((char*)string, (unsigned)precision);
|
|
precision = 0;
|
|
break;
|
|
|
|
#ifndef _USER32_WSPRINTF
|
|
case _T('G'):
|
|
case _T('E'):
|
|
case _T('A'):
|
|
case _T('g'):
|
|
case _T('e'):
|
|
case _T('a'):
|
|
case _T('f'):
|
|
#ifdef _UNICODE
|
|
flags |= FLAG_WIDECHAR;
|
|
#else
|
|
flags &= ~FLAG_WIDECHAR;
|
|
#endif
|
|
/* Capture the double as 64bit int to avoid changing it with the FPU */
|
|
unsigned __int64 fpval = va_arg(argptr, unsigned __int64);
|
|
written = streamout_double(stream, chr, fpval, flags, fieldwidth, precision);
|
|
written_all += written;
|
|
continue;
|
|
#endif
|
|
|
|
case _T('d'):
|
|
case _T('i'):
|
|
val64 = (__int64)va_arg_f(argptr, flags);
|
|
|
|
if ((__int64)val64 < 0)
|
|
{
|
|
val64 = -(__int64)val64;
|
|
prefix = _T("-");
|
|
}
|
|
else if (flags & FLAG_FORCE_SIGN)
|
|
prefix = _T("+");
|
|
else if (flags & FLAG_FORCE_SIGNSP)
|
|
prefix = _T(" ");
|
|
|
|
goto case_number;
|
|
|
|
case _T('o'):
|
|
base = 8;
|
|
if (flags & FLAG_SPECIAL)
|
|
{
|
|
prefix = _T("0");
|
|
if (precision > 0) precision--;
|
|
}
|
|
goto case_unsigned;
|
|
|
|
case _T('p'):
|
|
precision = 2 * sizeof(void*);
|
|
flags &= ~FLAG_PAD_ZERO;
|
|
flags |= FLAG_INTPTR;
|
|
/* Fall through */
|
|
|
|
case _T('X'):
|
|
digits = digits_u;
|
|
/* Fall through */
|
|
|
|
case _T('x'):
|
|
base = 16;
|
|
if (flags & FLAG_SPECIAL)
|
|
{
|
|
prefix = &digits[16];
|
|
#ifdef _USER32_WSPRINTF
|
|
fieldwidth += 2;
|
|
#endif
|
|
}
|
|
|
|
case _T('u'):
|
|
case_unsigned:
|
|
val64 = va_arg_fu(argptr, flags);
|
|
|
|
case_number:
|
|
#ifdef _UNICODE
|
|
flags |= FLAG_WIDECHAR;
|
|
#else
|
|
flags &= ~FLAG_WIDECHAR;
|
|
#endif
|
|
if (precision < 0) precision = 1;
|
|
|
|
/* Gather digits in reverse order */
|
|
while (val64)
|
|
{
|
|
*--string = digits[val64 % base];
|
|
val64 /= base;
|
|
precision--;
|
|
}
|
|
|
|
len = _tcslen(string);
|
|
break;
|
|
|
|
default:
|
|
/* Treat anything else as a new character */
|
|
format--;
|
|
continue;
|
|
}
|
|
|
|
/* Calculate padding */
|
|
prefixlen = prefix ? _tcslen(prefix) : 0;
|
|
if (precision < 0) precision = 0;
|
|
padding = (int)(fieldwidth - len - prefixlen - precision);
|
|
if (padding < 0) padding = 0;
|
|
|
|
/* Optional left space padding */
|
|
if ((flags & (FLAG_ALIGN_LEFT | FLAG_PAD_ZERO)) == 0)
|
|
{
|
|
for (; padding > 0; padding--)
|
|
{
|
|
if ((written = streamout_char(stream, _T(' '))) == 0) return -1;
|
|
written_all += written;
|
|
}
|
|
}
|
|
|
|
/* Optional prefix */
|
|
if (prefix)
|
|
{
|
|
written = streamout_string(stream, prefix, prefixlen);
|
|
if (written == -1) return -1;
|
|
written_all += written;
|
|
}
|
|
|
|
/* Optional left '0' padding */
|
|
if ((flags & FLAG_ALIGN_LEFT) == 0) precision += padding;
|
|
while (precision-- > 0)
|
|
{
|
|
if ((written = streamout_char(stream, _T('0'))) == 0) return -1;
|
|
written_all += written;
|
|
}
|
|
|
|
/* Output the string */
|
|
if (flags & FLAG_WIDECHAR)
|
|
written = streamout_wstring(stream, (wchar_t*)string, len);
|
|
else
|
|
written = streamout_astring(stream, (char*)string, len);
|
|
if (written == -1) return -1;
|
|
written_all += written;
|
|
|
|
/* Optional right '0' padding */
|
|
while (rpadding-- > 0)
|
|
{
|
|
if ((written = streamout_char(stream, _T('0'))) == 0) return -1;
|
|
written_all += written;
|
|
len++;
|
|
}
|
|
|
|
/* Optional right padding */
|
|
if (flags & FLAG_ALIGN_LEFT)
|
|
{
|
|
while (padding-- > 0)
|
|
{
|
|
if ((written = streamout_char(stream, _T(' '))) == 0) return -1;
|
|
written_all += written;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (written == -1) return -1;
|
|
|
|
return written_all;
|
|
}
|
|
|