Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-06 09:05:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
8315c8b7f8
gecko-dev/intl/icu/source/i18n/unum.cpp
Jeff Walden 013fc50cd5 Bug 924839 - Update our embedded ICU to 52.1, plus a very few local patches. r=lots of people, see subsequent lines in this commit message for the original subcomponents (merged together for landing), and the original bug for the original patch divisions 
Bug 924839 - Remove a patch already part of ICU 52.1.  See http://bugs.icu-project.org/trac/ticket/10283 but also note the relevant code was removed completely upstream.  r=glandium
* * *
Bug 924839 - Remove another patch already part of ICU 52.1.  See http://bugs.icu-project.org/trac/ticket/10290 for that.  r=gaston
* * *
Bug 924839 - Remove another patch already in ICU 52.1.  See http://bugs.icu-project.org/trac/ticket/10045 for more.  r=Norbert
* * *
Bug 924839 - Remove another patch already applied upstream.  See http://bugs.icu-project.org/trac/changeset/32937 for more.  r=gaston
* * *
Bug 924839 - Update the ICU update script to update to 52.1, *without* applying any of our local patches.  r=glandium
* * *
Bug 924839 - Make the ICU update script only do updating within intl/icu/source and nowhere else.  r=glandium
* * *
Bug 924839 - Implement the changes that would be made by |cd intl/; ./update-icu.sh http://source.icu-project.org/repos/icu/icu/tags/release-52-1/;|, run with the prior changesets' changes made (thus not applying any of our local patches).  These changes don't actually work without subsequent adjustments, but this provides a codebase upon which those adjustments can be made, for the purpose of generating local patches to be kept in intl/icu-patches/.  rs=the-usual-suspects
* * *
Bug 924839 - Update the bug 899722 local patch to make runConfigureICU not override CC/CXX on BSD systems.  r=gaston
* * *
Bug 924839 - Update the bug 724533 patch that makes ICU builds with MozillaBuild on Windows.  r=glandium
* * *
Bug 924839 - Import an upstream patch fixing the genrb tool to properly handle the -R (--omitCollationRules) option.  See http://bugs.icu-project.org/trac/ticket/10043 for the original bug report and a link to the ultimate upstream landing.  r=Norbert
* * *
Bug 924839 - Import the upstream fix for http://bugs.icu-project.org/trac/ticket/10486 so that ICU with -DU_USING_ICU_NAMESPACE=0 will compile on Windows.  r=Norbert
* * *
Bug 924839 - Adjust the update script to update ICU, then to apply all local patches (rather than skipping the second step).  Thus if the update script is properly run, now, the final result should be no changes at all to the tree.  NOT REVIEWED YET
* * *
Bug 924839 - Update jstests that depend on CLDR locale data to match CLDR 24.  r=Norbert
2013-11-12 16:23:48 -08:00

843 lines
24 KiB
C++
Raw Blame History

