Inctroduce NewStrictSubstring to avoid check for SubString(str, 0, str.length...

src/json-parser.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 91 matching lines @@
   Handle<String> ParseJsonString() {
     return ScanJsonString<false>();
   }
   Handle<String> ParseJsonSymbol() {
     return ScanJsonString<true>();
   }
   template <bool is_symbol>
   Handle<String> ScanJsonString();
   // Slow version for unicode support, uses the first ascii_count characters,
   // as first part of a ConsString
-  Handle<String> SlowScanJsonString();
+  Handle<String> SlowScanJsonString(int beg_pos);
 
   // A JSON number (production JSONNumber) is a subset of the valid JavaScript
   // decimal number literals.
   // It includes an optional minus sign, must have at least one
   // digit before and after a decimal point, may not have prefixed zeros (unless
   // the integer part is zero), and may include an exponent part (e.g., "e-10").
   // Hexadecimal and octal numbers are not allowed.
   Handle<Object> ParseJsonNumber();
 
   // Parse a single JSON value from input (grammar production JSONValue).
@@ skipping 26 matching lines @@
   inline Isolate* isolate() { return isolate_; }
 
   static const int kInitialSpecialStringSize = 1024;
 
 
  private:
   Handle<String> source_;
   int source_length_;
   Handle<SeqAsciiString> seq_source_;
 
-  // begin and end position of scanned string or number
-  int beg_pos_;
-  int end_pos_;
-
   Isolate* isolate_;
   uc32 c0_;
   int position_;
-
-  double number_;
 };
 
 template <bool seq_ascii>
 Handle<Object> JsonParser<seq_ascii>::ParseJson(Handle<String> source) {
   isolate_ = source->map()->isolate();
   source_ = Handle<String>(source->TryFlattenGetString());
   source_length_ = source_->length() - 1;
 
   // Optimized fast case where we only have ascii characters.
   if (seq_ascii) {
@@ skipping 168 matching lines @@
   for (int i = 0, n = elements.length(); i < n; i++) {
     fast_elements->set(i, *elements[i]);
   }
   return isolate()->factory()->NewJSArrayWithElements(fast_elements);
 }
 
 
 template <bool seq_ascii>
 Handle<Object> JsonParser<seq_ascii>::ParseJsonNumber() {
   bool negative = false;
-  beg_pos_ = position_;
+  int beg_pos = position_;
   if (c0_ == '-') {
     Advance();
     negative = true;
   }
   if (c0_ == '0') {
     Advance();
     // Prefix zero is only allowed if it's the only digit before
     // a decimal point or exponent.
     if ('0' <= c0_ && c0_ <= '9') return ReportUnexpectedCharacter();
   } else {
     int i = 0;
     int digits = 0;
     if (c0_ < '1' || c0_ > '9') return ReportUnexpectedCharacter();
     do {
       i = i * 10 + c0_ - '0';
       digits++;
       Advance();
     } while (c0_ >= '0' && c0_ <= '9');
     if (c0_ != '.' && c0_ != 'e' && c0_ != 'E' && digits < 10) {
-      number_ = (negative ? -i : i);
       SkipWhitespace();
-      return isolate()->factory()->NewNumber(number_);
+      return Handle<Smi>(Smi::FromInt((negative ? -i : i)), isolate());
     }
   }
   if (c0_ == '.') {
     Advance();
     if (c0_ < '0' || c0_ > '9') return ReportUnexpectedCharacter();
     do {
       Advance();
     } while (c0_ >= '0' && c0_ <= '9');
   }
   if (AsciiAlphaToLower(c0_) == 'e') {
     Advance();
     if (c0_ == '-' || c0_ == '+') Advance();
     if (c0_ < '0' || c0_ > '9') return ReportUnexpectedCharacter();
     do {
       Advance();
     } while (c0_ >= '0' && c0_ <= '9');
   }
-  int length = position_ - beg_pos_;
+  int length = position_ - beg_pos;
+  double number;
   if (seq_ascii) {
-    Vector<const char> chars(seq_source_->GetChars() +  beg_pos_, length);
-    number_ = StringToDouble(isolate()->unicode_cache(),
+    Vector<const char> chars(seq_source_->GetChars() +  beg_pos, length);
+    number = StringToDouble(isolate()->unicode_cache(),
                              chars,
                              NO_FLAGS,  // Hex, octal or trailing junk.
                              OS::nan_value());
   } else {
     Vector<char> buffer = Vector<char>::New(length);
-    String::WriteToFlat(*source_, buffer.start(), beg_pos_, position_);
+    String::WriteToFlat(*source_, buffer.start(), beg_pos, position_);
     Vector<const char> result =
         Vector<const char>(reinterpret_cast<const char*>(buffer.start()),
         length);
-    number_ = StringToDouble(isolate()->unicode_cache(),
+    number = StringToDouble(isolate()->unicode_cache(),
                              result,
                              NO_FLAGS,  // Hex, octal or trailing junk.
                              0.0);
     buffer.Dispose();
   }
   SkipWhitespace();
-  return isolate()->factory()->NewNumber(number_);
+  return isolate()->factory()->NewNumber(number);
 }
 
 template <bool seq_ascii>
-Handle<String> JsonParser<seq_ascii>::SlowScanJsonString() {
+Handle<String> JsonParser<seq_ascii>::SlowScanJsonString(int beg_pos) {
   // The currently scanned ascii characters.
-  Handle<String> ascii(isolate()->factory()->NewSubString(source_,
-                                                          beg_pos_,
-                                                          position_));
+  Handle<String> ascii(isolate()->factory()->NewStrictSubString(source_,
+                                                                beg_pos,
+                                                                position_));
   Handle<String> two_byte =
       isolate()->factory()->NewRawTwoByteString(kInitialSpecialStringSize,
                                                 NOT_TENURED);
   Handle<SeqTwoByteString> seq_two_byte =
       Handle<SeqTwoByteString>::cast(two_byte);
 
   int allocation_count = 1;
   int count = 0;
 
   while (c0_ != '"') {
@@ skipping 76 matching lines @@
     isolate()->heap()->CreateFillerObjectAt(start_filler_object, delta);
   }
   return isolate()->factory()->NewConsString(ascii, seq_two_byte);
 }
 
 template <bool seq_ascii>
 template <bool is_symbol>
 Handle<String> JsonParser<seq_ascii>::ScanJsonString() {
   ASSERT_EQ('"', c0_);
   Advance();
-  beg_pos_ = position_;
+  int beg_pos = position_;
   // Fast case for ascii only without escape characters.
   while (c0_ != '"') {
     // Check for control character (0x00-0x1f) or unterminated string (<0).
     if (c0_ < 0x20) return Handle<String>::null();
     if (c0_ != '\\' && (seq_ascii || c0_ < kMaxAsciiCharCode)) {
       Advance();
     } else {
-      return this->SlowScanJsonString();
+      return this->SlowScanJsonString(beg_pos);
     }
   }
   ASSERT_EQ('"', c0_);
-  end_pos_ = position_;
+  int end_pos = position_;
   // Advance past the last '"'.
   AdvanceSkipWhitespace();
   if (seq_ascii && is_symbol) {
     return isolate()->factory()->LookupAsciiSymbol(seq_source_,
-                                                   beg_pos_,
-                                                   end_pos_ - beg_pos_);
+                                                   beg_pos,
+                                                   end_pos - beg_pos);
   } else {
-    return isolate()->factory()->NewSubString(source_, beg_pos_, end_pos_);
+    return isolate()->factory()->NewStrictSubString(source_,
+                                                    beg_pos,
+                                                    end_pos);
   }
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSON_PARSER_H_