diff options
Diffstat (limited to 'deps/node/deps/icu-small/source/i18n/rbt_set.cpp')
-rw-r--r-- | deps/node/deps/icu-small/source/i18n/rbt_set.cpp | 469 |
1 files changed, 0 insertions, 469 deletions
diff --git a/deps/node/deps/icu-small/source/i18n/rbt_set.cpp b/deps/node/deps/icu-small/source/i18n/rbt_set.cpp deleted file mode 100644 index 939c0ea3..00000000 --- a/deps/node/deps/icu-small/source/i18n/rbt_set.cpp +++ /dev/null @@ -1,469 +0,0 @@ -// © 2016 and later: Unicode, Inc. and others. -// License & terms of use: http://www.unicode.org/copyright.html -/* - ********************************************************************** - * Copyright (C) 1999-2011, International Business Machines - * Corporation and others. All Rights Reserved. - ********************************************************************** - * Date Name Description - * 11/17/99 aliu Creation. - ********************************************************************** - */ - -#include "unicode/utypes.h" - -#if !UCONFIG_NO_TRANSLITERATION - -#include "unicode/unistr.h" -#include "unicode/uniset.h" -#include "unicode/utf16.h" -#include "rbt_set.h" -#include "rbt_rule.h" -#include "cmemory.h" -#include "putilimp.h" - -U_CDECL_BEGIN -static void U_CALLCONV _deleteRule(void *rule) { - delete (icu::TransliterationRule *)rule; -} -U_CDECL_END - -//---------------------------------------------------------------------- -// BEGIN Debugging support -//---------------------------------------------------------------------- - -// #define DEBUG_RBT - -#ifdef DEBUG_RBT -#include <stdio.h> -#include "charstr.h" - -/** - * @param appendTo result is appended to this param. - * @param input the string being transliterated - * @param pos the index struct - */ -static UnicodeString& _formatInput(UnicodeString &appendTo, - const UnicodeString& input, - const UTransPosition& pos) { - // Output a string of the form aaa{bbb|ccc|ddd}eee, where - // the {} indicate the context start and limit, and the || - // indicate the start and limit. - if (0 <= pos.contextStart && - pos.contextStart <= pos.start && - pos.start <= pos.limit && - pos.limit <= pos.contextLimit && - pos.contextLimit <= input.length()) { - - UnicodeString a, b, c, d, e; - input.extractBetween(0, pos.contextStart, a); - input.extractBetween(pos.contextStart, pos.start, b); - input.extractBetween(pos.start, pos.limit, c); - input.extractBetween(pos.limit, pos.contextLimit, d); - input.extractBetween(pos.contextLimit, input.length(), e); - appendTo.append(a).append((UChar)123/*{*/).append(b). - append((UChar)124/*|*/).append(c).append((UChar)124/*|*/).append(d). - append((UChar)125/*}*/).append(e); - } else { - appendTo.append("INVALID UTransPosition"); - //appendTo.append((UnicodeString)"INVALID UTransPosition {cs=" + - // pos.contextStart + ", s=" + pos.start + ", l=" + - // pos.limit + ", cl=" + pos.contextLimit + "} on " + - // input); - } - return appendTo; -} - -// Append a hex string to the target -UnicodeString& _appendHex(uint32_t number, - int32_t digits, - UnicodeString& target) { - static const UChar digitString[] = { - 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, - 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0 - }; - while (digits--) { - target += digitString[(number >> (digits*4)) & 0xF]; - } - return target; -} - -// Replace nonprintable characters with unicode escapes -UnicodeString& _escape(const UnicodeString &source, - UnicodeString &target) { - for (int32_t i = 0; i < source.length(); ) { - UChar32 ch = source.char32At(i); - i += U16_LENGTH(ch); - if (ch < 0x09 || (ch > 0x0A && ch < 0x20)|| ch > 0x7E) { - if (ch <= 0xFFFF) { - target += "\\u"; - _appendHex(ch, 4, target); - } else { - target += "\\U"; - _appendHex(ch, 8, target); - } - } else { - target += ch; - } - } - return target; -} - -inline void _debugOut(const char* msg, TransliterationRule* rule, - const Replaceable& theText, UTransPosition& pos) { - UnicodeString buf(msg, ""); - if (rule) { - UnicodeString r; - rule->toRule(r, TRUE); - buf.append((UChar)32).append(r); - } - buf.append(UnicodeString(" => ", "")); - UnicodeString* text = (UnicodeString*)&theText; - _formatInput(buf, *text, pos); - UnicodeString esc; - _escape(buf, esc); - CharString cbuf(esc); - printf("%s\n", (const char*) cbuf); -} - -#else -#define _debugOut(msg, rule, theText, pos) -#endif - -//---------------------------------------------------------------------- -// END Debugging support -//---------------------------------------------------------------------- - -// Fill the precontext and postcontext with the patterns of the rules -// that are masking one another. -static void maskingError(const icu::TransliterationRule& rule1, - const icu::TransliterationRule& rule2, - UParseError& parseError) { - icu::UnicodeString r; - int32_t len; - - parseError.line = parseError.offset = -1; - - // for pre-context - rule1.toRule(r, FALSE); - len = uprv_min(r.length(), U_PARSE_CONTEXT_LEN-1); - r.extract(0, len, parseError.preContext); - parseError.preContext[len] = 0; - - //for post-context - r.truncate(0); - rule2.toRule(r, FALSE); - len = uprv_min(r.length(), U_PARSE_CONTEXT_LEN-1); - r.extract(0, len, parseError.postContext); - parseError.postContext[len] = 0; -} - -U_NAMESPACE_BEGIN - -/** - * Construct a new empty rule set. - */ -TransliterationRuleSet::TransliterationRuleSet(UErrorCode& status) : UMemory() { - ruleVector = new UVector(&_deleteRule, NULL, status); - if (U_FAILURE(status)) { - return; - } - if (ruleVector == NULL) { - status = U_MEMORY_ALLOCATION_ERROR; - } - rules = NULL; - maxContextLength = 0; -} - -/** - * Copy constructor. - */ -TransliterationRuleSet::TransliterationRuleSet(const TransliterationRuleSet& other) : - UMemory(other), - ruleVector(0), - rules(0), - maxContextLength(other.maxContextLength) { - - int32_t i, len; - uprv_memcpy(index, other.index, sizeof(index)); - UErrorCode status = U_ZERO_ERROR; - ruleVector = new UVector(&_deleteRule, NULL, status); - if (other.ruleVector != 0 && ruleVector != 0 && U_SUCCESS(status)) { - len = other.ruleVector->size(); - for (i=0; i<len && U_SUCCESS(status); ++i) { - TransliterationRule *tempTranslitRule = new TransliterationRule(*(TransliterationRule*)other.ruleVector->elementAt(i)); - // Null pointer test - if (tempTranslitRule == NULL) { - status = U_MEMORY_ALLOCATION_ERROR; - break; - } - ruleVector->addElement(tempTranslitRule, status); - if (U_FAILURE(status)) { - break; - } - } - } - if (other.rules != 0 && U_SUCCESS(status)) { - UParseError p; - freeze(p, status); - } -} - -/** - * Destructor. - */ -TransliterationRuleSet::~TransliterationRuleSet() { - delete ruleVector; // This deletes the contained rules - uprv_free(rules); -} - -void TransliterationRuleSet::setData(const TransliterationRuleData* d) { - /** - * We assume that the ruleset has already been frozen. - */ - int32_t len = index[256]; // see freeze() - for (int32_t i=0; i<len; ++i) { - rules[i]->setData(d); - } -} - -/** - * Return the maximum context length. - * @return the length of the longest preceding context. - */ -int32_t TransliterationRuleSet::getMaximumContextLength(void) const { - return maxContextLength; -} - -/** - * Add a rule to this set. Rules are added in order, and order is - * significant. The last call to this method must be followed by - * a call to <code>freeze()</code> before the rule set is used. - * - * <p>If freeze() has already been called, calling addRule() - * unfreezes the rules, and freeze() must be called again. - * - * @param adoptedRule the rule to add - */ -void TransliterationRuleSet::addRule(TransliterationRule* adoptedRule, - UErrorCode& status) { - if (U_FAILURE(status)) { - delete adoptedRule; - return; - } - ruleVector->addElement(adoptedRule, status); - - int32_t len; - if ((len = adoptedRule->getContextLength()) > maxContextLength) { - maxContextLength = len; - } - - uprv_free(rules); - rules = 0; -} - -/** - * Check this for masked rules and index it to optimize performance. - * The sequence of operations is: (1) add rules to a set using - * <code>addRule()</code>; (2) freeze the set using - * <code>freeze()</code>; (3) use the rule set. If - * <code>addRule()</code> is called after calling this method, it - * invalidates this object, and this method must be called again. - * That is, <code>freeze()</code> may be called multiple times, - * although for optimal performance it shouldn't be. - */ -void TransliterationRuleSet::freeze(UParseError& parseError,UErrorCode& status) { - /* Construct the rule array and index table. We reorder the - * rules by sorting them into 256 bins. Each bin contains all - * rules matching the index value for that bin. A rule - * matches an index value if string whose first key character - * has a low byte equal to the index value can match the rule. - * - * Each bin contains zero or more rules, in the same order - * they were found originally. However, the total rules in - * the bins may exceed the number in the original vector, - * since rules that have a variable as their first key - * character will generally fall into more than one bin. - * - * That is, each bin contains all rules that either have that - * first index value as their first key character, or have - * a set containing the index value as their first character. - */ - int32_t n = ruleVector->size(); - int32_t j; - int16_t x; - UVector v(2*n, status); // heuristic; adjust as needed - - if (U_FAILURE(status)) { - return; - } - - /* Precompute the index values. This saves a LOT of time. - * Be careful not to call malloc(0). - */ - int16_t* indexValue = (int16_t*) uprv_malloc( sizeof(int16_t) * (n > 0 ? n : 1) ); - /* test for NULL */ - if (indexValue == 0) { - status = U_MEMORY_ALLOCATION_ERROR; - return; - } - for (j=0; j<n; ++j) { - TransliterationRule* r = (TransliterationRule*) ruleVector->elementAt(j); - indexValue[j] = r->getIndexValue(); - } - for (x=0; x<256; ++x) { - index[x] = v.size(); - for (j=0; j<n; ++j) { - if (indexValue[j] >= 0) { - if (indexValue[j] == x) { - v.addElement(ruleVector->elementAt(j), status); - } - } else { - // If the indexValue is < 0, then the first key character is - // a set, and we must use the more time-consuming - // matchesIndexValue check. In practice this happens - // rarely, so we seldom tread this code path. - TransliterationRule* r = (TransliterationRule*) ruleVector->elementAt(j); - if (r->matchesIndexValue((uint8_t)x)) { - v.addElement(r, status); - } - } - } - } - uprv_free(indexValue); - index[256] = v.size(); - - /* Freeze things into an array. - */ - uprv_free(rules); // Contains alias pointers - - /* You can't do malloc(0)! */ - if (v.size() == 0) { - rules = NULL; - return; - } - rules = (TransliterationRule **)uprv_malloc(v.size() * sizeof(TransliterationRule *)); - /* test for NULL */ - if (rules == 0) { - status = U_MEMORY_ALLOCATION_ERROR; - return; - } - for (j=0; j<v.size(); ++j) { - rules[j] = (TransliterationRule*) v.elementAt(j); - } - - // TODO Add error reporting that indicates the rules that - // are being masked. - //UnicodeString errors; - - /* Check for masking. This is MUCH faster than our old check, - * which was each rule against each following rule, since we - * only have to check for masking within each bin now. It's - * 256*O(n2^2) instead of O(n1^2), where n1 is the total rule - * count, and n2 is the per-bin rule count. But n2<<n1, so - * it's a big win. - */ - for (x=0; x<256; ++x) { - for (j=index[x]; j<index[x+1]-1; ++j) { - TransliterationRule* r1 = rules[j]; - for (int32_t k=j+1; k<index[x+1]; ++k) { - TransliterationRule* r2 = rules[k]; - if (r1->masks(*r2)) { -//| if (errors == null) { -//| errors = new StringBuffer(); -//| } else { -//| errors.append("\n"); -//| } -//| errors.append("Rule " + r1 + " masks " + r2); - status = U_RULE_MASK_ERROR; - maskingError(*r1, *r2, parseError); - return; - } - } - } - } - - //if (errors != null) { - // throw new IllegalArgumentException(errors.toString()); - //} -} - -/** - * Transliterate the given text with the given UTransPosition - * indices. Return TRUE if the transliteration should continue - * or FALSE if it should halt (because of a U_PARTIAL_MATCH match). - * Note that FALSE is only ever returned if isIncremental is TRUE. - * @param text the text to be transliterated - * @param pos the position indices, which will be updated - * @param incremental if TRUE, assume new text may be inserted - * at index.limit, and return FALSE if thre is a partial match. - * @return TRUE unless a U_PARTIAL_MATCH has been obtained, - * indicating that transliteration should stop until more text - * arrives. - */ -UBool TransliterationRuleSet::transliterate(Replaceable& text, - UTransPosition& pos, - UBool incremental) { - int16_t indexByte = (int16_t) (text.char32At(pos.start) & 0xFF); - for (int32_t i=index[indexByte]; i<index[indexByte+1]; ++i) { - UMatchDegree m = rules[i]->matchAndReplace(text, pos, incremental); - switch (m) { - case U_MATCH: - _debugOut("match", rules[i], text, pos); - return TRUE; - case U_PARTIAL_MATCH: - _debugOut("partial match", rules[i], text, pos); - return FALSE; - default: /* Ram: added default to make GCC happy */ - break; - } - } - // No match or partial match from any rule - pos.start += U16_LENGTH(text.char32At(pos.start)); - _debugOut("no match", NULL, text, pos); - return TRUE; -} - -/** - * Create rule strings that represents this rule set. - */ -UnicodeString& TransliterationRuleSet::toRules(UnicodeString& ruleSource, - UBool escapeUnprintable) const { - int32_t i; - int32_t count = ruleVector->size(); - ruleSource.truncate(0); - for (i=0; i<count; ++i) { - if (i != 0) { - ruleSource.append((UChar) 0x000A /*\n*/); - } - TransliterationRule *r = - (TransliterationRule*) ruleVector->elementAt(i); - r->toRule(ruleSource, escapeUnprintable); - } - return ruleSource; -} - -/** - * Return the set of all characters that may be modified - * (getTarget=false) or emitted (getTarget=true) by this set. - */ -UnicodeSet& TransliterationRuleSet::getSourceTargetSet(UnicodeSet& result, - UBool getTarget) const -{ - result.clear(); - int32_t count = ruleVector->size(); - for (int32_t i=0; i<count; ++i) { - TransliterationRule* r = - (TransliterationRule*) ruleVector->elementAt(i); - if (getTarget) { - r->addTargetSetTo(result); - } else { - r->addSourceSetTo(result); - } - } - return result; -} - -U_NAMESPACE_END - -#endif /* #if !UCONFIG_NO_TRANSLITERATION */ |