[runtime] Support Proxy setPrototypeOf trap

src/parsing/scanner.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.
 
 // Features shared by parsing and pre-parsing scanners.
 
 #ifndef V8_PARSING_SCANNER_H_
 #define V8_PARSING_SCANNER_H_
 
 #include "src/allocation.h"
@@ skipping 28 matching lines @@
 }
 
 
 // ---------------------------------------------------------------------
 // Buffered stream of UTF-16 code units, using an internal UTF-16 buffer.
 // A code unit is a 16 bit value representing either a 16 bit code point
 // or one part of a surrogate pair that make a single 21 bit code point.
 
 class Utf16CharacterStream {
  public:
-  Utf16CharacterStream() : pos_(0) { }
-  virtual ~Utf16CharacterStream() { }
+  Utf16CharacterStream() : pos_(0) {}
+  virtual ~Utf16CharacterStream() {}
 
   // Returns and advances past the next UTF-16 code unit in the input
   // stream. If there are no more code units, it returns a negative
   // value.
   inline uc32 Advance() {
     if (buffer_cursor_ < buffer_end_ || ReadBlock()) {
       pos_++;
       return static_cast<uc32>(*(buffer_cursor_++));
     }
     // Note: currently the following increment is necessary to avoid a
@@ skipping 47 matching lines @@
   size_t pos_;
 };
 
 
 // ---------------------------------------------------------------------
 // DuplicateFinder discovers duplicate symbols.
 
 class DuplicateFinder {
  public:
   explicit DuplicateFinder(UnicodeCache* constants)
-      : unicode_constants_(constants),
-        backing_store_(16),
-        map_(&Match) { }
+      : unicode_constants_(constants), backing_store_(16), map_(&Match) {}
 
   int AddOneByteSymbol(Vector<const uint8_t> key, int value);
   int AddTwoByteSymbol(Vector<const uint16_t> key, int value);
   // Add a a number literal by converting it (if necessary)
   // to the string that ToString(ToNumber(literal)) would generate.
   // and then adding that string with AddOneByteSymbol.
   // This string is the actual value used as key in an object literal,
   // and the one that must be different from the other keys.
   int AddNumber(Vector<const uint8_t> key, int value);
 
@@ skipping 26 matching lines @@
   // Buffer used for string->number->canonical string conversions.
   char number_buffer_[kBufferSize];
 };
 
 
 // ----------------------------------------------------------------------------
 // LiteralBuffer -  Collector of chars of literals.
 
 class LiteralBuffer {
  public:
-  LiteralBuffer() : is_one_byte_(true), position_(0), backing_store_() { }
+  LiteralBuffer() : is_one_byte_(true), position_(0), backing_store_() {}
 
   ~LiteralBuffer() { backing_store_.Dispose(); }
 
   INLINE(void AddChar(uint32_t code_unit)) {
     if (position_ >= backing_store_.length()) ExpandBuffer();
     if (is_one_byte_) {
       if (code_unit <= unibrow::Latin1::kMaxChar) {
         backing_store_[position_] = static_cast<byte>(code_unit);
         position_ += kOneByteSize;
         return;
@@ skipping 11 matching lines @@
       *reinterpret_cast<uint16_t*>(&backing_store_[position_]) =
           unibrow::Utf16::TrailSurrogate(code_unit);
       position_ += kUC16Size;
     }
   }
 
   bool is_one_byte() const { return is_one_byte_; }
 
   bool is_contextual_keyword(Vector<const char> keyword) const {
     return is_one_byte() && keyword.length() == position_ &&
-        (memcmp(keyword.start(), backing_store_.start(), position_) == 0);
+           (memcmp(keyword.start(), backing_store_.start(), position_) == 0);
   }
 
   Vector<const uint16_t> two_byte_literal() const {
     DCHECK(!is_one_byte_);
     DCHECK((position_ & 0x1) == 0);
     return Vector<const uint16_t>(
         reinterpret_cast<const uint16_t*>(backing_store_.start()),
         position_ >> 1);
   }
 
   Vector<const uint8_t> one_byte_literal() const {
     DCHECK(is_one_byte_);
     return Vector<const uint8_t>(
-        reinterpret_cast<const uint8_t*>(backing_store_.start()),
-        position_);
+        reinterpret_cast<const uint8_t*>(backing_store_.start()), position_);
   }
 
-  int length() const {
-    return is_one_byte_ ? position_ : (position_ >> 1);
-  }
+  int length() const { return is_one_byte_ ? position_ : (position_ >> 1); }
 
   void ReduceLength(int delta) {
     position_ -= delta * (is_one_byte_ ? kOneByteSize : kUC16Size);
   }
 
   void Reset() {
     position_ = 0;
     is_one_byte_ = true;
   }
 
@@ skipping 65 matching lines @@
 
 class Scanner {
  public:
   // Scoped helper for literal recording. Automatically drops the literal
   // if aborting the scanning before it's complete.
   class LiteralScope {
    public:
     explicit LiteralScope(Scanner* self) : scanner_(self), complete_(false) {
       scanner_->StartLiteral();
     }
-     ~LiteralScope() {
-       if (!complete_) scanner_->DropLiteral();
-     }
-    void Complete() {
-      complete_ = true;
+    ~LiteralScope() {
+      if (!complete_) scanner_->DropLiteral();
     }
+    void Complete() { complete_ = true; }
 
    private:
     Scanner* scanner_;
     bool complete_;
   };
 
   // Scoped helper for a re-settable bookmark.
   class BookmarkScope {
    public:
     explicit BookmarkScope(Scanner* scanner) : scanner_(scanner) {
       DCHECK_NOT_NULL(scanner_);
     }
     ~BookmarkScope() { scanner_->DropBookmark(); }
 
     bool Set() { return scanner_->SetBookmark(); }
     void Reset() { scanner_->ResetToBookmark(); }
     bool HasBeenSet() { return scanner_->BookmarkHasBeenSet(); }
     bool HasBeenReset() { return scanner_->BookmarkHasBeenReset(); }
 
    private:
     Scanner* scanner_;
 
     DISALLOW_COPY_AND_ASSIGN(BookmarkScope);
   };
 
   // Representation of an interval of source positions.
   struct Location {
-    Location(int b, int e) : beg_pos(b), end_pos(e) { }
-    Location() : beg_pos(0), end_pos(0) { }
+    Location(int b, int e) : beg_pos(b), end_pos(e) {}
+    Location() : beg_pos(0), end_pos(0) {}
 
-    bool IsValid() const {
-      return beg_pos >= 0 && end_pos >= beg_pos;
-    }
+    bool IsValid() const { return beg_pos >= 0 && end_pos >= beg_pos; }
 
     static Location invalid() { return Location(-1, -1); }
 
     int beg_pos;
     int end_pos;
   };
 
   // -1 is outside of the range of any real source code.
   static const int kNoOctalLocation = -1;
 
@@ skipping 33 matching lines @@
     return next_.literal_chars->is_contextual_keyword(keyword);
   }
 
   const AstRawString* CurrentSymbol(AstValueFactory* ast_value_factory);
   const AstRawString* NextSymbol(AstValueFactory* ast_value_factory);
   const AstRawString* CurrentRawSymbol(AstValueFactory* ast_value_factory);
 
   double DoubleValue();
   bool ContainsDot();
   bool LiteralMatches(const char* data, int length, bool allow_escapes = true) {
-    if (is_literal_one_byte() &&
-        literal_length() == length &&
+    if (is_literal_one_byte() && literal_length() == length &&
         (allow_escapes || !literal_contains_escapes())) {
       const char* token =
           reinterpret_cast<const char*>(literal_one_byte_string().start());
       return !strncmp(token, data, length);
     }
     return false;
   }
   inline bool UnescapedLiteralMatches(const char* data, int length) {
     return LiteralMatches(data, length, false);
   }
 
   void IsGetOrSet(bool* is_get, bool* is_set) {
-    if (is_literal_one_byte() &&
-        literal_length() == 3 &&
+    if (is_literal_one_byte() && literal_length() == 3 &&
         !literal_contains_escapes()) {
       const char* token =
           reinterpret_cast<const char*>(literal_one_byte_string().start());
       *is_get = strncmp(token, "get", 3) == 0;
       *is_set = !*is_get && strncmp(token, "set", 3) == 0;
     }
   }
 
   int FindSymbol(DuplicateFinder* finder, int value);
 
@@ skipping 339 matching lines @@
   bool has_line_terminator_before_next_;
   // Whether there is a multi-line comment that contains a
   // line-terminator after the current token, and before the next.
   bool has_multiline_comment_before_next_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_SCANNER_H_