/*
*******************************************************************************
* Copyright (C) 1996-2013, International Business Machines
* Corporation and others. All Rights Reserved.
*******************************************************************************
* Modification History:
*
* Date Name Description
* 06/24/99 helena Integrated Alan's NF enhancements and Java2 bug fixes
*******************************************************************************
*/
#include "unicode/utypes.h"
#if !UCONFIG_NO_FORMATTING
#include "unicode/unum.h"
#include "unicode/uloc.h"
#include "unicode/numfmt.h"
#include "unicode/decimfmt.h"
#include "unicode/rbnf.h"
#include "unicode/ustring.h"
#include "unicode/fmtable.h"
#include "unicode/dcfmtsym.h"
#include "unicode/curramt.h"
#include "unicode/localpointer.h"
#include "uassert.h"
#include "cpputils.h"
#include "cstring.h"
U_NAMESPACE_USE
U_CAPI UNumberFormat* U_EXPORT2
unum_open( UNumberFormatStyle style,
const UChar* pattern,
int32_t patternLength,
const char* locale,
UParseError* parseErr,
UErrorCode* status) {
if(U_FAILURE(*status)) {
return NULL;
}
NumberFormat *retVal = NULL;
switch(style) {
case UNUM_DECIMAL:
case UNUM_CURRENCY:
case UNUM_PERCENT:
case UNUM_SCIENTIFIC:
retVal = NumberFormat::createInstance(Locale(locale), style, *status);
break;
case UNUM_PATTERN_DECIMAL: {
UParseError tErr;
/* UnicodeString can handle the case when patternLength = -1. */
const UnicodeString pat(pattern, patternLength);
if(parseErr==NULL){
parseErr = &tErr;
}
DecimalFormatSymbols *syms = new DecimalFormatSymbols(Locale(locale), *status);
if(syms == NULL) {
*status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
if (U_FAILURE(*status)) {
delete syms;
return NULL;
}
retVal = new DecimalFormat(pat, syms, *parseErr, *status);
if(retVal == NULL) {
delete syms;
}
} break;
#if U_HAVE_RBNF
case UNUM_PATTERN_RULEBASED: {
UParseError tErr;
/* UnicodeString can handle the case when patternLength = -1. */
const UnicodeString pat(pattern, patternLength);
if(parseErr==NULL){
parseErr = &tErr;
}
retVal = new RuleBasedNumberFormat(pat, Locale(locale), *parseErr, *status);
} break;
case UNUM_SPELLOUT:
retVal = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale(locale), *status);
break;
case UNUM_ORDINAL:
retVal = new RuleBasedNumberFormat(URBNF_ORDINAL, Locale(locale), *status);
break;
case UNUM_DURATION:
retVal = new RuleBasedNumberFormat(URBNF_DURATION, Locale(locale), *status);
break;
case UNUM_NUMBERING_SYSTEM:
retVal = new RuleBasedNumberFormat(URBNF_NUMBERING_SYSTEM, Locale(locale), *status);
break;
#endif
default:
*status = U_UNSUPPORTED_ERROR;
return NULL;
}
if(retVal == NULL && U_SUCCESS(*status)) {
*status = U_MEMORY_ALLOCATION_ERROR;
}
return reinterpret_cast<UNumberFormat *>(retVal);
}
U_CAPI void U_EXPORT2
unum_close(UNumberFormat* fmt)
{
delete (NumberFormat*) fmt;
}
U_CAPI UNumberFormat* U_EXPORT2
unum_clone(const UNumberFormat *fmt,
UErrorCode *status)
{
if(U_FAILURE(*status))
return 0;
Format *res = 0;
const NumberFormat* nf = reinterpret_cast<const NumberFormat*>(fmt);
const DecimalFormat* df = dynamic_cast<const DecimalFormat*>(nf);
if (df != NULL) {
res = df->clone();
} else {
const RuleBasedNumberFormat* rbnf = dynamic_cast<const RuleBasedNumberFormat*>(nf);
U_ASSERT(rbnf != NULL);
res = rbnf->clone();
}
if(res == 0) {
*status = U_MEMORY_ALLOCATION_ERROR;
return 0;
}
return (UNumberFormat*) res;
}
U_CAPI int32_t U_EXPORT2
unum_format( const UNumberFormat* fmt,
int32_t number,
UChar* result,
int32_t resultLength,
UFieldPosition *pos,
UErrorCode* status)
{
return unum_formatInt64(fmt, number, result, resultLength, pos, status);
}
U_CAPI int32_t U_EXPORT2
unum_formatInt64(const UNumberFormat* fmt,
int64_t number,
UChar* result,
int32_t resultLength,
UFieldPosition *pos,
UErrorCode* status)
{
if(U_FAILURE(*status))
return -1;
UnicodeString res;
if(!(result==NULL && resultLength==0)) {
// NULL destination for pure preflighting: empty dummy string
// otherwise, alias the destination buffer
res.setTo(result, 0, resultLength);
}
FieldPosition fp;
if(pos != 0)
fp.setField(pos->field);
((const NumberFormat*)fmt)->format(number, res, fp, *status);
if(pos != 0) {
pos->beginIndex = fp.getBeginIndex();
pos->endIndex = fp.getEndIndex();
}
return res.extract(result, resultLength, *status);
}
U_CAPI int32_t U_EXPORT2
unum_formatDouble( const UNumberFormat* fmt,
double number,
UChar* result,
int32_t resultLength,
UFieldPosition *pos, /* 0 if ignore */
UErrorCode* status)
{
if(U_FAILURE(*status)) return -1;
UnicodeString res;
if(!(result==NULL && resultLength==0)) {
// NULL destination for pure preflighting: empty dummy string
// otherwise, alias the destination buffer
res.setTo(result, 0, resultLength);
}
FieldPosition fp;
if(pos != 0)
fp.setField(pos->field);
((const NumberFormat*)fmt)->format(number, res, fp, *status);
if(pos != 0) {
pos->beginIndex = fp.getBeginIndex();
pos->endIndex = fp.getEndIndex();
}
return res.extract(result, resultLength, *status);
}
U_CAPI int32_t U_EXPORT2
unum_formatDecimal(const UNumberFormat* fmt,
const char * number,
int32_t length,
UChar* result,
int32_t resultLength,
UFieldPosition *pos, /* 0 if ignore */
UErrorCode* status) {
if(U_FAILURE(*status)) {
return -1;
}
if ((result == NULL && resultLength != 0) || resultLength < 0) {
*status = U_ILLEGAL_ARGUMENT_ERROR;
return -1;
}
FieldPosition fp;
if(pos != 0) {
fp.setField(pos->field);
}
if (length < 0) {
length = uprv_strlen(number);
}
StringPiece numSP(number, length);
Formattable numFmtbl(numSP, *status);
UnicodeString resultStr;
if (resultLength > 0) {
// Alias the destination buffer.
resultStr.setTo(result, 0, resultLength);
}
((const NumberFormat*)fmt)->format(numFmtbl, resultStr, fp, *status);
if(pos != 0) {
pos->beginIndex = fp.getBeginIndex();
pos->endIndex = fp.getEndIndex();
}
return resultStr.extract(result, resultLength, *status);
}
U_CAPI int32_t U_EXPORT2
unum_formatDoubleCurrency(const UNumberFormat* fmt,
double number,
UChar* currency,
UChar* result,
int32_t resultLength,
UFieldPosition* pos, /* ignored if 0 */
UErrorCode* status) {
if (U_FAILURE(*status)) return -1;
UnicodeString res;
if (!(result==NULL && resultLength==0)) {
// NULL destination for pure preflighting: empty dummy string
// otherwise, alias the destination buffer
res.setTo(result, 0, resultLength);
}
FieldPosition fp;
if (pos != 0) {
fp.setField(pos->field);
}
CurrencyAmount *tempCurrAmnt = new CurrencyAmount(number, currency, *status);
// Check for null pointer.
if (tempCurrAmnt == NULL) {
*status = U_MEMORY_ALLOCATION_ERROR;
return -1;
}
Formattable n(tempCurrAmnt);
((const NumberFormat*)fmt)->format(n, res, fp, *status);
if (pos != 0) {
pos->beginIndex = fp.getBeginIndex();
pos->endIndex = fp.getEndIndex();
}
return res.extract(result, resultLength, *status);
}
static void
parseRes(Formattable& res,
const UNumberFormat* fmt,
const UChar* text,
int32_t textLength,
int32_t *parsePos /* 0 = start */,
UErrorCode *status)
{
if(U_FAILURE(*status))
return;
const UnicodeString src((UBool)(textLength == -1), text, textLength);
ParsePosition pp;
if(parsePos != 0)
pp.setIndex(*parsePos);
((const NumberFormat*)fmt)->parse(src, res, pp);
if(pp.getErrorIndex() != -1) {
*status = U_PARSE_ERROR;
if(parsePos != 0) {
*parsePos = pp.getErrorIndex();
}
} else if(parsePos != 0) {
*parsePos = pp.getIndex();
}
}
U_CAPI int32_t U_EXPORT2
unum_parse( const UNumberFormat* fmt,
const UChar* text,
int32_t textLength,
int32_t *parsePos /* 0 = start */,
UErrorCode *status)
{
Formattable res;
parseRes(res, fmt, text, textLength, parsePos, status);
return res.getLong(*status);
}
U_CAPI int64_t U_EXPORT2
unum_parseInt64( const UNumberFormat* fmt,
const UChar* text,
int32_t textLength,
int32_t *parsePos /* 0 = start */,
UErrorCode *status)
{
Formattable res;
parseRes(res, fmt, text, textLength, parsePos, status);
return res.getInt64(*status);
}
U_CAPI double U_EXPORT2
unum_parseDouble( const UNumberFormat* fmt,
const UChar* text,
int32_t textLength,
int32_t *parsePos /* 0 = start */,
UErrorCode *status)
{
Formattable res;
parseRes(res, fmt, text, textLength, parsePos, status);
return res.getDouble(*status);
}
U_CAPI int32_t U_EXPORT2
unum_parseDecimal(const UNumberFormat* fmt,
const UChar* text,
int32_t textLength,
int32_t *parsePos /* 0 = start */,
char *outBuf,
int32_t outBufLength,
UErrorCode *status)
{
if (U_FAILURE(*status)) {
return -1;
}
if ((outBuf == NULL && outBufLength != 0) || outBufLength < 0) {
*status = U_ILLEGAL_ARGUMENT_ERROR;
return -1;
}
Formattable res;
parseRes(res, fmt, text, textLength, parsePos, status);
StringPiece sp = res.getDecimalNumber(*status);
if (U_FAILURE(*status)) {
return -1;
} else if (sp.size() > outBufLength) {
*status = U_BUFFER_OVERFLOW_ERROR;
} else if (sp.size() == outBufLength) {
uprv_strncpy(outBuf, sp.data(), sp.size());
*status = U_STRING_NOT_TERMINATED_WARNING;
} else {
U_ASSERT(outBufLength > 0);
uprv_strcpy(outBuf, sp.data());
}
return sp.size();
}
U_CAPI double U_EXPORT2
unum_parseDoubleCurrency(const UNumberFormat* fmt,
const UChar* text,
int32_t textLength,
int32_t* parsePos, /* 0 = start */
UChar* currency,
UErrorCode* status) {
double doubleVal = 0.0;
currency[0] = 0;
if (U_FAILURE(*status)) {
return doubleVal;
}
const UnicodeString src((UBool)(textLength == -1), text, textLength);
ParsePosition pp;
if (parsePos != NULL) {
pp.setIndex(*parsePos);
}
*status = U_PARSE_ERROR; // assume failure, reset if succeed
LocalPointer<CurrencyAmount> currAmt(((const NumberFormat*)fmt)->parseCurrency(src, pp));
if (pp.getErrorIndex() != -1) {
if (parsePos != NULL) {
*parsePos = pp.getErrorIndex();
}
} else {
if (parsePos != NULL) {
*parsePos = pp.getIndex();
}
if (pp.getIndex() > 0) {
*status = U_ZERO_ERROR;
u_strcpy(currency, currAmt->getISOCurrency());
doubleVal = currAmt->getNumber().getDouble(*status);
}
}
return doubleVal;
}
U_CAPI const char* U_EXPORT2
unum_getAvailable(int32_t index)
{
return uloc_getAvailable(index);
}
U_CAPI int32_t U_EXPORT2
unum_countAvailable()
{
return uloc_countAvailable();
}
U_CAPI int32_t U_EXPORT2
unum_getAttribute(const UNumberFormat* fmt,
UNumberFormatAttribute attr)
{
const NumberFormat* nf = reinterpret_cast<const NumberFormat*>(fmt);
if ( attr == UNUM_LENIENT_PARSE ) {
// Supported for all subclasses
return nf->isLenient();
}
// The remaining attributea are only supported for DecimalFormat
const DecimalFormat* df = dynamic_cast<const DecimalFormat*>(nf);
if (df != NULL) {
UErrorCode ignoredStatus = U_ZERO_ERROR;
return df->getAttribute( attr, ignoredStatus );
}
return -1;
}
U_CAPI void U_EXPORT2
unum_setAttribute( UNumberFormat* fmt,
UNumberFormatAttribute attr,
int32_t newValue)
{
NumberFormat* nf = reinterpret_cast<NumberFormat*>(fmt);
if ( attr == UNUM_LENIENT_PARSE ) {
// Supported for all subclasses
// keep this here as the class may not be a DecimalFormat
return nf->setLenient(newValue != 0);
}
// The remaining attributea are only supported for DecimalFormat
DecimalFormat* df = dynamic_cast<DecimalFormat*>(nf);
if (df != NULL) {
UErrorCode ignoredStatus = U_ZERO_ERROR;
df->setAttribute(attr, newValue, ignoredStatus);
}
}
U_CAPI double U_EXPORT2
unum_getDoubleAttribute(const UNumberFormat* fmt,
UNumberFormatAttribute attr)
{
const NumberFormat* nf = reinterpret_cast<const NumberFormat*>(fmt);
const DecimalFormat* df = dynamic_cast<const DecimalFormat*>(nf);
if (df != NULL && attr == UNUM_ROUNDING_INCREMENT) {
return df->getRoundingIncrement();
} else {
return -1.0;
}
}
U_CAPI void U_EXPORT2
unum_setDoubleAttribute( UNumberFormat* fmt,
UNumberFormatAttribute attr,
double newValue)
{
NumberFormat* nf = reinterpret_cast<NumberFormat*>(fmt);
DecimalFormat* df = dynamic_cast<DecimalFormat*>(nf);
if (df != NULL && attr == UNUM_ROUNDING_INCREMENT) {
df->setRoundingIncrement(newValue);
}
}
U_CAPI int32_t U_EXPORT2
unum_getTextAttribute(const UNumberFormat* fmt,
UNumberFormatTextAttribute tag,
UChar* result,
int32_t resultLength,
UErrorCode* status)
{
if(U_FAILURE(*status))
return -1;
UnicodeString res;
if(!(result==NULL && resultLength==0)) {
// NULL destination for pure preflighting: empty dummy string
// otherwise, alias the destination buffer
res.setTo(result, 0, resultLength);
}
const NumberFormat* nf = reinterpret_cast<const NumberFormat*>(fmt);
const DecimalFormat* df = dynamic_cast<const DecimalFormat*>(nf);
if (df != NULL) {
switch(tag) {
case UNUM_POSITIVE_PREFIX:
df->getPositivePrefix(res);
break;
case UNUM_POSITIVE_SUFFIX:
df->getPositiveSuffix(res);
break;
case UNUM_NEGATIVE_PREFIX:
df->getNegativePrefix(res);
break;
case UNUM_NEGATIVE_SUFFIX:
df->getNegativeSuffix(res);
break;
case UNUM_PADDING_CHARACTER:
res = df->getPadCharacterString();
break;
case UNUM_CURRENCY_CODE:
res = UnicodeString(df->getCurrency());
break;
default:
*status = U_UNSUPPORTED_ERROR;
return -1;
}
} else {
const RuleBasedNumberFormat* rbnf = dynamic_cast<const RuleBasedNumberFormat*>(nf);
U_ASSERT(rbnf != NULL);
if (tag == UNUM_DEFAULT_RULESET) {
res = rbnf->getDefaultRuleSetName();
} else if (tag == UNUM_PUBLIC_RULESETS) {
int32_t count = rbnf->getNumberOfRuleSetNames();
for (int i = 0; i < count; ++i) {
res += rbnf->getRuleSetName(i);
res += (UChar)0x003b; // semicolon
}
} else {
*status = U_UNSUPPORTED_ERROR;
return -1;
}
}
return res.extract(result, resultLength, *status);
}
U_CAPI void U_EXPORT2
unum_setTextAttribute( UNumberFormat* fmt,
UNumberFormatTextAttribute tag,
const UChar* newValue,
int32_t newValueLength,
UErrorCode *status)
{
if(U_FAILURE(*status))
return;
UnicodeString val(newValue, newValueLength);
NumberFormat* nf = reinterpret_cast<NumberFormat*>(fmt);
DecimalFormat* df = dynamic_cast<DecimalFormat*>(nf);
if (df != NULL) {
switch(tag) {
case UNUM_POSITIVE_PREFIX:
df->setPositivePrefix(val);
break;
case UNUM_POSITIVE_SUFFIX:
df->setPositiveSuffix(val);
break;
case UNUM_NEGATIVE_PREFIX:
df->setNegativePrefix(val);
break;
case UNUM_NEGATIVE_SUFFIX:
df->setNegativeSuffix(val);
break;
case UNUM_PADDING_CHARACTER:
df->setPadCharacter(val);
break;
case UNUM_CURRENCY_CODE:
df->setCurrency(val.getTerminatedBuffer(), *status);
break;
default:
*status = U_UNSUPPORTED_ERROR;
break;
}
} else {
RuleBasedNumberFormat* rbnf = dynamic_cast<RuleBasedNumberFormat*>(nf);
U_ASSERT(rbnf != NULL);
if (tag == UNUM_DEFAULT_RULESET) {
rbnf->setDefaultRuleSet(val, *status);
} else {
*status = U_UNSUPPORTED_ERROR;
}
}
}
U_CAPI int32_t U_EXPORT2
unum_toPattern( const UNumberFormat* fmt,
UBool isPatternLocalized,
UChar* result,
int32_t resultLength,
UErrorCode* status)
{
if(U_FAILURE(*status))
return -1;
UnicodeString pat;
if(!(result==NULL && resultLength==0)) {
// NULL destination for pure preflighting: empty dummy string
// otherwise, alias the destination buffer
pat.setTo(result, 0, resultLength);
}
const NumberFormat* nf = reinterpret_cast<const NumberFormat*>(fmt);
const DecimalFormat* df = dynamic_cast<const DecimalFormat*>(nf);
if (df != NULL) {
if(isPatternLocalized)
df->toLocalizedPattern(pat);
else
df->toPattern(pat);
} else {
const RuleBasedNumberFormat* rbnf = dynamic_cast<const RuleBasedNumberFormat*>(nf);
U_ASSERT(rbnf != NULL);
pat = rbnf->getRules();
}
return pat.extract(result, resultLength, *status);
}
U_CAPI int32_t U_EXPORT2
unum_getSymbol(const UNumberFormat *fmt,
UNumberFormatSymbol symbol,
UChar *buffer,
int32_t size,
UErrorCode *status)
{
if(status==NULL || U_FAILURE(*status)) {
return 0;
}
if(fmt==NULL || symbol< 0 || symbol>=UNUM_FORMAT_SYMBOL_COUNT) {
*status=U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
const NumberFormat *nf = reinterpret_cast<const NumberFormat *>(fmt);
const DecimalFormat *dcf = dynamic_cast<const DecimalFormat *>(nf);
if (dcf == NULL) {
*status = U_UNSUPPORTED_ERROR;
return 0;
}
return dcf->
getDecimalFormatSymbols()->
getConstSymbol((DecimalFormatSymbols::ENumberFormatSymbol)symbol).
extract(buffer, size, *status);
}
U_CAPI void U_EXPORT2
unum_setSymbol(UNumberFormat *fmt,
UNumberFormatSymbol symbol,
const UChar *value,
int32_t length,
UErrorCode *status)
{
if(status==NULL || U_FAILURE(*status)) {
return;
}
if(fmt==NULL || symbol< 0 || symbol>=UNUM_FORMAT_SYMBOL_COUNT || value==NULL || length<-1) {
*status=U_ILLEGAL_ARGUMENT_ERROR;
return;
}
NumberFormat *nf = reinterpret_cast<NumberFormat *>(fmt);
DecimalFormat *dcf = dynamic_cast<DecimalFormat *>(nf);
if (dcf == NULL) {
*status = U_UNSUPPORTED_ERROR;
return;
}
DecimalFormatSymbols symbols(*dcf->getDecimalFormatSymbols());
symbols.setSymbol((DecimalFormatSymbols::ENumberFormatSymbol)symbol,
UnicodeString(value, length)); /* UnicodeString can handle the case when length = -1. */
dcf->setDecimalFormatSymbols(symbols);
}
U_CAPI void U_EXPORT2
unum_applyPattern( UNumberFormat *fmt,
UBool localized,
const UChar *pattern,
int32_t patternLength,
UParseError *parseError,
UErrorCode* status)
{
UErrorCode tStatus = U_ZERO_ERROR;
UParseError tParseError;
if(parseError == NULL){
parseError = &tParseError;
}
if(status==NULL){
status = &tStatus;
}
int32_t len = (patternLength == -1 ? u_strlen(pattern) : patternLength);
const UnicodeString pat((UChar*)pattern, len, len);
// Verify if the object passed is a DecimalFormat object
NumberFormat* nf = reinterpret_cast<NumberFormat*>(fmt);
DecimalFormat* df = dynamic_cast<DecimalFormat*>(nf);
if (df != NULL) {
if(localized) {
df->applyLocalizedPattern(pat,*parseError, *status);
} else {
df->applyPattern(pat,*parseError, *status);
}
} else {
*status = U_UNSUPPORTED_ERROR;
return;
}
}
U_CAPI const char* U_EXPORT2
unum_getLocaleByType(const UNumberFormat *fmt,
ULocDataLocaleType type,
UErrorCode* status)
{
if (fmt == NULL) {
if (U_SUCCESS(*status)) {
*status = U_ILLEGAL_ARGUMENT_ERROR;
}
return NULL;
}
return ((const Format*)fmt)->getLocaleID(type, *status);
}
U_INTERNAL UFormattable * U_EXPORT2
unum_parseToUFormattable(const UNumberFormat* fmt,
UFormattable *result,
const UChar* text,
int32_t textLength,
int32_t* parsePos, /* 0 = start */
UErrorCode* status) {
UFormattable *newFormattable = NULL;
if (U_FAILURE(*status)) return result;
if (fmt == NULL || (text==NULL && textLength!=0)) {
*status = U_ILLEGAL_ARGUMENT_ERROR;
return result;
}
if (result == NULL) { // allocate if not allocated.
newFormattable = result = ufmt_open(status);
}
parseRes(*(Formattable::fromUFormattable(result)), fmt, text, textLength, parsePos, status);
if (U_FAILURE(*status) && newFormattable != NULL) {
ufmt_close(newFormattable);
result = NULL; // deallocate if there was a parse error
}
return result;
}
U_INTERNAL int32_t U_EXPORT2
unum_formatUFormattable(const UNumberFormat* fmt,
const UFormattable *number,
UChar *result,
int32_t resultLength,
UFieldPosition *pos, /* ignored if 0 */
UErrorCode *status) {
if (U_FAILURE(*status)) {
return 0;
}
if (fmt == NULL || number==NULL ||
(result==NULL ? resultLength!=0 : resultLength<0)) {
*status = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
UnicodeString res(result, 0, resultLength);
FieldPosition fp;
if(pos != 0)
fp.setField(pos->field);
((const NumberFormat*)fmt)->format(*(Formattable::fromUFormattable(number)), res, fp, *status);
if(pos != 0) {
pos->beginIndex = fp.getBeginIndex();
pos->endIndex = fp.getEndIndex();
}
return res.extract(result, resultLength, *status);
}
#endif /* #if !UCONFIG_NO_FORMATTING */
Reference in New Issue View Git Blame Copy Permalink