| // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| part of dart.utf; |
| |
| class _HelperStreamController<T> extends StreamController<T> { |
| final Function onPauseChanged; |
| |
| _HelperStreamController(this.onPauseChanged); |
| |
| void onPauseStateChange() { |
| onPauseChanged(); |
| } |
| } |
| |
| abstract class _StringDecoder implements StreamTransformer<List<int>, String> { |
| _HelperStreamController<String> _controller; |
| StreamSubscription<List<int>> _subscription; |
| List<int> _carry; |
| List<int> _buffer; |
| int _replacementChar; |
| bool _paused = false; |
| |
| _StringDecoder(int this._replacementChar) { |
| _controller = new _HelperStreamController<String>(_onPauseChanged); |
| } |
| |
| void _onPauseChanged() { |
| _paused = _controller.isPaused; |
| if (_subscription == null) return; |
| if (_paused) { |
| _subscription.pause(); |
| } else { |
| _subscription.resume(); |
| } |
| } |
| |
| Stream<String> bind(Stream<List<int>> stream) { |
| _subscription = stream.listen( |
| _onData, |
| onError: _controller.signalError, |
| onDone: () { |
| if (_carry != null) { |
| _controller.add(new String.fromCharCodes( |
| new List.fixedLength(_carry.length, fill: _replacementChar))); |
| } |
| _controller.close(); |
| }, |
| unsubscribeOnError: false); |
| if (_paused) _subscription.pause(); |
| return _controller.stream; |
| } |
| |
| void _onData(List<int> bytes) { |
| _buffer = <int>[]; |
| List<int> carry = _carry; |
| _carry = null; |
| int pos = 0; |
| int available = bytes.length; |
| // If we have carry-over data, start from negative index, indicating carry |
| // index. |
| int goodChars = 0; |
| if (carry != null) pos = -carry.length; |
| while (pos < available) { |
| int currentPos = pos; |
| int getNext() { |
| if (pos < 0) { |
| return carry[pos++ + carry.length]; |
| } else if (pos < available) { |
| return bytes[pos++]; |
| } |
| return null; |
| } |
| int consumed = _processBytes(getNext); |
| if (consumed > 0) { |
| goodChars = _buffer.length; |
| } else if (consumed == 0) { |
| _buffer.length = goodChars; |
| if (currentPos < 0) { |
| _carry = []; |
| _carry.addAll(carry); |
| _carry.addAll(bytes); |
| } else { |
| _carry = bytes.getRange(currentPos, bytes.length - currentPos); |
| } |
| break; |
| } else { |
| // Invalid byte at position pos - 1 |
| _buffer.length = goodChars; |
| _addChar(-1); |
| goodChars = _buffer.length; |
| } |
| } |
| if (_buffer.length > 0) { |
| // Limit to 'goodChars', if lower than actual charCodes in the buffer. |
| _controller.add(new String.fromCharCodes(_buffer)); |
| } |
| _buffer = null; |
| } |
| |
| int _processBytes(int getNext()); |
| |
| void _addChar(int char) { |
| if (char > 0x10FFFF || char < 0) char = _replacementChar; |
| _buffer.add(char); |
| } |
| } |
| |
| /** |
| * StringTransformer that decodes a stream of UTF-8 encoded bytes. |
| */ |
| class Utf8DecoderTransformer extends _StringDecoder { |
| Utf8DecoderTransformer( |
| [int replacementChar = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) |
| : super(replacementChar); |
| |
| int _processBytes(int getNext()) { |
| int value = getNext(); |
| if ((value & 0xFF) != value) return -1; // Not a byte. |
| if ((value & 0x80) == 0x80) { |
| int additionalBytes; |
| int min; |
| if ((value & 0xe0) == 0xc0) { // 110xxxxx |
| value = value & 0x1F; |
| additionalBytes = 1; |
| min = 0x80; |
| } else if ((value & 0xf0) == 0xe0) { // 1110xxxx |
| value = value & 0x0F; |
| additionalBytes = 2; |
| min = 0x800; |
| } else if ((value & 0xf8) == 0xf0) { // 11110xxx |
| value = value & 0x07; |
| additionalBytes = 3; |
| min = 0x10000; |
| } else if ((value & 0xfc) == 0xf8) { // 111110xx |
| value = value & 0x03; |
| additionalBytes = 4; |
| min = 0x200000; |
| } else if ((value & 0xfe) == 0xfc) { // 1111110x |
| value = value & 0x01; |
| additionalBytes = 5; |
| min = 0x4000000; |
| } else { |
| return -1; |
| } |
| for (int i = 0; i < additionalBytes; i++) { |
| int next = getNext(); |
| if (next == null) return 0; // Not enough chars, reset. |
| if ((next & 0xc0) != 0x80 || (next & 0xff) != next) return -1; |
| value = value << 6 | (next & 0x3f); |
| } |
| // Invalid charCode if less then minimum expected. |
| if (value < min) value = -1; |
| _addChar(value); |
| return 1 + additionalBytes; |
| } |
| _addChar(value); |
| return 1; |
| } |
| } |
| |
| |
| abstract class _StringEncoder implements StreamTransformer<String, List<int>> { |
| _HelperStreamController<List<int>> _controller; |
| StreamSubscription<String> _subscription; |
| |
| void _onPauseChanged() { |
| if (_controller.isPaused) { |
| _subscription.pause(); |
| } else { |
| _subscription.resume(); |
| } |
| } |
| Stream<List<int>> bind(Stream<String> stream) { |
| _controller = new _HelperStreamController(_onPauseChanged); |
| _subscription = stream.listen( |
| (string) => _controller.add(_processString(string)), |
| onError: _controller.signalError, |
| onDone: _controller.close, |
| unsubscribeOnError: false); |
| return _controller.stream; |
| } |
| |
| List<int> _processString(String string); |
| } |
| |
| /** |
| * StringTransformer that UTF-8 encodes a stream of strings. |
| */ |
| class Utf8EncoderTransformer extends _StringEncoder { |
| List<int> _processString(String string) { |
| var bytes = []; |
| int pos = 0; |
| List<int> codepoints = _utf16CodeUnitsToCodepoints(string.charCodes); |
| int length = codepoints.length; |
| for (int i = 0; i < length; i++) { |
| int additionalBytes; |
| int charCode = codepoints[i]; |
| if (charCode <= 0x007F) { |
| additionalBytes = 0; |
| bytes.add(charCode); |
| } else if (charCode <= 0x07FF) { |
| // 110xxxxx (xxxxx is top 5 bits). |
| bytes.add(((charCode >> 6) & 0x1F) | 0xC0); |
| additionalBytes = 1; |
| } else if (charCode <= 0xFFFF) { |
| // 1110xxxx (xxxx is top 4 bits) |
| bytes.add(((charCode >> 12) & 0x0F)| 0xE0); |
| additionalBytes = 2; |
| } else { |
| // 11110xxx (xxx is top 3 bits) |
| bytes.add(((charCode >> 18) & 0x07) | 0xF0); |
| additionalBytes = 3; |
| } |
| for (int i = additionalBytes; i > 0; i--) { |
| // 10xxxxxx (xxxxxx is next 6 bits from the top). |
| bytes.add(((charCode >> (6 * (i - 1))) & 0x3F) | 0x80); |
| } |
| pos += additionalBytes + 1; |
| } |
| return bytes; |
| } |
| } |