tor-browser

strrepl.cpp (11087B)

---

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
**********************************************************************
*   Copyright (c) 2002-2012, International Business Machines Corporation
*   and others.  All Rights Reserved.
**********************************************************************
*   Date        Name        Description
*   01/21/2002  aliu        Creation.
**********************************************************************
*/

#include "unicode/utypes.h"

#if !UCONFIG_NO_TRANSLITERATION

#include "unicode/uniset.h"
#include "unicode/utf16.h"
#include "strrepl.h"
#include "rbt_data.h"
#include "util.h"

U_NAMESPACE_BEGIN

UnicodeReplacer::~UnicodeReplacer() {}
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(StringReplacer)

/**
* Construct a StringReplacer that sets the emits the given output
* text and sets the cursor to the given position.
* @param theOutput text that will replace input text when the
* replace() method is called.  May contain stand-in characters
* that represent nested replacers.
* @param theCursorPos cursor position that will be returned by
* the replace() method
* @param theData transliterator context object that translates
* stand-in characters to UnicodeReplacer objects
*/
StringReplacer::StringReplacer(const UnicodeString& theOutput,
                              int32_t theCursorPos,
                              const TransliterationRuleData* theData) {
   output = theOutput;
   cursorPos = theCursorPos;
   hasCursor = true;
   data = theData;
   isComplex = true;
}

/**
* Construct a StringReplacer that sets the emits the given output
* text and does not modify the cursor.
* @param theOutput text that will replace input text when the
* replace() method is called.  May contain stand-in characters
* that represent nested replacers.
* @param theData transliterator context object that translates
* stand-in characters to UnicodeReplacer objects
*/
StringReplacer::StringReplacer(const UnicodeString& theOutput,
                              const TransliterationRuleData* theData) {
   output = theOutput;
   cursorPos = 0;
   hasCursor = false;
   data = theData;
   isComplex = true;
}

/**
* Copy constructor.
*/
StringReplacer::StringReplacer(const StringReplacer& other) :
   UnicodeFunctor(other),
   UnicodeReplacer(other)
{
   output = other.output;
   cursorPos = other.cursorPos;
   hasCursor = other.hasCursor;
   data = other.data;
   isComplex = other.isComplex;
}

/**
* Destructor
*/
StringReplacer::~StringReplacer() {
}

/**
* Implement UnicodeFunctor
*/
StringReplacer* StringReplacer::clone() const {
   return new StringReplacer(*this);
}

/**
* Implement UnicodeFunctor
*/
UnicodeReplacer* StringReplacer::toReplacer() const {
 return const_cast<StringReplacer *>(this);
}

/**
* UnicodeReplacer API
*/
int32_t StringReplacer::replace(Replaceable& text,
                               int32_t start,
                               int32_t limit,
                               int32_t& cursor) {
   int32_t outLen;
   int32_t newStart = 0;

   // NOTE: It should be possible to _always_ run the complex
   // processing code; just slower.  If not, then there is a bug
   // in the complex processing code.

   // Simple (no nested replacers) Processing Code :
   if (!isComplex) {
       text.handleReplaceBetween(start, limit, output);
       outLen = output.length();

       // Setup default cursor position (for cursorPos within output)
       newStart = cursorPos;
   }

   // Complex (nested replacers) Processing Code :
   else {
       /* When there are segments to be copied, use the Replaceable.copy()
        * API in order to retain out-of-band data.  Copy everything to the
        * end of the string, then copy them back over the key.  This preserves
        * the integrity of indices into the key and surrounding context while
        * generating the output text.
        */
       UnicodeString buf;
       int32_t oOutput; // offset into 'output'
       isComplex = false;

       // The temporary buffer starts at tempStart, and extends
       // to destLimit.  The start of the buffer has a single
       // character from before the key.  This provides style
       // data when addition characters are filled into the
       // temporary buffer.  If there is nothing to the left, use
       // the non-character U+FFFF, which Replaceable subclasses
       // should treat specially as a "no-style character."
       // destStart points to the point after the style context
       // character, so it is tempStart+1 or tempStart+2.
       int32_t tempStart = text.length(); // start of temp buffer
       int32_t destStart = tempStart; // copy new text to here
       if (start > 0) {
           int32_t len = U16_LENGTH(text.char32At(start-1));
           text.copy(start-len, start, tempStart);
           destStart += len;
       } else {
           UnicodeString str(static_cast<char16_t>(0xFFFF));
           text.handleReplaceBetween(tempStart, tempStart, str);
           destStart++;
       }
       int32_t destLimit = destStart;

       for (oOutput=0; oOutput<output.length(); ) {
           if (oOutput == cursorPos) {
               // Record the position of the cursor
               newStart = destLimit - destStart; // relative to start
           }
           UChar32 c = output.char32At(oOutput);
           UnicodeReplacer* r = data->lookupReplacer(c);
           if (r == nullptr) {
               // Accumulate straight (non-segment) text.
               buf.append(c);
           } else {
               isComplex = true;

               // Insert any accumulated straight text.
               if (buf.length() > 0) {
                   text.handleReplaceBetween(destLimit, destLimit, buf);
                   destLimit += buf.length();
                   buf.truncate(0);
               }

               // Delegate output generation to replacer object
               int32_t len = r->replace(text, destLimit, destLimit, cursor);
               destLimit += len;
           }
           oOutput += U16_LENGTH(c);
       }
       // Insert any accumulated straight text.
       if (buf.length() > 0) {
           text.handleReplaceBetween(destLimit, destLimit, buf);
           destLimit += buf.length();
       }
       if (oOutput == cursorPos) {
           // Record the position of the cursor
           newStart = destLimit - destStart; // relative to start
       }

       outLen = destLimit - destStart;

       // Copy new text to start, and delete it
       text.copy(destStart, destLimit, start);
       text.handleReplaceBetween(tempStart + outLen, destLimit + outLen, UnicodeString());

       // Delete the old text (the key)
       text.handleReplaceBetween(start + outLen, limit + outLen, UnicodeString());
   }        

   if (hasCursor) {
       // Adjust the cursor for positions outside the key.  These
       // refer to code points rather than code units.  If cursorPos
       // is within the output string, then use newStart, which has
       // already been set above.
       if (cursorPos < 0) {
           newStart = start;
           int32_t n = cursorPos;
           // Outside the output string, cursorPos counts code points
           while (n < 0 && newStart > 0) {
               newStart -= U16_LENGTH(text.char32At(newStart-1));
               ++n;
           }
           newStart += n;
       } else if (cursorPos > output.length()) {
           newStart = start + outLen;
           int32_t n = cursorPos - output.length();
           // Outside the output string, cursorPos counts code points
           while (n > 0 && newStart < text.length()) {
               newStart += U16_LENGTH(text.char32At(newStart));
               --n;
           }
           newStart += n;
       } else {
           // Cursor is within output string.  It has been set up above
           // to be relative to start.
           newStart += start;
       }

       cursor = newStart;
   }

   return outLen;
}

