static int32_t
u_scanf_integer_handler(UFILE *input,
u_scanf_spec_info *info,
ufmt_args *args,
const UChar *fmt,
int32_t *fmtConsumed,
int32_t *argConverted)
{
int32_t len;
void *num = (void*) (args[0].ptrValue);
UNumberFormat *format;
int32_t parsePos = 0;
int32_t skipped;
UErrorCode status = U_ZERO_ERROR;
int64_t result;
/* skip all ws in the input */
skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
/* fill the input's internal buffer */
ufile_fill_uchar_buffer(input);
/* determine the size of the input's buffer */
len = (int32_t)(input->str.fLimit - input->str.fPos);
/* truncate to the width, if specified */
if(info->fWidth != -1)
len = ufmt_min(len, info->fWidth);
/* get the formatter */
format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_DECIMAL);
/* handle error */
if(format == 0)
return 0;
/* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */
skipped += u_scanf_skip_leading_positive_sign(input, format, &status);
/* parse the number */
result = unum_parseInt64(format, input->str.fPos, len, &parsePos, &status);
/* mask off any necessary bits */
if (!info->fSkipArg) {
if (info->fIsShort)
*(int16_t*)num = (int16_t)(UINT16_MAX & result);
else if (info->fIsLongLong)
*(int64_t*)num = result;
else
*(int32_t*)num = (int32_t)(UINT32_MAX & result);
}
/* update the input's position to reflect consumed data */
input->str.fPos += parsePos;
/* we converted 1 arg */
*argConverted = !info->fSkipArg;
return parsePos + skipped;
}
static int32_t
u_scanf_spellout_handler(UFILE *input,
u_scanf_spec_info *info,
ufmt_args *args,
const UChar *fmt,
int32_t *fmtConsumed,
int32_t *argConverted)
{
int32_t len;
double num;
UNumberFormat *format;
int32_t parsePos = 0;
int32_t skipped;
UErrorCode status = U_ZERO_ERROR;
/* skip all ws in the input */
skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
/* fill the input's internal buffer */
ufile_fill_uchar_buffer(input);
/* determine the size of the input's buffer */
len = (int32_t)(input->str.fLimit - input->str.fPos);
/* truncate to the width, if specified */
if(info->fWidth != -1)
len = ufmt_min(len, info->fWidth);
/* get the formatter */
format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_SPELLOUT);
/* handle error */
if(format == 0)
return 0;
/* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */
/* This is not applicable to RBNF. */
/*skipped += u_scanf_skip_leading_positive_sign(input, format, &status);*/
/* parse the number */
num = unum_parseDouble(format, input->str.fPos, len, &parsePos, &status);
if (!info->fSkipArg) {
*(double*)(args[0].ptrValue) = num;
}
/* mask off any necessary bits */
/* if(! info->fIsLong_double)
num &= DBL_MAX;*/
/* update the input's position to reflect consumed data */
input->str.fPos += parsePos;
/* we converted 1 arg */
*argConverted = !info->fSkipArg;
return parsePos + skipped;
}
static int32_t
u_printf_scidbl_handler(const u_printf_stream_handler *handler,
void *context,
ULocaleBundle *formatBundle,
const u_printf_spec_info *info,
const ufmt_args *args)
{
u_printf_spec_info scidbl_info;
double num = args[0].doubleValue;
int32_t retVal;
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 */
retVal = u_printf_double_handler(handler, context, formatBundle, &scidbl_info, args);
}
else if(num < 0.0001 || (scidbl_info.fPrecision < 1 && 1000000.0 <= num)
|| (scidbl_info.fPrecision != -1 && num > uprv_pow10(scidbl_info.fPrecision)))
{
/* use 'e' or 'E' notation */
scidbl_info.fSpec = scidbl_info.fSpec - 2;
if (scidbl_info.fPrecision == -1) {
scidbl_info.fPrecision = 5;
}
/* call the scientific handler */
retVal = u_printf_scientific_handler(handler, context, formatBundle, &scidbl_info, args);
}
else {
UNumberFormat *format = u_locbund_getNumberFormat(formatBundle, UNUM_DECIMAL);
int32_t maxSigDecimalDigits = unum_getAttribute(format, UNUM_MAX_SIGNIFICANT_DIGITS);
int32_t significantDigits = scidbl_info.fPrecision;
/* use 'f' notation */
scidbl_info.fSpec = 0x0066;
if (significantDigits == -1) {
significantDigits = 6;
}
unum_setAttribute(format, UNUM_SIGNIFICANT_DIGITS_USED, TRUE);
unum_setAttribute(format, UNUM_MAX_SIGNIFICANT_DIGITS, significantDigits);
/* call the double handler */
retVal = u_printf_double_handler(handler, context, formatBundle, &scidbl_info, args);
unum_setAttribute(format, UNUM_MAX_SIGNIFICANT_DIGITS, maxSigDecimalDigits);
unum_setAttribute(format, UNUM_SIGNIFICANT_DIGITS_USED, FALSE);
}
return retVal;
}
static int32_t
u_printf_uinteger_handler(const u_printf_stream_handler *handler,
void *context,
ULocaleBundle *formatBundle,
const u_printf_spec_info *info,
const ufmt_args *args)
{
int64_t num = args[0].int64Value;
UNumberFormat *format;
UChar result[UPRINTF_BUFFER_SIZE];
int32_t minDigits = -1;
int32_t resultLen;
UErrorCode status = U_ZERO_ERROR;
/* TODO: Fix this once uint64_t can be formatted. */
if (info->fIsShort)
num &= UINT16_MAX;
else if (!info->fIsLongLong)
num &= UINT32_MAX;
/* get the formatter */
format = u_locbund_getNumberFormat(formatBundle, UNUM_DECIMAL);
/* handle error */
if(format == 0)
return 0;
/* set the appropriate flags on the formatter */
/* set the minimum integer digits */
if(info->fPrecision != -1) {
/* set the minimum # of digits */
minDigits = unum_getAttribute(format, UNUM_MIN_INTEGER_DIGITS);
unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, info->fPrecision);
}
/* To mirror other stdio implementations, we ignore the sign argument */
/* format the number */
resultLen = unum_formatInt64(format, num, result, UPRINTF_BUFFER_SIZE, 0, &status);
if (U_FAILURE(status)) {
resultLen = 0;
}
/* restore the number format */
if (minDigits != -1) {
unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, minDigits);
}
return handler->pad_and_justify(context, info, result, resultLen);
}
int32_t
u_sprintf_double_handler(u_localized_string *output,
const u_sprintf_spec_info *info,
const ufmt_args *args)
{
double num = (double) (args[0].doubleValue);
UNumberFormat *format;
UChar result [USPRINTF_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(output->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(! output->fOwnBundle) {
output->fBundle = u_locbund_clone(output->fBundle);
output->fOwnBundle = TRUE;
format = u_locbund_getNumberFormat(output->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 regardless of locale */
unum_setAttribute(format, UNUM_FRACTION_DIGITS, 6);
}
/* set whether to show the sign */
u_sprintf_set_sign(format, info, &status);
/* format the number */
unum_formatDouble(format, num, result, USPRINTF_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_sprintf_pad_and_justify(output, info, result, u_strlen(result));
}
/* HSYS */
int32_t
u_sprintf_integer_handler(u_localized_string *output,
const u_sprintf_spec_info *info,
const ufmt_args *args)
{
long num = (long) (args[0].intValue);
UNumberFormat *format;
UChar result [USPRINTF_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(output->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(! output->fOwnBundle) {
output->fBundle = u_locbund_clone(output->fBundle);
output->fOwnBundle = TRUE;
format = u_locbund_getNumberFormat(output->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(! output->fOwnBundle) {
output->fBundle = u_locbund_clone(output->fBundle);
output->fOwnBundle = TRUE;
format = u_locbund_getNumberFormat(output->fBundle);
}
u_sprintf_set_sign(format, info, &status);
}
/* format the number */
unum_format(format, num, result, USPRINTF_BUFFER_SIZE, 0, &status);
/* restore the number format */
if(minDigits != -1) {
unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, minDigits);
}
return u_sprintf_pad_and_justify(output, info, result, u_strlen(result));
}
U_CAPI const UNumberFormat* U_EXPORT2 u_fgetNumberFormat(UFILE *file)
{
return u_locbund_getNumberFormat(&file->str.fBundle, UNUM_DECIMAL);
}
static int32_t
u_scanf_scidbl_handler(UFILE *input,
u_scanf_spec_info *info,
ufmt_args *args,
const UChar *fmt,
int32_t *fmtConsumed,
int32_t *argConverted)
{
int32_t len;
double num;
UNumberFormat *scientificFormat, *genericFormat;
/*int32_t scientificResult, genericResult;*/
double scientificResult, genericResult;
int32_t scientificParsePos = 0, genericParsePos = 0, parsePos = 0;
int32_t skipped;
UErrorCode scientificStatus = U_ZERO_ERROR;
UErrorCode genericStatus = U_ZERO_ERROR;
/* since we can't determine by scanning the characters whether */
/* a number was formatted in the 'f' or 'g' styles, parse the */
/* string with both formatters, and assume whichever one */
/* parsed the most is the correct formatter to use */
/* skip all ws in the input */
skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
/* fill the input's internal buffer */
ufile_fill_uchar_buffer(input);
/* determine the size of the input's buffer */
len = (int32_t)(input->str.fLimit - input->str.fPos);
/* truncate to the width, if specified */
if(info->fWidth != -1)
len = ufmt_min(len, info->fWidth);
/* get the formatters */
scientificFormat = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_SCIENTIFIC);
genericFormat = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_DECIMAL);
/* handle error */
if(scientificFormat == 0 || genericFormat == 0)
return 0;
/* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */
skipped += u_scanf_skip_leading_positive_sign(input, genericFormat, &genericStatus);
/* parse the number using each format*/
scientificResult = unum_parseDouble(scientificFormat, input->str.fPos, len,
&scientificParsePos, &scientificStatus);
genericResult = unum_parseDouble(genericFormat, input->str.fPos, len,
&genericParsePos, &genericStatus);
/* determine which parse made it farther */
if(scientificParsePos > genericParsePos) {
/* stash the result in num */
num = scientificResult;
/* update the input's position to reflect consumed data */
parsePos += scientificParsePos;
}
else {
/* stash the result in num */
num = genericResult;
/* update the input's position to reflect consumed data */
parsePos += genericParsePos;
}
input->str.fPos += parsePos;
if (!info->fSkipArg) {
if (info->fIsLong)
*(double*)(args[0].ptrValue) = num;
else if (info->fIsLongDouble)
*(long double*)(args[0].ptrValue) = num;
else
*(float*)(args[0].ptrValue) = (float)num;
}
/* mask off any necessary bits */
/* if(! info->fIsLong_double)
num &= DBL_MAX;*/
/* we converted 1 arg */
*argConverted = !info->fSkipArg;
return parsePos + skipped;
}
static int32_t
u_scanf_scientific_handler(UFILE *input,
u_scanf_spec_info *info,
ufmt_args *args,
const UChar *fmt,
int32_t *fmtConsumed,
int32_t *argConverted)
{
int32_t len;
double num;
UNumberFormat *format;
int32_t parsePos = 0;
int32_t skipped;
UErrorCode status = U_ZERO_ERROR;
UChar srcExpBuf[UPRINTF_SYMBOL_BUFFER_SIZE];
int32_t srcLen, expLen;
UChar expBuf[UPRINTF_SYMBOL_BUFFER_SIZE];
/* skip all ws in the input */
skipped = u_scanf_skip_leading_ws(input, info->fPadChar);
/* fill the input's internal buffer */
ufile_fill_uchar_buffer(input);
/* determine the size of the input's buffer */
len = (int32_t)(input->str.fLimit - input->str.fPos);
/* truncate to the width, if specified */
if(info->fWidth != -1)
len = ufmt_min(len, info->fWidth);
/* get the formatter */
format = u_locbund_getNumberFormat(&input->str.fBundle, UNUM_SCIENTIFIC);
/* handle error */
if(format == 0)
return 0;
/* set the appropriate flags on the formatter */
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,
input->str.fBundle.fLocale,
&status);
}
else {
expLen = u_strToUpper(expBuf, (int32_t)sizeof(expBuf),
srcExpBuf, srcLen,
input->str.fBundle.fLocale,
&status);
}
unum_setSymbol(format,
UNUM_EXPONENTIAL_SYMBOL,
expBuf,
expLen,
&status);
/* Skip the positive prefix. ICU normally can't handle this due to strict parsing. */
skipped += u_scanf_skip_leading_positive_sign(input, format, &status);
/* parse the number */
num = unum_parseDouble(format, input->str.fPos, len, &parsePos, &status);
if (!info->fSkipArg) {
if (info->fIsLong)
*(double*)(args[0].ptrValue) = num;
else if (info->fIsLongDouble)
*(long double*)(args[0].ptrValue) = num;
else
*(float*)(args[0].ptrValue) = (float)num;
}
/* mask off any necessary bits */
/* if(! info->fIsLong_double)
num &= DBL_MAX;*/
/* update the input's position to reflect consumed data */
input->str.fPos += parsePos;
/* we converted 1 arg */
*argConverted = !info->fSkipArg;
return parsePos + skipped;
}
static int32_t
u_printf_spellout_handler(const u_printf_stream_handler *handler,
void *context,
ULocaleBundle *formatBundle,
const u_printf_spec_info *info,
const ufmt_args *args)
{
double num = (double) (args[0].doubleValue);
UNumberFormat *format;
UChar result[UPRINTF_BUFFER_SIZE];
UChar prefixBuffer[UPRINTF_BUFFER_SIZE];
int32_t prefixBufferLen = sizeof(prefixBuffer);
int32_t minDecimalDigits;
int32_t maxDecimalDigits;
int32_t resultLen;
UErrorCode status = U_ZERO_ERROR;
prefixBuffer[0] = 0;
/* mask off any necessary bits */
/* if(! info->fIsLongDouble)
num &= DBL_MAX;*/
/* get the formatter */
format = u_locbund_getNumberFormat(formatBundle, UNUM_SPELLOUT);
/* handle error */
if(format == 0)
return 0;
/* save the formatter's state */
minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS);
maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS);
/* set the appropriate flags and number of decimal digits on the formatter */
if(info->fPrecision != -1) {
/* set the # of decimal digits */
unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision);
}
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) {
u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status);
}
/* format the number */
resultLen = unum_formatDouble(format, num, result, UPRINTF_BUFFER_SIZE, 0, &status);
if (U_FAILURE(status)) {
resultLen = 0;
}
/* restore the number format */
/* TODO: Is this needed? */
unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits);
unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits);
if (info->fShowSign) {
/* Reset back to original value regardless of what the error was */
UErrorCode localStatus = U_ZERO_ERROR;
u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &localStatus);
}
return handler->pad_and_justify(context, info, result, resultLen);
}
static int32_t
u_printf_scientific_handler(const u_printf_stream_handler *handler,
void *context,
ULocaleBundle *formatBundle,
const u_printf_spec_info *info,
const ufmt_args *args)
{
double num = (double) (args[0].doubleValue);
UNumberFormat *format;
UChar result[UPRINTF_BUFFER_SIZE];
UChar prefixBuffer[UPRINTF_BUFFER_SIZE];
int32_t prefixBufferLen = sizeof(prefixBuffer);
int32_t minDecimalDigits;
int32_t maxDecimalDigits;
UErrorCode status = U_ZERO_ERROR;
UChar srcExpBuf[UPRINTF_SYMBOL_BUFFER_SIZE];
int32_t srcLen, expLen;
int32_t resultLen;
UChar expBuf[UPRINTF_SYMBOL_BUFFER_SIZE];
prefixBuffer[0] = 0;
/* mask off any necessary bits */
/* if(! info->fIsLongDouble)
num &= DBL_MAX;*/
/* get the formatter */
format = u_locbund_getNumberFormat(formatBundle, UNUM_SCIENTIFIC);
/* handle error */
if(format == 0)
return 0;
/* set the appropriate flags on the formatter */
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,
formatBundle->fLocale,
&status);
}
else {
expLen = u_strToUpper(expBuf, (int32_t)sizeof(expBuf),
srcExpBuf, srcLen,
formatBundle->fLocale,
&status);
}
unum_setSymbol(format,
UNUM_EXPONENTIAL_SYMBOL,
expBuf,
expLen,
&status);
/* save the formatter's state */
minDecimalDigits = unum_getAttribute(format, UNUM_MIN_FRACTION_DIGITS);
maxDecimalDigits = unum_getAttribute(format, UNUM_MAX_FRACTION_DIGITS);
/* set the appropriate flags and number of decimal digits on the formatter */
if(info->fPrecision != -1) {
/* set the # of decimal digits */
if (info->fOrigSpec == (UChar)0x65 /* e */ || info->fOrigSpec == (UChar)0x45 /* E */) {
unum_setAttribute(format, UNUM_FRACTION_DIGITS, info->fPrecision);
}
else {
unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, 1);
unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, info->fPrecision);
}
}
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) {
u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status);
}
/* format the number */
resultLen = unum_formatDouble(format, num, result, UPRINTF_BUFFER_SIZE, 0, &status);
if (U_FAILURE(status)) {
resultLen = 0;
}
/* restore the number format */
/* TODO: Is this needed? */
unum_setAttribute(format, UNUM_MIN_FRACTION_DIGITS, minDecimalDigits);
unum_setAttribute(format, UNUM_MAX_FRACTION_DIGITS, maxDecimalDigits);
/* Since we're the only one using the scientific
format, we don't need to save the old exponent value. */
/*unum_setSymbol(format,
UNUM_EXPONENTIAL_SYMBOL,
srcExpBuf,
srcLen,
&status);*/
if (info->fShowSign) {
/* Reset back to original value regardless of what the error was */
UErrorCode localStatus = U_ZERO_ERROR;
u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &localStatus);
}
return handler->pad_and_justify(context, info, result, resultLen);
}
/* HSYS */
static int32_t
u_printf_integer_handler(const u_printf_stream_handler *handler,
void *context,
ULocaleBundle *formatBundle,
const u_printf_spec_info *info,
const ufmt_args *args)
{
int64_t num = args[0].int64Value;
UNumberFormat *format;
UChar result[UPRINTF_BUFFER_SIZE];
UChar prefixBuffer[UPRINTF_BUFFER_SIZE];
int32_t prefixBufferLen = sizeof(prefixBuffer);
int32_t minDigits = -1;
int32_t resultLen;
UErrorCode status = U_ZERO_ERROR;
prefixBuffer[0] = 0;
/* mask off any necessary bits */
if (info->fIsShort)
num = (int16_t)num;
else if (!info->fIsLongLong)
num = (int32_t)num;
/* get the formatter */
format = u_locbund_getNumberFormat(formatBundle, UNUM_DECIMAL);
/* handle error */
if(format == 0)
return 0;
/* set the appropriate flags on the formatter */
/* set the minimum integer digits */
if(info->fPrecision != -1) {
/* 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) {
u_printf_set_sign(format, info, prefixBuffer, &prefixBufferLen, &status);
}
/* format the number */
resultLen = unum_formatInt64(format, num, result, UPRINTF_BUFFER_SIZE, 0, &status);
if (U_FAILURE(status)) {
resultLen = 0;
}
/* restore the number format */
if (minDigits != -1) {
unum_setAttribute(format, UNUM_MIN_INTEGER_DIGITS, minDigits);
}
if (info->fShowSign) {
/* Reset back to original value regardless of what the error was */
UErrorCode localStatus = U_ZERO_ERROR;
u_printf_reset_sign(format, info, prefixBuffer, &prefixBufferLen, &localStatus);
}
return handler->pad_and_justify(context, info, result, resultLen);
}
