[runtime] Support Proxy setPrototypeOf trap

src/parsing/json-parser.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_PARSING_JSON_PARSER_H_
 #define V8_PARSING_JSON_PARSER_H_
 
 #include "src/char-predicates.h"
 #include "src/conversions.h"
 #include "src/debug/debug.h"
@@ skipping 80 matching lines @@
       AdvanceSkipWhitespace();
       return true;
     }
     return false;
   }
 
   // A JSON string (production JSONString) is subset of valid JavaScript string
   // literals. The string must only be double-quoted (not single-quoted), and
   // the only allowed backslash-escapes are ", /, \, b, f, n, r, t and
   // four-digit hex escapes (uXXXX). Any other use of backslashes is invalid.
-  Handle<String> ParseJsonString() {
-    return ScanJsonString<false>();
-  }
+  Handle<String> ParseJsonString() { return ScanJsonString<false>(); }
 
   bool ParseJsonString(Handle<String> expected) {
     int length = expected->length();
     if (source_->length() - position_ - 1 > length) {
       DisallowHeapAllocation no_gc;
       String::FlatContent content = expected->GetFlatContent();
       if (content.IsOneByte()) {
         DCHECK_EQ('"', c0_);
         const uint8_t* input_chars = seq_source_->GetChars() + position_ + 1;
         const uint8_t* expected_chars = content.ToOneByteVector().start();
@@ skipping 355 matching lines @@
         Handle<Object> value;
 
         key = ParseJsonInternalizedString();
         if (key.is_null() || c0_ != ':') return ReportUnexpectedCharacter();
 
         AdvanceSkipWhitespace();
         value = ParseJsonValue();
         if (value.is_null()) return ReportUnexpectedCharacter();
 
         JSObject::DefinePropertyOrElementIgnoreAttributes(json_object, key,
-                                                          value).Check();
+                                                          value)
+            .Check();
       }
     }
 
     if (c0_ != '}') {
       return ReportUnexpectedCharacter();
     }
   }
   AdvanceSkipWhitespace();
   return scope.CloseAndEscape(json_object);
 }
@@ skipping 85 matching lines @@
     Advance();
     if (c0_ == '-' || c0_ == '+') Advance();
     if (!IsDecimalDigit(c0_)) return ReportUnexpectedCharacter();
     do {
       Advance();
     } while (IsDecimalDigit(c0_));
   }
   int length = position_ - beg_pos;
   double number;
   if (seq_one_byte) {
-    Vector<const uint8_t> chars(seq_source_->GetChars() +  beg_pos, length);
+    Vector<const uint8_t> chars(seq_source_->GetChars() + beg_pos, length);
     number = StringToDouble(isolate()->unicode_cache(), chars,
                             NO_FLAGS,  // Hex, octal or trailing junk.
                             std::numeric_limits<double>::quiet_NaN());
   } else {
     Vector<uint8_t> buffer = Vector<uint8_t>::New(length);
     String::WriteToFlat(*source_, buffer.start(), beg_pos, position_);
     Vector<const uint8_t> result =
         Vector<const uint8_t>(buffer.start(), length);
-    number = StringToDouble(isolate()->unicode_cache(),
-                            result,
+    number = StringToDouble(isolate()->unicode_cache(), result,
                             NO_FLAGS,  // Hex, octal or trailing junk.
                             0.0);
     buffer.Dispose();
   }
   SkipWhitespace();
   return factory()->NewNumber(number, pretenure_);
 }
 
 
 template <typename StringType>
 inline void SeqStringSet(Handle<StringType> seq_str, int i, uc32 c);
 
 template <>
 inline void SeqStringSet(Handle<SeqTwoByteString> seq_str, int i, uc32 c) {
   seq_str->SeqTwoByteStringSet(i, c);
 }
 
 template <>
 inline void SeqStringSet(Handle<SeqOneByteString> seq_str, int i, uc32 c) {
   seq_str->SeqOneByteStringSet(i, c);
 }
 
 template <typename StringType>
-inline Handle<StringType> NewRawString(Factory* factory,
-                                       int length,
+inline Handle<StringType> NewRawString(Factory* factory, int length,
                                        PretenureFlag pretenure);
 
 template <>
-inline Handle<SeqTwoByteString> NewRawString(Factory* factory,
-                                             int length,
+inline Handle<SeqTwoByteString> NewRawString(Factory* factory, int length,
                                              PretenureFlag pretenure) {
   return factory->NewRawTwoByteString(length, pretenure).ToHandleChecked();
 }
 
 template <>
-inline Handle<SeqOneByteString> NewRawString(Factory* factory,
-                                           int length,
-                                           PretenureFlag pretenure) {
+inline Handle<SeqOneByteString> NewRawString(Factory* factory, int length,
+                                             PretenureFlag pretenure) {
   return factory->NewRawOneByteString(length, pretenure).ToHandleChecked();
 }
 
 
 // Scans the rest of a JSON string starting from position_ and writes
 // prefix[start..end] along with the scanned characters into a
 // sequential string of type StringType.
 template <bool seq_one_byte>
 template <typename StringType, typename SinkChar>
 Handle<String> JsonParser<seq_one_byte>::SlowScanJsonString(
@@ skipping 62 matching lines @@
           }
           if (sizeof(SinkChar) == kUC16Size ||
               value <= String::kMaxOneByteCharCode) {
             SeqStringSet(seq_string, count++, value);
             break;
           } else {
             // StringType is SeqOneByteString and we just read a non-Latin1
             // char.
             position_ -= 6;  // Rewind position_ to \ in \uxxxx.
             Advance();
-            return SlowScanJsonString<SeqTwoByteString, uc16>(seq_string,
-                                                              0,
+            return SlowScanJsonString<SeqTwoByteString, uc16>(seq_string, 0,
                                                               count);
           }
         }
         default:
           return Handle<String>::null();
       }
       Advance();
     }
   }
 