/**
* UnicodeReplacer API
*/
UnicodeString& StringReplacer::toReplacerPattern(UnicodeString& rule,
                                                UBool escapeUnprintable) const {
   rule.truncate(0);
   UnicodeString quoteBuf;

   int32_t cursor = cursorPos;

   // Handle a cursor preceding the output
   if (hasCursor && cursor < 0) {
       while (cursor++ < 0) {
           ICU_Utility::appendToRule(rule, static_cast<char16_t>(0x0040) /*@*/, true, escapeUnprintable, quoteBuf);
       }
       // Fall through and append '|' below
   }

   for (int32_t i=0; i<output.length(); ++i) {
       if (hasCursor && i == cursor) {
           ICU_Utility::appendToRule(rule, static_cast<char16_t>(0x007C) /*|*/, true, escapeUnprintable, quoteBuf);
       }
       char16_t c = output.charAt(i); // Ok to use 16-bits here

       UnicodeReplacer* r = data->lookupReplacer(c);
       if (r == nullptr) {
           ICU_Utility::appendToRule(rule, c, false, escapeUnprintable, quoteBuf);
       } else {
           UnicodeString buf;
           r->toReplacerPattern(buf, escapeUnprintable);
           buf.insert(0, static_cast<char16_t>(0x20));
           buf.append(static_cast<char16_t>(0x20));
           ICU_Utility::appendToRule(rule, buf,
                                     true, escapeUnprintable, quoteBuf);
       }
   }

   // Handle a cursor after the output.  Use > rather than >= because
   // if cursor == output.length() it is at the end of the output,
   // which is the default position, so we need not emit it.
   if (hasCursor && cursor > output.length()) {
       cursor -= output.length();
       while (cursor-- > 0) {
           ICU_Utility::appendToRule(rule, static_cast<char16_t>(0x0040) /*@*/, true, escapeUnprintable, quoteBuf);
       }
       ICU_Utility::appendToRule(rule, static_cast<char16_t>(0x007C) /*|*/, true, escapeUnprintable, quoteBuf);
   }
   // Flush quoteBuf out to result
   ICU_Utility::appendToRule(rule, -1,
                             true, escapeUnprintable, quoteBuf);

   return rule;
}

/**
* Implement UnicodeReplacer
*/
void StringReplacer::addReplacementSetTo(UnicodeSet& toUnionTo) const {
   UChar32 ch;
   for (int32_t i=0; i<output.length(); i+=U16_LENGTH(ch)) {
   ch = output.char32At(i);
   UnicodeReplacer* r = data->lookupReplacer(ch);
   if (r == nullptr) {
       toUnionTo.add(ch);
   } else {
       r->addReplacementSetTo(toUnionTo);
   }
   }
}

/**
* UnicodeFunctor API
*/
void StringReplacer::setData(const TransliterationRuleData* d) {
   data = d;
   int32_t i = 0;
   while (i<output.length()) {
       UChar32 c = output.char32At(i);
       UnicodeFunctor* f = data->lookup(c);
       if (f != nullptr) {
           f->setData(data);
       }
       i += U16_LENGTH(c);
   }
}

U_NAMESPACE_END

#endif /* #if !UCONFIG_NO_TRANSLITERATION */

//eof