void ICULocale::setDecimalSymbol(unsigned index, UNumberFormatSymbol symbol)
{
UErrorCode status = U_ZERO_ERROR;
int32_t bufferLength = unum_getSymbol(m_numberFormat, symbol, 0, 0, &status);
ASSERT(U_SUCCESS(status) || status == U_BUFFER_OVERFLOW_ERROR);
if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
return;
Vector<UChar> buffer(bufferLength);
status = U_ZERO_ERROR;
unum_getSymbol(m_numberFormat, symbol, buffer.data(), bufferLength, &status);
if (U_FAILURE(status))
return;
m_decimalSymbols[index] = String::adopt(buffer);
}
String LocaleICU::decimalSymbol(UNumberFormatSymbol symbol)
{
UErrorCode status = U_ZERO_ERROR;
int32_t bufferLength = unum_getSymbol(m_numberFormat, symbol, 0, 0, &status);
ASSERT(U_SUCCESS(status) || status == U_BUFFER_OVERFLOW_ERROR);
if (U_FAILURE(status) && status != U_BUFFER_OVERFLOW_ERROR)
return String();
StringBuffer<UChar> buffer(bufferLength);
status = U_ZERO_ERROR;
unum_getSymbol(m_numberFormat, symbol, buffer.characters(), bufferLength, &status);
if (U_FAILURE(status))
return String();
return String::adopt(buffer);
}
/* TODO: Is setting the prefix symbol to a positive sign a good idea in all locales? */
static void
u_sprintf_set_sign(UNumberFormat *format,
const u_sprintf_spec_info *info,
UErrorCode *status)
{
if(info->fShowSign) {
if (info->fSpace) {
/* Setting UNUM_PLUS_SIGN_SYMBOL affects the exponent too. */
/* unum_setSymbol(format, UNUM_PLUS_SIGN_SYMBOL, gSpaceStr, 1, &status); */
unum_setTextAttribute(format, UNUM_POSITIVE_PREFIX, gSpaceStr, 1, status);
}
else {
UChar plusSymbol[USPRINTF_SYMBOL_BUFFER_SIZE];
int32_t symbolLen;
symbolLen = unum_getSymbol(format,
UNUM_PLUS_SIGN_SYMBOL,
plusSymbol,
sizeof(plusSymbol)/sizeof(*plusSymbol),
status);
unum_setTextAttribute(format,
UNUM_POSITIVE_PREFIX,
plusSymbol,
symbolLen,
status);
}
}
}
/* TODO: Is always skipping the prefix symbol as a positive sign a good idea in all locales? */
static int32_t
u_scanf_skip_leading_positive_sign(UFILE *input,
UNumberFormat *format,
UErrorCode *status)
{
UChar c;
int32_t count = 0;
UBool isNotEOF;
UChar plusSymbol[USCANF_SYMBOL_BUFFER_SIZE];
int32_t symbolLen;
UErrorCode localStatus = U_ZERO_ERROR;
if (U_SUCCESS(*status)) {
symbolLen = unum_getSymbol(format,
UNUM_PLUS_SIGN_SYMBOL,
plusSymbol,
UPRV_LENGTHOF(plusSymbol),
&localStatus);
if (U_SUCCESS(localStatus)) {
/* skip all leading ws in the input */
while( (isNotEOF = ufile_getch(input, &c)) && (count < symbolLen && c == plusSymbol[count]) )
{
count++;
}
/* put the final character back on the input */
if(isNotEOF) {
u_fungetc(c, input);
}
}
}
return count;
}
static String HHVM_METHOD(NumberFormatter, getSymbol, int64_t attr) {
NUMFMT_GET(obj, this_, String());
UErrorCode error = U_ZERO_ERROR;
int32_t len = unum_getSymbol(obj->formatter(),
(UNumberFormatSymbol)attr,
nullptr, 0, &error);
if (error != U_BUFFER_OVERFLOW_ERROR) {
obj->setError(error);
return String();
}
icu::UnicodeString out;
error = U_ZERO_ERROR;
len = unum_getSymbol(obj->formatter(), (UNumberFormatSymbol)attr,
out.getBuffer(len + 1), len + 1, &error);
NUMFMT_CHECK(obj, error, String());
out.releaseBuffer(len);
String ret(u8(out, error));
NUMFMT_CHECK(obj, error, String());
return ret;
}
/*
Function:
GetLocaleInfoDecimalFormatSymbol
Obtains the value of a DecimalFormatSymbols
*/
static UErrorCode GetLocaleInfoDecimalFormatSymbol(const char* locale,
UNumberFormatSymbol symbol,
UChar* value,
int32_t valueLength)
{
UErrorCode status = U_ZERO_ERROR;
UNumberFormat* pFormat = unum_open(UNUM_DECIMAL, NULL, 0, locale, NULL, &status);
unum_getSymbol(pFormat, symbol, value, valueLength, &status);
unum_close(pFormat);
return status;
}
/*
Function:
GetLocaleInfoDecimalFormatSymbol
Obtains the value of a DecimalFormatSymbols
*/
UErrorCode
GetLocaleInfoDecimalFormatSymbol(const char* locale, UNumberFormatSymbol symbol, UChar* value, int32_t valueLength)
{
UErrorCode status = U_ZERO_ERROR;
UNumberFormat* pFormat = unum_open(UNUM_DECIMAL, nullptr, 0, locale, nullptr, &status);
UNumberFormatHolder formatHolder(pFormat, status);
if (U_FAILURE(status))
{
return status;
}
unum_getSymbol(pFormat, symbol, value, valueLength, &status);
return status;
}
int32_t
u_sprintf_scientific_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;
UChar srcExpBuf[USPRINTF_SYMBOL_BUFFER_SIZE];
int32_t srcLen, expLen;
UChar expBuf[USPRINTF_SYMBOL_BUFFER_SIZE];
/* mask off any necessary bits */
/* if(! info->fIsLongDouble)
num &= DBL_MAX;*/
/* get the formatter */
format = u_locbund_getScientificFormat(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_getScientificFormat(output->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,
output->fBundle->fLocale,
&status);
}
else {
expLen = u_strToUpper(expBuf, (int32_t)sizeof(expBuf),
srcExpBuf, srcLen,
output->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 */
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);
/* Since we clone the fBundle and we're only using the scientific
format, we don't need to save the old exponent value. */
/*unum_setSymbol(format,
UNUM_EXPONENTIAL_SYMBOL,
srcExpBuf,
srcLen,
&status);*/
return u_sprintf_pad_and_justify(output, info, result, u_strlen(result));
}
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_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);
}
