1289 lines
40 KiB
C
1289 lines
40 KiB
C
/*
|
|
******************************************************************************
|
|
*
|
|
* Copyright (C) 1998-2001, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
*
|
|
******************************************************************************
|
|
*
|
|
* File uprintf.c
|
|
*
|
|
* Modification History:
|
|
*
|
|
* Date Name Description
|
|
* 11/19/98 stephen Creation.
|
|
* 03/12/99 stephen Modified for new C API.
|
|
* Added conversion from default codepage.
|
|
******************************************************************************
|
|
*/
|
|
|
|
#include "unicode/utypes.h"
|
|
#include "uprintf.h"
|
|
#include "uprntf_p.h"
|
|
#include "unicode/ustdio.h"
|
|
#include "ufile.h"
|
|
#include "unicode/ustring.h"
|
|
#include "locbund.h"
|
|
#include "unicode/unum.h"
|
|
#include "unicode/udat.h"
|
|
|
|
#include "cmemory.h"
|
|
|
|
|
|
/* --- Prototypes ---------------------------- */
|
|
|
|
int32_t
|
|
u_printf_simple_percent_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_string_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_date_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_scientific_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_scidbl_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_uchar_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_currency_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_ustring_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_percent_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_time_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_spellout_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_hex_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_char_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_integer_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_uinteger_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_double_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_count_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_octal_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
int32_t
|
|
u_printf_pointer_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args);
|
|
|
|
/* ANSI style formatting */
|
|
/* Use US-ASCII characters only for formatting */
|
|
|
|
/* % */
|
|
#define UFMT_SIMPLE_PERCENT {ufmt_simple_percent, u_printf_simple_percent_handler}
|
|
/* s */
|
|
#define UFMT_STRING {ufmt_string, u_printf_string_handler}
|
|
/* c */
|
|
#define UFMT_CHAR {ufmt_char, u_printf_char_handler}
|
|
/* d, i */
|
|
#define UFMT_INT {ufmt_int, u_printf_integer_handler}
|
|
/* u */
|
|
#define UFMT_UINT {ufmt_int, u_printf_uinteger_handler}
|
|
/* o */
|
|
#define UFMT_OCTAL {ufmt_int, u_printf_octal_handler}
|
|
/* x, X */
|
|
#define UFMT_HEX {ufmt_int, u_printf_hex_handler}
|
|
/* f */
|
|
#define UFMT_DOUBLE {ufmt_double, u_printf_double_handler}
|
|
/* e, E */
|
|
#define UFMT_SCIENTIFIC {ufmt_double, u_printf_scientific_handler}
|
|
/* g, G */
|
|
#define UFMT_SCIDBL {ufmt_double, u_printf_scidbl_handler}
|
|
/* n */
|
|
#define UFMT_COUNT {ufmt_count, u_printf_count_handler}
|
|
|
|
/* non-ANSI extensions */
|
|
/* Use US-ASCII characters only for formatting */
|
|
|
|
/* p */
|
|
#define UFMT_POINTER {ufmt_pointer, u_printf_pointer_handler}
|
|
/* D */
|
|
#define UFMT_DATE {ufmt_date, u_printf_date_handler}
|
|
/* T */
|
|
#define UFMT_TIME {ufmt_date, u_printf_time_handler}
|
|
/* V */
|
|
#define UFMT_SPELLOUT {ufmt_double, u_printf_spellout_handler}
|
|
/* P */
|
|
#define UFMT_PERCENT {ufmt_double, u_printf_percent_handler}
|
|
/* M */
|
|
#define UFMT_CURRENCY {ufmt_double, u_printf_currency_handler}
|
|
/* K */
|
|
#define UFMT_UCHAR {ufmt_uchar, u_printf_uchar_handler}
|
|
/* U */
|
|
#define UFMT_USTRING {ufmt_ustring, u_printf_ustring_handler}
|
|
|
|
|
|
#define UFMT_EMPTY {ufmt_empty, NULL}
|
|
|
|
struct u_printf_info {
|
|
ufmt_type_info info;
|
|
u_printf_handler handler;
|
|
};
|
|
typedef struct u_printf_info u_printf_info;
|
|
|
|
/* Use US-ASCII characters only for formatting. Most codepages have
|
|
characters 20-7F from Unicode. Using any other codepage specific
|
|
characters will make it very difficult to format the string on
|
|
non-Unicode machines */
|
|
static const u_printf_info g_u_printf_infos[108] = {
|
|
/* 0x20 */
|
|
UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY,
|
|
UFMT_EMPTY, UFMT_SIMPLE_PERCENT,UFMT_EMPTY, UFMT_EMPTY,
|
|
UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY,
|
|
UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY,
|
|
|
|
/* 0x30 */
|
|
UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY,
|
|
UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY,
|
|
UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY,
|
|
UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY,
|
|
|
|
/* 0x40 */
|
|
UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY,
|
|
UFMT_DATE, UFMT_SCIENTIFIC, UFMT_EMPTY, UFMT_SCIDBL,
|
|
UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_UCHAR,
|
|
UFMT_EMPTY, UFMT_CURRENCY, UFMT_EMPTY, UFMT_EMPTY,
|
|
|
|
/* 0x50 */
|
|
UFMT_PERCENT, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY,
|
|
UFMT_TIME, UFMT_USTRING, UFMT_SPELLOUT, UFMT_EMPTY,
|
|
UFMT_HEX, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY,
|
|
UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY,
|
|
|
|
/* 0x60 */
|
|
UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_CHAR,
|
|
UFMT_INT, UFMT_SCIENTIFIC, UFMT_DOUBLE, UFMT_SCIDBL,
|
|
UFMT_EMPTY, UFMT_INT, UFMT_EMPTY, UFMT_EMPTY,
|
|
UFMT_EMPTY, UFMT_EMPTY, UFMT_COUNT, UFMT_OCTAL,
|
|
|
|
/* 0x70 */
|
|
UFMT_POINTER, UFMT_EMPTY, UFMT_EMPTY, UFMT_STRING,
|
|
UFMT_EMPTY, UFMT_UINT, UFMT_EMPTY, UFMT_EMPTY,
|
|
UFMT_HEX, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY,
|
|
UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY, UFMT_EMPTY,
|
|
};
|
|
|
|
#define UPRINTF_NUM_FMT_HANDLERS sizeof(g_u_printf_infos)
|
|
|
|
/* We do not use handlers for 0-0x1f */
|
|
#define UPRINTF_BASE_FMT_HANDLERS 0x20
|
|
|
|
/* buffer size for formatting */
|
|
#define UFPRINTF_BUFFER_SIZE 1024
|
|
#define UFPRINTF_EXP_BUFFER_SIZE 8
|
|
|
|
int32_t
|
|
u_fprintf( UFILE *f,
|
|
const char *patternSpecification,
|
|
... )
|
|
{
|
|
va_list ap;
|
|
int32_t count;
|
|
|
|
va_start(ap, patternSpecification);
|
|
count = u_vfprintf(f, patternSpecification, ap);
|
|
va_end(ap);
|
|
|
|
return count;
|
|
}
|
|
|
|
int32_t
|
|
u_fprintf_u( UFILE *f,
|
|
const UChar *patternSpecification,
|
|
... )
|
|
{
|
|
va_list ap;
|
|
int32_t count;
|
|
|
|
va_start(ap, patternSpecification);
|
|
count = u_vfprintf_u(f, patternSpecification, ap);
|
|
va_end(ap);
|
|
|
|
return count;
|
|
}
|
|
|
|
U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
|
|
u_vfprintf( UFILE *f,
|
|
const char *patternSpecification,
|
|
va_list ap)
|
|
{
|
|
int32_t count;
|
|
UChar *pattern;
|
|
|
|
/* convert from the default codepage to Unicode */
|
|
pattern = ufmt_defaultCPToUnicode(patternSpecification,
|
|
strlen(patternSpecification));
|
|
if(pattern == 0) {
|
|
return 0;
|
|
}
|
|
|
|
/* do the work */
|
|
count = u_vfprintf_u(f, pattern, ap);
|
|
|
|
/* clean up */
|
|
uprv_free(pattern);
|
|
|
|
return count;
|
|
}
|
|
|
|
static int32_t
|
|
u_printf_pad_and_justify(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const UChar *result,
|
|
int32_t resultLen)
|
|
{
|
|
int32_t written, i;
|
|
|
|
/* pad and justify, if needed */
|
|
if(info->fWidth != -1 && resultLen < info->fWidth) {
|
|
/* left justify */
|
|
if(info->fLeft) {
|
|
written = u_file_write(result, resultLen, stream);
|
|
for(i = 0; i < info->fWidth - resultLen; ++i) {
|
|
written += u_file_write(&info->fPadChar, 1, stream);
|
|
}
|
|
}
|
|
/* right justify */
|
|
else {
|
|
written = 0;
|
|
for(i = 0; i < info->fWidth - resultLen; ++i) {
|
|
written += u_file_write(&info->fPadChar, 1, stream);
|
|
}
|
|
written += u_file_write(result, resultLen, stream);
|
|
}
|
|
}
|
|
/* just write the formatted output */
|
|
else
|
|
written = u_file_write(result, resultLen, stream);
|
|
|
|
return written;
|
|
}
|
|
|
|
/* handle a '%' */
|
|
|
|
int32_t
|
|
u_printf_simple_percent_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
/* put a single '%' on the stream */
|
|
u_fputc(0x0025, stream);
|
|
/* we wrote one character */
|
|
return 1;
|
|
}
|
|
|
|
/* handle 's' */
|
|
|
|
int32_t
|
|
u_printf_string_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
UChar *s;
|
|
int32_t len, written;
|
|
const char *arg = (const char*)(args[0].ptrValue);
|
|
|
|
/* convert from the default codepage to Unicode */
|
|
s = ufmt_defaultCPToUnicode(arg, strlen(arg));
|
|
if(s == 0) {
|
|
return 0;
|
|
}
|
|
len = u_strlen(s);
|
|
|
|
/* width = minimum # of characters to write */
|
|
/* precision = maximum # of characters to write */
|
|
|
|
/* precision takes precedence over width */
|
|
/* determine if the string should be truncated */
|
|
if(info->fPrecision != -1 && len > info->fPrecision) {
|
|
written = u_file_write(s, info->fPrecision, stream);
|
|
}
|
|
/* determine if the string should be padded */
|
|
else {
|
|
written = u_printf_pad_and_justify(stream, info, s, len);
|
|
}
|
|
|
|
/* clean up */
|
|
uprv_free(s);
|
|
|
|
return written;
|
|
}
|
|
|
|
/* HSYS */
|
|
int32_t
|
|
u_printf_integer_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
long num = (long) (args[0].intValue);
|
|
UNumberFormat *format;
|
|
UChar result [UFPRINTF_BUFFER_SIZE];
|
|
int32_t minDigits = -1;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
/* mask off any necessary bits */
|
|
if(info->fIsShort)
|
|
num &= UINT16_MAX;
|
|
else if(! info->fIsLong || ! info->fIsLongLong)
|
|
num &= UINT32_MAX;
|
|
|
|
/* get the formatter */
|
|
format = u_locbund_getNumberFormat(stream->fBundle);
|
|
|
|
/* handle error */
|
|
if(format == 0)
|
|
return 0;
|
|
|
|
/* set the appropriate flags on the formatter */
|
|
|
|
/* set the minimum integer digits */
|
|
if(info->fPrecision != -1) {
|
|
/* clone the stream's bundle if it isn't owned */
|
|
if(! stream->fOwnBundle) {
|
|
stream->fBundle = u_locbund_clone(stream->fBundle);
|
|
stream->fOwnBundle = TRUE;
|
|
format = u_locbund_getNumberFormat(stream->fBundle);
|
|
}
|
|
|
|
/* set the minimum # of digits */
|
|
minDigits = unum_getAttribute(format, UNUM_MIN_INTEGER_DIGITS);
|
|
unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, info->fPrecision);
|
|
}
|
|
|
|
/* set whether to show the sign */
|
|
if(info->fShowSign) {
|
|
/* clone the stream's bundle if it isn't owned */
|
|
if(! stream->fOwnBundle) {
|
|
stream->fBundle = u_locbund_clone(stream->fBundle);
|
|
stream->fOwnBundle = TRUE;
|
|
format = u_locbund_getNumberFormat(stream->fBundle);
|
|
}
|
|
|
|
/* set whether to show the sign*/
|
|
/* {sfb} TODO */
|
|
}
|
|
|
|
/* format the number */
|
|
unum_format(format, num, result, UFPRINTF_BUFFER_SIZE, 0, &status);
|
|
|
|
/* restore the number format */
|
|
if(minDigits != -1)
|
|
unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, minDigits);
|
|
|
|
return u_printf_pad_and_justify(stream, info, result, u_strlen(result));
|
|
}
|
|
|
|
int32_t
|
|
u_printf_hex_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
long num = (long) (args[0].intValue);
|
|
UChar result[UFPRINTF_BUFFER_SIZE];
|
|
int32_t len = UFPRINTF_BUFFER_SIZE;
|
|
|
|
|
|
/* mask off any necessary bits */
|
|
if(info->fIsShort)
|
|
num &= UINT16_MAX;
|
|
else if(! info->fIsLong || ! info->fIsLongLong)
|
|
num &= UINT32_MAX;
|
|
|
|
/* format the number, preserving the minimum # of digits */
|
|
ufmt_ltou(result, &len, num, 16,
|
|
(UBool)(info->fSpec == 0x0078),
|
|
(info->fPrecision == -1 && info->fZero) ? info->fWidth : info->fPrecision);
|
|
|
|
/* convert to alt form, if desired */
|
|
if(num != 0 && info->fAlt && len < UFPRINTF_BUFFER_SIZE - 2) {
|
|
/* shift the formatted string right by 2 chars */
|
|
memmove(result + 2, result, len * sizeof(UChar));
|
|
result[0] = 0x0030;
|
|
result[1] = info->fSpec;
|
|
len += 2;
|
|
}
|
|
|
|
return u_printf_pad_and_justify(stream, info, result, len);
|
|
}
|
|
|
|
int32_t
|
|
u_printf_octal_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
long num = (long) (args[0].intValue);
|
|
UChar result[UFPRINTF_BUFFER_SIZE];
|
|
int32_t len = UFPRINTF_BUFFER_SIZE;
|
|
|
|
|
|
/* mask off any necessary bits */
|
|
if(info->fIsShort)
|
|
num &= UINT16_MAX;
|
|
else if(! info->fIsLong || ! info->fIsLongLong)
|
|
num &= UINT32_MAX;
|
|
|
|
/* format the number, preserving the minimum # of digits */
|
|
ufmt_ltou(result, &len, num, 8,
|
|
FALSE, /* doesn't matter for octal */
|
|
info->fPrecision == -1 && info->fZero ? info->fWidth : info->fPrecision);
|
|
|
|
/* convert to alt form, if desired */
|
|
if(info->fAlt && result[0] != 0x0030 && len < UFPRINTF_BUFFER_SIZE - 1) {
|
|
/* shift the formatted string right by 1 char */
|
|
memmove(result + 1, result, len * sizeof(UChar));
|
|
result[0] = 0x0030;
|
|
len += 1;
|
|
}
|
|
|
|
return u_printf_pad_and_justify(stream, info, result, len);
|
|
}
|
|
|
|
|
|
int32_t
|
|
u_printf_uinteger_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
u_printf_spec_info uint_info;
|
|
ufmt_args uint_args;
|
|
|
|
memcpy(&uint_info, info, sizeof(u_printf_spec_info));
|
|
memcpy(&uint_args, args, sizeof(ufmt_args));
|
|
|
|
uint_info.fPrecision = 0;
|
|
uint_info.fAlt = FALSE;
|
|
|
|
/* Get around int32_t limitations */
|
|
uint_args.doubleValue = ((double) ((uint32_t) (uint_args.intValue)));
|
|
|
|
return u_printf_double_handler(stream, &uint_info, &uint_args);
|
|
}
|
|
|
|
int32_t
|
|
u_printf_double_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
double num = (double) (args[0].doubleValue);
|
|
UNumberFormat *format;
|
|
UChar result [UFPRINTF_BUFFER_SIZE];
|
|
int32_t minDecimalDigits;
|
|
int32_t maxDecimalDigits;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
/* mask off any necessary bits */
|
|
/* if(! info->fIsLongDouble)
|
|
num &= DBL_MAX;*/
|
|
|
|
/* get the formatter */
|
|
format = u_locbund_getNumberFormat(stream->fBundle);
|
|
|
|
/* handle error */
|
|
if(format == 0)
|
|
return 0;
|
|
|
|
/* set the appropriate flags on the formatter */
|
|
|
|
/* clone the stream's bundle if it isn't owned */
|
|
if(! stream->fOwnBundle) {
|
|
stream->fBundle = u_locbund_clone(stream->fBundle);
|
|
stream->fOwnBundle = TRUE;
|
|
format = u_locbund_getNumberFormat(stream->fBundle);
|
|
}
|
|
|
|
/* set the number of decimal digits */
|
|
|
|
/* save the formatter's state */
|
|
minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS);
|
|
maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS);
|
|
|
|
if(info->fPrecision != -1) {
|
|
/* set the # of decimal digits */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision);
|
|
}
|
|
else if(info->fPrecision == 0 && ! info->fAlt) {
|
|
/* no decimal point in this case */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, 0);
|
|
}
|
|
else if(info->fAlt) {
|
|
/* '#' means always show decimal point */
|
|
/* copy of printf behavior on Solaris - '#' shows 6 digits */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
|
|
}
|
|
else {
|
|
/* # of decimal digits is 6 if precision not specified */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
|
|
}
|
|
|
|
/* set whether to show the sign */
|
|
if(info->fShowSign) {
|
|
/* set whether to show the sign*/
|
|
/* {sfb} TODO */
|
|
}
|
|
|
|
/* format the number */
|
|
unum_formatDouble(format, num, result, UFPRINTF_BUFFER_SIZE, 0, &status);
|
|
|
|
/* restore the number format */
|
|
unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits);
|
|
unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits);
|
|
|
|
return u_printf_pad_and_justify(stream, info, result, u_strlen(result));
|
|
}
|
|
|
|
|
|
int32_t
|
|
u_printf_char_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
UChar *s;
|
|
int32_t len = 1, written;
|
|
unsigned char arg = (unsigned char)(args[0].intValue);
|
|
|
|
/* convert from default codepage to Unicode */
|
|
s = ufmt_defaultCPToUnicode((const char *)&arg, 1);
|
|
if(s == 0) {
|
|
return 0;
|
|
}
|
|
if (arg != 0) {
|
|
len = u_strlen(s);
|
|
}
|
|
|
|
/* width = minimum # of characters to write */
|
|
/* precision = maximum # of characters to write */
|
|
|
|
/* precision takes precedence over width */
|
|
/* determine if the string should be truncated */
|
|
if(info->fPrecision != -1 && len > info->fPrecision) {
|
|
written = u_file_write(s, info->fPrecision, stream);
|
|
}
|
|
else {
|
|
/* determine if the string should be padded */
|
|
written = u_printf_pad_and_justify(stream, info, s, len);
|
|
}
|
|
|
|
/* clean up */
|
|
uprv_free(s);
|
|
|
|
return written;
|
|
}
|
|
|
|
|
|
int32_t
|
|
u_printf_pointer_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
long num = (long) (args[0].intValue);
|
|
UChar result[UFPRINTF_BUFFER_SIZE];
|
|
int32_t len = UFPRINTF_BUFFER_SIZE;
|
|
|
|
|
|
/* format the pointer in hex */
|
|
ufmt_ltou(result, &len, num, 16, TRUE, info->fPrecision);
|
|
|
|
return u_printf_pad_and_justify(stream, info, result, len);
|
|
}
|
|
|
|
|
|
int32_t
|
|
u_printf_scientific_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
double num = (double) (args[0].doubleValue);
|
|
UNumberFormat *format;
|
|
UChar result [UFPRINTF_BUFFER_SIZE];
|
|
int32_t minDecimalDigits;
|
|
int32_t maxDecimalDigits;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
UChar srcExpBuf[UFPRINTF_EXP_BUFFER_SIZE];
|
|
int32_t srcLen, expLen;
|
|
UChar expBuf[UFPRINTF_EXP_BUFFER_SIZE];
|
|
|
|
|
|
/* mask off any necessary bits */
|
|
/* if(! info->fIsLongDouble)
|
|
num &= DBL_MAX;*/
|
|
|
|
/* get the formatter */
|
|
format = u_locbund_getScientificFormat(stream->fBundle);
|
|
|
|
/* handle error */
|
|
if(format == 0)
|
|
return 0;
|
|
|
|
/* set the appropriate flags on the formatter */
|
|
|
|
/* clone the stream's bundle if it isn't owned */
|
|
if(! stream->fOwnBundle) {
|
|
stream->fBundle = u_locbund_clone(stream->fBundle);
|
|
stream->fOwnBundle = TRUE;
|
|
format = u_locbund_getScientificFormat(stream->fBundle);
|
|
}
|
|
|
|
srcLen = unum_getSymbol(format,
|
|
UNUM_EXPONENTIAL_SYMBOL,
|
|
srcExpBuf,
|
|
sizeof(srcExpBuf),
|
|
&status);
|
|
|
|
/* Upper/lower case the e */
|
|
if (info->fSpec == (UChar)0x65 /* e */) {
|
|
expLen = u_strToLower(expBuf, (int32_t)sizeof(expBuf),
|
|
srcExpBuf, srcLen,
|
|
stream->fBundle->fLocale,
|
|
&status);
|
|
}
|
|
else {
|
|
expLen = u_strToUpper(expBuf, (int32_t)sizeof(expBuf),
|
|
srcExpBuf, srcLen,
|
|
stream->fBundle->fLocale,
|
|
&status);
|
|
}
|
|
|
|
unum_setSymbol(format,
|
|
UNUM_EXPONENTIAL_SYMBOL,
|
|
expBuf,
|
|
expLen,
|
|
&status);
|
|
|
|
/* set the number of decimal digits */
|
|
|
|
/* save the formatter's state */
|
|
minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS);
|
|
maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS);
|
|
|
|
if(info->fPrecision != -1) {
|
|
/* set the # of decimal digits */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision);
|
|
}
|
|
else if(info->fPrecision == 0 && ! info->fAlt) {
|
|
/* no decimal point in this case */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, 0);
|
|
}
|
|
else if(info->fAlt) {
|
|
/* '#' means always show decimal point */
|
|
/* copy of printf behavior on Solaris - '#' shows 6 digits */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
|
|
}
|
|
else {
|
|
/* # of decimal digits is 6 if precision not specified */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
|
|
}
|
|
|
|
/* set whether to show the sign */
|
|
if(info->fShowSign) {
|
|
/* set whether to show the sign*/
|
|
/* {sfb} TODO */
|
|
}
|
|
|
|
/* format the number */
|
|
unum_formatDouble(format, num, result, UFPRINTF_BUFFER_SIZE, 0, &status);
|
|
|
|
/* restore the number format */
|
|
unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits);
|
|
unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits);
|
|
|
|
unum_setSymbol(format,
|
|
UNUM_EXPONENTIAL_SYMBOL,
|
|
srcExpBuf,
|
|
srcLen,
|
|
&status);
|
|
|
|
return u_printf_pad_and_justify(stream, info, result, u_strlen(result));
|
|
}
|
|
|
|
int32_t
|
|
u_printf_date_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
UDate num = (UDate) (args[0].dateValue);
|
|
UDateFormat *format;
|
|
UChar result [UFPRINTF_BUFFER_SIZE];
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
|
|
/* get the formatter */
|
|
format = u_locbund_getDateFormat(stream->fBundle);
|
|
|
|
/* handle error */
|
|
if(format == 0)
|
|
return 0;
|
|
|
|
/* format the date */
|
|
udat_format(format, num, result, UFPRINTF_BUFFER_SIZE, 0, &status);
|
|
|
|
return u_printf_pad_and_justify(stream, info, result, u_strlen(result));
|
|
}
|
|
|
|
int32_t
|
|
u_printf_time_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
UDate num = (UDate) (args[0].dateValue);
|
|
UDateFormat *format;
|
|
UChar result [UFPRINTF_BUFFER_SIZE];
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
|
|
/* get the formatter */
|
|
format = u_locbund_getTimeFormat(stream->fBundle);
|
|
|
|
/* handle error */
|
|
if(format == 0)
|
|
return 0;
|
|
|
|
/* format the time */
|
|
udat_format(format, num, result, UFPRINTF_BUFFER_SIZE, 0, &status);
|
|
|
|
return u_printf_pad_and_justify(stream, info, result, u_strlen(result));
|
|
}
|
|
|
|
|
|
int32_t
|
|
u_printf_percent_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
double num = (double) (args[0].doubleValue);
|
|
UNumberFormat *format;
|
|
UChar result [UFPRINTF_BUFFER_SIZE];
|
|
int32_t minDecimalDigits;
|
|
int32_t maxDecimalDigits;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
|
|
/* mask off any necessary bits */
|
|
/* if(! info->fIsLongDouble)
|
|
num &= DBL_MAX;*/
|
|
|
|
/* get the formatter */
|
|
format = u_locbund_getPercentFormat(stream->fBundle);
|
|
|
|
/* handle error */
|
|
if(format == 0)
|
|
return 0;
|
|
|
|
/* set the appropriate flags on the formatter */
|
|
|
|
/* clone the stream's bundle if it isn't owned */
|
|
if(! stream->fOwnBundle) {
|
|
stream->fBundle = u_locbund_clone(stream->fBundle);
|
|
stream->fOwnBundle = TRUE;
|
|
format = u_locbund_getPercentFormat(stream->fBundle);
|
|
}
|
|
|
|
/* set the number of decimal digits */
|
|
|
|
/* save the formatter's state */
|
|
minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS);
|
|
maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS);
|
|
|
|
if(info->fPrecision != -1) {
|
|
/* set the # of decimal digits */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision);
|
|
}
|
|
else if(info->fPrecision == 0 && ! info->fAlt) {
|
|
/* no decimal point in this case */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, 0);
|
|
}
|
|
else if(info->fAlt) {
|
|
/* '#' means always show decimal point */
|
|
/* copy of printf behavior on Solaris - '#' shows 6 digits */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
|
|
}
|
|
else {
|
|
/* # of decimal digits is 6 if precision not specified */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
|
|
}
|
|
|
|
/* set whether to show the sign */
|
|
if(info->fShowSign) {
|
|
/* set whether to show the sign*/
|
|
/* {sfb} TODO */
|
|
}
|
|
|
|
/* format the number */
|
|
unum_formatDouble(format, num, result, UFPRINTF_BUFFER_SIZE, 0, &status);
|
|
|
|
/* restore the number format */
|
|
unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits);
|
|
unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits);
|
|
|
|
return u_printf_pad_and_justify(stream, info, result, u_strlen(result));
|
|
}
|
|
|
|
|
|
int32_t
|
|
u_printf_currency_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
double num = (double) (args[0].doubleValue);
|
|
UNumberFormat *format;
|
|
UChar result [UFPRINTF_BUFFER_SIZE];
|
|
int32_t minDecimalDigits;
|
|
int32_t maxDecimalDigits;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
|
|
/* mask off any necessary bits */
|
|
/* if(! info->fIsLongDouble)
|
|
num &= DBL_MAX;*/
|
|
|
|
/* get the formatter */
|
|
format = u_locbund_getCurrencyFormat(stream->fBundle);
|
|
|
|
/* handle error */
|
|
if(format == 0)
|
|
return 0;
|
|
|
|
/* set the appropriate flags on the formatter */
|
|
|
|
/* clone the stream's bundle if it isn't owned */
|
|
if(! stream->fOwnBundle) {
|
|
stream->fBundle = u_locbund_clone(stream->fBundle);
|
|
stream->fOwnBundle = TRUE;
|
|
format = u_locbund_getCurrencyFormat(stream->fBundle);
|
|
}
|
|
|
|
/* set the number of decimal digits */
|
|
|
|
/* save the formatter's state */
|
|
minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS);
|
|
maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS);
|
|
|
|
if(info->fPrecision != -1) {
|
|
/* set the # of decimal digits */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision);
|
|
}
|
|
else if(info->fPrecision == 0 && ! info->fAlt) {
|
|
/* no decimal point in this case */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, 0);
|
|
}
|
|
else if(info->fAlt) {
|
|
/* '#' means always show decimal point */
|
|
/* copy of printf behavior on Solaris - '#' shows 6 digits */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
|
|
}
|
|
else {
|
|
/* # of decimal digits is 6 if precision not specified */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
|
|
}
|
|
|
|
/* set whether to show the sign */
|
|
if(info->fShowSign) {
|
|
/* set whether to show the sign*/
|
|
/* {sfb} TODO */
|
|
}
|
|
|
|
/* format the number */
|
|
unum_formatDouble(format, num, result, UFPRINTF_BUFFER_SIZE, 0, &status);
|
|
|
|
/* restore the number format */
|
|
unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits);
|
|
unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits);
|
|
|
|
return u_printf_pad_and_justify(stream, info, result, u_strlen(result));
|
|
}
|
|
|
|
int32_t
|
|
u_printf_ustring_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
int32_t len, written;
|
|
const UChar *arg = (const UChar*)(args[0].ptrValue);
|
|
|
|
/* allocate enough space for the buffer */
|
|
len = u_strlen(arg);
|
|
|
|
/* width = minimum # of characters to write */
|
|
/* precision = maximum # of characters to write */
|
|
|
|
/* precision takes precedence over width */
|
|
/* determine if the string should be truncated */
|
|
if(info->fPrecision != -1 && len > info->fPrecision) {
|
|
written = u_file_write(arg, info->fPrecision, stream);
|
|
}
|
|
else {
|
|
/* determine if the string should be padded */
|
|
written = u_printf_pad_and_justify(stream, info, arg, len);
|
|
}
|
|
|
|
return written;
|
|
}
|
|
|
|
|
|
|
|
int32_t
|
|
u_printf_uchar_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
int32_t written = 0;
|
|
UChar arg = (UChar)(args[0].intValue);
|
|
|
|
|
|
/* width = minimum # of characters to write */
|
|
/* precision = maximum # of characters to write */
|
|
|
|
/* precision takes precedence over width */
|
|
/* determine if the char should be printed */
|
|
if(info->fPrecision != -1 && info->fPrecision < 1) {
|
|
/* write nothing */
|
|
written = 0;
|
|
}
|
|
else {
|
|
/* determine if the string should be padded */
|
|
written = u_printf_pad_and_justify(stream, info, &arg, 1);
|
|
}
|
|
|
|
return written;
|
|
}
|
|
|
|
int32_t
|
|
u_printf_scidbl_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
u_printf_spec_info scidbl_info;
|
|
double num = args[0].doubleValue;
|
|
|
|
memcpy(&scidbl_info, info, sizeof(u_printf_spec_info));
|
|
|
|
/* determine whether to use 'd', 'e' or 'f' notation */
|
|
if (scidbl_info.fPrecision == -1 && num == uprv_trunc(num))
|
|
{
|
|
/* use 'f' notation */
|
|
scidbl_info.fSpec = 0x0066;
|
|
scidbl_info.fPrecision = 0;
|
|
/* call the double handler */
|
|
return u_printf_double_handler(stream, &scidbl_info, args);
|
|
}
|
|
else if(num < 0.0001
|
|
|| (scidbl_info.fPrecision != -1 && num > uprv_pow10(scidbl_info.fPrecision)))
|
|
{
|
|
/* use 'e' or 'E' notation */
|
|
scidbl_info.fSpec = scidbl_info.fSpec - 1;
|
|
/* call the scientific handler */
|
|
return u_printf_scientific_handler(stream, &scidbl_info, args);
|
|
}
|
|
else {
|
|
/* use 'f' notation */
|
|
scidbl_info.fSpec = 0x0066;
|
|
/* call the double handler */
|
|
return u_printf_double_handler(stream, &scidbl_info, args);
|
|
}
|
|
}
|
|
|
|
|
|
int32_t
|
|
u_printf_count_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
int *count = (int*)(args[0].ptrValue);
|
|
|
|
/* in the special case of count, the u_printf_spec_info's width */
|
|
/* will contain the # of chars written thus far */
|
|
*count = info->fWidth;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int32_t
|
|
u_printf_spellout_handler(UFILE *stream,
|
|
const u_printf_spec_info *info,
|
|
const ufmt_args *args)
|
|
{
|
|
double num = (double) (args[0].doubleValue);
|
|
UNumberFormat *format;
|
|
UChar result [UFPRINTF_BUFFER_SIZE];
|
|
int32_t minDecimalDigits;
|
|
int32_t maxDecimalDigits;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
|
|
/* mask off any necessary bits */
|
|
/* if(! info->fIsLongDouble)
|
|
num &= DBL_MAX;*/
|
|
|
|
/* get the formatter */
|
|
format = u_locbund_getSpelloutFormat(stream->fBundle);
|
|
|
|
/* handle error */
|
|
if(format == 0)
|
|
return 0;
|
|
|
|
/* set the appropriate flags on the formatter */
|
|
|
|
/* clone the stream's bundle if it isn't owned */
|
|
if(! stream->fOwnBundle) {
|
|
stream->fBundle = u_locbund_clone(stream->fBundle);
|
|
stream->fOwnBundle = TRUE;
|
|
format = u_locbund_getSpelloutFormat(stream->fBundle);
|
|
}
|
|
|
|
/* set the number of decimal digits */
|
|
|
|
/* save the formatter's state */
|
|
minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS);
|
|
maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS);
|
|
|
|
if(info->fPrecision != -1) {
|
|
/* set the # of decimal digits */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision);
|
|
}
|
|
else if(info->fPrecision == 0 && ! info->fAlt) {
|
|
/* no decimal point in this case */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, 0);
|
|
}
|
|
else if(info->fAlt) {
|
|
/* '#' means always show decimal point */
|
|
/* copy of printf behavior on Solaris - '#' shows 6 digits */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
|
|
}
|
|
else {
|
|
/* # of decimal digits is 6 if precision not specified */
|
|
unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
|
|
}
|
|
|
|
/* set whether to show the sign */
|
|
if(info->fShowSign) {
|
|
/* set whether to show the sign*/
|
|
/* {sfb} TODO */
|
|
}
|
|
|
|
/* format the number */
|
|
unum_formatDouble(format, num, result, UFPRINTF_BUFFER_SIZE, 0, &status);
|
|
|
|
/* restore the number format */
|
|
unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits);
|
|
unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits);
|
|
|
|
return u_printf_pad_and_justify(stream, info, result, u_strlen(result));
|
|
}
|
|
|
|
#define UP_PERCENT 0x0025
|
|
|
|
U_CAPI int32_t U_EXPORT2 /* U_CAPI ... U_EXPORT2 added by Peter Kirk 17 Nov 2001 */
|
|
u_vfprintf_u( UFILE *f,
|
|
const UChar *patternSpecification,
|
|
va_list ap)
|
|
{
|
|
u_printf_spec spec;
|
|
const UChar *alias;
|
|
int32_t patCount, written;
|
|
uint16_t handlerNum;
|
|
|
|
ufmt_args args;
|
|
|
|
ufmt_type_info info;
|
|
u_printf_handler handler;
|
|
|
|
/* alias the pattern */
|
|
alias = patternSpecification;
|
|
|
|
/* haven't written anything yet */
|
|
written = 0;
|
|
|
|
/* iterate through the pattern */
|
|
for(;;) {
|
|
|
|
/* find the next '%' */
|
|
patCount = 0;
|
|
while(*alias != UP_PERCENT && *alias != 0x0000) {
|
|
alias++;
|
|
++patCount;
|
|
}
|
|
|
|
/* write any characters before the '%' */
|
|
if(patCount > 0)
|
|
written += u_file_write(alias - patCount, patCount, f);
|
|
|
|
/* break if at end of string */
|
|
if(*alias == 0x0000)
|
|
break;
|
|
|
|
/* parse the specifier */
|
|
patCount = u_printf_parse_spec(alias, &spec);
|
|
|
|
/* fill in the precision and width, if specified out of line */
|
|
|
|
/* width specified out of line */
|
|
if(spec.fInfo.fWidth == -2) {
|
|
if(spec.fWidthPos == -1) {
|
|
/* read the width from the argument list */
|
|
spec.fInfo.fWidth = va_arg(ap, int);
|
|
}
|
|
else {
|
|
/* handle positional parameter */
|
|
}
|
|
|
|
/* if it's negative, take the absolute value and set left alignment */
|
|
if(spec.fInfo.fWidth < 0) {
|
|
spec.fInfo.fWidth *= -1;
|
|
spec.fInfo.fLeft = TRUE;
|
|
}
|
|
}
|
|
|
|
/* precision specified out of line */
|
|
if(spec.fInfo.fPrecision == -2) {
|
|
if(spec.fPrecisionPos == -1) {
|
|
/* read the precision from the argument list */
|
|
spec.fInfo.fPrecision = va_arg(ap, int);
|
|
}
|
|
else {
|
|
/* handle positional parameter */
|
|
}
|
|
|
|
/* if it's negative, set it to zero */
|
|
if(spec.fInfo.fPrecision < 0)
|
|
spec.fInfo.fPrecision = 0;
|
|
}
|
|
|
|
handlerNum = (uint16_t)(spec.fInfo.fSpec - UPRINTF_BASE_FMT_HANDLERS);
|
|
if (handlerNum < UPRINTF_NUM_FMT_HANDLERS) {
|
|
/* query the info function for argument information */
|
|
info = g_u_printf_infos[ handlerNum ].info;
|
|
if(info > ufmt_simple_percent) {
|
|
switch(info) {
|
|
|
|
case ufmt_count:
|
|
/* set the spec's width to the # of chars written */
|
|
spec.fInfo.fWidth = written;
|
|
|
|
case ufmt_char:
|
|
case ufmt_uchar:
|
|
case ufmt_int:
|
|
args.intValue = va_arg(ap, int);
|
|
break;
|
|
|
|
case ufmt_wchar:
|
|
args.wcharValue = va_arg(ap, wchar_t);
|
|
break;
|
|
|
|
case ufmt_string:
|
|
args.ptrValue = va_arg(ap, char*);
|
|
break;
|
|
|
|
case ufmt_wstring:
|
|
args.ptrValue = va_arg(ap, wchar_t*);
|
|
break;
|
|
|
|
case ufmt_ustring:
|
|
args.ptrValue = va_arg(ap, UChar*);
|
|
break;
|
|
|
|
case ufmt_pointer:
|
|
args.ptrValue = va_arg(ap, void*);
|
|
break;
|
|
|
|
case ufmt_float:
|
|
args.floatValue = (float) va_arg(ap, double);
|
|
break;
|
|
|
|
case ufmt_double:
|
|
args.doubleValue = va_arg(ap, double);
|
|
break;
|
|
|
|
case ufmt_date:
|
|
args.dateValue = va_arg(ap, UDate);
|
|
break;
|
|
|
|
default:
|
|
break; /* Should never get here */
|
|
}
|
|
}
|
|
|
|
/* call the handler function */
|
|
handler = g_u_printf_infos[ handlerNum ].handler;
|
|
if(handler != 0) {
|
|
written += (*handler)(f, &spec.fInfo, &args);
|
|
}
|
|
else {
|
|
/* just echo unknown tags */
|
|
written += u_file_write(alias, patCount, f);
|
|
}
|
|
}
|
|
else {
|
|
/* just echo unknown tags */
|
|
written += u_file_write(alias, patCount, f);
|
|
}
|
|
|
|
/* update the pointer in pattern and continue */
|
|
alias += patCount;
|
|
}
|
|
|
|
/* return # of UChars written */
|
|
return written;
|
|
}
|
|
|