| OLD | NEW | 
|---|
|  | (Empty) | 
| 1 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file |  | 
| 2 // for details. All rights reserved. Use of this source code is governed by a |  | 
| 3 // BSD-style license that can be found in the LICENSE file. |  | 
| 4 |  | 
| 5 part of dart.utf; |  | 
| 6 |  | 
| 7 /** |  | 
| 8  * *DEPRECATED*: Use `package:utf/utf.dart` or, when applicable, `dart:convert` |  | 
| 9  * instead. |  | 
| 10  */ |  | 
| 11 @deprecated |  | 
| 12 IterableUtf32Decoder decodeUtf32AsIterable(List<int> bytes, [ |  | 
| 13     int offset = 0, int length, |  | 
| 14     int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) { |  | 
| 15   return new IterableUtf32Decoder._( |  | 
| 16       () => new Utf32BytesDecoder(bytes, offset, length, replacementCodepoint)); |  | 
| 17 } |  | 
| 18 |  | 
| 19 /** |  | 
| 20  * *DEPRECATED*: Use `package:utf/utf.dart` or, when applicable, `dart:convert` |  | 
| 21  * instead. |  | 
| 22  */ |  | 
| 23 @deprecated |  | 
| 24 IterableUtf32Decoder decodeUtf32beAsIterable(List<int> bytes, [ |  | 
| 25     int offset = 0, int length, bool stripBom = true, |  | 
| 26     int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) { |  | 
| 27   return new IterableUtf32Decoder._( |  | 
| 28       () => new Utf32beBytesDecoder(bytes, offset, length, stripBom, |  | 
| 29           replacementCodepoint)); |  | 
| 30 } |  | 
| 31 |  | 
| 32 /** |  | 
| 33  * *DEPRECATED*: Use `package:utf/utf.dart` or, when applicable, `dart:convert` |  | 
| 34  * instead. |  | 
| 35  */ |  | 
| 36 @deprecated |  | 
| 37 IterableUtf32Decoder decodeUtf32leAsIterable(List<int> bytes, [ |  | 
| 38     int offset = 0, int length, bool stripBom = true, |  | 
| 39     int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) { |  | 
| 40   return new IterableUtf32Decoder._( |  | 
| 41       () => new Utf32leBytesDecoder(bytes, offset, length, stripBom, |  | 
| 42           replacementCodepoint)); |  | 
| 43 } |  | 
| 44 |  | 
| 45 /** |  | 
| 46  * *DEPRECATED*: Use `package:utf/utf.dart` or, when applicable, `dart:convert` |  | 
| 47  * instead. |  | 
| 48  */ |  | 
| 49 @deprecated |  | 
| 50 String decodeUtf32(List<int> bytes, [int offset = 0, int length, |  | 
| 51     int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) { |  | 
| 52   return new String.fromCharCodes((new Utf32BytesDecoder(bytes, offset, length, |  | 
| 53       replacementCodepoint)).decodeRest()); |  | 
| 54 } |  | 
| 55 |  | 
| 56 /** |  | 
| 57  * *DEPRECATED*: Use `package:utf/utf.dart` or, when applicable, `dart:convert` |  | 
| 58  * instead. |  | 
| 59  */ |  | 
| 60 @deprecated |  | 
| 61 String decodeUtf32be( |  | 
| 62     List<int> bytes, [int offset = 0, int length, bool stripBom = true, |  | 
| 63     int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) => |  | 
| 64   new String.fromCharCodes((new Utf32beBytesDecoder(bytes, offset, length, |  | 
| 65     stripBom, replacementCodepoint)).decodeRest()); |  | 
| 66 |  | 
| 67 /** |  | 
| 68  * *DEPRECATED*: Use `package:utf/utf.dart` or, when applicable, `dart:convert` |  | 
| 69  * instead. |  | 
| 70  */ |  | 
| 71 @deprecated |  | 
| 72 String decodeUtf32le( |  | 
| 73     List<int> bytes, [int offset = 0, int length, bool stripBom = true, |  | 
| 74     int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) => |  | 
| 75     new String.fromCharCodes((new Utf32leBytesDecoder(bytes, offset, length, |  | 
| 76       stripBom, replacementCodepoint)).decodeRest()); |  | 
| 77 |  | 
| 78 /** |  | 
| 79  * *DEPRECATED*: Use `package:utf/utf.dart` or, when applicable, `dart:convert` |  | 
| 80  * instead. |  | 
| 81  */ |  | 
| 82 @deprecated |  | 
| 83 List<int> encodeUtf32(String str) => |  | 
| 84     encodeUtf32be(str, true); |  | 
| 85 |  | 
| 86 /** |  | 
| 87  * *DEPRECATED*: Use `package:utf/utf.dart` or, when applicable, `dart:convert` |  | 
| 88  * instead. |  | 
| 89  */ |  | 
| 90 @deprecated |  | 
| 91 List<int> encodeUtf32be(String str, [bool writeBOM = false]) { |  | 
| 92   List<int> utf32CodeUnits = stringToCodepoints(str); |  | 
| 93   List<int> encoding = new List<int>(4 * utf32CodeUnits.length + |  | 
| 94       (writeBOM ? 4 : 0)); |  | 
| 95   int i = 0; |  | 
| 96   if (writeBOM) { |  | 
| 97     encoding[i++] = 0; |  | 
| 98     encoding[i++] = 0; |  | 
| 99     encoding[i++] = UNICODE_UTF_BOM_HI; |  | 
| 100     encoding[i++] = UNICODE_UTF_BOM_LO; |  | 
| 101   } |  | 
| 102   for (int unit in utf32CodeUnits) { |  | 
| 103     encoding[i++] = (unit >> 24) & UNICODE_BYTE_ZERO_MASK; |  | 
| 104     encoding[i++] = (unit >> 16) & UNICODE_BYTE_ZERO_MASK; |  | 
| 105     encoding[i++] = (unit >> 8) & UNICODE_BYTE_ZERO_MASK; |  | 
| 106     encoding[i++] = unit & UNICODE_BYTE_ZERO_MASK; |  | 
| 107   } |  | 
| 108   return encoding; |  | 
| 109 } |  | 
| 110 |  | 
| 111 /** |  | 
| 112  * *DEPRECATED*: Use `package:utf/utf.dart` or, when applicable, `dart:convert` |  | 
| 113  * instead. |  | 
| 114  */ |  | 
| 115 @deprecated |  | 
| 116 List<int> encodeUtf32le(String str, [bool writeBOM = false]) { |  | 
| 117   List<int> utf32CodeUnits = stringToCodepoints(str); |  | 
| 118   List<int> encoding = new List<int>(4 * utf32CodeUnits.length + |  | 
| 119       (writeBOM ? 4 : 0)); |  | 
| 120   int i = 0; |  | 
| 121   if (writeBOM) { |  | 
| 122     encoding[i++] = UNICODE_UTF_BOM_LO; |  | 
| 123     encoding[i++] = UNICODE_UTF_BOM_HI; |  | 
| 124     encoding[i++] = 0; |  | 
| 125     encoding[i++] = 0; |  | 
| 126   } |  | 
| 127   for (int unit in utf32CodeUnits) { |  | 
| 128     encoding[i++] = unit & UNICODE_BYTE_ZERO_MASK; |  | 
| 129     encoding[i++] = (unit >> 8) & UNICODE_BYTE_ZERO_MASK; |  | 
| 130     encoding[i++] = (unit >> 16) & UNICODE_BYTE_ZERO_MASK; |  | 
| 131     encoding[i++] = (unit >> 24) & UNICODE_BYTE_ZERO_MASK; |  | 
| 132   } |  | 
| 133   return encoding; |  | 
| 134 } |  | 
| 135 |  | 
| 136 /** |  | 
| 137  * *DEPRECATED*: Use `package:utf/utf.dart` or, when applicable, `dart:convert` |  | 
| 138  * instead. |  | 
| 139  */ |  | 
| 140 @deprecated |  | 
| 141 bool hasUtf32Bom( |  | 
| 142     List<int> utf32EncodedBytes, [int offset = 0, int length]) { |  | 
| 143   return hasUtf32beBom(utf32EncodedBytes, offset, length) || |  | 
| 144       hasUtf32leBom(utf32EncodedBytes, offset, length); |  | 
| 145 } |  | 
| 146 |  | 
| 147 /** |  | 
| 148  * *DEPRECATED*: Use `package:utf/utf.dart` or, when applicable, `dart:convert` |  | 
| 149  * instead. |  | 
| 150  */ |  | 
| 151 @deprecated |  | 
| 152 bool hasUtf32beBom(List<int> utf32EncodedBytes, [int offset = 0, int length]) { |  | 
| 153   int end = length != null ? offset + length : utf32EncodedBytes.length; |  | 
| 154   return (offset + 4) <= end && |  | 
| 155       utf32EncodedBytes[offset] == 0 && utf32EncodedBytes[offset + 1] == 0 && |  | 
| 156       utf32EncodedBytes[offset + 2] == UNICODE_UTF_BOM_HI && |  | 
| 157       utf32EncodedBytes[offset + 3] == UNICODE_UTF_BOM_LO; |  | 
| 158 } |  | 
| 159 |  | 
| 160 /** |  | 
| 161  * *DEPRECATED*: Use `package:utf/utf.dart` or, when applicable, `dart:convert` |  | 
| 162  * instead. |  | 
| 163  */ |  | 
| 164 @deprecated |  | 
| 165 bool hasUtf32leBom(List<int> utf32EncodedBytes, [int offset = 0, int length]) { |  | 
| 166   int end = length != null ? offset + length : utf32EncodedBytes.length; |  | 
| 167   return (offset + 4) <= end && |  | 
| 168       utf32EncodedBytes[offset] == UNICODE_UTF_BOM_LO && |  | 
| 169       utf32EncodedBytes[offset + 1] == UNICODE_UTF_BOM_HI && |  | 
| 170       utf32EncodedBytes[offset + 2] == 0 && utf32EncodedBytes[offset + 3] == 0; |  | 
| 171 } |  | 
| 172 |  | 
| 173 typedef Utf32BytesDecoder Utf32BytesDecoderProvider(); |  | 
| 174 |  | 
| 175 /** |  | 
| 176  * *DEPRECATED*: Use `package:utf/utf.dart` or, when applicable, `dart:convert` |  | 
| 177  * instead. |  | 
| 178  */ |  | 
| 179 @deprecated |  | 
| 180 class IterableUtf32Decoder extends IterableBase<int> { |  | 
| 181   final Utf32BytesDecoderProvider codeunitsProvider; |  | 
| 182 |  | 
| 183   IterableUtf32Decoder._(this.codeunitsProvider); |  | 
| 184 |  | 
| 185   Utf32BytesDecoder get iterator => codeunitsProvider(); |  | 
| 186 } |  | 
| 187 |  | 
| 188 /** |  | 
| 189  * *DEPRECATED*: Use `package:utf/utf.dart` or, when applicable, `dart:convert` |  | 
| 190  * instead. |  | 
| 191  */ |  | 
| 192 @deprecated |  | 
| 193 abstract class Utf32BytesDecoder implements _ListRangeIterator { |  | 
| 194   final _ListRangeIterator utf32EncodedBytesIterator; |  | 
| 195   final int replacementCodepoint; |  | 
| 196   int _current = null; |  | 
| 197 |  | 
| 198   Utf32BytesDecoder._fromListRangeIterator( |  | 
| 199       this.utf32EncodedBytesIterator, this.replacementCodepoint); |  | 
| 200 |  | 
| 201   factory Utf32BytesDecoder(List<int> utf32EncodedBytes, [ |  | 
| 202       int offset = 0, int length, |  | 
| 203       int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) { |  | 
| 204     if (length == null) { |  | 
| 205       length = utf32EncodedBytes.length - offset; |  | 
| 206     } |  | 
| 207     if (hasUtf32beBom(utf32EncodedBytes, offset, length)) { |  | 
| 208       return new Utf32beBytesDecoder(utf32EncodedBytes, offset + 4, length - 4, |  | 
| 209           false, replacementCodepoint); |  | 
| 210     } else if (hasUtf32leBom(utf32EncodedBytes, offset, length)) { |  | 
| 211       return new Utf32leBytesDecoder(utf32EncodedBytes, offset + 4, length - 4, |  | 
| 212           false, replacementCodepoint); |  | 
| 213     } else { |  | 
| 214       return new Utf32beBytesDecoder(utf32EncodedBytes, offset, length, false, |  | 
| 215           replacementCodepoint); |  | 
| 216     } |  | 
| 217   } |  | 
| 218 |  | 
| 219   List<int> decodeRest() { |  | 
| 220     List<int> codeunits = new List<int>(remaining); |  | 
| 221     int i = 0; |  | 
| 222     while (moveNext()) { |  | 
| 223       codeunits[i++] = current; |  | 
| 224     } |  | 
| 225     return codeunits; |  | 
| 226   } |  | 
| 227 |  | 
| 228   int get current => _current; |  | 
| 229 |  | 
| 230   bool moveNext() { |  | 
| 231     _current = null; |  | 
| 232     if (utf32EncodedBytesIterator.remaining < 4) { |  | 
| 233       utf32EncodedBytesIterator.skip(utf32EncodedBytesIterator.remaining); |  | 
| 234       if (replacementCodepoint != null) { |  | 
| 235           _current = replacementCodepoint; |  | 
| 236           return true; |  | 
| 237       } else { |  | 
| 238         throw new ArgumentError( |  | 
| 239             "Invalid UTF32 at ${utf32EncodedBytesIterator.position}"); |  | 
| 240       } |  | 
| 241     } else { |  | 
| 242       int codepoint = decode(); |  | 
| 243       if (_validCodepoint(codepoint)) { |  | 
| 244         _current = codepoint; |  | 
| 245         return true; |  | 
| 246       } else if (replacementCodepoint != null) { |  | 
| 247         _current = replacementCodepoint; |  | 
| 248         return true; |  | 
| 249       } else { |  | 
| 250         throw new ArgumentError( |  | 
| 251             "Invalid UTF32 at ${utf32EncodedBytesIterator.position}"); |  | 
| 252       } |  | 
| 253     } |  | 
| 254   } |  | 
| 255 |  | 
| 256   int get position => utf32EncodedBytesIterator.position ~/ 4; |  | 
| 257 |  | 
| 258   void backup([int by = 1]) { |  | 
| 259     utf32EncodedBytesIterator.backup(4 * by); |  | 
| 260   } |  | 
| 261 |  | 
| 262   int get remaining => (utf32EncodedBytesIterator.remaining + 3) ~/ 4; |  | 
| 263 |  | 
| 264   void skip([int count = 1]) { |  | 
| 265     utf32EncodedBytesIterator.skip(4 * count); |  | 
| 266   } |  | 
| 267 |  | 
| 268   int decode(); |  | 
| 269 } |  | 
| 270 |  | 
| 271 /** |  | 
| 272  * *DEPRECATED*: Use `package:utf/utf.dart` or, when applicable, `dart:convert` |  | 
| 273  * instead. |  | 
| 274  */ |  | 
| 275 @deprecated |  | 
| 276 class Utf32beBytesDecoder extends Utf32BytesDecoder { |  | 
| 277   Utf32beBytesDecoder(List<int> utf32EncodedBytes, [int offset = 0, |  | 
| 278       int length, bool stripBom = true, |  | 
| 279       int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) : |  | 
| 280       super._fromListRangeIterator( |  | 
| 281           (new _ListRange(utf32EncodedBytes, offset, length)).iterator, |  | 
| 282           replacementCodepoint) { |  | 
| 283     if (stripBom && hasUtf32beBom(utf32EncodedBytes, offset, length)) { |  | 
| 284       skip(); |  | 
| 285     } |  | 
| 286   } |  | 
| 287 |  | 
| 288   int decode() { |  | 
| 289     utf32EncodedBytesIterator.moveNext(); |  | 
| 290     int value = utf32EncodedBytesIterator.current; |  | 
| 291     utf32EncodedBytesIterator.moveNext(); |  | 
| 292     value = (value << 8) + utf32EncodedBytesIterator.current; |  | 
| 293     utf32EncodedBytesIterator.moveNext(); |  | 
| 294     value = (value << 8) + utf32EncodedBytesIterator.current; |  | 
| 295     utf32EncodedBytesIterator.moveNext(); |  | 
| 296     value = (value << 8) + utf32EncodedBytesIterator.current; |  | 
| 297     return value; |  | 
| 298   } |  | 
| 299 } |  | 
| 300 |  | 
| 301 /** |  | 
| 302  * *DEPRECATED*: Use `package:utf/utf.dart` or, when applicable, `dart:convert` |  | 
| 303  * instead. |  | 
| 304  */ |  | 
| 305 @deprecated |  | 
| 306 class Utf32leBytesDecoder extends Utf32BytesDecoder { |  | 
| 307   Utf32leBytesDecoder(List<int> utf32EncodedBytes, [int offset = 0, |  | 
| 308       int length, bool stripBom = true, |  | 
| 309       int replacementCodepoint = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) : |  | 
| 310       super._fromListRangeIterator( |  | 
| 311           (new _ListRange(utf32EncodedBytes, offset, length)).iterator, |  | 
| 312           replacementCodepoint) { |  | 
| 313     if (stripBom && hasUtf32leBom(utf32EncodedBytes, offset, length)) { |  | 
| 314       skip(); |  | 
| 315     } |  | 
| 316   } |  | 
| 317 |  | 
| 318   int decode() { |  | 
| 319     utf32EncodedBytesIterator.moveNext(); |  | 
| 320     int value = utf32EncodedBytesIterator.current; |  | 
| 321     utf32EncodedBytesIterator.moveNext(); |  | 
| 322     value += (utf32EncodedBytesIterator.current << 8); |  | 
| 323     utf32EncodedBytesIterator.moveNext(); |  | 
| 324     value += (utf32EncodedBytesIterator.current << 16); |  | 
| 325     utf32EncodedBytesIterator.moveNext(); |  | 
| 326     value += (utf32EncodedBytesIterator.current << 24); |  | 
| 327     return value; |  | 
| 328   } |  | 
| 329 } |  | 
| 330 |  | 
| 331 bool _validCodepoint(int codepoint) { |  | 
| 332   return (codepoint >= 0 && codepoint < UNICODE_UTF16_RESERVED_LO) || |  | 
| 333       (codepoint > UNICODE_UTF16_RESERVED_HI && |  | 
| 334       codepoint < UNICODE_VALID_RANGE_MAX); |  | 
| 335 } |  | 
| OLD | NEW | 
|---|