295 lines
8.5 KiB
C++
295 lines
8.5 KiB
C++
/*
|
|
**********************************************************************
|
|
* Copyright (C) 2016 and later: Unicode, Inc. and others.
|
|
* License & terms of use: http://www.unicode.org/copyright.html
|
|
**********************************************************************
|
|
* Date Name Description
|
|
* 07/23/01 aliu Creation.
|
|
**********************************************************************
|
|
*/
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_TRANSLITERATION
|
|
|
|
#include "strmatch.h"
|
|
#include "rbt_data.h"
|
|
#include "util.h"
|
|
#include "unicode/uniset.h"
|
|
#include "unicode/utf16.h"
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(StringMatcher)
|
|
|
|
StringMatcher::StringMatcher(const UnicodeString& theString,
|
|
int32_t start,
|
|
int32_t limit,
|
|
int32_t segmentNum,
|
|
const TransliterationRuleData& theData) :
|
|
data(&theData),
|
|
segmentNumber(segmentNum),
|
|
matchStart(-1),
|
|
matchLimit(-1)
|
|
{
|
|
theString.extractBetween(start, limit, pattern);
|
|
}
|
|
|
|
StringMatcher::StringMatcher(const StringMatcher& o) :
|
|
UnicodeFunctor(o),
|
|
UnicodeMatcher(o),
|
|
UnicodeReplacer(o),
|
|
pattern(o.pattern),
|
|
data(o.data),
|
|
segmentNumber(o.segmentNumber),
|
|
matchStart(o.matchStart),
|
|
matchLimit(o.matchLimit)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Destructor
|
|
*/
|
|
StringMatcher::~StringMatcher() {
|
|
}
|
|
|
|
/**
|
|
* Implement UnicodeFunctor
|
|
*/
|
|
UnicodeFunctor* StringMatcher::clone() const {
|
|
return new StringMatcher(*this);
|
|
}
|
|
|
|
/**
|
|
* UnicodeFunctor API. Cast 'this' to a UnicodeMatcher* pointer
|
|
* and return the pointer.
|
|
*/
|
|
UnicodeMatcher* StringMatcher::toMatcher() const {
|
|
StringMatcher *nonconst_this = const_cast<StringMatcher *>(this);
|
|
UnicodeMatcher *nonconst_base = static_cast<UnicodeMatcher *>(nonconst_this);
|
|
|
|
return nonconst_base;
|
|
}
|
|
|
|
/**
|
|
* UnicodeFunctor API. Cast 'this' to a UnicodeReplacer* pointer
|
|
* and return the pointer.
|
|
*/
|
|
UnicodeReplacer* StringMatcher::toReplacer() const {
|
|
StringMatcher *nonconst_this = const_cast<StringMatcher *>(this);
|
|
UnicodeReplacer *nonconst_base = static_cast<UnicodeReplacer *>(nonconst_this);
|
|
|
|
return nonconst_base;
|
|
}
|
|
|
|
/**
|
|
* Implement UnicodeMatcher
|
|
*/
|
|
UMatchDegree StringMatcher::matches(const Replaceable& text,
|
|
int32_t& offset,
|
|
int32_t limit,
|
|
UBool incremental) {
|
|
int32_t i;
|
|
int32_t cursor = offset;
|
|
if (limit < cursor) {
|
|
// Match in the reverse direction
|
|
for (i=pattern.length()-1; i>=0; --i) {
|
|
UChar keyChar = pattern.charAt(i);
|
|
UnicodeMatcher* subm = data->lookupMatcher(keyChar);
|
|
if (subm == 0) {
|
|
if (cursor > limit &&
|
|
keyChar == text.charAt(cursor)) {
|
|
--cursor;
|
|
} else {
|
|
return U_MISMATCH;
|
|
}
|
|
} else {
|
|
UMatchDegree m =
|
|
subm->matches(text, cursor, limit, incremental);
|
|
if (m != U_MATCH) {
|
|
return m;
|
|
}
|
|
}
|
|
}
|
|
// Record the match position, but adjust for a normal
|
|
// forward start, limit, and only if a prior match does not
|
|
// exist -- we want the rightmost match.
|
|
if (matchStart < 0) {
|
|
matchStart = cursor+1;
|
|
matchLimit = offset+1;
|
|
}
|
|
} else {
|
|
for (i=0; i<pattern.length(); ++i) {
|
|
if (incremental && cursor == limit) {
|
|
// We've reached the context limit without a mismatch and
|
|
// without completing our match.
|
|
return U_PARTIAL_MATCH;
|
|
}
|
|
UChar keyChar = pattern.charAt(i);
|
|
UnicodeMatcher* subm = data->lookupMatcher(keyChar);
|
|
if (subm == 0) {
|
|
// Don't need the cursor < limit check if
|
|
// incremental is TRUE (because it's done above); do need
|
|
// it otherwise.
|
|
if (cursor < limit &&
|
|
keyChar == text.charAt(cursor)) {
|
|
++cursor;
|
|
} else {
|
|
return U_MISMATCH;
|
|
}
|
|
} else {
|
|
UMatchDegree m =
|
|
subm->matches(text, cursor, limit, incremental);
|
|
if (m != U_MATCH) {
|
|
return m;
|
|
}
|
|
}
|
|
}
|
|
// Record the match position
|
|
matchStart = offset;
|
|
matchLimit = cursor;
|
|
}
|
|
|
|
offset = cursor;
|
|
return U_MATCH;
|
|
}
|
|
|
|
/**
|
|
* Implement UnicodeMatcher
|
|
*/
|
|
UnicodeString& StringMatcher::toPattern(UnicodeString& result,
|
|
UBool escapeUnprintable) const
|
|
{
|
|
result.truncate(0);
|
|
UnicodeString str, quoteBuf;
|
|
if (segmentNumber > 0) {
|
|
result.append((UChar)40); /*(*/
|
|
}
|
|
for (int32_t i=0; i<pattern.length(); ++i) {
|
|
UChar keyChar = pattern.charAt(i);
|
|
const UnicodeMatcher* m = data->lookupMatcher(keyChar);
|
|
if (m == 0) {
|
|
ICU_Utility::appendToRule(result, keyChar, FALSE, escapeUnprintable, quoteBuf);
|
|
} else {
|
|
ICU_Utility::appendToRule(result, m->toPattern(str, escapeUnprintable),
|
|
TRUE, escapeUnprintable, quoteBuf);
|
|
}
|
|
}
|
|
if (segmentNumber > 0) {
|
|
result.append((UChar)41); /*)*/
|
|
}
|
|
// Flush quoteBuf out to result
|
|
ICU_Utility::appendToRule(result, -1,
|
|
TRUE, escapeUnprintable, quoteBuf);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Implement UnicodeMatcher
|
|
*/
|
|
UBool StringMatcher::matchesIndexValue(uint8_t v) const {
|
|
if (pattern.length() == 0) {
|
|
return TRUE;
|
|
}
|
|
UChar32 c = pattern.char32At(0);
|
|
const UnicodeMatcher *m = data->lookupMatcher(c);
|
|
return (m == 0) ? ((c & 0xFF) == v) : m->matchesIndexValue(v);
|
|
}
|
|
|
|
/**
|
|
* Implement UnicodeMatcher
|
|
*/
|
|
void StringMatcher::addMatchSetTo(UnicodeSet& toUnionTo) const {
|
|
UChar32 ch;
|
|
for (int32_t i=0; i<pattern.length(); i+=U16_LENGTH(ch)) {
|
|
ch = pattern.char32At(i);
|
|
const UnicodeMatcher* matcher = data->lookupMatcher(ch);
|
|
if (matcher == NULL) {
|
|
toUnionTo.add(ch);
|
|
} else {
|
|
matcher->addMatchSetTo(toUnionTo);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* UnicodeReplacer API
|
|
*/
|
|
int32_t StringMatcher::replace(Replaceable& text,
|
|
int32_t start,
|
|
int32_t limit,
|
|
int32_t& /*cursor*/) {
|
|
|
|
int32_t outLen = 0;
|
|
|
|
// Copy segment with out-of-band data
|
|
int32_t dest = limit;
|
|
// If there was no match, that means that a quantifier
|
|
// matched zero-length. E.g., x (a)* y matched "xy".
|
|
if (matchStart >= 0) {
|
|
if (matchStart != matchLimit) {
|
|
text.copy(matchStart, matchLimit, dest);
|
|
outLen = matchLimit - matchStart;
|
|
}
|
|
}
|
|
|
|
text.handleReplaceBetween(start, limit, UnicodeString()); // delete original text
|
|
|
|
return outLen;
|
|
}
|
|
|
|
/**
|
|
* UnicodeReplacer API
|
|
*/
|
|
UnicodeString& StringMatcher::toReplacerPattern(UnicodeString& rule,
|
|
UBool /*escapeUnprintable*/) const {
|
|
// assert(segmentNumber > 0);
|
|
rule.truncate(0);
|
|
rule.append((UChar)0x0024 /*$*/);
|
|
ICU_Utility::appendNumber(rule, segmentNumber, 10, 1);
|
|
return rule;
|
|
}
|
|
|
|
/**
|
|
* Remove any match info. This must be called before performing a
|
|
* set of matches with this segment.
|
|
*/
|
|
void StringMatcher::resetMatch() {
|
|
matchStart = matchLimit = -1;
|
|
}
|
|
|
|
/**
|
|
* Union the set of all characters that may output by this object
|
|
* into the given set.
|
|
* @param toUnionTo the set into which to union the output characters
|
|
*/
|
|
void StringMatcher::addReplacementSetTo(UnicodeSet& /*toUnionTo*/) const {
|
|
// The output of this replacer varies; it is the source text between
|
|
// matchStart and matchLimit. Since this varies depending on the
|
|
// input text, we can't compute it here. We can either do nothing
|
|
// or we can add ALL characters to the set. It's probably more useful
|
|
// to do nothing.
|
|
}
|
|
|
|
/**
|
|
* Implement UnicodeFunctor
|
|
*/
|
|
void StringMatcher::setData(const TransliterationRuleData* d) {
|
|
data = d;
|
|
int32_t i = 0;
|
|
while (i<pattern.length()) {
|
|
UChar32 c = pattern.char32At(i);
|
|
UnicodeFunctor* f = data->lookup(c);
|
|
if (f != NULL) {
|
|
f->setData(data);
|
|
}
|
|
i += U16_LENGTH(c);
|
|
}
|
|
}
|
|
|
|
U_NAMESPACE_END
|
|
|
|
#endif /* #if !UCONFIG_NO_TRANSLITERATION */
|
|
|
|
//eof
|