// © 2016 and later: Unicode, Inc. and others. // License & terms of use: http://www.unicode.org/copyright.html /* ****************************************************************************** * Copyright (C) 1997-2015, International Business Machines * Corporation and others. All Rights Reserved. ****************************************************************************** * file name: nfrs.cpp * encoding: UTF-8 * tab size: 8 (not used) * indentation:4 * * Modification history * Date Name Comments * 10/11/2001 Doug Ported from ICU4J */ #include "nfrs.h" #if U_HAVE_RBNF #include "unicode/uchar.h" #include "nfrule.h" #include "nfrlist.h" #include "patternprops.h" #include "putilimp.h" #ifdef RBNF_DEBUG #include "cmemory.h" #endif enum { … }; U_NAMESPACE_BEGIN #if 0 // euclid's algorithm works with doubles // note, doubles only get us up to one quadrillion or so, which // isn't as much range as we get with longs. We probably still // want either 64-bit math, or BigInteger. static int64_t util_lcm(int64_t x, int64_t y) { x.abs(); y.abs(); if (x == 0 || y == 0) { return 0; } else { do { if (x < y) { int64_t t = x; x = y; y = t; } x -= y * (x/y); } while (x != 0); return y; } } #else /** * Calculates the least common multiple of x and y. */ static int64_t util_lcm(int64_t x, int64_t y) { … } #endif static const char16_t gPercent = …; static const char16_t gColon = …; static const char16_t gSemicolon = …; static const char16_t gLineFeed = …; static const char16_t gPercentPercent[] = …; /* "%%" */ static const char16_t gNoparse[] = …; /* "@noparse" */ NFRuleSet::NFRuleSet(RuleBasedNumberFormat *_owner, UnicodeString* descriptions, int32_t index, UErrorCode& status) : … { … } void NFRuleSet::parseRules(UnicodeString& description, UErrorCode& status) { … } /** * Set one of the non-numerical rules. * @param rule The rule to set. */ void NFRuleSet::setNonNumericalRule(NFRule *rule) { … } /** * Determine the best fraction rule to use. Rules matching the decimal point from * DecimalFormatSymbols become the main set of rules to use. * @param originalIndex The index into nonNumericalRules * @param newRule The new rule to consider * @param rememberRule Should the new rule be added to fractionRules. */ void NFRuleSet::setBestFractionRule(int32_t originalIndex, NFRule *newRule, UBool rememberRule) { … } NFRuleSet::~NFRuleSet() { … } static UBool util_equalRules(const NFRule* rule1, const NFRule* rule2) { … } bool NFRuleSet::operator==(const NFRuleSet& rhs) const { … } void NFRuleSet::setDecimalFormatSymbols(const DecimalFormatSymbols &newSymbols, UErrorCode& status) { … } #define RECURSION_LIMIT … void NFRuleSet::format(int64_t number, UnicodeString& toAppendTo, int32_t pos, int32_t recursionCount, UErrorCode& status) const { … } void NFRuleSet::format(double number, UnicodeString& toAppendTo, int32_t pos, int32_t recursionCount, UErrorCode& status) const { … } const NFRule* NFRuleSet::findDoubleRule(double number) const { … } const NFRule * NFRuleSet::findNormalRule(int64_t number) const { … } /** * If this rule is a fraction rule set, this function is used by * findRule() to select the most appropriate rule for formatting * the number. Basically, the base value of each rule in the rule * set is treated as the denominator of a fraction. Whichever * denominator can produce the fraction closest in value to the * number passed in is the result. If there's a tie, the earlier * one in the list wins. (If there are two rules in a row with the * same base value, the first one is used when the numerator of the * fraction would be 1, and the second rule is used the rest of the * time. * @param number The number being formatted (which will always be * a number between 0 and 1) * @return The rule to use to format this number */ const NFRule* NFRuleSet::findFractionRuleSetRule(double number) const { … } /** * Parses a string. Matches the string to be parsed against each * of its rules (with a base value less than upperBound) and returns * the value produced by the rule that matched the most characters * in the source string. * @param text The string to parse * @param parsePosition The initial position is ignored and assumed * to be 0. On exit, this object has been updated to point to the * first character position this rule set didn't consume. * @param upperBound Limits the rules that can be allowed to match. * Only rules whose base values are strictly less than upperBound * are considered. * @return The numerical result of parsing this string. This will * be the matching rule's base value, composed appropriately with * the results of matching any of its substitutions. The object * will be an instance of Long if it's an integral value; otherwise, * it will be an instance of Double. This function always returns * a valid object: If nothing matched the input string at all, * this function returns new Long(0), and the parse position is * left unchanged. */ #ifdef RBNF_DEBUG #include <stdio.h> static void dumpUS(FILE* f, const UnicodeString& us) { int len = us.length(); char* buf = (char *)uprv_malloc((len+1)*sizeof(char)); //new char[len+1]; if (buf != nullptr) { us.extract(0, len, buf); buf[len] = 0; fprintf(f, "%s", buf); uprv_free(buf); //delete[] buf; } } #endif UBool NFRuleSet::parse(const UnicodeString& text, ParsePosition& pos, double upperBound, uint32_t nonNumericalExecutedRuleMask, Formattable& result) const { … } void NFRuleSet::appendRules(UnicodeString& result) const { … } // utility functions int64_t util64_fromDouble(double d) { … } uint64_t util64_pow(uint32_t base, uint16_t exponent) { … } static const uint8_t asciiDigits[] = …; static const char16_t kUMinus = …; #ifdef RBNF_DEBUG static const char kMinus = '-'; static const uint8_t digitInfo[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x80u, 0x81u, 0x82u, 0x83u, 0x84u, 0x85u, 0x86u, 0x87u, 0x88u, 0x89u, 0, 0, 0, 0, 0, 0, 0, 0x8au, 0x8bu, 0x8cu, 0x8du, 0x8eu, 0x8fu, 0x90u, 0x91u, 0x92u, 0x93u, 0x94u, 0x95u, 0x96u, 0x97u, 0x98u, 0x99u, 0x9au, 0x9bu, 0x9cu, 0x9du, 0x9eu, 0x9fu, 0xa0u, 0xa1u, 0xa2u, 0xa3u, 0, 0, 0, 0, 0, 0, 0x8au, 0x8bu, 0x8cu, 0x8du, 0x8eu, 0x8fu, 0x90u, 0x91u, 0x92u, 0x93u, 0x94u, 0x95u, 0x96u, 0x97u, 0x98u, 0x99u, 0x9au, 0x9bu, 0x9cu, 0x9du, 0x9eu, 0x9fu, 0xa0u, 0xa1u, 0xa2u, 0xa3u, 0, 0, 0, 0, 0, }; int64_t util64_atoi(const char* str, uint32_t radix) { if (radix > 36) { radix = 36; } else if (radix < 2) { radix = 2; } int64_t lradix = radix; int neg = 0; if (*str == kMinus) { ++str; neg = 1; } int64_t result = 0; uint8_t b; while ((b = digitInfo[*str++]) && ((b &= 0x7f) < radix)) { result *= lradix; result += (int32_t)b; } if (neg) { result = -result; } return result; } int64_t util64_utoi(const char16_t* str, uint32_t radix) { if (radix > 36) { radix = 36; } else if (radix < 2) { radix = 2; } int64_t lradix = radix; int neg = 0; if (*str == kUMinus) { ++str; neg = 1; } int64_t result = 0; char16_t c; uint8_t b; while (((c = *str++) < 0x0080) && (b = digitInfo[c]) && ((b &= 0x7f) < radix)) { result *= lradix; result += (int32_t)b; } if (neg) { result = -result; } return result; } uint32_t util64_toa(int64_t w, char* buf, uint32_t len, uint32_t radix, UBool raw) { if (radix > 36) { radix = 36; } else if (radix < 2) { radix = 2; } int64_t base = radix; char* p = buf; if (len && (w < 0) && (radix == 10) && !raw) { w = -w; *p++ = kMinus; --len; } else if (len && (w == 0)) { *p++ = (char)raw ? 0 : asciiDigits[0]; --len; } while (len && w != 0) { int64_t n = w / base; int64_t m = n * base; int32_t d = (int32_t)(w-m); *p++ = raw ? (char)d : asciiDigits[d]; w = n; --len; } if (len) { *p = 0; // null terminate if room for caller convenience } len = p - buf; if (*buf == kMinus) { ++buf; } while (--p > buf) { char c = *p; *p = *buf; *buf = c; ++buf; } return len; } #endif uint32_t util64_tou(int64_t w, char16_t* buf, uint32_t len, uint32_t radix, UBool raw) { … } U_NAMESPACE_END /* U_HAVE_RBNF */ #endif
Codebase Browser
chromium