| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "base/strings/utf_offset_string_conversions.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 | |
| 9 #include "base/logging.h" | |
| 10 #include "base/memory/scoped_ptr.h" | |
| 11 #include "base/strings/string_piece.h" | |
| 12 #include "base/strings/utf_string_conversion_utils.h" | |
| 13 | |
| 14 namespace base { | |
| 15 | |
| 16 OffsetAdjuster::Adjustment::Adjustment(size_t original_offset, | |
| 17 size_t original_length, | |
| 18 size_t output_length) | |
| 19 : original_offset(original_offset), | |
| 20 original_length(original_length), | |
| 21 output_length(output_length) { | |
| 22 } | |
| 23 | |
| 24 // static | |
| 25 void OffsetAdjuster::AdjustOffsets( | |
| 26 const Adjustments& adjustments, | |
| 27 std::vector<size_t>* offsets_for_adjustment) { | |
| 28 if (!offsets_for_adjustment || adjustments.empty()) | |
| 29 return; | |
| 30 for (std::vector<size_t>::iterator i(offsets_for_adjustment->begin()); | |
| 31 i != offsets_for_adjustment->end(); ++i) | |
| 32 AdjustOffset(adjustments, &(*i)); | |
| 33 } | |
| 34 | |
| 35 // static | |
| 36 void OffsetAdjuster::AdjustOffset(const Adjustments& adjustments, | |
| 37 size_t* offset) { | |
| 38 if (*offset == string16::npos) | |
| 39 return; | |
| 40 int adjustment = 0; | |
| 41 for (Adjustments::const_iterator i = adjustments.begin(); | |
| 42 i != adjustments.end(); ++i) { | |
| 43 if (*offset <= i->original_offset) | |
| 44 break; | |
| 45 if (*offset < (i->original_offset + i->original_length)) { | |
| 46 *offset = string16::npos; | |
| 47 return; | |
| 48 } | |
| 49 adjustment += static_cast<int>(i->original_length - i->output_length); | |
| 50 } | |
| 51 *offset -= adjustment; | |
| 52 } | |
| 53 | |
| 54 // static | |
| 55 void OffsetAdjuster::UnadjustOffsets( | |
| 56 const Adjustments& adjustments, | |
| 57 std::vector<size_t>* offsets_for_unadjustment) { | |
| 58 if (!offsets_for_unadjustment || adjustments.empty()) | |
| 59 return; | |
| 60 for (std::vector<size_t>::iterator i(offsets_for_unadjustment->begin()); | |
| 61 i != offsets_for_unadjustment->end(); ++i) | |
| 62 UnadjustOffset(adjustments, &(*i)); | |
| 63 } | |
| 64 | |
| 65 // static | |
| 66 void OffsetAdjuster::UnadjustOffset(const Adjustments& adjustments, | |
| 67 size_t* offset) { | |
| 68 if (*offset == string16::npos) | |
| 69 return; | |
| 70 int adjustment = 0; | |
| 71 for (Adjustments::const_iterator i = adjustments.begin(); | |
| 72 i != adjustments.end(); ++i) { | |
| 73 if (*offset + adjustment <= i->original_offset) | |
| 74 break; | |
| 75 adjustment += static_cast<int>(i->original_length - i->output_length); | |
| 76 if ((*offset + adjustment) < | |
| 77 (i->original_offset + i->original_length)) { | |
| 78 *offset = string16::npos; | |
| 79 return; | |
| 80 } | |
| 81 } | |
| 82 *offset += adjustment; | |
| 83 } | |
| 84 | |
| 85 // static | |
| 86 void OffsetAdjuster::MergeSequentialAdjustments( | |
| 87 const Adjustments& first_adjustments, | |
| 88 Adjustments* adjustments_on_adjusted_string) { | |
| 89 Adjustments::iterator adjusted_iter = adjustments_on_adjusted_string->begin(); | |
| 90 Adjustments::const_iterator first_iter = first_adjustments.begin(); | |
| 91 // Simultaneously iterate over all |adjustments_on_adjusted_string| and | |
| 92 // |first_adjustments|, adding adjustments to or correcting the adjustments | |
| 93 // in |adjustments_on_adjusted_string| as we go. |shift| keeps track of the | |
| 94 // current number of characters collapsed by |first_adjustments| up to this | |
| 95 // point. |currently_collapsing| keeps track of the number of characters | |
| 96 // collapsed by |first_adjustments| into the current |adjusted_iter|'s | |
| 97 // length. These are characters that will change |shift| as soon as we're | |
| 98 // done processing the current |adjusted_iter|; they are not yet reflected in | |
| 99 // |shift|. | |
| 100 size_t shift = 0; | |
| 101 size_t currently_collapsing = 0; | |
| 102 while (adjusted_iter != adjustments_on_adjusted_string->end()) { | |
| 103 if ((first_iter == first_adjustments.end()) || | |
| 104 ((adjusted_iter->original_offset + shift + | |
| 105 adjusted_iter->original_length) <= first_iter->original_offset)) { | |
| 106 // Entire |adjusted_iter| (accounting for its shift and including its | |
| 107 // whole original length) comes before |first_iter|. | |
| 108 // | |
| 109 // Correct the offset at |adjusted_iter| and move onto the next | |
| 110 // adjustment that needs revising. | |
| 111 adjusted_iter->original_offset += shift; | |
| 112 shift += currently_collapsing; | |
| 113 currently_collapsing = 0; | |
| 114 ++adjusted_iter; | |
| 115 } else if ((adjusted_iter->original_offset + shift) > | |
| 116 first_iter->original_offset) { | |
| 117 // |first_iter| comes before the |adjusted_iter| (as adjusted by |shift|). | |
| 118 | |
| 119 // It's not possible for the adjustments to overlap. (It shouldn't | |
| 120 // be possible that we have an |adjusted_iter->original_offset| that, | |
| 121 // when adjusted by the computed |shift|, is in the middle of | |
| 122 // |first_iter|'s output's length. After all, that would mean the | |
| 123 // current adjustment_on_adjusted_string somehow points to an offset | |
| 124 // that was supposed to have been eliminated by the first set of | |
| 125 // adjustments.) | |
| 126 DCHECK_LE(first_iter->original_offset + first_iter->output_length, | |
| 127 adjusted_iter->original_offset + shift); | |
| 128 | |
| 129 // Add the |first_adjustment_iter| to the full set of adjustments while | |
| 130 // making sure |adjusted_iter| continues pointing to the same element. | |
| 131 // We do this by inserting the |first_adjustment_iter| right before | |
| 132 // |adjusted_iter|, then incrementing |adjusted_iter| so it points to | |
| 133 // the following element. | |
| 134 shift += first_iter->original_length - first_iter->output_length; | |
| 135 adjusted_iter = adjustments_on_adjusted_string->insert( | |
| 136 adjusted_iter, *first_iter); | |
| 137 ++adjusted_iter; | |
| 138 ++first_iter; | |
| 139 } else { | |
| 140 // The first adjustment adjusted something that then got further adjusted | |
| 141 // by the second set of adjustments. In other words, |first_iter| points | |
| 142 // to something in the range covered by |adjusted_iter|'s length (after | |
| 143 // accounting for |shift|). Precisely, | |
| 144 // adjusted_iter->original_offset + shift | |
| 145 // <= | |
| 146 // first_iter->original_offset | |
| 147 // <= | |
| 148 // adjusted_iter->original_offset + shift + | |
| 149 // adjusted_iter->original_length | |
| 150 | |
| 151 // Modify the current |adjusted_iter| to include whatever collapsing | |
| 152 // happened in |first_iter|, then advance to the next |first_adjustments| | |
| 153 // because we dealt with the current one. | |
| 154 const int collapse = static_cast<int>(first_iter->original_length) - | |
| 155 static_cast<int>(first_iter->output_length); | |
| 156 // This function does not know how to deal with a string that expands and | |
| 157 // then gets modified, only strings that collapse and then get modified. | |
| 158 DCHECK_GT(collapse, 0); | |
| 159 adjusted_iter->original_length += collapse; | |
| 160 currently_collapsing += collapse; | |
| 161 ++first_iter; | |
| 162 } | |
| 163 } | |
| 164 DCHECK_EQ(0u, currently_collapsing); | |
| 165 if (first_iter != first_adjustments.end()) { | |
| 166 // Only first adjustments are left. These do not need to be modified. | |
| 167 // (Their offsets are already correct with respect to the original string.) | |
| 168 // Append them all. | |
| 169 DCHECK(adjusted_iter == adjustments_on_adjusted_string->end()); | |
| 170 adjustments_on_adjusted_string->insert( | |
| 171 adjustments_on_adjusted_string->end(), first_iter, | |
| 172 first_adjustments.end()); | |
| 173 } | |
| 174 } | |
| 175 | |
| 176 // Converts the given source Unicode character type to the given destination | |
| 177 // Unicode character type as a STL string. The given input buffer and size | |
| 178 // determine the source, and the given output STL string will be replaced by | |
| 179 // the result. If non-NULL, |adjustments| is set to reflect the all the | |
| 180 // alterations to the string that are not one-character-to-one-character. | |
| 181 // It will always be sorted by increasing offset. | |
| 182 template<typename SrcChar, typename DestStdString> | |
| 183 bool ConvertUnicode(const SrcChar* src, | |
| 184 size_t src_len, | |
| 185 DestStdString* output, | |
| 186 OffsetAdjuster::Adjustments* adjustments) { | |
| 187 if (adjustments) | |
| 188 adjustments->clear(); | |
| 189 // ICU requires 32-bit numbers. | |
| 190 bool success = true; | |
| 191 int32 src_len32 = static_cast<int32>(src_len); | |
| 192 for (int32 i = 0; i < src_len32; i++) { | |
| 193 uint32 code_point; | |
| 194 size_t original_i = i; | |
| 195 size_t chars_written = 0; | |
| 196 if (ReadUnicodeCharacter(src, src_len32, &i, &code_point)) { | |
| 197 chars_written = WriteUnicodeCharacter(code_point, output); | |
| 198 } else { | |
| 199 chars_written = WriteUnicodeCharacter(0xFFFD, output); | |
| 200 success = false; | |
| 201 } | |
| 202 | |
| 203 // Only bother writing an adjustment if this modification changed the | |
| 204 // length of this character. | |
| 205 // NOTE: ReadUnicodeCharacter() adjusts |i| to point _at_ the last | |
| 206 // character read, not after it (so that incrementing it in the loop | |
| 207 // increment will place it at the right location), so we need to account | |
| 208 // for that in determining the amount that was read. | |
| 209 if (adjustments && ((i - original_i + 1) != chars_written)) { | |
| 210 adjustments->push_back(OffsetAdjuster::Adjustment( | |
| 211 original_i, i - original_i + 1, chars_written)); | |
| 212 } | |
| 213 } | |
| 214 return success; | |
| 215 } | |
| 216 | |
| 217 bool UTF8ToUTF16WithAdjustments( | |
| 218 const char* src, | |
| 219 size_t src_len, | |
| 220 string16* output, | |
| 221 base::OffsetAdjuster::Adjustments* adjustments) { | |
| 222 PrepareForUTF16Or32Output(src, src_len, output); | |
| 223 return ConvertUnicode(src, src_len, output, adjustments); | |
| 224 } | |
| 225 | |
| 226 string16 UTF8ToUTF16WithAdjustments( | |
| 227 const base::StringPiece& utf8, | |
| 228 base::OffsetAdjuster::Adjustments* adjustments) { | |
| 229 string16 result; | |
| 230 UTF8ToUTF16WithAdjustments(utf8.data(), utf8.length(), &result, adjustments); | |
| 231 return result; | |
| 232 } | |
| 233 | |
| 234 string16 UTF8ToUTF16AndAdjustOffsets( | |
| 235 const base::StringPiece& utf8, | |
| 236 std::vector<size_t>* offsets_for_adjustment) { | |
| 237 std::for_each(offsets_for_adjustment->begin(), | |
| 238 offsets_for_adjustment->end(), | |
| 239 LimitOffset<base::StringPiece>(utf8.length())); | |
| 240 OffsetAdjuster::Adjustments adjustments; | |
| 241 string16 result = UTF8ToUTF16WithAdjustments(utf8, &adjustments); | |
| 242 OffsetAdjuster::AdjustOffsets(adjustments, offsets_for_adjustment); | |
| 243 return result; | |
| 244 } | |
| 245 | |
| 246 std::string UTF16ToUTF8AndAdjustOffsets( | |
| 247 const base::StringPiece16& utf16, | |
| 248 std::vector<size_t>* offsets_for_adjustment) { | |
| 249 std::for_each(offsets_for_adjustment->begin(), | |
| 250 offsets_for_adjustment->end(), | |
| 251 LimitOffset<base::StringPiece16>(utf16.length())); | |
| 252 std::string result; | |
| 253 PrepareForUTF8Output(utf16.data(), utf16.length(), &result); | |
| 254 OffsetAdjuster::Adjustments adjustments; | |
| 255 ConvertUnicode(utf16.data(), utf16.length(), &result, &adjustments); | |
| 256 OffsetAdjuster::AdjustOffsets(adjustments, offsets_for_adjustment); | |
| 257 return result; | |
| 258 } | |
| 259 | |
| 260 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
