| /* |
| ********************************************************************** |
| * Copyright (C) 1999-2015, 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 "starboard/client_porting/poem/string_poem.h" |
| #include "unicode/rep.h" |
| #include "unicode/uniset.h" |
| #include "rbt_pars.h" |
| #include "rbt_data.h" |
| #include "rbt_rule.h" |
| #include "rbt.h" |
| #include "mutex.h" |
| #include "umutex.h" |
| |
| U_NAMESPACE_BEGIN |
| |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RuleBasedTransliterator) |
| |
| static UMutex transliteratorDataMutex = U_MUTEX_INITIALIZER; |
| static Replaceable *gLockedText = NULL; |
| |
| void RuleBasedTransliterator::_construct(const UnicodeString& rules, |
| UTransDirection direction, |
| UParseError& parseError, |
| UErrorCode& status) { |
| fData = 0; |
| isDataOwned = TRUE; |
| if (U_FAILURE(status)) { |
| return; |
| } |
| |
| TransliteratorParser parser(status); |
| parser.parse(rules, direction, parseError, status); |
| if (U_FAILURE(status)) { |
| return; |
| } |
| |
| if (parser.idBlockVector.size() != 0 || |
| parser.compoundFilter != NULL || |
| parser.dataVector.size() == 0) { |
| status = U_INVALID_RBT_SYNTAX; // ::ID blocks disallowed in RBT |
| return; |
| } |
| |
| fData = (TransliterationRuleData*)parser.dataVector.orphanElementAt(0); |
| setMaximumContextLength(fData->ruleSet.getMaximumContextLength()); |
| } |
| |
| /** |
| * Constructs a new transliterator from the given rules. |
| * @param id the id for the transliterator. |
| * @param rules rules, separated by ';' |
| * @param direction either FORWARD or REVERSE. |
| * @param adoptedFilter the filter for this transliterator. |
| * @param parseError Struct to recieve information on position |
| * of error if an error is encountered |
| * @param status Output param set to success/failure code. |
| * @exception IllegalArgumentException if rules are malformed |
| * or direction is invalid. |
| */ |
| RuleBasedTransliterator::RuleBasedTransliterator( |
| const UnicodeString& id, |
| const UnicodeString& rules, |
| UTransDirection direction, |
| UnicodeFilter* adoptedFilter, |
| UParseError& parseError, |
| UErrorCode& status) : |
| Transliterator(id, adoptedFilter) { |
| _construct(rules, direction,parseError,status); |
| } |
| |
| /** |
| * Constructs a new transliterator from the given rules. |
| * @param id the id for the transliterator. |
| * @param rules rules, separated by ';' |
| * @param direction either FORWARD or REVERSE. |
| * @param adoptedFilter the filter for this transliterator. |
| * @param status Output param set to success/failure code. |
| * @exception IllegalArgumentException if rules are malformed |
| * or direction is invalid. |
| */ |
| /*RuleBasedTransliterator::RuleBasedTransliterator( |
| const UnicodeString& id, |
| const UnicodeString& rules, |
| UTransDirection direction, |
| UnicodeFilter* adoptedFilter, |
| UErrorCode& status) : |
| Transliterator(id, adoptedFilter) { |
| UParseError parseError; |
| _construct(rules, direction,parseError, status); |
| }*/ |
| |
| /** |
| * Covenience constructor with no filter. |
| */ |
| /*RuleBasedTransliterator::RuleBasedTransliterator( |
| const UnicodeString& id, |
| const UnicodeString& rules, |
| UTransDirection direction, |
| UErrorCode& status) : |
| Transliterator(id, 0) { |
| UParseError parseError; |
| _construct(rules, direction,parseError, status); |
| }*/ |
| |
| /** |
| * Covenience constructor with no filter and FORWARD direction. |
| */ |
| /*RuleBasedTransliterator::RuleBasedTransliterator( |
| const UnicodeString& id, |
| const UnicodeString& rules, |
| UErrorCode& status) : |
| Transliterator(id, 0) { |
| UParseError parseError; |
| _construct(rules, UTRANS_FORWARD, parseError, status); |
| }*/ |
| |
| /** |
| * Covenience constructor with FORWARD direction. |
| */ |
| /*RuleBasedTransliterator::RuleBasedTransliterator( |
| const UnicodeString& id, |
| const UnicodeString& rules, |
| UnicodeFilter* adoptedFilter, |
| UErrorCode& status) : |
| Transliterator(id, adoptedFilter) { |
| UParseError parseError; |
| _construct(rules, UTRANS_FORWARD,parseError, status); |
| }*/ |
| |
| RuleBasedTransliterator::RuleBasedTransliterator(const UnicodeString& id, |
| const TransliterationRuleData* theData, |
| UnicodeFilter* adoptedFilter) : |
| Transliterator(id, adoptedFilter), |
| fData((TransliterationRuleData*)theData), // cast away const |
| isDataOwned(FALSE) { |
| setMaximumContextLength(fData->ruleSet.getMaximumContextLength()); |
| } |
| |
| /** |
| * Internal constructor. |
| */ |
| RuleBasedTransliterator::RuleBasedTransliterator(const UnicodeString& id, |
| TransliterationRuleData* theData, |
| UBool isDataAdopted) : |
| Transliterator(id, 0), |
| fData(theData), |
| isDataOwned(isDataAdopted) { |
| setMaximumContextLength(fData->ruleSet.getMaximumContextLength()); |
| } |
| |
| /** |
| * Copy constructor. |
| */ |
| RuleBasedTransliterator::RuleBasedTransliterator( |
| const RuleBasedTransliterator& other) : |
| Transliterator(other), fData(other.fData), |
| isDataOwned(other.isDataOwned) { |
| |
| // The data object may or may not be owned. If it is not owned we |
| // share it; it is invariant. If it is owned, it's still |
| // invariant, but we need to copy it to prevent double-deletion. |
| // If this becomes a performance issue (if people do a lot of RBT |
| // copying -- unlikely) we can reference count the data object. |
| |
| // Only do a deep copy if this is owned data, that is, data that |
| // will be later deleted. System transliterators contain |
| // non-owned data. |
| if (isDataOwned) { |
| fData = new TransliterationRuleData(*other.fData); |
| } |
| } |
| |
| /** |
| * Destructor. |
| */ |
| RuleBasedTransliterator::~RuleBasedTransliterator() { |
| // Delete the data object only if we own it. |
| if (isDataOwned) { |
| delete fData; |
| } |
| } |
| |
| Transliterator* // Covariant return NOT ALLOWED (for portability) |
| RuleBasedTransliterator::clone(void) const { |
| return new RuleBasedTransliterator(*this); |
| } |
| |
| /** |
| * Implements {@link Transliterator#handleTransliterate}. |
| */ |
| void |
| RuleBasedTransliterator::handleTransliterate(Replaceable& text, UTransPosition& index, |
| UBool isIncremental) const { |
| /* We keep contextStart and contextLimit fixed the entire time, |
| * relative to the text -- contextLimit may move numerically if |
| * text is inserted or removed. The start offset moves toward |
| * limit, with replacements happening under it. |
| * |
| * Example: rules 1. ab>x|y |
| * 2. yc>z |
| * |
| * |eabcd begin - no match, advance start |
| * e|abcd match rule 1 - change text & adjust start |
| * ex|ycd match rule 2 - change text & adjust start |
| * exz|d no match, advance start |
| * exzd| done |
| */ |
| |
| /* A rule like |
| * a>b|a |
| * creates an infinite loop. To prevent that, we put an arbitrary |
| * limit on the number of iterations that we take, one that is |
| * high enough that any reasonable rules are ok, but low enough to |
| * prevent a server from hanging. The limit is 16 times the |
| * number of characters n, unless n is so large that 16n exceeds a |
| * uint32_t. |
| */ |
| uint32_t loopCount = 0; |
| uint32_t loopLimit = index.limit - index.start; |
| if (loopLimit >= 0x10000000) { |
| loopLimit = 0xFFFFFFFF; |
| } else { |
| loopLimit <<= 4; |
| } |
| |
| // Transliterator locking. Rule-based Transliterators are not thread safe; concurrent |
| // operations must be prevented. |
| // A Complication: compound transliterators can result in recursive entries to this |
| // function, sometimes with different "This" objects, always with the same text. |
| // Double-locking must be prevented in these cases. |
| // |
| |
| // If the transliteration data is exclusively owned by this transliterator object, |
| // we don't need to do any locking. No sharing between transliterators is possible, |
| // so no concurrent access from multiple threads is possible. |
| UBool lockedMutexAtThisLevel = FALSE; |
| if (isDataOwned == FALSE) { |
| // Test whether this request is operating on the same text string as |
| // some other transliteration that is still in progress and holding the |
| // transliteration mutex. If so, do not lock the transliteration |
| // mutex again. |
| // |
| // gLockedText variable is protected by the global ICU mutex. |
| // Shared RBT data protected by transliteratorDataMutex. |
| // |
| // TODO(andy): Need a better scheme for handling this. |
| UBool needToLock; |
| { |
| Mutex m; |
| needToLock = (&text != gLockedText); |
| } |
| if (needToLock) { |
| umtx_lock(&transliteratorDataMutex); // Contention, longish waits possible here. |
| Mutex m; |
| gLockedText = &text; |
| lockedMutexAtThisLevel = TRUE; |
| } |
| } |
| |
| // Check to make sure we don't dereference a null pointer. |
| if (fData != NULL) { |
| while (index.start < index.limit && |
| loopCount <= loopLimit && |
| fData->ruleSet.transliterate(text, index, isIncremental)) { |
| ++loopCount; |
| } |
| } |
| if (lockedMutexAtThisLevel) { |
| { |
| Mutex m; |
| gLockedText = NULL; |
| } |
| umtx_unlock(&transliteratorDataMutex); |
| } |
| } |
| |
| UnicodeString& RuleBasedTransliterator::toRules(UnicodeString& rulesSource, |
| UBool escapeUnprintable) const { |
| return fData->ruleSet.toRules(rulesSource, escapeUnprintable); |
| } |
| |
| /** |
| * Implement Transliterator framework |
| */ |
| void RuleBasedTransliterator::handleGetSourceSet(UnicodeSet& result) const { |
| fData->ruleSet.getSourceTargetSet(result, FALSE); |
| } |
| |
| /** |
| * Override Transliterator framework |
| */ |
| UnicodeSet& RuleBasedTransliterator::getTargetSet(UnicodeSet& result) const { |
| return fData->ruleSet.getSourceTargetSet(result, TRUE); |
| } |
| |
| U_NAMESPACE_END |
| |
| #endif /* #if !UCONFIG_NO_TRANSLITERATION */ |
