Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(308)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: lib/json/json.dart

Issue 10230004: Optimize the JSON parser by tokenizing while parsing and using jump-table. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Created 8 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « no previous file | tests/utils/src/JsonTest.dart » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file 1 // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file
2 // for details. All rights reserved. Use of this source code is governed by a 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. 3 // BSD-style license that can be found in the LICENSE file.
4 4
5 #library("json"); 5 #library("json");
6 6
7 // Pure Dart implementation of JSON protocol. 7 // Pure Dart implementation of JSON protocol.
8 8
9 /** 9 /**
10 * Utility class to parse JSON and serialize objects to JSON. 10 * Utility class to parse JSON and serialize objects to JSON.
11 */ 11 */
12 class JSON { 12 class JSON {
13 /** 13 /**
14 * Parses [:json:] and build the corresponding object. 14 * Parses [:json:] and build the corresponding object.
15 */ 15 */
16 static parse(String json) { 16 static parse(String json) {
17 return JsonParser.parse(json); 17 return JsonParser.parse(json);
18 } 18 }
19 19
20 /** 20 /**
21 * Serializes [:object:] into JSON string. 21 * Serializes [:object:] into JSON string.
22 */ 22 */
23 static String stringify(Object object) { 23 static String stringify(Object object) {
24 return JsonStringifier.stringify(object); 24 return JsonStringifier.stringify(object);
25 } 25 }
26 } 26 }
27 27
28 //// Implementation /////////////////////////////////////////////////////////// 28 //// Implementation ///////////////////////////////////////////////////////////
29 29
30 /** 30 class JSONParseException {
31 * Union-like class for JSON tokens. 31 JSONParseException(int this.position, String message) {
Anton Muhin 2012/04/26 16:13:20 I think you can omit int before this.position.
Anders Johnsen 2012/04/27 05:22:22 I'm unsure to why we would omit int here. Could yo
Anton Muhin 2012/04/27 16:45:40 Why duplicate type info? Field position is known
32 */ 32 this.message = "JSONParseException: $message, at offset $position";
Anton Muhin 2012/04/26 16:13:20 nit: please, use single quote lines (here and belo
Anders Johnsen 2012/04/27 05:22:22 Sure, changed, but why favor single over double?
Anton Muhin 2012/04/27 16:45:40 Sorry, I don't know---for some reason I use single
Lasse Reichstein Nielsen 2012/04/30 08:12:02 It seems it's the most prevalent quoting in Dart,
Anton Muhin 2012/05/02 10:07:14 Lasse, this file used single quotes, not double qu
33 class JsonToken { 33 }
34 static final int STRING = 0; 34
35 static final int NUMBER = 1; 35 String toString() => message;
36 static final int NULL = 2; 36
37 static final int FALSE = 3; 37 String message;
Anton Muhin 2012/04/26 16:13:20 message should be final as well, and probably you
Anders Johnsen 2012/04/27 05:22:22 Done.
Lasse Reichstein Nielsen 2012/04/30 08:12:02 I'd also move the fields above the constructor.
38 static final int TRUE = 4; 38 final int position;
39 static final int RBRACKET = 5;
40 static final int LBRACKET = 6;
41 static final int RBRACE = 7;
42 static final int LBRACE = 8;
43 static final int COLON = 9;
44 static final int COMMA = 10;
45
46 final int kind;
47 final String _s;
48 final num _n;
49
50 String get str() {
51 assert(kind == STRING);
52 return _s;
53 }
54
55 num get number() {
56 assert(kind == NUMBER);
57 return _n;
58 }
59
60 const JsonToken._internal(this.kind, this._s, this._n);
61
62 factory JsonToken.string(String s) {
63 return new JsonToken._internal(STRING, s, 0);
64 }
65 factory JsonToken.number(num n) {
66 return new JsonToken._internal(NUMBER, '', n);
67 }
68 factory JsonToken.atom(int kind) {
69 return new JsonToken._internal(kind, '', 0);
70 }
71
72 String toString() {
73 switch (kind) {
74 case STRING:
75 return 'STRING(${str})';
76
77 case NUMBER:
78 return 'NUMBER(${number})';
79
80 case NULL:
81 return 'ATOM(null)';
82
83 case FALSE:
84 return 'ATOM(false)';
85
86 case TRUE:
87 return 'ATOM(true)';
88
89 case RBRACKET:
90 return 'ATOM(])';
91
92 case LBRACKET:
93 return 'ATOM([)';
94
95 case RBRACE:
96 return 'ATOM(})';
97
98 case LBRACE:
99 return 'ATOM({)';
100
101 case COLON:
102 return 'ATOM(:)';
103
104 case COMMA:
105 return 'ATOM(,)';
106 }
107 }
108 } 39 }
109 40
110 typedef bool Predicate(int c);
111
112 class JsonTokenizer {
113 static final int BACKSPACE = 8; // '\b'.charCodeAt(0)
114 static final int TAB = 9; // '\t'.charCodeAt(0)
115 static final int NEW_LINE = 10; // '\n'.charCodeAt(0)
116 static final int FORM_FEED = 12; // '\f'.charCodeAt(0)
117 static final int CARRIAGE_RETURN = 13; // '\r'.charCodeAt(0)
118 static final int SPACE = 32; // ' '.charCodeAt(0)
119 static final int QUOTE = 34; // '"'.charCodeAt(0)
120 static final int PLUS = 43; // '+'.charCodeAt(0)
121 static final int COMMA = 44; // ','.charCodeAt(0)
122 static final int MINUS = 45; // '-'.charCodeAt(0)
123 static final int DOT = 46; // '.'.charCodeAt(0)
124 static final int SLASH = 47; // '/'.charCodeAt(0)
125 static final int ZERO = 48; // '0'.charCodeAt(0)
126 static final int NINE = 57; // '9'.charCodeAt(0)
127 static final int COLON = 58; // ':'.charCodeAt(0)
128 static final int A_BIG = 65; // 'A'.charCodeAt(0)
129 static final int E_BIG = 69; // 'E'.charCodeAt(0)
130 static final int Z_BIG = 90; // 'Z'.charCodeAt(0)
131 static final int LBRACKET = 91; // '['.charCodeAt(0)
132 static final int BACKSLASH = 92; // '\\'.charCodeAt(0)
133 static final int RBRACKET = 93; // ']'.charCodeAt(0)
134 static final int A_SMALL = 97; // 'a'.charCodeAt(0)
135 static final int B_SMALL = 98; // 'b'.charCodeAt(0)
136 static final int E_SMALL = 101; // 'e'.charCodeAt(0)
137 static final int F_SMALL = 102; // 'f'.charCodeAt(0)
138 static final int N_SMALL = 110; // 'n'.charCodeAt(0)
139 static final int R_SMALL = 114; // 'r'.charCodeAt(0)
140 static final int T_SMALL = 116; // 't'.charCodeAt(0)
141 static final int U_SMALL = 117; // 'u'.charCodeAt(0)
142 static final int Z_SMALL = 122; // 'z'.charCodeAt(0)
143 static final int LBRACE = 123; // '{'.charCodeAt(0)
144 static final int RBRACE = 125; // '}'.charCodeAt(0)
145
146 JsonTokenizer(String s) : _s = '${s} ', _pos = 0, _len = s.length + 1;
147
148 /**
149 * Fetches next token or [:null:] if the stream has been exhausted.
150 */
151 JsonToken next() {
152 while (_pos < _len && isWhitespace(_s.charCodeAt(_pos))) {
153 _pos++;
154 }
155 if (_pos == _len) {
156 return null;
157 }
158
159 final int cur = _s.charCodeAt(_pos);
160 switch (true) {
161 case cur == QUOTE:
162 _pos++;
163 List<int> charCodes = new List<int>();
164 while (_pos < _len) {
165 int c = _s.charCodeAt(_pos);
166 if (c == QUOTE) {
167 break;
168 }
169 if (c == BACKSLASH) {
170 _pos++;
171 if (_pos == _len) {
172 throw '\\ at the end';
173 }
174
175 switch (_s[_pos]) {
176 case '"':
177 c = QUOTE;
178 break;
179 case '\\':
180 c = BACKSLASH;
181 break;
182 case '/':
183 c = SLASH;
184 break;
185 case 'b':
186 c = BACKSPACE;
187 break;
188 case 'n':
189 c = NEW_LINE;
190 break;
191 case 'r':
192 c = CARRIAGE_RETURN;
193 break;
194 case 'f':
195 c = FORM_FEED;
196 break;
197 case 't':
198 c = TAB;
199 break;
200 case 'u':
201 if (_pos + 5 > _len) {
202 throw 'Invalid unicode esacape sequence:'
203 '\\${_s.substring(_pos, _len)}';
204 }
205 final codeString = _s.substring(_pos + 1, _pos + 5);
206 c = Math.parseInt('0x${codeString}');
207 if (c >= 128) {
208 // TODO(jmessery): the VM doesn't support 2-byte strings yet
209 // see runtime/lib/string.cc:49
210 // So instead we replace these characters with '?'
211 c = '?'.charCodeAt(0);
212 }
213 _pos += 4;
214 break;
215 default:
216 throw 'Invalid esacape sequence: \\${_s[_pos]}';
217 }
218 }
219 charCodes.add(c);
220 _pos++;
221 }
222 if (_pos == _len) {
223 throw 'Unmatched quote';
224 }
225
226 final String body = new String.fromCharCodes(charCodes);
227 _pos++;
228 return new JsonToken.string(body);
229
230 case cur == MINUS || isDigit(cur):
231 skipDigits() {
232 _scanWhile((int c) => isDigit(c), 'Invalid number');
233 }
234
235 int c = cur;
236 final int startPos = _pos;
237 int value = 0;
238 bool isNegative = false;
239 if (c == MINUS) {
240 isNegative = true;
241 _pos++;
242 c = _s.charCodeAt(_pos);
243 }
244 while (isDigit(c)) {
245 value = value * 10 + c - ZERO;
246 _pos++;
247 c = _s.charCodeAt(_pos);
248 }
249
250 if (c != DOT) {
251 if (c != E_SMALL && cur != E_BIG) {
252 if (isNegative) value = -value;
253 return new JsonToken.number(value);
254 }
255 } else {
256 _pos++;
257 skipDigits();
258 c = _s.charCodeAt(_pos);
259 }
260
261 if (c == E_SMALL || c == E_BIG) {
262 // TODO: consider keeping E+ as an integer.
263 _pos++;
264 c = _s.charCodeAt(_pos);
265 if (c == PLUS || c == MINUS) {
266 _pos++;
267 }
268 skipDigits();
269 }
270
271 final String body = _s.substring(startPos, _pos);
272 return new JsonToken.number(Math.parseDouble(body));
273
274 case cur == LBRACE:
275 _pos++;
276 return new JsonToken.atom(JsonToken.LBRACE);
277
278 case cur == RBRACE:
279 _pos++;
280 return new JsonToken.atom(JsonToken.RBRACE);
281
282 case cur == LBRACKET:
283 _pos++;
284 return new JsonToken.atom(JsonToken.LBRACKET);
285
286 case cur == RBRACKET:
287 _pos++;
288 return new JsonToken.atom(JsonToken.RBRACKET);
289
290 case cur == COMMA:
291 _pos++;
292 return new JsonToken.atom(JsonToken.COMMA);
293
294 case cur == COLON:
295 _pos++;
296 return new JsonToken.atom(JsonToken.COLON);
297
298 case isLetter(cur):
299 final int startPos = _pos;
300 _pos++;
301 while (_pos < _len && isLetter(_s.charCodeAt(_pos))) {
302 _pos++;
303 }
304 final String body = _s.substring(startPos, _pos);
305 switch (body) {
306 case 'null':
307 return new JsonToken.atom(JsonToken.NULL);
308
309 case 'false':
310 return new JsonToken.atom(JsonToken.FALSE);
311
312 case 'true':
313 return new JsonToken.atom(JsonToken.TRUE);
314
315 default:
316 throw 'Unexpected sequence ${body}';
317 }
318 // TODO: Bogous, to please DartVM.
319 return null;
320
321 default:
322 throw 'Invalid token';
323 }
324 }
325
326 final String _s;
327 int _pos;
328 final int _len;
329
330 void _scanWhile(Predicate predicate, String errorMsg) {
331 while (_pos < _len && predicate(_s.charCodeAt(_pos))) {
332 _pos++;
333 }
334 if (_pos == _len) {
335 throw errorMsg;
336 }
337 }
338
339 // TODO other kind of whitespace.
340 static bool isWhitespace(int c) {
341 return c == SPACE || c == TAB || c == NEW_LINE || c == CARRIAGE_RETURN;
342 }
343 static bool isDigit(int c) {
344 return (ZERO <= c) && (c <= NINE);
345 }
346 static bool isLetter(int c) {
347 return ((A_SMALL <= c) && (c <= Z_SMALL)) || ((A_BIG <= c) && (c <= Z_BIG)) ;
348 }
349 }
350
351 class JsonParser { 41 class JsonParser {
42 static final int BACKSPACE = 8;
43 static final int TAB = 9;
44 static final int NEW_LINE = 10;
45 static final int FORM_FEED = 12;
46 static final int CARRIAGE_RETURN = 13;
47 static final int SPACE = 32;
48 static final int QUOTE = 34;
49 static final int PLUS = 43;
50 static final int COMMA = 44;
51 static final int MINUS = 45;
52 static final int DOT = 46;
53 static final int SLASH = 47;
54 static final int CHAR_0 = 48;
55 static final int CHAR_1 = 49;
56 static final int CHAR_2 = 50;
57 static final int CHAR_3 = 51;
58 static final int CHAR_4 = 52;
59 static final int CHAR_5 = 53;
60 static final int CHAR_6 = 54;
61 static final int CHAR_7 = 55;
62 static final int CHAR_8 = 56;
63 static final int CHAR_9 = 57;
64 static final int COLON = 58;
65 static final int CHAR_CAPITAL_E = 69;
66 static final int LBRACKET = 91;
67 static final int BACKSLASH = 92;
68 static final int RBRACKET = 93;
69 static final int CHAR_B = 98;
70 static final int CHAR_E = 101;
71 static final int CHAR_F = 102;
72 static final int CHAR_N = 110;
73 static final int CHAR_R = 114;
74 static final int CHAR_T = 116;
75 static final int CHAR_U = 117;
76 static final int LBRACE = 123;
77 static final int RBRACE = 125;
78
79 static final int STRING_LITERAL = QUOTE;
80 static final int NUMBER_LITERAL = MINUS;
81 static final int NULL_LITERAL = CHAR_N;
82 static final int FALSE_LITERAL = CHAR_F;
83 static final int TRUE_LITERAL = CHAR_T;
84
85 static final int WHITESPACE = SPACE;
86
87
352 static parse(String json) { 88 static parse(String json) {
353 return new JsonParser._internal(json)._parseToplevel(); 89 return new JsonParser._internal(json)._parseToplevel();
354 } 90 }
355 91
356 final JsonTokenizer _tokenizer; 92 JsonParser._internal(String this.json) {
357 93 // Use a list as jump-table, faster then switch and if.
358 JsonParser._internal(String json) : _tokenizer = new JsonTokenizer(json) {} 94 tokens = new List<int>(RBRACE + 1);
95 tokens[TAB] = WHITESPACE;
96 tokens[NEW_LINE] = WHITESPACE;
97 tokens[CARRIAGE_RETURN] = WHITESPACE;
98 tokens[SPACE] = WHITESPACE;
99 tokens[CHAR_0] = NUMBER_LITERAL;
100 tokens[CHAR_1] = NUMBER_LITERAL;
101 tokens[CHAR_2] = NUMBER_LITERAL;
102 tokens[CHAR_3] = NUMBER_LITERAL;
103 tokens[CHAR_4] = NUMBER_LITERAL;
104 tokens[CHAR_5] = NUMBER_LITERAL;
105 tokens[CHAR_6] = NUMBER_LITERAL;
106 tokens[CHAR_7] = NUMBER_LITERAL;
107 tokens[CHAR_8] = NUMBER_LITERAL;
108 tokens[CHAR_9] = NUMBER_LITERAL;
109 tokens[MINUS] = NUMBER_LITERAL;
110 tokens[LBRACE] = LBRACE;
111 tokens[RBRACE] = RBRACE;
112 tokens[LBRACKET] = LBRACKET;
113 tokens[RBRACKET] = RBRACKET;
114 tokens[QUOTE] = STRING_LITERAL;
115 tokens[COLON] = COLON;
116 tokens[COMMA] = COMMA;
117 tokens[CHAR_N] = NULL_LITERAL;
118 tokens[CHAR_T] = TRUE_LITERAL;
119 tokens[CHAR_F] = FALSE_LITERAL;
120 }
359 121
360 _parseToplevel() { 122 _parseToplevel() {
361 JsonToken token = _tokenizer.next(); 123 final result = _parseValue();
362 final result = _parseValue(token); 124 if (_token() !== null) {
363 token = _tokenizer.next(); 125 _error('Junk at the end of JSON input');
364 if (token !== null) {
365 throw 'Junk at the end';
366 } 126 }
367 return result; 127 return result;
368 } 128 }
369 129
370 _parseValue(final JsonToken token) { 130 _parseValue() {
371 if (token === null) { 131 int tokenKind = _token();
Anton Muhin 2012/04/26 16:13:20 please, final tokenKind
Anders Johnsen 2012/04/27 05:22:22 Done.
Lasse Reichstein Nielsen 2012/04/30 08:12:02 final int tokenKind; Don't drop the type. (I don't
Anton Muhin 2012/05/02 10:07:14 Again, that's the style in this file. And I used
372 throw 'Nothing to parse'; 132 if (tokenKind === null) {
373 } 133 _error('Nothing to parse');
374 switch (token.kind) { 134 }
375 case JsonToken.STRING: 135 switch (tokenKind) {
376 return token.str; 136 case STRING_LITERAL: return _parseString();
377 137 case NUMBER_LITERAL: return _parseNumber();
378 case JsonToken.NUMBER: 138 case NULL_LITERAL: return _parseWord("null", null);
379 return token.number; 139 case FALSE_LITERAL: return _parseWord("false", false);
380 140 case TRUE_LITERAL: return _parseWord("true", true);
381 case JsonToken.NULL: 141 case LBRACE: return _parseObject();
382 return null; 142 case LBRACKET: return _parseList();
383
384 case JsonToken.FALSE:
385 return false;
386
387 case JsonToken.TRUE:
388 return true;
389
390 case JsonToken.LBRACE:
391 return _parseObject();
392
393 case JsonToken.LBRACKET:
394 return _parseList();
395 143
396 default: 144 default:
397 throw 'Unexpected token: ${token}'; 145 _error('Unexpected token');
398 } 146 }
147 }
148
149 Object _parseWord(String word, Object value) {
Anton Muhin 2012/04/26 16:13:20 shouldn't it be _expectWord rather than parse?
Anders Johnsen 2012/04/27 05:22:22 Yeah, also, renamed to expectKeyword.
150 if (json.length - position < word.length ||
151 json.substring(position, position + word.length) != word) {
152 _error("Expected keyword '$word'");
153 }
154 position += word.length;
155 return value;
399 } 156 }
400 157
401 _parseObject() { 158 _parseObject() {
402 final object = {}; 159 final object = {};
403 160
404 _parseSequence(JsonToken.RBRACE, (JsonToken token) { 161 position++; // Eat '{'.
405 _assertTokenKind(token, JsonToken.STRING); 162
406 final String key = token.str; 163 // Return early if empty object.
407 164 if (_isa(RBRACE)) {
408 token = _tokenizer.next(); 165 position++;
409 _assertTokenKind(token, JsonToken.COLON); 166 return object;
410 167 }
411 token = _tokenizer.next(); 168
412 final value = _parseValue(token); 169 void parseObjectEntry() {
Anton Muhin 2012/04/26 16:13:20 as you're fighting for performance, is local funct
Anders Johnsen 2012/04/27 05:22:22 Well spotted, rewritten!
413 170 String key = _parseString();
Anton Muhin 2012/04/26 16:13:20 final key = ..., please
Anders Johnsen 2012/04/27 05:22:22 Done.
414 object[key] = value; 171 if (!_isa(COLON)) _error("Expected ':' when parsing object");
Anton Muhin 2012/04/26 16:13:20 will it work properly for "foo"[space]:?
Anders Johnsen 2012/04/27 05:22:22 Yes, every token-based method uses _token, that wi
415 }); 172 position++;
173 object[key] = _parseValue();
174 }
175
176 parseObjectEntry();
177 while (_isa(COMMA)) {
178 position++; // Skip ','.
179 parseObjectEntry();
180 };
181
182 if (!_isa(RBRACE)) _error("Expected '}' at end of object");
183 position++;
184
416 185
417 return object; 186 return object;
418 } 187 }
419 188
420 _parseList() { 189 _parseList() {
421 final list = []; 190 final list = [];
422 191
423 _parseSequence(JsonToken.RBRACKET, (JsonToken token) { 192 position++; // Eat '['.
424 final value = _parseValue(token); 193
425 list.add(value); 194 // Return early if empty list.
426 }); 195 if (!_isa(RBRACKET)) {
196 list.add(_parseValue());
197
198 while (_isa(COMMA)) {
Anton Muhin 2012/04/26 16:13:20 ditto
Anders Johnsen 2012/04/27 05:22:22 Same. Added test case.
199 position++;
200 list.add(_parseValue());
201 };
202
203 if (!_isa(RBRACKET)) _error("Expected ']' at end of list");
204 }
205 position++;
427 206
428 return list; 207 return list;
429 } 208 }
430 209
431 void _parseSequence(int endTokenKind, void parseElement(JsonToken token)) { 210 String _parseString() {
432 JsonToken token = _tokenizer.next(); 211 if (!_isa(STRING_LITERAL)) _error("Expected string literal");
433 if (token === null) { 212
434 throw 'Unexpected end of stream'; 213 position++; // Eat '"'.
435 } 214
436 if (token.kind == endTokenKind) { 215 List<int> charCodes = new List<int>();
437 return; 216 while (true) {
438 } 217 int c = _char();
439 218 if (c == QUOTE) {
440 parseElement(token); 219 position++;
441 220 break;
442 token = _tokenizer.next(); 221 }
443 if (token === null) { 222 if (c == BACKSLASH) {
444 throw 'Expected either comma or terminator'; 223 position++;
445 } 224 if (position == json.length) {
446 while (token.kind != endTokenKind) { 225 _error('\\ at the end of input');
447 _assertTokenKind(token, JsonToken.COMMA); 226 }
448 227
449 token = _tokenizer.next(); 228 switch (_char()) {
450 parseElement(token); 229 case QUOTE:
451 230 c = QUOTE;
452 token = _tokenizer.next(); 231 break;
453 } 232 case BACKSLASH:
454 } 233 c = BACKSLASH;
455 234 break;
456 void _assertTokenKind(JsonToken token, int kind) { 235 case SLASH:
457 if (token === null || token.kind != kind) { 236 c = SLASH;
458 throw 'Unexpected token kind: token = ${token}, expected kind = ${kind}'; 237 break;
459 } 238 case CHAR_B:
460 } 239 c = BACKSPACE;
461 240 break;
462 // TODO: consider factor out error throwing code and build more complicated 241 case CHAR_N:
463 // data structure to provide more info for a caller. 242 c = NEW_LINE;
243 break;
244 case CHAR_R:
245 c = CARRIAGE_RETURN;
246 break;
247 case CHAR_F:
248 c = FORM_FEED;
249 break;
250 case CHAR_T:
251 c = TAB;
252 break;
253 case CHAR_U:
254 if (position + 5 > json.length) {
255 _error('Invalid unicode esacape sequence');
256 }
257 final codeString = json.substring(position + 1, position + 5);
258 try {
259 c = Math.parseInt('0x${codeString}');
260 } catch (var e) {
261 _error('Invalid unicode esacape sequence');
262 }
263 position += 4;
264 break;
265 default:
266 _error('Invalid esacape sequence in string literal');
267 }
268 }
269 charCodes.add(c);
270 position++;
271 }
272
273 return new String.fromCharCodes(charCodes);
274 }
275
276 num _parseNumber() {
277 if (!_isa(NUMBER_LITERAL)) _error("Expected number literal");
278
279 final int startPos = position;
280 if (_isChar(MINUS)) position++;
281 if (_isChar(CHAR_0)) {
282 position++;
283 } else if (_isDigit()) {
284 position++;
285 while (_isDigit()) position++;
286 }
287
288 bool isInt = true;
289 if (_isChar(DOT)) {
290 position++;
291 if (_isDigit()) {
292 isInt = false;
293 while (_isDigit()) position++;
294 } else {
295 position--; // No digit, recover.
296 }
297 }
298
299 if (_isChar(CHAR_E) || _isChar(CHAR_CAPITAL_E)) {
300 int recoverTo = position;
301 position++;
302 if (_isChar(MINUS) || _isChar(PLUS)) position++;
303 if (_isDigit()) {
304 position++;
305 isInt = false;
306 while (_isDigit()) position++;
307 } else {
308 position = recoverTo; // No digit, recover.
309 }
310 }
311
312 String number = json.substring(startPos, position);
313 if (isInt) {
314 return Math.parseInt(number);
315 } else {
316 return Math.parseDouble(number);
317 }
318 }
319
320 bool _isChar(int char) {
Anton Muhin 2012/04/26 16:13:20 => syntax?
Anders Johnsen 2012/04/27 05:22:22 Done.
321 return _char() == char;
322 }
323
324 bool _isDigit() {
325 int char = _char();
326 return char >= CHAR_0 && char <= CHAR_9;
327 }
328
329 bool _isa(int tokenKind) {
330 return _token() == tokenKind;
331 }
332
333 int _char() {
334 if (position >= json.length) {
335 _error("Unexpected end of JSON stream");
336 }
337 return json.charCodeAt(position);
338 }
339
340 int _token() {
341 while (true) {
342 if (position >= json.length) return null;
343 int char = json.charCodeAt(position);
344 int token = tokens[char];
345 if (token === WHITESPACE) {
346 position++;
347 continue;
348 }
349 if (token === null) _error("Invalid JSON token");
350 return token;
351 }
352 }
353
354 void _error(String message) {
355 throw new JSONParseException(position, message);
356 }
357
358 final String json;
359 int position = 0;
360 List<int> tokens;
464 } 361 }
465 362
466 // TODO: proper base class. 363 // TODO: proper base class.
467 class JsonUnsupportedObjectType { 364 class JsonUnsupportedObjectType {
468 const JsonUnsupportedObjectType(); 365 const JsonUnsupportedObjectType();
469 } 366 }
470 367
471 class JsonStringifier { 368 class JsonStringifier {
472 static String stringify(final object) { 369 static String stringify(final object) {
473 JsonStringifier stringifier = new JsonStringifier._internal(); 370 JsonStringifier stringifier = new JsonStringifier._internal();
(...skipping 26 matching lines...) Expand all
500 static int _hexDigit(int x) => x < 10 ? 48 + x : 87 + x; 397 static int _hexDigit(int x) => x < 10 ? 48 + x : 87 + x;
501 398
502 static void _escape(StringBuffer sb, String s) { 399 static void _escape(StringBuffer sb, String s) {
503 final int length = s.length; 400 final int length = s.length;
504 bool needsEscape = false; 401 bool needsEscape = false;
505 final charCodes = new List<int>(); 402 final charCodes = new List<int>();
506 for (int i = 0; i < length; i++) { 403 for (int i = 0; i < length; i++) {
507 int charCode = s.charCodeAt(i); 404 int charCode = s.charCodeAt(i);
508 if (charCode < 32) { 405 if (charCode < 32) {
509 needsEscape = true; 406 needsEscape = true;
510 charCodes.add(JsonTokenizer.BACKSLASH); 407 charCodes.add(JsonParser.BACKSLASH);
511 switch (charCode) { 408 switch (charCode) {
512 case JsonTokenizer.BACKSPACE: 409 case JsonParser.BACKSPACE:
513 charCodes.add(JsonTokenizer.B_SMALL); 410 charCodes.add(JsonParser.CHAR_B);
514 break; 411 break;
515 case JsonTokenizer.TAB: 412 case JsonParser.TAB:
516 charCodes.add(JsonTokenizer.T_SMALL); 413 charCodes.add(JsonParser.CHAR_T);
517 break; 414 break;
518 case JsonTokenizer.NEW_LINE: 415 case JsonParser.NEW_LINE:
519 charCodes.add(JsonTokenizer.N_SMALL); 416 charCodes.add(JsonParser.CHAR_N);
520 break; 417 break;
521 case JsonTokenizer.FORM_FEED: 418 case JsonParser.FORM_FEED:
522 charCodes.add(JsonTokenizer.F_SMALL); 419 charCodes.add(JsonParser.CHAR_F);
523 break; 420 break;
524 case JsonTokenizer.CARRIAGE_RETURN: 421 case JsonParser.CARRIAGE_RETURN:
525 charCodes.add(JsonTokenizer.R_SMALL); 422 charCodes.add(JsonParser.CHAR_R);
526 break; 423 break;
527 default: 424 default:
528 charCodes.add(JsonTokenizer.U_SMALL); 425 charCodes.add(JsonParser.CHAR_U);
529 charCodes.add(_hexDigit((charCode >> 12) & 0xf)); 426 charCodes.add(_hexDigit((charCode >> 12) & 0xf));
530 charCodes.add(_hexDigit((charCode >> 8) & 0xf)); 427 charCodes.add(_hexDigit((charCode >> 8) & 0xf));
531 charCodes.add(_hexDigit((charCode >> 4) & 0xf)); 428 charCodes.add(_hexDigit((charCode >> 4) & 0xf));
532 charCodes.add(_hexDigit(charCode & 0xf)); 429 charCodes.add(_hexDigit(charCode & 0xf));
533 break; 430 break;
534 } 431 }
535 } else if (charCode == JsonTokenizer.QUOTE || 432 } else if (charCode == JsonParser.QUOTE ||
536 charCode == JsonTokenizer.BACKSLASH) { 433 charCode == JsonParser.BACKSLASH) {
537 needsEscape = true; 434 needsEscape = true;
538 charCodes.add(JsonTokenizer.BACKSLASH); 435 charCodes.add(JsonParser.BACKSLASH);
539 charCodes.add(charCode); 436 charCodes.add(charCode);
540 } else { 437 } else {
541 charCodes.add(charCode); 438 charCodes.add(charCode);
542 } 439 }
543 } 440 }
544 sb.add(needsEscape ? new String.fromCharCodes(charCodes) : s); 441 sb.add(needsEscape ? new String.fromCharCodes(charCodes) : s);
545 } 442 }
546 443
547 void _checkCycle(final object) { 444 void _checkCycle(final object) {
548 // TODO: use Iterables. 445 // TODO: use Iterables.
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after
613 }); 510 });
614 _sb.add('}'); 511 _sb.add('}');
615 _seen.removeLast(); 512 _seen.removeLast();
616 return; 513 return;
617 514
618 default: 515 default:
619 throw const JsonUnsupportedObjectType(); 516 throw const JsonUnsupportedObjectType();
620 } 517 }
621 } 518 }
622 } 519 }
OLDNEW
« no previous file with comments | « no previous file | tests/utils/src/JsonTest.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698