@@ skipping 21 matching lines @@
     // parsed is not a known internalized string, contains backslashes or
     // unexpectedly reaches the end of string, return with an empty handle.
     uint32_t running_hash = isolate()->heap()->HashSeed();
     int position = position_;
     uc32 c0 = c0_;
     do {
       if (c0 == '\\') {
         c0_ = c0;
         int beg_pos = position_;
         position_ = position;
-        return SlowScanJsonString<SeqOneByteString, uint8_t>(source_,
-                                                             beg_pos,
+        return SlowScanJsonString<SeqOneByteString, uint8_t>(source_, beg_pos,
                                                              position_);
       }
       if (c0 < 0x20) return Handle<String>::null();
       if (static_cast<uint32_t>(c0) >
           unibrow::Utf16::kMaxNonSurrogateCharCode) {
-        running_hash =
-            StringHasher::AddCharacterCore(running_hash,
-                                           unibrow::Utf16::LeadSurrogate(c0));
-        running_hash =
-            StringHasher::AddCharacterCore(running_hash,
-                                           unibrow::Utf16::TrailSurrogate(c0));
+        running_hash = StringHasher::AddCharacterCore(
+            running_hash, unibrow::Utf16::LeadSurrogate(c0));
+        running_hash = StringHasher::AddCharacterCore(
+            running_hash, unibrow::Utf16::TrailSurrogate(c0));
       } else {
         running_hash = StringHasher::AddCharacterCore(running_hash, c0);
       }
       position++;
       if (position >= source_length_) return Handle<String>::null();
       c0 = seq_source_->SeqOneByteStringGet(position);
     } while (c0 != '"');
     int length = position - position_;
     uint32_t hash = (length <= String::kMaxHashCalcLength)
                         ? StringHasher::GetHashCore(running_hash)
                         : static_cast<uint32_t>(length);
-    Vector<const uint8_t> string_vector(
-        seq_source_->GetChars() + position_, length);
+    Vector<const uint8_t> string_vector(seq_source_->GetChars() + position_,
+                                        length);
     StringTable* string_table = isolate()->heap()->string_table();
     uint32_t capacity = string_table->Capacity();
     uint32_t entry = StringTable::FirstProbe(hash, capacity);
     uint32_t count = 1;
     Handle<String> result;
     while (true) {
       Object* element = string_table->KeyAt(entry);
       if (element == isolate()->heap()->undefined_value()) {
         // Lookup failure.
-        result = factory()->InternalizeOneByteString(
-            seq_source_, position_, length);
+        result =
+            factory()->InternalizeOneByteString(seq_source_, position_, length);
         break;
       }
       if (element != isolate()->heap()->the_hole_value() &&
           String::cast(element)->IsOneByteEqualTo(string_vector)) {
         result = Handle<String>(String::cast(element), isolate());
 #ifdef DEBUG
         uint32_t hash_field =
             (hash << String::kHashShift) | String::kIsNotArrayIndexMask;
         DCHECK_EQ(static_cast<int>(result->Hash()),
                   static_cast<int>(hash_field >> String::kHashShift));
@@ skipping 10 matching lines @@
 
   int beg_pos = position_;
   // Fast case for Latin1 only without escape characters.
   do {
     // Check for control character (0x00-0x1f) or unterminated string (<0).
     if (c0_ < 0x20) return Handle<String>::null();
     if (c0_ != '\\') {
       if (seq_one_byte || c0_ <= String::kMaxOneByteCharCode) {
         Advance();
       } else {
-        return SlowScanJsonString<SeqTwoByteString, uc16>(source_,
-                                                          beg_pos,
+        return SlowScanJsonString<SeqTwoByteString, uc16>(source_, beg_pos,
                                                           position_);
       }
     } else {
-      return SlowScanJsonString<SeqOneByteString, uint8_t>(source_,
-                                                           beg_pos,
+      return SlowScanJsonString<SeqOneByteString, uint8_t>(source_, beg_pos,
                                                            position_);
     }
   } while (c0_ != '"');
   int length = position_ - beg_pos;
   Handle<String> result =
       factory()->NewRawOneByteString(length, pretenure_).ToHandleChecked();
   uint8_t* dest = SeqOneByteString::cast(*result)->GetChars();
   String::WriteToFlat(*source_, dest, beg_pos, position_);
 
   DCHECK_EQ('"', c0_);
   // Advance past the last '"'.
   AdvanceSkipWhitespace();
   return result;
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_JSON_PARSER_H_