Google Git
Sign in
dart / sdk.git / c261ddbc2d82b841a4c5771d133cd66cd88748a9 / . / runtime / lib / convert_patch.dart
blob: d4acc18a55dae6fd2575946215a18f1f4ad6ca23 [file] [log] [blame]
// Copyright (c) 2014, 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.
import "dart:_internal" show POWERS_OF_TEN;
// JSON conversion.
patch _parseJson(String json, reviver(var key, var value)) {
_BuildJsonListener listener;
if (reviver == null) {
listener = new _BuildJsonListener();
} else {
listener = new _ReviverJsonListener(reviver);
}
var parser = new _JsonStringParser(listener);
parser.chunk = json;
parser.chunkEnd = json.length;
parser.parse(0);
parser.close();
return listener.result;
}
patch class Utf8Decoder {
/* patch */
Converter<List<int>, dynamic/*=T*/> fuse/*<T>*/(
Converter<String, dynamic/*=T*/> next) {
if (next is JsonDecoder) {
return new _JsonUtf8Decoder(next._reviver, this._allowMalformed)
as dynamic/*=Converter<List<int>, T>*/;
}
// TODO(lrn): Recognize a fused decoder where the next step is JsonDecoder.
return super.fuse/*<T>*/(next);
}
// Allow intercepting of UTF-8 decoding when built-in lists are passed.
/* patch */
static String _convertIntercepted(
bool allowMalformed, List<int> codeUnits, int start, int end) {
return null; // This call was not intercepted.
}
}
class _JsonUtf8Decoder extends Converter<List<int>, Object> {
final _Reviver _reviver;
final bool _allowMalformed;
_JsonUtf8Decoder(this._reviver, this._allowMalformed);
Object convert(List<int> input) {
var parser = _JsonUtf8DecoderSink._createParser(_reviver, _allowMalformed);
parser.chunk = input;
parser.chunkEnd = input.length;
parser.parse(0);
return parser.result;
}
ByteConversionSink startChunkedConversion(Sink<Object> sink) {
return new _JsonUtf8DecoderSink(_reviver, sink, _allowMalformed);
}
}
//// Implementation ///////////////////////////////////////////////////////////
// Simple API for JSON parsing.
/**
* Listener for parsing events from [_ChunkedJsonParser].
*/
abstract class _JsonListener {
void handleString(String value) {}
void handleNumber(num value) {}
void handleBool(bool value) {}
void handleNull() {}
void beginObject() {}
void propertyName() {}
void propertyValue() {}
void endObject() {}
void beginArray() {}
void arrayElement() {}
void endArray() {}
/**
* Read out the final result of parsing a JSON string.
*
* Must only be called when the entire input has been parsed.
*/
get result;
}
/**
* A [_JsonListener] that builds data objects from the parser events.
*
* This is a simple stack-based object builder. It keeps the most recently
* seen value in a variable, and uses it depending on the following event.
*/
class _BuildJsonListener extends _JsonListener {
/**
* Stack used to handle nested containers.
*
* The current container is pushed on the stack when a new one is
* started. If the container is a [Map], there is also a current [key]
* which is also stored on the stack.
*/
List stack = [];
/** The current [Map] or [List] being built. */
var currentContainer;
/** The most recently read property key. */
String key;
/** The most recently read value. */
var value;
/** Pushes the currently active container (and key, if a [Map]). */
void pushContainer() {
if (currentContainer is Map) stack.add(key);
stack.add(currentContainer);
}
/** Pops the top container from the [stack], including a key if applicable. */
void popContainer() {
value = currentContainer;
currentContainer = stack.removeLast();
if (currentContainer is Map) key = stack.removeLast();
}
void handleString(String value) { this.value = value; }
void handleNumber(num value) { this.value = value; }
void handleBool(bool value) { this.value = value; }
void handleNull() { this.value = null; }
void beginObject() {
pushContainer();
currentContainer = {};
}
void propertyName() {
key = value;
value = null;
}
void propertyValue() {
Map map = currentContainer;
map[key] = value;
key = value = null;
}
void endObject() {
popContainer();
}
void beginArray() {
pushContainer();
currentContainer = [];
}
void arrayElement() {
List list = currentContainer;
currentContainer.add(value);
value = null;
}
void endArray() {
popContainer();
}
/** Read out the final result of parsing a JSON string. */
get result {
assert(currentContainer == null);
return value;
}
}
class _ReviverJsonListener extends _BuildJsonListener {
final _Reviver reviver;
_ReviverJsonListener(reviver(key, value)) : this.reviver = reviver;
void arrayElement() {
List list = currentContainer;
value = reviver(list.length, value);
super.arrayElement();
}
void propertyValue() {
value = reviver(key, value);
super.propertyValue();
}
get result {
return reviver(null, value);
}
}
/**
* Buffer holding parts of a numeral.
*
* The buffer contains the characters of a JSON number.
* These are all ASCII, so an [Uint8List] is used as backing store.
*
* This buffer is used when a JSON number is split between separate chunks.
*
*/
class _NumberBuffer {
static const int minCapacity = 16;
static const int kDefaultOverhead = 5;
Uint8List list;
int length = 0;
_NumberBuffer(int initialCapacity)
: list = new Uint8List(_initialCapacity(initialCapacity));
int get capacity => list.length;
// Pick an initial capacity greater than the first part's size.
// The typical use case has two parts, this is the attempt at
// guessing the size of the second part without overdoing it.
// The default estimate of the second part is [kDefaultOverhead],
// then round to multiplum of four, and return the result,
// or [minCapacity] if that is greater.
static int _initialCapacity(int minCapacity) {
minCapacity += kDefaultOverhead;
if (minCapacity < minCapacity) return minCapacity;
minCapacity = (minCapacity + 3) & ~3; // Round to multiple of four.
return minCapacity;
}
// Grows to the exact size asked for.
void ensureCapacity(int newCapacity) {
Uint8List list = this.list;
if (newCapacity <= list.length) return;
Uint8List newList = new Uint8List(newCapacity);
newList.setRange(0, list.length, list, 0);
this.list = newList;
}
String getString() {
String result = new String.fromCharCodes(list, 0, length);
return result;
}
// TODO(lrn): See if parsing of numbers can be abstracted to something
// not only working on strings, but also on char-code lists, without lossing
// performance.
int parseInt() => int.parse(getString());
double parseDouble() => double.parse(getString());
}
/**
* Chunked JSON parser.
*
* Receives inputs in chunks, gives access to individual parts of the input,
* and stores input state between chunks.
*
* Implementations include [String] and UTF-8 parsers.
*/
abstract class _ChunkedJsonParser {
// A simple non-recursive state-based parser for JSON.
//
// Literal values accepted in states ARRAY_EMPTY, ARRAY_COMMA, OBJECT_COLON
// and strings also in OBJECT_EMPTY, OBJECT_COMMA.
// VALUE STRING : , } ] Transitions to
// EMPTY X X -> END
// ARRAY_EMPTY X X @ -> ARRAY_VALUE / pop
// ARRAY_VALUE @ @ -> ARRAY_COMMA / pop
// ARRAY_COMMA X X -> ARRAY_VALUE
// OBJECT_EMPTY X @ -> OBJECT_KEY / pop
// OBJECT_KEY @ -> OBJECT_COLON
// OBJECT_COLON X X -> OBJECT_VALUE
// OBJECT_VALUE @ @ -> OBJECT_COMMA / pop
// OBJECT_COMMA X -> OBJECT_KEY
// END
// Starting a new array or object will push the current state. The "pop"
// above means restoring this state and then marking it as an ended value.
// X means generic handling, @ means special handling for just that
// state - that is, values are handled generically, only punctuation
// cares about the current state.
// Values for states are chosen so bits 0 and 1 tell whether
// a string/value is allowed, and setting bits 0 through 2 after a value
// gets to the next state (not empty, doesn't allow a value).
// State building-block constants.
static const int TOP_LEVEL = 0;
static const int INSIDE_ARRAY = 1;
static const int INSIDE_OBJECT = 2;
static const int AFTER_COLON = 3; // Always inside object.
static const int ALLOW_STRING_MASK = 8; // Allowed if zero.
static const int ALLOW_VALUE_MASK = 4; // Allowed if zero.
static const int ALLOW_VALUE = 0;
static const int STRING_ONLY = 4;
static const int NO_VALUES = 12;
// Objects and arrays are "empty" until their first property/element.
// At this position, they may either have an entry or a close-bracket.
static const int EMPTY = 0;
static const int NON_EMPTY = 16;
static const int EMPTY_MASK = 16; // Empty if zero.
// Actual states : Context | Is empty? | Next?
static const int STATE_INITIAL = TOP_LEVEL | EMPTY | ALLOW_VALUE;
static const int STATE_END = TOP_LEVEL | NON_EMPTY | NO_VALUES;
static const int STATE_ARRAY_EMPTY = INSIDE_ARRAY | EMPTY | ALLOW_VALUE;
static const int STATE_ARRAY_VALUE = INSIDE_ARRAY | NON_EMPTY | NO_VALUES;
static const int STATE_ARRAY_COMMA = INSIDE_ARRAY | NON_EMPTY | ALLOW_VALUE;
static const int STATE_OBJECT_EMPTY = INSIDE_OBJECT | EMPTY | STRING_ONLY;
static const int STATE_OBJECT_KEY = INSIDE_OBJECT | NON_EMPTY | NO_VALUES;
static const int STATE_OBJECT_COLON = AFTER_COLON | NON_EMPTY | ALLOW_VALUE;
static const int STATE_OBJECT_VALUE = AFTER_COLON | NON_EMPTY | NO_VALUES;
static const int STATE_OBJECT_COMMA = INSIDE_OBJECT | NON_EMPTY | STRING_ONLY;
// Bits set in state after successfully reading a value.
// This transitions the state to expect the next punctuation.
static const int VALUE_READ_BITS = NON_EMPTY | NO_VALUES;
// Character code constants.
static const int BACKSPACE = 0x08;
static const int TAB = 0x09;
static const int NEWLINE = 0x0a;
static const int CARRIAGE_RETURN = 0x0d;
static const int FORM_FEED = 0x0c;
static const int SPACE = 0x20;
static const int QUOTE = 0x22;
static const int PLUS = 0x2b;
static const int COMMA = 0x2c;
static const int MINUS = 0x2d;
static const int DECIMALPOINT = 0x2e;
static const int SLASH = 0x2f;
static const int CHAR_0 = 0x30;
static const int CHAR_9 = 0x39;
static const int COLON = 0x3a;
static const int CHAR_E = 0x45;
static const int LBRACKET = 0x5b;
static const int BACKSLASH = 0x5c;
static const int RBRACKET = 0x5d;
static const int CHAR_a = 0x61;
static const int CHAR_b = 0x62;
static const int CHAR_e = 0x65;
static const int CHAR_f = 0x66;
static const int CHAR_l = 0x6c;
static const int CHAR_n = 0x6e;
static const int CHAR_r = 0x72;
static const int CHAR_s = 0x73;
static const int CHAR_t = 0x74;
static const int CHAR_u = 0x75;
static const int LBRACE = 0x7b;
static const int RBRACE = 0x7d;
// State of partial value at chunk split.
static const int NO_PARTIAL = 0;
static const int PARTIAL_STRING = 1;
static const int PARTIAL_NUMERAL = 2;
static const int PARTIAL_KEYWORD = 3;
static const int MASK_PARTIAL = 3;
// Partial states for numerals. Values can be |'ed with PARTIAL_NUMERAL.
static const int NUM_SIGN = 0; // After initial '-'.
static const int NUM_ZERO = 4; // After '0' as first digit.
static const int NUM_DIGIT = 8; // After digit, no '.' or 'e' seen.
static const int NUM_DOT = 12; // After '.'.
static const int NUM_DOT_DIGIT = 16; // After a decimal digit (after '.').
static const int NUM_E = 20; // After 'e' or 'E'.
static const int NUM_E_SIGN = 24; // After '-' or '+' after 'e' or 'E'.
static const int NUM_E_DIGIT = 28; // After exponent digit.
static const int NUM_SUCCESS = 32; // Never stored as partial state.
// Partial states for strings.
static const int STR_PLAIN = 0; // Inside string, but not escape.
static const int STR_ESCAPE = 4; // After '\'.
static const int STR_U = 16; // After '\u' and 0-3 hex digits.
static const int STR_U_COUNT_SHIFT = 2; // Hex digit count in bits 2-3.
static const int STR_U_VALUE_SHIFT = 5; // Hex digit value in bits 5+.
// Partial states for keywords.
static const int KWD_TYPE_MASK = 12;
static const int KWD_TYPE_SHIFT = 2;
static const int KWD_NULL = 0; // Prefix of "null" seen.
static const int KWD_TRUE = 4; // Prefix of "true" seen.
static const int KWD_FALSE = 8; // Prefix of "false" seen.
static const int KWD_COUNT_SHIFT = 4; // Prefix length in bits 4+.
// Mask used to mask off two lower bits.
static const int TWO_BIT_MASK = 3;
final _JsonListener listener;
// The current parsing state.
int state = STATE_INITIAL;
List<int> states = <int>[];
/**
* Stores tokenizer state between chunks.
*
* This state is stored when a chunk stops in the middle of a
* token (string, numeral, boolean or null).
*
* The partial state is used to continue parsing on the next chunk.
* The previous chunk is not retained, any data needed are stored in
* this integer, or in the [buffer] field as a string-building buffer
* or a [_NumberBuffer].
*
* Prefix state stored in [prefixState] as bits.
*
* ..00 : No partial value (NO_PARTIAL).
*
* ..00001 : Partial string, not inside escape.
* ..00101 : Partial string, after '\'.
* ..vvvv1dd01 : Partial \u escape.
* The 'dd' bits (2-3) encode the number of hex digits seen.
* Bits 5-16 encode the value of the hex digits seen so far.
*
* ..0ddd10 : Partial numeral.
* The `ddd` bits store the parts of in the numeral seen so
* far, as the constants `NUM_*` defined above.
* The characters of the numeral are stored in [buffer]
* as a [_NumberBuffer].
*
* ..0ddd0011 : Partial 'null' keyword.
* ..0ddd0111 : Partial 'true' keyword.
* ..0ddd1011 : Partial 'false' keyword.
* For all three keywords, the `ddd` bits encode the number
* of letters seen.
*/
int partialState = NO_PARTIAL;
/**
* Extra data stored while parsing a primitive value.
* May be set during parsing, always set at chunk end if a value is partial.
*
* May contain a string buffer while parsing strings.
*/
var buffer = null;
_ChunkedJsonParser(this.listener);
/**
* Push the current parse [state] on a stack.
*
* State is pushed when a new array or object literal starts,
* so the parser can go back to the correct value when the literal ends.
*/
void saveState(int state) {
states.add(state);
}
/**
* Restore a state pushed with [saveState].
*/
int restoreState() {
return states.removeLast(); // Throws if empty.
}
/**
* Finalizes the parsing.
*
* Throws if the source read so far doesn't end up with a complete
* parsed value. That means it must not be inside a list or object
* literal, and any partial value read should also be a valid complete
* value.
*
* The only valid partial state is a number that ends in a digit, and
* only if the number is the entire JSON value being parsed
* (otherwise it would be inside a list or object).
* Such a number will be completed. Any other partial state is an error.
*/
void close() {
if (partialState != NO_PARTIAL) {
int partialType = partialState & MASK_PARTIAL;
if (partialType == PARTIAL_NUMERAL) {
int numState = partialState & ~MASK_PARTIAL;
// A partial number might be a valid number if we know it's done.
// There is an unnecessary overhead if input is a single number,
// but this is assumed to be rare.
_NumberBuffer buffer = this.buffer;
this.buffer = null;
finishChunkNumber(numState, 0, 0, buffer);
} else if (partialType == PARTIAL_STRING) {
fail(chunkEnd, "Unterminated string");
} else {
assert(partialType == PARTIAL_KEYWORD);
fail(chunkEnd); // Incomplete literal.
}
}
if (state != STATE_END) {
fail(chunkEnd);
}
}
/**
* Read out the result after successfully closing the parser.
*
* The parser is closed by calling [close] or calling [addSourceChunk] with
* `true` as second (`isLast`) argument.
*/
Object get result {
return listener.result;
}
/** Sets the current source chunk. */
void set chunk(var source);
/**
* Length of current chunk.
*
* The valid arguments to [getChar] are 0 .. `chunkEnd - 1`.
*/
int get chunkEnd;
/**
* Returns the chunk itself.
*
* Only used by [fail] to include the chunk in the thrown [FormatException].
*/
get chunk;
/**
* Get charcacter/code unit of current chunk.
*
* The [index] must be non-negative and less than `chunkEnd`.
* In practive, [index] will be no smaller than the `start` argument passed
* to [parse].
*/
int getChar(int index);
/**
* Copy ASCII characters from start to end of chunk into a list.
*
* Used for number buffer (always copies ASCII, so encoding is not important).
*/
void copyCharsToList(int start, int end, List<int> target, int offset);
/**
* Build a string using input code units.
*
* Creates a string buffer and enables adding characters and slices
* to that buffer.
* The buffer is stored in the [buffer] field. If the string is unterminated,
* the same buffer is used to continue parsing in the next chunk.
*/
void beginString();
/**
* Add single character code to string being built.
*
* Used for unparsed escape sequences.
*/
void addCharToString(int charCode);
/**
* Adds slice of current chunk to string being built.
*
* The [start] positions is inclusive, [end] is exclusive.
*/
void addSliceToString(int start, int end);
/** Finalizes the string being built and returns it as a String. */
String endString();
/**
* Extracts a literal string from a slice of the current chunk.
*
* No interpretation of the content is performed, except for converting
* the source format to string.
* This can be implemented more or less efficiently depending on the
* underlying source.
*
* This is used for string literals that contain no escapes.
*
* The [bits] integer is an upper bound on the code point in the range
* from `start` to `end`.
* Usually found by doing bitwise or of all the values.
* The function may choose to optimize depending on the value.
*/
String getString(int start, int end, int bits);
/**
* Parse a slice of the current chunk as an integer.
*
* The format is expected to be correct.
*/
int parseInt(int start, int end) {
const int asciiBits = 0x7f; // Integer literals are ASCII only.
return int.parse(getString(start, end, asciiBits));
}
/**
* Parse a slice of the current chunk as a double.
*
* The format is expected to be correct.
* This is used by [parseNumber] when the double value cannot be
* built exactly during parsing.
*/
double parseDouble(int start, int end) {
const int asciiBits = 0x7f; // Double literals are ASCII only.
return double.parse(getString(start, end, asciiBits));
}
/**
* Create a _NumberBuffer containing the digits from [start] to [chunkEnd].
*
* This creates a number buffer and initializes it with the part of the
* number literal ending the current chunk
*/
void createNumberBuffer(int start) {
assert(start >= 0);
assert(start < chunkEnd);
int length = chunkEnd - start;
var buffer = new _NumberBuffer(length);
copyCharsToList(start, chunkEnd, buffer.list, 0);
buffer.length = length;
return buffer;
}
/**
* Continues parsing a partial value.
*/
int parsePartial(int position) {
if (position == chunkEnd) return position;
int partialState = this.partialState;
assert(partialState != NO_PARTIAL);
int partialType = partialState & MASK_PARTIAL;
this.partialState = NO_PARTIAL;
partialState = partialState & ~MASK_PARTIAL;
assert(partialType != 0);
if (partialType == PARTIAL_STRING) {
position = parsePartialString(position, partialState);
} else if (partialType == PARTIAL_NUMERAL) {
position = parsePartialNumber(position, partialState);
} else if (partialType == PARTIAL_KEYWORD) {
position = parsePartialKeyword(position, partialState);
}
return position;
}
/**
* Parses the remainder of a number into the number buffer.
*
* Syntax is checked while pasing.
* Starts at position, which is expected to be the start of the chunk,
* and returns the index of the first non-number-literal character found,
* or chunkEnd if the entire chunk is a valid number continuation.
* Throws if a syntax error is detected.
*/
int parsePartialNumber(int position, int state) {
int start = position;
// Primitive implementation, can be optimized.
_NumberBuffer buffer = this.buffer;
this.buffer = null;
int end = chunkEnd;
toBailout: {
if (position == end) break toBailout;
int char = getChar(position);
int digit = char ^ CHAR_0;
if (state == NUM_SIGN) {
if (digit <= 9) {
if (digit == 0) {
state = NUM_ZERO;
} else {
state = NUM_DIGIT;
}
position++;
if (position == end) break toBailout;
char = getChar(position);
digit = char ^ CHAR_0;
} else {
return fail(position);
}
}
if (state == NUM_ZERO) {
// JSON does not allow insignificant leading zeros (e.g., "09").
if (digit <= 9) return fail(position);
state = NUM_DIGIT;
}
while (state == NUM_DIGIT) {
if (digit > 9) {
if (char == DECIMALPOINT) {
state = NUM_DOT;
} else if ((char | 0x20) == CHAR_e) {
state = NUM_E;
} else {
finishChunkNumber(state, start, position, buffer);
return position;
}
}
position++;
if (position == end) break toBailout;
char = getChar(position);
digit = char ^ CHAR_0;
}
if (state == NUM_DOT) {
if (digit > 9) return fail(position);
state = NUM_DOT_DIGIT;
}
while (state == NUM_DOT_DIGIT) {
if (digit > 9) {
if ((char | 0x20) == CHAR_e) {
state = NUM_E;
} else {
finishChunkNumber(state, start, position, buffer);
return position;
}
}
position++;
if (position == end) break toBailout;
char = getChar(position);
digit = char ^ CHAR_0;
}
if (state == NUM_E) {
if (char == PLUS || char == MINUS) {
state = NUM_E_SIGN;
position++;
if (position == end) break toBailout;
char = getChar(position);
digit = char ^ CHAR_0;
}
}
assert(state >= NUM_E);
while (digit <= 9) {
state = NUM_E_DIGIT;
position++;
if (position == end) break toBailout;
char = getChar(position);
digit = char ^ CHAR_0;
}
finishChunkNumber(state, start, position, buffer);
return position;
}
// Bailout code in case the current chunk ends while parsing the numeral.
assert(position == end);
continueChunkNumber(state, start, buffer);
return chunkEnd;
}
/**
* Continues parsing a partial string literal.
*
* Handles partial escapes and then hands the parsing off to
* [parseStringToBuffer].
*/
int parsePartialString(int position, int partialState) {
if (partialState == STR_PLAIN) {
return parseStringToBuffer(position);
}
if (partialState == STR_ESCAPE) {
position = parseStringEscape(position);
// parseStringEscape sets partialState if it sees the end.
if (position == chunkEnd) return position;
return parseStringToBuffer(position);
}
assert((partialState & STR_U) != 0);
int value = partialState >> STR_U_VALUE_SHIFT;
int count = (partialState >> STR_U_COUNT_SHIFT) & TWO_BIT_MASK;
for (int i = count; i < 4; i++, position++) {
if (position == chunkEnd) return chunkStringEscapeU(i, value);
int char = getChar(position);
int digit = parseHexDigit(char);
if (digit < 0) fail(position, "Invalid hex digit");
value = 16 * value + digit;
}
addCharToString(value);
return parseStringToBuffer(position);
}
/**
* Continues parsing a partial keyword.
*/
int parsePartialKeyword(int position, int partialState) {
int keywordType = partialState & KWD_TYPE_MASK;
int count = partialState >> KWD_COUNT_SHIFT;
int keywordTypeIndex = keywordType >> KWD_TYPE_SHIFT;
String keyword = const ["null", "true", "false"][keywordTypeIndex];
assert(count < keyword.length);
do {
if (position == chunkEnd) {
this.partialState =
PARTIAL_KEYWORD | keywordType | (count << KWD_COUNT_SHIFT);
return chunkEnd;
}
int expectedChar = keyword.codeUnitAt(count);
if (getChar(position) != expectedChar) return fail(position);
position++;
count++;
} while (count < keyword.length);
if (keywordType == KWD_NULL) {
listener.handleNull();
} else {
listener.handleBool(keywordType == KWD_TRUE);
}
return position;
}
/** Convert hex-digit to its value. Returns -1 if char is not a hex digit. */
int parseHexDigit(int char) {
int digit = char ^ 0x30;
if (digit <= 9) return digit;
int letter = (char | 0x20) ^ 0x60;
// values 1 .. 6 are 'a' through 'f'
if (letter <= 6 && letter > 0) return letter + 9;
return -1;
}
/**
* Parses the current chunk as a chunk of JSON.
*
* Starts parsing at [position] and continues until [chunkEnd].
* Continues parsing where the previous chunk (if any) ended.
*/
void parse(int position) {
int length = chunkEnd;
if (partialState != NO_PARTIAL) {
position = parsePartial(position);
if (position == length) return;
}
int state = this.state;
while (position < length) {
int char = getChar(position);
switch (char) {
case SPACE:
case CARRIAGE_RETURN:
case NEWLINE:
case TAB:
position++;
break;
case QUOTE:
if ((state & ALLOW_STRING_MASK) != 0) return fail(position);
state |= VALUE_READ_BITS;
position = parseString(position + 1);
break;
case LBRACKET:
if ((state & ALLOW_VALUE_MASK) != 0) return fail(position);
listener.beginArray();
saveState(state);
state = STATE_ARRAY_EMPTY;
position++;
break;
case LBRACE:
if ((state & ALLOW_VALUE_MASK) != 0) return fail(position);
listener.beginObject();
saveState(state);
state = STATE_OBJECT_EMPTY;
position++;
break;
case CHAR_n:
if ((state & ALLOW_VALUE_MASK) != 0) return fail(position);
state |= VALUE_READ_BITS;
position = parseNull(position);
break;
case CHAR_f:
if ((state & ALLOW_VALUE_MASK) != 0) return fail(position);
state |= VALUE_READ_BITS;
position = parseFalse(position);
break;
case CHAR_t:
if ((state & ALLOW_VALUE_MASK) != 0) return fail(position);
state |= VALUE_READ_BITS;
position = parseTrue(position);
break;
case COLON:
if (state != STATE_OBJECT_KEY) return fail(position);
listener.propertyName();
state = STATE_OBJECT_COLON;
position++;
break;
case COMMA:
if (state == STATE_OBJECT_VALUE) {
listener.propertyValue();
state = STATE_OBJECT_COMMA;
position++;
} else if (state == STATE_ARRAY_VALUE) {
listener.arrayElement();
state = STATE_ARRAY_COMMA;
position++;
} else {
return fail(position);
}
break;
case RBRACKET:
if (state == STATE_ARRAY_EMPTY) {
listener.endArray();
} else if (state == STATE_ARRAY_VALUE) {
listener.arrayElement();
listener.endArray();
} else {
return fail(position);
}
state = restoreState() | VALUE_READ_BITS;
position++;
break;
case RBRACE:
if (state == STATE_OBJECT_EMPTY) {
listener.endObject();
} else if (state == STATE_OBJECT_VALUE) {
listener.propertyValue();
listener.endObject();
} else {
return fail(position);
}
state = restoreState() | VALUE_READ_BITS;
position++;
break;
default:
if ((state & ALLOW_VALUE_MASK) != 0) fail(position);
state |= VALUE_READ_BITS;
if (char == null) print("$chunk - $position");
position = parseNumber(char, position);
break;
}
}
this.state = state;
}
/**
* Parses a "true" literal starting at [position].
*
* The character `source[position]` must be "t".
*/
int parseTrue(int position) {
assert(getChar(position) == CHAR_t);
if (chunkEnd < position + 4) {
return parseKeywordPrefix(position, "true", KWD_TRUE);
}
if (getChar(position + 1) != CHAR_r ||
getChar(position + 2) != CHAR_u ||
getChar(position + 3) != CHAR_e) {
return fail(position);
}
listener.handleBool(true);
return position + 4;
}
/**
* Parses a "false" literal starting at [position].
*
* The character `source[position]` must be "f".
*/
int parseFalse(int position) {
assert(getChar(position) == CHAR_f);
if (chunkEnd < position + 5) {
return parseKeywordPrefix(position, "false", KWD_FALSE);
}
if (getChar(position + 1) != CHAR_a ||
getChar(position + 2) != CHAR_l ||
getChar(position + 3) != CHAR_s ||
getChar(position + 4) != CHAR_e) {
return fail(position);
}
listener.handleBool(false);
return position + 5;
}
/**
* Parses a "null" literal starting at [position].
*
* The character `source[position]` must be "n".
*/
int parseNull(int position) {
assert(getChar(position) == CHAR_n);
if (chunkEnd < position + 4) {
return parseKeywordPrefix(position, "null", KWD_NULL);
}
if (getChar(position + 1) != CHAR_u ||
getChar(position + 2) != CHAR_l ||
getChar(position + 3) != CHAR_l) {
return fail(position);
}
listener.handleNull();
return position + 4;
}
int parseKeywordPrefix(int position, String chars, int type) {
assert(getChar(position) == chars.codeUnitAt(0));
int length = chunkEnd;
int start = position;
int count = 1;
while (++position < length) {
int char = getChar(position);
if (char != chars.codeUnitAt(count)) return fail(start);
count++;
}
this.partialState = PARTIAL_KEYWORD | type | (count << KWD_COUNT_SHIFT);
return length;
}
/**
* Parses a string value.
*
* Initial [position] is right after the initial quote.
* Returned position right after the final quote.
*/
int parseString(int position) {
// Format: '"'([^\x00-\x1f\\\"]|'\\'[bfnrt/\\"])*'"'
// Initial position is right after first '"'.
int start = position;
int end = chunkEnd;
int bits = 0;
while (position < end) {
int char = getChar(position++);
bits |= char; // Includes final '"', but that never matters.
// BACKSLASH is larger than QUOTE and SPACE.
if (char > BACKSLASH) {
continue;
}
if (char == BACKSLASH) {
beginString();
int sliceEnd = position - 1;
if (start < sliceEnd) addSliceToString(start, sliceEnd);
return parseStringToBuffer(sliceEnd);
}
if (char == QUOTE) {
listener.handleString(getString(start, position - 1, bits));
return position;
}
if (char < SPACE) {
return fail(position - 1, "Control character in string");
}
}
beginString();
if (start < end) addSliceToString(start, end);
return chunkString(STR_PLAIN);
}
/**
* Sets up a partial string state.
*
* The state is either not inside an escape, or right after a backslash.
* For partial strings ending inside a Unicode escape, use
* [chunkStringEscapeU].
*/
int chunkString(int stringState) {
partialState = PARTIAL_STRING | stringState;
return chunkEnd;
}
/**
* Sets up a partial string state for a partially parsed Unicode escape.
*
* The partial string state includes the current [buffer] and the
* number of hex digits of the Unicode seen so far (e.g., for `"\u30')
* the state knows that two digits have been seen, and what their value is.
*
* Returns [chunkEnd] so it can be used as part of a return statement.
*/
int chunkStringEscapeU(int count, int value) {
partialState = PARTIAL_STRING | STR_U |
(count << STR_U_COUNT_SHIFT) |
(value << STR_U_VALUE_SHIFT);
return chunkEnd;
}
/**
* Parses the remainder of a string literal into a buffer.
*
* The buffer is stored in [buffer] and its underlying format depends on
* the input chunk type. For example UTF-8 decoding happens in the
* buffer, not in the parser, since all significant JSON characters are ASCII.
*
* This function scans through the string literal for escapes, and copies
* slices of non-escape characters using [addSliceToString].
*/
int parseStringToBuffer(position) {
int end = chunkEnd;
int start = position;
while (true) {
if (position == end) {
if (position > start) {
addSliceToString(start, position);
}
return chunkString(STR_PLAIN);
}
int char = getChar(position++);
if (char > BACKSLASH) continue;
if (char < SPACE) {
return fail(position - 1); // Control character in string.
}
if (char == QUOTE) {
int quotePosition = position - 1;
if (quotePosition > start) {
addSliceToString(start, quotePosition);
}
listener.handleString(endString());
return position;
}
if (char != BACKSLASH) {
continue;
}
// Handle escape.
if (position - 1 > start) {
addSliceToString(start, position - 1);
}
if (position == end) return chunkString(STR_ESCAPE);
position = parseStringEscape(position);
if (position == end) return position;
start = position;
}
return -1; // UNREACHABLE.
}
/**
* Parse a string escape.
*
* Position is right after the initial backslash.
* The following escape is parsed into a character code which is added to
* the current string buffer using [addCharToString].
*
* Returns position after the last character of the escape.
*/
int parseStringEscape(int position) {
int char = getChar(position++);
int length = chunkEnd;
switch (char) {
case CHAR_b: char = BACKSPACE; break;
case CHAR_f: char = FORM_FEED; break;
case CHAR_n: char = NEWLINE; break;
case CHAR_r: char = CARRIAGE_RETURN; break;
case CHAR_t: char = TAB; break;
case SLASH:
case BACKSLASH:
case QUOTE:
break;
case CHAR_u:
int hexStart = position - 1;
int value = 0;
for (int i = 0; i < 4; i++) {
if (position == length) return chunkStringEscapeU(i, value);
char = getChar(position++);
int digit = char ^ 0x30;
value *= 16;
if (digit <= 9) {
value += digit;
} else {
digit = (char | 0x20) - CHAR_a;
if (digit < 0 || digit > 5) {
return fail(hexStart, "Invalid unicode escape");
}
value += digit + 10;
}
}
char = value;
break;
default:
if (char < SPACE) return fail(position, "Control character in string");
return fail(position, "Unrecognized string escape");
}
addCharToString(char);
if (position == length) return chunkString(STR_PLAIN);
return position;
}
/// Sets up a partial numeral state.
/// Returns chunkEnd to allow easy one-line bailout tests.
int beginChunkNumber(int state, int start) {
int end = chunkEnd;
int length = end - start;
var buffer = new _NumberBuffer(length);
copyCharsToList(start, end, buffer.list, 0);
buffer.length = length;
this.buffer = buffer;
this.partialState = PARTIAL_NUMERAL | state;
return end;
}
void addNumberChunk(_NumberBuffer buffer, int start, int end, int overhead) {
int length = end - start;
int count = buffer.length;
int newCount = count + length;
int newCapacity = newCount + overhead;
buffer.ensureCapacity(newCapacity);
copyCharsToList(start, end, buffer.list, count);
buffer.length = newCount;
}
// Continues an already chunked number accross an entire chunk.
int continueChunkNumber(int state, int start, _NumberBuffer buffer) {
int end = chunkEnd;
addNumberChunk(buffer, start, end, _NumberBuffer.kDefaultOverhead);
this.buffer = buffer;
this.partialState = PARTIAL_NUMERAL | state;
return end;
}
int finishChunkNumber(int state, int start, int end, _NumberBuffer buffer) {
if (state == NUM_ZERO) {
listener.handleNumber(0);
return end;
}
if (end > start) {
addNumberChunk(buffer, start, end, 0);
}
if (state == NUM_DIGIT) {
listener.handleNumber(buffer.parseInt());
} else if (state == NUM_DOT_DIGIT || state == NUM_E_DIGIT) {
listener.handleNumber(buffer.parseDouble());
} else {
fail(chunkEnd, "Unterminated number literal");
}
return end;
}
int parseNumber(int char, int position) {
// Also called on any unexpected character.
// Format:
// '-'?('0'|[1-9][0-9]*)('.'[0-9]+)?([eE][+-]?[0-9]+)?
int start = position;
int length = chunkEnd;
// Collects an int value while parsing. Used for both an integer literal,
// an the exponent part of a double literal.
int intValue = 0;
double doubleValue = 0.0; // Collect double value while parsing.
int sign = 1;
bool isDouble = false;
// Break this block when the end of the number literal is reached.
// At that time, position points to the next character, and isDouble
// is set if the literal contains a decimal point or an exponential.
if (char == MINUS) {
sign = -1;
position++;
if (position == length) return beginChunkNumber(NUM_SIGN, start);
char = getChar(position);
}
int digit = char ^ CHAR_0;
if (digit > 9) {
if (sign < 0) {
fail(position, "Missing expected digit");
} else {
// If it doesn't even start out as a numeral.
fail(position, "Unexpected character");
}
}
if (digit == 0) {
position++;
if (position == length) return beginChunkNumber(NUM_ZERO, start);
char = getChar(position);
digit = char ^ CHAR_0;
// If starting with zero, next character must not be digit.
if (digit <= 9) fail(position);
} else {
do {
intValue = 10 * intValue + digit;
position++;
if (position == length) return beginChunkNumber(NUM_DIGIT, start);
char = getChar(position);
digit = char ^ CHAR_0;
} while (digit <= 9);
}
if (char == DECIMALPOINT) {
isDouble = true;
doubleValue = intValue.toDouble();
intValue = 0;
position++;
if (position == length) return beginChunkNumber(NUM_DOT, start);
char = getChar(position);
digit = char ^ CHAR_0;
if (digit > 9) fail(position);
do {
doubleValue = 10.0 * doubleValue + digit;
intValue -= 1;
position++;
if (position == length) return beginChunkNumber(NUM_DOT_DIGIT, start);
char = getChar(position);
digit = char ^ CHAR_0;
} while (digit <= 9);
}
if ((char | 0x20) == CHAR_e) {
if (!isDouble) {
doubleValue = intValue.toDouble();
intValue = 0;
isDouble = true;
}
position++;
if (position == length) return beginChunkNumber(NUM_E, start);
char = getChar(position);
int expSign = 1;
int exponent = 0;
if (char == PLUS || char == MINUS) {
expSign = 0x2C - char; // -1 for MINUS, +1 for PLUS
position++;
if (position == length) return beginChunkNumber(NUM_E_SIGN, start);
char = getChar(position);
}
digit = char ^ CHAR_0;
if (digit > 9) {
fail(position, "Missing expected digit");
}
do {
exponent = 10 * exponent + digit;
position++;
if (position == length) return beginChunkNumber(NUM_E_DIGIT, start);
char = getChar(position);
digit = char ^ CHAR_0;
} while (digit <= 9);
intValue += expSign * exponent;
}
if (!isDouble) {
listener.handleNumber(sign * intValue);
return position;
}
// Double values at or above this value (2 ** 53) may have lost precission.
// Only trust results that are below this value.
const double maxExactDouble = 9007199254740992.0;
if (doubleValue < maxExactDouble) {
int exponent = intValue;
double signedMantissa = doubleValue * sign;
if (exponent >= -22) {
if (exponent < 0) {
listener.handleNumber(signedMantissa / POWERS_OF_TEN[-exponent]);
return position;
}
if (exponent == 0) {
listener.handleNumber(signedMantissa);
return position;
}
if (exponent <= 22) {
listener.handleNumber(signedMantissa * POWERS_OF_TEN[exponent]);
return position;
}
}
}
// If the value is outside the range +/-maxExactDouble or
// exponent is outside the range +/-22, then we can't trust simple double
// arithmetic to get the exact result, so we use the system double parsing.
listener.handleNumber(parseDouble(start, position));
return position;
}
fail(int position, [String message]) {
if (message == null) {
message = "Unexpected character";
if (position == chunkEnd) message = "Unexpected end of input";
}
throw new FormatException(message, chunk, position);
}
}
/**
* Chunked JSON parser that parses [String] chunks.
*/
class _JsonStringParser extends _ChunkedJsonParser {
String chunk;
int chunkEnd;
_JsonStringParser(_JsonListener listener) : super(listener);
int getChar(int position) => chunk.codeUnitAt(position);
String getString(int start, int end, int bits) {
return chunk.substring(start, end);
}
void beginString() {
this.buffer = new StringBuffer();
}
void addSliceToString(int start, int end) {
StringBuffer buffer = this.buffer;
buffer.write(chunk.substring(start, end));
}
void addCharToString(int charCode) {
StringBuffer buffer = this.buffer;
buffer.writeCharCode(charCode);
}
String endString() {
StringBuffer buffer = this.buffer;
this.buffer = null;
return buffer.toString();
}
void copyCharsToList(int start, int end, List target, int offset) {
int length = end - start;
for (int i = 0; i < length; i++) {
target[offset + i] = chunk.codeUnitAt(start + i);
}
}
double parseDouble(int start, int end) {
return _parseDouble(chunk, start, end);
}
}
patch class JsonDecoder {
/* patch */ StringConversionSink startChunkedConversion(Sink<Object> sink) {
return new _JsonStringDecoderSink(this._reviver, sink);
}
}
/**
* Implements the chunked conversion from a JSON string to its corresponding
* object.
*
* The sink only creates one object, but its input can be chunked.
*/
class _JsonStringDecoderSink extends StringConversionSinkBase {
_ChunkedJsonParser _parser;
Function _reviver;
final Sink<Object> _sink;
_JsonStringDecoderSink(reviver, this._sink)
: _reviver = reviver, _parser = _createParser(reviver);
static _ChunkedJsonParser _createParser(reviver) {
_BuildJsonListener listener;
if (reviver == null) {
listener = new _BuildJsonListener();
} else {
listener = new _ReviverJsonListener(reviver);
}
return new _JsonStringParser(listener);
}
void addSlice(String chunk, int start, int end, bool isLast) {
_parser.chunk = chunk;
_parser.chunkEnd = end;
_parser.parse(start);
if (isLast) _parser.close();
}
void add(String chunk) {
addSlice(chunk, 0, chunk.length, false);
}
void close() {
_parser.close();
var decoded = _parser.result;
_sink.add(decoded);
_sink.close();
}
ByteConversionSink asUtf8Sink(bool allowMalformed) {
_parser = null;
return new _JsonUtf8DecoderSink(_reviver, _sink, allowMalformed);
}
}
class _Utf8StringBuffer {
static const int INITIAL_CAPACITY = 32;
// Partial state encoding.
static const int MASK_TWO_BIT = 0x03;
static const int MASK_SIZE = MASK_TWO_BIT;
static const int SHIFT_MISSING = 2;
static const int SHIFT_VALUE = 4;
static const int NO_PARTIAL = 0;
// UTF-8 encoding and limits.
static const int MAX_ASCII = 127;
static const int MAX_TWO_BYTE = 0x7ff;
static const int MAX_THREE_BYTE = 0xffff;
static const int MAX_UNICODE = 0X10ffff;
static const int MASK_TWO_BYTE = 0x1f;
static const int MASK_THREE_BYTE = 0x0f;
static const int MASK_FOUR_BYTE = 0x07;
static const int MASK_CONTINUE_TAG = 0xC0;
static const int MASK_CONTINUE_VALUE = 0x3f;
static const int CONTINUE_TAG = 0x80;
// UTF-16 surrogate encoding.
static const int LEAD_SURROGATE = 0xD800;
static const int TAIL_SURROGATE = 0xDC00;
static const int SHIFT_HIGH_SURROGATE = 10;
static const int MASK_LOW_SURROGATE = 0x3ff;
// The internal buffer starts as Uint8List, but may change to Uint16List
// if the string contains non-Latin-1 characters.
List<int> buffer = new Uint8List(INITIAL_CAPACITY);
// Number of elements in buffer.
int length = 0;
// Partial decoding state, for cases where an UTF-8 sequences is split
// between chunks.
int partialState = NO_PARTIAL;
// Whether all characters so far have been Latin-1 (and the buffer is
// still a Uint8List). Set to false when the first non-Latin-1 character
// is encountered, and the buffer is then also converted to a Uint16List.
bool isLatin1 = true;
// If allowing malformed, invalid UTF-8 sequences are converted to
// U+FFFD.
bool allowMalformed;
_Utf8StringBuffer(this.allowMalformed);
/**
* Parse the continuation of a multi-byte UTF-8 sequence.
*
* Parse [utf8] from [position] to [end]. If the sequence extends beyond
* `end`, store the partial state in [partialState], and continue from there
* on the next added slice.
*
* The [size] is the number of expected continuation bytes total,
* and [missing] is the number of remaining continuation bytes.
* The [size] is used to detect overlong encodings.
* The [value] is the value collected so far.
*
* When called after seeing the first multi-byte marker, the [size] and
* [missing] values are always the same, but they may differ if continuing
* after a partial sequence.
*/
int addContinuation(List<int> utf8, int position, int end,
int size, int missing, int value) {
int codeEnd = position + missing;
do {
if (position == end) {
missing = codeEnd - position;
partialState =
size | (missing << SHIFT_MISSING) | (value << SHIFT_VALUE);
return end;
}
int char = utf8[position];
if ((char & MASK_CONTINUE_TAG) != CONTINUE_TAG) {
if (allowMalformed) {
addCharCode(0xFFFD);
return position;
}
throw new FormatException("Expected UTF-8 continuation byte, "
"found $char", utf8, position);
}
value = 64 * value + (char & MASK_CONTINUE_VALUE);
position++;
} while (position < codeEnd);
if (value <= const [0, MAX_ASCII, MAX_TWO_BYTE, MAX_THREE_BYTE][size]) {
// Over-long encoding.
if (allowMalformed) {
value = 0xFFFD;
} else {
throw new FormatException(
"Invalid encoding: U+${value.toRadixString(16).padLeft(4, '0')}"
" encoded in ${size + 1} bytes.", utf8, position - 1);
}
}
addCharCode(value);
return position;
}
void addCharCode(int char) {
assert(char >= 0);
assert(char <= MAX_UNICODE);
if (partialState != NO_PARTIAL) {
if (allowMalformed) {
partialState = NO_PARTIAL;
addCharCode(0xFFFD);
} else {
throw new FormatException("Incomplete UTF-8 sequence", utf8);
}
}
if (isLatin1 && char > 0xff) {
_to16Bit(); // Also grows a little if close to full.
}
int length = this.length;
if (char <= MAX_THREE_BYTE) {
if (length == buffer.length) _grow();
buffer[length] = char;
this.length = length + 1;
return;
}
if (length + 2 > buffer.length) _grow();
int bits = char - 0x10000;
buffer[length] = LEAD_SURROGATE | (bits >> SHIFT_HIGH_SURROGATE);
buffer[length + 1] = TAIL_SURROGATE | (bits & MASK_LOW_SURROGATE);
this.length = length + 2;
}
void _to16Bit() {
assert(isLatin1);
Uint16List newBuffer;
if ((length + INITIAL_CAPACITY) * 2 <= buffer.length) {
// Reuse existing buffer if it's big enough.
newBuffer = new Uint16List.view(buffer.buffer);
} else {
int newCapacity = buffer.length;
if (newCapacity - length < INITIAL_CAPACITY) {
newCapacity = length + INITIAL_CAPACITY;
}
newBuffer = new Uint16List(newCapacity);
}
newBuffer.setRange(0, length, buffer);
buffer = newBuffer;
isLatin1 = false;
}
void _grow() {
int newCapacity = buffer.length * 2;
List newBuffer;
if (isLatin1) {
newBuffer = new Uint8List(newCapacity);
} else {
newBuffer = new Uint16List(newCapacity);
}
newBuffer.setRange(0, length, buffer);
buffer = newBuffer;
}
void addSlice(List<int> utf8, int position, int end) {
assert(position < end);
if (partialState > 0) {
int continueByteCount = (partialState & MASK_TWO_BIT);
int missing = (partialState >> SHIFT_MISSING) & MASK_TWO_BIT;
int value = partialState >> SHIFT_VALUE;
partialState = NO_PARTIAL;
position = addContinuation(utf8, position, end,
continueByteCount, missing, value);
if (position == end) return;
}
// Keep index and capacity in local variables while looping over
// ASCII characters.
int index = length;
int capacity = buffer.length;
while (position < end) {
int char = utf8[position];
if (char <= MAX_ASCII) {
if (index == capacity) {
length = index;
_grow();
capacity = buffer.length;
}
buffer[index++] = char;
position++;
continue;
}
length = index;
if ((char & MASK_CONTINUE_TAG) == CONTINUE_TAG) {
if (allowMalformed) {
addCharCode(0xFFFD);
position++;
} else {
throw new FormatException("Unexepected UTF-8 continuation byte",
utf8, position);
}
} else if (char < 0xE0) { // C0-DF
// Two-byte.
position = addContinuation(utf8, position + 1, end, 1, 1,
char & MASK_TWO_BYTE);
} else if (char < 0xF0) { // E0-EF
// Three-byte.
position = addContinuation(utf8, position + 1, end, 2, 2,
char & MASK_THREE_BYTE);
} else if (char < 0xF8) { // F0-F7
// Four-byte.
position = addContinuation(utf8, position + 1, end, 3, 3,
char & MASK_FOUR_BYTE);
} else {
if (allowMalformed) {
addCharCode(0xFFFD);
position++;
} else {
throw new FormatException("Invalid UTF-8 byte: $char",
utf8, position);
}
}
index = length;
capacity = buffer.length;
}
length = index;
}
String toString() {
if (partialState != NO_PARTIAL) {
if (allowMalformed) {
partialState = NO_PARTIAL;
addCharCode(0xFFFD);
} else {
int continueByteCount = (partialState & MASK_TWO_BIT);
int missing = (partialState >> SHIFT_MISSING) & MASK_TWO_BIT;
int value = partialState >> SHIFT_VALUE;
int seenByteCount = continueByteCount - missing + 1;
List source = new Uint8List(seenByteCount);
while (seenByteCount > 1) {
seenByteCount--;
source[seenByteCount] = CONTINUE_TAG | (value & MASK_CONTINUE_VALUE);
value >>= 6;
}
source[0] = value | (0x3c0 >> (continueByteCount - 1));
throw new FormatException("Incomplete UTF-8 sequence",
source, source.length);
}
}
return new String.fromCharCodes(buffer, 0, length);
}
}
/**
* Chunked JSON parser that parses UTF-8 chunks.
*/
class _JsonUtf8Parser extends _ChunkedJsonParser {
final bool allowMalformed;
List<int> chunk;
int chunkEnd;
_JsonUtf8Parser(_JsonListener listener, this.allowMalformed)
: super(listener);
int getChar(int position) => chunk[position];
String getString(int start, int end, int bits) {
const int maxAsciiChar = 0x7f;
if (bits <= maxAsciiChar) {
return new String.fromCharCodes(chunk, start, end);
}
beginString();
if (start < end) addSliceToString(start, end);
String result = endString();
return result;
}
void beginString() {
this.buffer = new _Utf8StringBuffer(allowMalformed);
}
void addSliceToString(int start, int end) {
_Utf8StringBuffer buffer = this.buffer;
buffer.addSlice(chunk, start, end);
}
void addCharToString(int charCode) {
_Utf8StringBuffer buffer = this.buffer;
buffer.addCharCode(charCode);
}
String endString() {
_Utf8StringBuffer buffer = this.buffer;
this.buffer = null;
return buffer.toString();
}
void copyCharsToList(int start, int end, List target, int offset) {
int length = end - start;
target.setRange(offset, offset + length, chunk, start);
}
double parseDouble(int start, int end) {
String string = getString(start, end, 0x7f);
return _parseDouble(string, 0, string.length);
}
}
double _parseDouble(String source, int start, int end)
native "Double_parse";
/**
* Implements the chunked conversion from a UTF-8 encoding of JSON
* to its corresponding object.
*/
class _JsonUtf8DecoderSink extends ByteConversionSinkBase {
_JsonUtf8Parser _parser;
final Sink<Object> _sink;
_JsonUtf8DecoderSink(reviver, this._sink, bool allowMalformed)
: _parser = _createParser(reviver, allowMalformed);
static _ChunkedJsonParser _createParser(reviver, bool allowMalformed) {
_BuildJsonListener listener;
if (reviver == null) {
listener = new _BuildJsonListener();
} else {
listener = new _ReviverJsonListener(reviver);
}
return new _JsonUtf8Parser(listener, allowMalformed);
}
void addSlice(List<int> chunk, int start, int end, bool isLast) {
_addChunk(chunk, start, end);
if (isLast) close();
}
void add(List<int> chunk) {
_addChunk(chunk, 0, chunk.length);
}
void _addChunk(List<int> chunk, int start, int end) {
_parser.chunk = chunk;
_parser.chunkEnd = end;
_parser.parse(start);
}
void close() {
_parser.close();
var decoded = _parser.result;
_sink.add(decoded);
_sink.close();
}
}