src/v8/src/json-parser.h

   1 // Copyright 2011 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_JSON_PARSER_H_
   6 #define V8_JSON_PARSER_H_
   7
   8 #include "src/v8.h"
   9
  10 #include "src/char-predicates-inl.h"
  11 #include "src/conversions.h"
  12 #include "src/heap/spaces-inl.h"
  13 #include "src/messages.h"
  14 #include "src/token.h"
  15
  16 namespace v8 {
  17 namespace internal {
  18
  19 // A simple json parser.
  20 template <bool seq_ascii>
  21 class JsonParser BASE_EMBEDDED {
  22  public:
  23   MUST_USE_RESULT static MaybeHandle<Object> Parse(Handle<String> source) {
  24     return JsonParser(source).ParseJson();
  25   }
  26
  27   static const int kEndOfString = -1;
  28
  29  private:
  30   explicit JsonParser(Handle<String> source)
  31       : source_(source),
  32         source_length_(source->length()),
  33         isolate_(source->map()->GetHeap()->isolate()),
  34         factory_(isolate_->factory()),
  35         zone_(isolate_),
  36         object_constructor_(isolate_->native_context()->object_function(),
  37                             isolate_),
  38         position_(-1) {
  39     source_ = String::Flatten(source_);
  40     pretenure_ = (source_length_ >= kPretenureTreshold) ? TENURED : NOT_TENURED;
  41
  42     // Optimized fast case where we only have ASCII characters.
  43     if (seq_ascii) {
  44       seq_source_ = Handle<SeqOneByteString>::cast(source_);
  45     }
  46   }
  47
  48   // Parse a string containing a single JSON value.
  49   MaybeHandle<Object> ParseJson();
  50
  51   inline void Advance() {
  52     position_++;
  53     if (position_ >= source_length_) {
  54       c0_ = kEndOfString;
  55     } else if (seq_ascii) {
  56       c0_ = seq_source_->SeqOneByteStringGet(position_);
  57     } else {
  58       c0_ = source_->Get(position_);
  59     }
  60   }
  61
  62   // The JSON lexical grammar is specified in the ECMAScript 5 standard,
  63   // section 15.12.1.1. The only allowed whitespace characters between tokens
  64   // are tab, carriage-return, newline and space.
  65
  66   inline void AdvanceSkipWhitespace() {
  67     do {
  68       Advance();
  69     } while (c0_ == ' ' || c0_ == '\t' || c0_ == '\n' || c0_ == '\r');
  70   }
  71
  72   inline void SkipWhitespace() {
  73     while (c0_ == ' ' || c0_ == '\t' || c0_ == '\n' || c0_ == '\r') {
  74       Advance();
  75     }
  76   }
  77
  78   inline uc32 AdvanceGetChar() {
  79     Advance();
  80     return c0_;
  81   }
  82
  83   // Checks that current charater is c.
  84   // If so, then consume c and skip whitespace.
  85   inline bool MatchSkipWhiteSpace(uc32 c) {
  86     if (c0_ == c) {
  87       AdvanceSkipWhitespace();
  88       return true;
  89     }
  90     return false;
  91   }
  92
  93   // A JSON string (production JSONString) is subset of valid JavaScript string
  94   // literals. The string must only be double-quoted (not single-quoted), and
  95   // the only allowed backslash-escapes are ", /, \, b, f, n, r, t and
  96   // four-digit hex escapes (uXXXX). Any other use of backslashes is invalid.
  97   Handle<String> ParseJsonString() {
  98     return ScanJsonString<false>();
  99   }
 100
 101   bool ParseJsonString(Handle<String> expected) {
 102     int length = expected->length();
 103     if (source_->length() - position_ - 1 > length) {
 104       DisallowHeapAllocation no_gc;
 105       String::FlatContent content = expected->GetFlatContent();
 106       if (content.IsAscii()) {
 107         DCHECK_EQ('"', c0_);
 108         const uint8_t* input_chars = seq_source_->GetChars() + position_ + 1;
 109         const uint8_t* expected_chars = content.ToOneByteVector().start();
 110         for (int i = 0; i < length; i++) {
 111           uint8_t c0 = input_chars[i];
 112           if (c0 != expected_chars[i] ||
 113               c0 == '"' || c0 < 0x20 || c0 == '\\') {
 114             return false;
 115           }
 116         }
 117         if (input_chars[length] == '"') {
 118           position_ = position_ + length + 1;
 119           AdvanceSkipWhitespace();
 120           return true;
 121         }
 122       }
 123     }
 124     return false;
 125   }
 126
 127   Handle<String> ParseJsonInternalizedString() {
 128     return ScanJsonString<true>();
 129   }
 130
 131   template <bool is_internalized>
 132   Handle<String> ScanJsonString();
 133   // Creates a new string and copies prefix[start..end] into the beginning
 134   // of it. Then scans the rest of the string, adding characters after the
 135   // prefix. Called by ScanJsonString when reaching a '\' or non-ASCII char.
 136   template <typename StringType, typename SinkChar>
 137   Handle<String> SlowScanJsonString(Handle<String> prefix, int start, int end);
 138
 139   // A JSON number (production JSONNumber) is a subset of the valid JavaScript
 140   // decimal number literals.
 141   // It includes an optional minus sign, must have at least one
 142   // digit before and after a decimal point, may not have prefixed zeros (unless
 143   // the integer part is zero), and may include an exponent part (e.g., "e-10").
 144   // Hexadecimal and octal numbers are not allowed.
 145   Handle<Object> ParseJsonNumber();
 146
 147   // Parse a single JSON value from input (grammar production JSONValue).
 148   // A JSON value is either a (double-quoted) string literal, a number literal,
 149   // one of "true", "false", or "null", or an object or array literal.
 150   Handle<Object> ParseJsonValue();
 151
 152   // Parse a JSON object literal (grammar production JSONObject).
 153   // An object literal is a squiggly-braced and comma separated sequence
 154   // (possibly empty) of key/value pairs, where the key is a JSON string
 155   // literal, the value is a JSON value, and the two are separated by a colon.
 156   // A JSON array doesn't allow numbers and identifiers as keys, like a
 157   // JavaScript array.
 158   Handle<Object> ParseJsonObject();
 159
 160   // Parses a JSON array literal (grammar production JSONArray). An array
 161   // literal is a square-bracketed and comma separated sequence (possibly empty)
 162   // of JSON values.
 163   // A JSON array doesn't allow leaving out values from the sequence, nor does
 164   // it allow a terminal comma, like a JavaScript array does.
 165   Handle<Object> ParseJsonArray();
 166
 167
 168   // Mark that a parsing error has happened at the current token, and
 169   // return a null handle. Primarily for readability.
 170   inline Handle<Object> ReportUnexpectedCharacter() {
 171     return Handle<Object>::null();
 172   }
 173
 174   inline Isolate* isolate() { return isolate_; }
 175   inline Factory* factory() { return factory_; }
 176   inline Handle<JSFunction> object_constructor() { return object_constructor_; }
 177
 178   static const int kInitialSpecialStringLength = 1024;
 179   static const int kPretenureTreshold = 100 * 1024;
 180
 181
 182  private:
 183   Zone* zone() { return &zone_; }
 184
 185   Handle<String> source_;
 186   int source_length_;
 187   Handle<SeqOneByteString> seq_source_;
 188
 189   PretenureFlag pretenure_;
 190   Isolate* isolate_;
 191   Factory* factory_;
 192   Zone zone_;
 193   Handle<JSFunction> object_constructor_;
 194   uc32 c0_;
 195   int position_;
 196 };
 197
 198 template <bool seq_ascii>
 199 MaybeHandle<Object> JsonParser<seq_ascii>::ParseJson() {
 200   // Advance to the first character (possibly EOS)
 201   AdvanceSkipWhitespace();
 202   Handle<Object> result = ParseJsonValue();
 203   if (result.is_null() || c0_ != kEndOfString) {
 204     // Some exception (for example stack overflow) is already pending.
 205     if (isolate_->has_pending_exception()) return Handle<Object>::null();
 206
 207     // Parse failed. Current character is the unexpected token.
 208     const char* message;
 209     Factory* factory = this->factory();
 210     Handle<JSArray> array;
 211
 212     switch (c0_) {
 213       case kEndOfString:
 214         message = "unexpected_eos";
 215         array = factory->NewJSArray(0);
 216         break;
 217       case '-':
 218       case '0':
 219       case '1':
 220       case '2':
 221       case '3':
 222       case '4':
 223       case '5':
 224       case '6':
 225       case '7':
 226       case '8':
 227       case '9':
 228         message = "unexpected_token_number";
 229         array = factory->NewJSArray(0);
 230         break;
 231       case '"':
 232         message = "unexpected_token_string";
 233         array = factory->NewJSArray(0);
 234         break;
 235       default:
 236         message = "unexpected_token";
 237         Handle<Object> name = factory->LookupSingleCharacterStringFromCode(c0_);
 238         Handle<FixedArray> element = factory->NewFixedArray(1);
 239         element->set(0, *name);
 240         array = factory->NewJSArrayWithElements(element);
 241         break;
 242     }
 243
 244     MessageLocation location(factory->NewScript(source_),
 245                              position_,
 246                              position_ + 1);
 247     Handle<Object> error = factory->NewSyntaxError(message, array);
 248     return isolate()->template Throw<Object>(error, &location);
 249   }
 250   return result;
 251 }
 252
 253
 254 // Parse any JSON value.
 255 template <bool seq_ascii>
 256 Handle<Object> JsonParser<seq_ascii>::ParseJsonValue() {
 257   StackLimitCheck stack_check(isolate_);
 258   if (stack_check.HasOverflowed()) {
 259     isolate_->StackOverflow();
 260     return Handle<Object>::null();
 261   }
 262
 263   if (c0_ == '"') return ParseJsonString();
 264   if ((c0_ >= '0' && c0_ <= '9') || c0_ == '-') return ParseJsonNumber();
 265   if (c0_ == '{') return ParseJsonObject();
 266   if (c0_ == '[') return ParseJsonArray();
 267   if (c0_ == 'f') {
 268     if (AdvanceGetChar() == 'a' && AdvanceGetChar() == 'l' &&
 269         AdvanceGetChar() == 's' && AdvanceGetChar() == 'e') {
 270       AdvanceSkipWhitespace();
 271       return factory()->false_value();
 272     }
 273     return ReportUnexpectedCharacter();
 274   }
 275   if (c0_ == 't') {
 276     if (AdvanceGetChar() == 'r' && AdvanceGetChar() == 'u' &&
 277         AdvanceGetChar() == 'e') {
 278       AdvanceSkipWhitespace();
 279       return factory()->true_value();
 280     }
 281     return ReportUnexpectedCharacter();
 282   }
 283   if (c0_ == 'n') {
 284     if (AdvanceGetChar() == 'u' && AdvanceGetChar() == 'l' &&
 285         AdvanceGetChar() == 'l') {
 286       AdvanceSkipWhitespace();
 287       return factory()->null_value();
 288     }
 289     return ReportUnexpectedCharacter();
 290   }
 291   return ReportUnexpectedCharacter();
 292 }
 293
 294
 295 // Parse a JSON object. Position must be right at '{'.
 296 template <bool seq_ascii>
 297 Handle<Object> JsonParser<seq_ascii>::ParseJsonObject() {
 298   HandleScope scope(isolate());
 299   Handle<JSObject> json_object =
 300       factory()->NewJSObject(object_constructor(), pretenure_);
 301   Handle<Map> map(json_object->map());
 302   ZoneList<Handle<Object> > properties(8, zone());
 303   DCHECK_EQ(c0_, '{');
 304
 305   bool transitioning = true;
 306
 307   AdvanceSkipWhitespace();
 308   if (c0_ != '}') {
 309     do {
 310       if (c0_ != '"') return ReportUnexpectedCharacter();
 311
 312       int start_position = position_;
 313       Advance();
 314
 315       uint32_t index = 0;
 316       if (c0_ >= '0' && c0_ <= '9') {
 317         // Maybe an array index, try to parse it.
 318         if (c0_ == '0') {
 319           // With a leading zero, the string has to be "0" only to be an index.
 320           Advance();
 321         } else {
 322           do {
 323             int d = c0_ - '0';
 324             if (index > 429496729U - ((d > 5) ? 1 : 0)) break;
 325             index = (index * 10) + d;
 326             Advance();
 327           } while (c0_ >= '0' && c0_ <= '9');
 328         }
 329
 330         if (c0_ == '"') {
 331           // Successfully parsed index, parse and store element.
 332           AdvanceSkipWhitespace();
 333
 334           if (c0_ != ':') return ReportUnexpectedCharacter();
 335           AdvanceSkipWhitespace();
 336           Handle<Object> value = ParseJsonValue();
 337           if (value.is_null()) return ReportUnexpectedCharacter();
 338
 339           JSObject::SetOwnElement(json_object, index, value, SLOPPY).Assert();
 340           continue;
 341         }
 342         // Not an index, fallback to the slow path.
 343       }
 344
 345       position_ = start_position;
 346 #ifdef DEBUG
 347       c0_ = '"';
 348 #endif
 349
 350       Handle<String> key;
 351       Handle<Object> value;
 352
 353       // Try to follow existing transitions as long as possible. Once we stop
 354       // transitioning, no transition can be found anymore.
 355       if (transitioning) {
 356         // First check whether there is a single expected transition. If so, try
 357         // to parse it first.
 358         bool follow_expected = false;
 359         Handle<Map> target;
 360         if (seq_ascii) {
 361           key = Map::ExpectedTransitionKey(map);
 362           follow_expected = !key.is_null() && ParseJsonString(key);
 363         }
 364         // If the expected transition hits, follow it.
 365         if (follow_expected) {
 366           target = Map::ExpectedTransitionTarget(map);
 367         } else {
 368           // If the expected transition failed, parse an internalized string and
 369           // try to find a matching transition.
 370           key = ParseJsonInternalizedString();
 371           if (key.is_null()) return ReportUnexpectedCharacter();
 372
 373           target = Map::FindTransitionToField(map, key);
 374           // If a transition was found, follow it and continue.
 375           transitioning = !target.is_null();
 376         }
 377         if (c0_ != ':') return ReportUnexpectedCharacter();
 378
 379         AdvanceSkipWhitespace();
 380         value = ParseJsonValue();
 381         if (value.is_null()) return ReportUnexpectedCharacter();
 382
 383         if (transitioning) {
 384           int descriptor = map->NumberOfOwnDescriptors();
 385           PropertyDetails details =
 386               target->instance_descriptors()->GetDetails(descriptor);
 387           Representation expected_representation = details.representation();
 388
 389           if (value->FitsRepresentation(expected_representation)) {
 390             if (expected_representation.IsDouble()) {
 391               value = Object::NewStorageFor(isolate(), value,
 392                                             expected_representation);
 393             } else if (expected_representation.IsHeapObject() &&
 394                        !target->instance_descriptors()->GetFieldType(
 395                            descriptor)->NowContains(value)) {
 396               Handle<HeapType> value_type(value->OptimalType(
 397                       isolate(), expected_representation));
 398               Map::GeneralizeFieldType(target, descriptor, value_type);
 399             }
 400             DCHECK(target->instance_descriptors()->GetFieldType(
 401                     descriptor)->NowContains(value));
 402             properties.Add(value, zone());
 403             map = target;
 404             continue;
 405           } else {
 406             transitioning = false;
 407           }
 408         }
 409
 410         // Commit the intermediate state to the object and stop transitioning.
 411         JSObject::AllocateStorageForMap(json_object, map);
 412         int length = properties.length();
 413         for (int i = 0; i < length; i++) {
 414           Handle<Object> value = properties[i];
 415           FieldIndex index = FieldIndex::ForPropertyIndex(*map, i);
 416           json_object->FastPropertyAtPut(index, *value);
 417         }
 418       } else {
 419         key = ParseJsonInternalizedString();
 420         if (key.is_null() || c0_ != ':') return ReportUnexpectedCharacter();
 421
 422         AdvanceSkipWhitespace();
 423         value = ParseJsonValue();
 424         if (value.is_null()) return ReportUnexpectedCharacter();
 425       }
 426
 427       JSObject::SetOwnPropertyIgnoreAttributes(
 428           json_object, key, value, NONE).Assert();
 429     } while (MatchSkipWhiteSpace(','));
 430     if (c0_ != '}') {
 431       return ReportUnexpectedCharacter();
 432     }
 433
 434     // If we transitioned until the very end, transition the map now.
 435     if (transitioning) {
 436       JSObject::AllocateStorageForMap(json_object, map);
 437       int length = properties.length();
 438       for (int i = 0; i < length; i++) {
 439         Handle<Object> value = properties[i];
 440         FieldIndex index = FieldIndex::ForPropertyIndex(*map, i);
 441         json_object->FastPropertyAtPut(index, *value);
 442       }
 443     }
 444   }
 445   AdvanceSkipWhitespace();
 446   return scope.CloseAndEscape(json_object);
 447 }
 448
 449 // Parse a JSON array. Position must be right at '['.
 450 template <bool seq_ascii>
 451 Handle<Object> JsonParser<seq_ascii>::ParseJsonArray() {
 452   HandleScope scope(isolate());
 453   ZoneList<Handle<Object> > elements(4, zone());
 454   DCHECK_EQ(c0_, '[');
 455
 456   AdvanceSkipWhitespace();
 457   if (c0_ != ']') {
 458     do {
 459       Handle<Object> element = ParseJsonValue();
 460       if (element.is_null()) return ReportUnexpectedCharacter();
 461       elements.Add(element, zone());
 462     } while (MatchSkipWhiteSpace(','));
 463     if (c0_ != ']') {
 464       return ReportUnexpectedCharacter();
 465     }
 466   }
 467   AdvanceSkipWhitespace();
 468   // Allocate a fixed array with all the elements.
 469   Handle<FixedArray> fast_elements =
 470       factory()->NewFixedArray(elements.length(), pretenure_);
 471   for (int i = 0, n = elements.length(); i < n; i++) {
 472     fast_elements->set(i, *elements[i]);
 473   }
 474   Handle<Object> json_array = factory()->NewJSArrayWithElements(
 475       fast_elements, FAST_ELEMENTS, pretenure_);
 476   return scope.CloseAndEscape(json_array);
 477 }
 478
 479
 480 template <bool seq_ascii>
 481 Handle<Object> JsonParser<seq_ascii>::ParseJsonNumber() {
 482   bool negative = false;
 483   int beg_pos = position_;
 484   if (c0_ == '-') {
 485     Advance();
 486     negative = true;
 487   }
 488   if (c0_ == '0') {
 489     Advance();
 490     // Prefix zero is only allowed if it's the only digit before
 491     // a decimal point or exponent.
 492     if ('0' <= c0_ && c0_ <= '9') return ReportUnexpectedCharacter();
 493   } else {
 494     int i = 0;
 495     int digits = 0;
 496     if (c0_ < '1' || c0_ > '9') return ReportUnexpectedCharacter();
 497     do {
 498       i = i * 10 + c0_ - '0';
 499       digits++;
 500       Advance();
 501     } while (c0_ >= '0' && c0_ <= '9');
 502     if (c0_ != '.' && c0_ != 'e' && c0_ != 'E' && digits < 10) {
 503       SkipWhitespace();
 504       return Handle<Smi>(Smi::FromInt((negative ? -i : i)), isolate());
 505     }
 506   }
 507   if (c0_ == '.') {
 508     Advance();
 509     if (c0_ < '0' || c0_ > '9') return ReportUnexpectedCharacter();
 510     do {
 511       Advance();
 512     } while (c0_ >= '0' && c0_ <= '9');
 513   }
 514   if (AsciiAlphaToLower(c0_) == 'e') {
 515     Advance();
 516     if (c0_ == '-' || c0_ == '+') Advance();
 517     if (c0_ < '0' || c0_ > '9') return ReportUnexpectedCharacter();
 518     do {
 519       Advance();
 520     } while (c0_ >= '0' && c0_ <= '9');
 521   }
 522   int length = position_ - beg_pos;
 523   double number;
 524   if (seq_ascii) {
 525     Vector<const uint8_t> chars(seq_source_->GetChars() +  beg_pos, length);
 526     number = StringToDouble(isolate()->unicode_cache(),
 527                             chars,
 528                             NO_FLAGS,  // Hex, octal or trailing junk.
 529                             base::OS::nan_value());
 530   } else {
 531     Vector<uint8_t> buffer = Vector<uint8_t>::New(length);
 532     String::WriteToFlat(*source_, buffer.start(), beg_pos, position_);
 533     Vector<const uint8_t> result =
 534         Vector<const uint8_t>(buffer.start(), length);
 535     number = StringToDouble(isolate()->unicode_cache(),
 536                             result,
 537                             NO_FLAGS,  // Hex, octal or trailing junk.
 538                             0.0);
 539     buffer.Dispose();
 540   }
 541   SkipWhitespace();
 542   return factory()->NewNumber(number, pretenure_);
 543 }
 544
 545
 546 template <typename StringType>
 547 inline void SeqStringSet(Handle<StringType> seq_str, int i, uc32 c);
 548
 549 template <>
 550 inline void SeqStringSet(Handle<SeqTwoByteString> seq_str, int i, uc32 c) {
 551   seq_str->SeqTwoByteStringSet(i, c);
 552 }
 553
 554 template <>
 555 inline void SeqStringSet(Handle<SeqOneByteString> seq_str, int i, uc32 c) {
 556   seq_str->SeqOneByteStringSet(i, c);
 557 }
 558
 559 template <typename StringType>
 560 inline Handle<StringType> NewRawString(Factory* factory,
 561                                        int length,
 562                                        PretenureFlag pretenure);
 563
 564 template <>
 565 inline Handle<SeqTwoByteString> NewRawString(Factory* factory,
 566                                              int length,
 567                                              PretenureFlag pretenure) {
 568   return factory->NewRawTwoByteString(length, pretenure).ToHandleChecked();
 569 }
 570
 571 template <>
 572 inline Handle<SeqOneByteString> NewRawString(Factory* factory,
 573                                            int length,
 574                                            PretenureFlag pretenure) {
 575   return factory->NewRawOneByteString(length, pretenure).ToHandleChecked();
 576 }
 577
 578
 579 // Scans the rest of a JSON string starting from position_ and writes
 580 // prefix[start..end] along with the scanned characters into a
 581 // sequential string of type StringType.
 582 template <bool seq_ascii>
 583 template <typename StringType, typename SinkChar>
 584 Handle<String> JsonParser<seq_ascii>::SlowScanJsonString(
 585     Handle<String> prefix, int start, int end) {
 586   int count = end - start;
 587   int max_length = count + source_length_ - position_;
 588   int length = Min(max_length, Max(kInitialSpecialStringLength, 2 * count));
 589   Handle<StringType> seq_string =
 590       NewRawString<StringType>(factory(), length, pretenure_);
 591   // Copy prefix into seq_str.
 592   SinkChar* dest = seq_string->GetChars();
 593   String::WriteToFlat(*prefix, dest, start, end);
 594
 595   while (c0_ != '"') {
 596     // Check for control character (0x00-0x1f) or unterminated string (<0).
 597     if (c0_ < 0x20) return Handle<String>::null();
 598     if (count >= length) {
 599       // We need to create a longer sequential string for the result.
 600       return SlowScanJsonString<StringType, SinkChar>(seq_string, 0, count);
 601     }
 602     if (c0_ != '\\') {
 603       // If the sink can contain UC16 characters, or source_ contains only
 604       // ASCII characters, there's no need to test whether we can store the
 605       // character. Otherwise check whether the UC16 source character can fit
 606       // in the ASCII sink.
 607       if (sizeof(SinkChar) == kUC16Size ||
 608           seq_ascii ||
 609           c0_ <= String::kMaxOneByteCharCode) {
 610         SeqStringSet(seq_string, count++, c0_);
 611         Advance();
 612       } else {
 613         // StringType is SeqOneByteString and we just read a non-ASCII char.
 614         return SlowScanJsonString<SeqTwoByteString, uc16>(seq_string, 0, count);
 615       }
 616     } else {
 617       Advance();  // Advance past the \.
 618       switch (c0_) {
 619         case '"':
 620         case '\\':
 621         case '/':
 622           SeqStringSet(seq_string, count++, c0_);
 623           break;
 624         case 'b':
 625           SeqStringSet(seq_string, count++, '\x08');
 626           break;
 627         case 'f':
 628           SeqStringSet(seq_string, count++, '\x0c');
 629           break;
 630         case 'n':
 631           SeqStringSet(seq_string, count++, '\x0a');
 632           break;
 633         case 'r':
 634           SeqStringSet(seq_string, count++, '\x0d');
 635           break;
 636         case 't':
 637           SeqStringSet(seq_string, count++, '\x09');
 638           break;
 639         case 'u': {
 640           uc32 value = 0;
 641           for (int i = 0; i < 4; i++) {
 642             Advance();
 643             int digit = HexValue(c0_);
 644             if (digit < 0) {
 645               return Handle<String>::null();
 646             }
 647             value = value * 16 + digit;
 648           }
 649           if (sizeof(SinkChar) == kUC16Size ||
 650               value <= String::kMaxOneByteCharCode) {
 651             SeqStringSet(seq_string, count++, value);
 652             break;
 653           } else {
 654             // StringType is SeqOneByteString and we just read a non-ASCII char.
 655             position_ -= 6;  // Rewind position_ to \ in \uxxxx.
 656             Advance();
 657             return SlowScanJsonString<SeqTwoByteString, uc16>(seq_string,
 658                                                               0,
 659                                                               count);
 660           }
 661         }
 662         default:
 663           return Handle<String>::null();
 664       }
 665       Advance();
 666     }
 667   }
 668
 669   DCHECK_EQ('"', c0_);
 670   // Advance past the last '"'.
 671   AdvanceSkipWhitespace();
 672
 673   // Shrink seq_string length to count and return.
 674   return SeqString::Truncate(seq_string, count);
 675 }
 676
 677
 678 template <bool seq_ascii>
 679 template <bool is_internalized>
 680 Handle<String> JsonParser<seq_ascii>::ScanJsonString() {
 681   DCHECK_EQ('"', c0_);
 682   Advance();
 683   if (c0_ == '"') {
 684     AdvanceSkipWhitespace();
 685     return factory()->empty_string();
 686   }
 687
 688   if (seq_ascii && is_internalized) {
 689     // Fast path for existing internalized strings.  If the the string being
 690     // parsed is not a known internalized string, contains backslashes or
 691     // unexpectedly reaches the end of string, return with an empty handle.
 692     uint32_t running_hash = isolate()->heap()->HashSeed();
 693     int position = position_;
 694     uc32 c0 = c0_;
 695     do {
 696       if (c0 == '\\') {
 697         c0_ = c0;
 698         int beg_pos = position_;
 699         position_ = position;
 700         return SlowScanJsonString<SeqOneByteString, uint8_t>(source_,
 701                                                              beg_pos,
 702                                                              position_);
 703       }
 704       if (c0 < 0x20) return Handle<String>::null();
 705       if (static_cast<uint32_t>(c0) >
 706           unibrow::Utf16::kMaxNonSurrogateCharCode) {
 707         running_hash =
 708             StringHasher::AddCharacterCore(running_hash,
 709                                            unibrow::Utf16::LeadSurrogate(c0));
 710         running_hash =
 711             StringHasher::AddCharacterCore(running_hash,
 712                                            unibrow::Utf16::TrailSurrogate(c0));
 713       } else {
 714         running_hash = StringHasher::AddCharacterCore(running_hash, c0);
 715       }
 716       position++;
 717       if (position >= source_length_) return Handle<String>::null();
 718       c0 = seq_source_->SeqOneByteStringGet(position);
 719     } while (c0 != '"');
 720     int length = position - position_;
 721     uint32_t hash = (length <= String::kMaxHashCalcLength)
 722                         ? StringHasher::GetHashCore(running_hash)
 723                         : static_cast<uint32_t>(length);
 724     Vector<const uint8_t> string_vector(
 725         seq_source_->GetChars() + position_, length);
 726     StringTable* string_table = isolate()->heap()->string_table();
 727     uint32_t capacity = string_table->Capacity();
 728     uint32_t entry = StringTable::FirstProbe(hash, capacity);
 729     uint32_t count = 1;
 730     Handle<String> result;
 731     while (true) {
 732       Object* element = string_table->KeyAt(entry);
 733       if (element == isolate()->heap()->undefined_value()) {
 734         // Lookup failure.
 735         result = factory()->InternalizeOneByteString(
 736             seq_source_, position_, length);
 737         break;
 738       }
 739       if (element != isolate()->heap()->the_hole_value() &&
 740           String::cast(element)->IsOneByteEqualTo(string_vector)) {
 741         result = Handle<String>(String::cast(element), isolate());
 742 #ifdef DEBUG
 743         uint32_t hash_field =
 744             (hash << String::kHashShift) | String::kIsNotArrayIndexMask;
 745         DCHECK_EQ(static_cast<int>(result->Hash()),
 746                   static_cast<int>(hash_field >> String::kHashShift));
 747 #endif
 748         break;
 749       }
 750       entry = StringTable::NextProbe(entry, count++, capacity);
 751     }
 752     position_ = position;
 753     // Advance past the last '"'.
 754     AdvanceSkipWhitespace();
 755     return result;
 756   }
 757
 758   int beg_pos = position_;
 759   // Fast case for ASCII only without escape characters.
 760   do {
 761     // Check for control character (0x00-0x1f) or unterminated string (<0).
 762     if (c0_ < 0x20) return Handle<String>::null();
 763     if (c0_ != '\\') {
 764       if (seq_ascii || c0_ <= String::kMaxOneByteCharCode) {
 765         Advance();
 766       } else {
 767         return SlowScanJsonString<SeqTwoByteString, uc16>(source_,
 768                                                           beg_pos,
 769                                                           position_);
 770       }
 771     } else {
 772       return SlowScanJsonString<SeqOneByteString, uint8_t>(source_,
 773                                                            beg_pos,
 774                                                            position_);
 775     }
 776   } while (c0_ != '"');
 777   int length = position_ - beg_pos;
 778   Handle<String> result =
 779       factory()->NewRawOneByteString(length, pretenure_).ToHandleChecked();
 780   uint8_t* dest = SeqOneByteString::cast(*result)->GetChars();
 781   String::WriteToFlat(*source_, dest, beg_pos, position_);
 782
 783   DCHECK_EQ('"', c0_);
 784   // Advance past the last '"'.
 785   AdvanceSkipWhitespace();
 786   return result;
 787 }
 788
 789 } }  // namespace v8::internal
 790
 791 #endif  // V8_JSON_PARSER_H_