[runtime] Support Proxy setPrototypeOf trap

src/parsing/scanner.cc

 // 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.
 
 #include "src/parsing/scanner.h"
 
 #include <stdint.h>
 
@@ skipping 82 matching lines @@
   }
   return x;
 }
 
 
 // Ensure that tokens can be stored in a byte.
 STATIC_ASSERT(Token::NUM_TOKENS <= 0x100);
 
 // Table of one-character tokens, by character (0x00..0x7f only).
 static const byte one_char_tokens[] = {
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::LPAREN,       // 0x28
-  Token::RPAREN,       // 0x29
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::COMMA,        // 0x2c
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::COLON,        // 0x3a
-  Token::SEMICOLON,    // 0x3b
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::CONDITIONAL,  // 0x3f
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::LBRACK,     // 0x5b
-  Token::ILLEGAL,
-  Token::RBRACK,     // 0x5d
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::ILLEGAL,
-  Token::LBRACE,       // 0x7b
-  Token::ILLEGAL,
-  Token::RBRACE,       // 0x7d
-  Token::BIT_NOT,      // 0x7e
-  Token::ILLEGAL
-};
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::LPAREN,  // 0x28
+    Token::RPAREN,  // 0x29
+    Token::ILLEGAL,     Token::ILLEGAL,
+    Token::COMMA,  // 0x2c
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,
+    Token::COLON,      // 0x3a
+    Token::SEMICOLON,  // 0x3b
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL,
+    Token::CONDITIONAL,  // 0x3f
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL,
+    Token::LBRACK,  // 0x5b
+    Token::ILLEGAL,
+    Token::RBRACK,  // 0x5d
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,     Token::ILLEGAL, Token::ILLEGAL, Token::ILLEGAL,
+    Token::ILLEGAL,
+    Token::LBRACE,  // 0x7b
+    Token::ILLEGAL,
+    Token::RBRACE,   // 0x7d
+    Token::BIT_NOT,  // 0x7e
+    Token::ILLEGAL};
 
 
 Token::Value Scanner::Next() {
   if (next_.token == Token::EOS) {
     next_.location.beg_pos = current_.location.beg_pos;
     next_.location.end_pos = current_.location.end_pos;
   }
   current_ = next_;
   if (V8_UNLIKELY(next_next_.token != Token::UNINITIALIZED)) {
     next_ = next_next_;
@@ skipping 127 matching lines @@
   if (!name.is_one_byte()) return;
   Vector<const uint8_t> name_literal = name.one_byte_literal();
   LiteralBuffer* value;
   if (name_literal == STATIC_CHAR_VECTOR("sourceURL")) {
     value = &source_url_;
   } else if (name_literal == STATIC_CHAR_VECTOR("sourceMappingURL")) {
     value = &source_mapping_url_;
   } else {
     return;
   }
-  if (c0_ != '=')
-    return;
+  if (c0_ != '=') return;
   Advance();
   value->Reset();
   while (c0_ >= 0 && unicode_cache_->IsWhiteSpace(c0_)) {
     Advance();
   }
   while (c0_ >= 0 && !unicode_cache_->IsLineTerminator(c0_)) {
     // Disallowed characters.
     if (c0_ == '"' || c0_ == '\'') {
       value->Reset();
       return;
@@ skipping 70 matching lines @@
         Advance();
         token = Token::WHITESPACE;
         break;
 
       case '\n':
         Advance();
         has_line_terminator_before_next_ = true;
         token = Token::WHITESPACE;
         break;
 
-      case '"': case '\'':
+      case '"':
+      case '\'':
         token = ScanString();
         break;
 
       case '<':
         // < <= << <<= <!--
         Advance();
         if (c0_ == '=') {
           token = Select(Token::LTE);
         } else if (c0_ == '<') {
           token = Select('=', Token::ASSIGN_SHL, Token::SHL);
@@ skipping 258 matching lines @@
   if (!in_template_literal && c0_ >= 0 && unicode_cache_->IsLineTerminator(c)) {
     // Allow CR+LF newlines in multiline string literals.
     if (IsCarriageReturn(c) && IsLineFeed(c0_)) Advance<capture_raw>();
     // Allow LF+CR newlines in multiline string literals.
     if (IsLineFeed(c) && IsCarriageReturn(c0_)) Advance<capture_raw>();
     return true;
   }
 
   switch (c) {
     case '\'':  // fall through
-    case '"' :  // fall through
-    case '\\': break;
-    case 'b' : c = '\b'; break;
-    case 'f' : c = '\f'; break;
-    case 'n' : c = '\n'; break;
-    case 'r' : c = '\r'; break;
-    case 't' : c = '\t'; break;
-    case 'u' : {
+    case '"':   // fall through
+    case '\\':
+      break;
+    case 'b':
+      c = '\b';
+      break;
+    case 'f':
+      c = '\f';
+      break;
+    case 'n':
+      c = '\n';
+      break;
+    case 'r':
+      c = '\r';
+      break;
+    case 't':
+      c = '\t';
+      break;
+    case 'u': {
       c = ScanUnicodeEscape<capture_raw>();
       if (c < 0) return false;
       break;
     }
     case 'v':
       c = '\v';
       break;
     case 'x': {
       c = ScanHexNumber<capture_raw>(2);
       if (c < 0) return false;
@@ skipping 63 matching lines @@
       literal.Complete();
       Advance<false, false>();
       return Token::STRING;
     }
     uc32 c = c0_;
     if (c == '\\') break;
     Advance<false, false>();
     AddLiteralChar(c);
   }
 
-  while (c0_ != quote && c0_ >= 0
-         && !unicode_cache_->IsLineTerminator(c0_)) {
+  while (c0_ != quote && c0_ >= 0 && !unicode_cache_->IsLineTerminator(c0_)) {
     uc32 c = c0_;
     Advance();
     if (c == '\\') {
       if (c0_ < 0 || !ScanEscape<false, false>()) return Token::ILLEGAL;
     } else {
       AddLiteralChar(c);
     }
   }
   if (c0_ != quote) return Token::ILLEGAL;
   literal.Complete();
@@ skipping 87 matching lines @@
 
 
 Token::Value Scanner::ScanTemplateContinuation() {
   DCHECK_EQ(next_.token, Token::RBRACE);
   next_.location.beg_pos = source_pos() - 1;  // We already consumed }
   return ScanTemplateSpan();
 }
 
 
 void Scanner::ScanDecimalDigits() {
-  while (IsDecimalDigit(c0_))
-    AddLiteralCharAdvance();
+  while (IsDecimalDigit(c0_)) AddLiteralCharAdvance();
 }
 
 
 Token::Value Scanner::ScanNumber(bool seen_period) {
   DCHECK(IsDecimalDigit(c0_));  // the first digit of the number or the fraction
 
   enum { DECIMAL, HEX, OCTAL, IMPLICIT_OCTAL, BINARY } kind = DECIMAL;
 
   LiteralScope literal(this);
   bool at_start = !seen_period;
@@ skipping 43 matching lines @@
         }
       } else if ('0' <= c0_ && c0_ <= '7') {
         // (possible) octal number
         kind = IMPLICIT_OCTAL;
         while (true) {
           if (c0_ == '8' || c0_ == '9') {
             at_start = false;
             kind = DECIMAL;
             break;
           }
-          if (c0_  < '0' || '7'  < c0_) {
+          if (c0_ < '0' || '7' < c0_) {
             // Octal literal finished.
             octal_pos_ = Location(start_pos, source_pos());
             break;
           }
           AddLiteralCharAdvance();
         }
       }
     }
 
     // Parse decimal digits and allow trailing fractional part.
@@ skipping 26 matching lines @@
       }
     }
   }
 
   // scan exponent, if any
   if (c0_ == 'e' || c0_ == 'E') {
     DCHECK(kind != HEX);  // 'e'/'E' must be scanned as part of the hex number
     if (kind != DECIMAL) return Token::ILLEGAL;
     // scan exponent
     AddLiteralCharAdvance();
-    if (c0_ == '+' || c0_ == '-')
-      AddLiteralCharAdvance();
+    if (c0_ == '+' || c0_ == '-') AddLiteralCharAdvance();
     if (!IsDecimalDigit(c0_)) {
       // we must have at least one decimal digit after 'e'/'E'
       return Token::ILLEGAL;
     }
     ScanDecimalDigits();
   }
 
   // The source character immediately following a numeric literal must
   // not be an identifier start or a decimal digit; see ECMA-262
   // section 7.8.3, page 17 (note that we read only one decimal digit
@@ skipping 105 matching lines @@
 static Token::Value KeywordOrIdentifierToken(const uint8_t* input,
                                              int input_length, bool escaped) {
   DCHECK(input_length >= 1);
   const int kMinLength = 2;
   const int kMaxLength = 10;
   if (input_length < kMinLength || input_length > kMaxLength) {
     return Token::IDENTIFIER;
   }
   switch (input[0]) {
     default:
-#define KEYWORD_GROUP_CASE(ch)                                \
-      break;                                                  \
-    case ch:
+#define KEYWORD_GROUP_CASE(ch) \
+  break;                       \
+  case ch:
 #define KEYWORD(keyword, token)                                     \
   {                                                                 \
     /* 'keyword' is a char array, so sizeof(keyword) is */          \
     /* strlen(keyword) plus 1 for the NUL char. */                  \
     const int keyword_length = sizeof(keyword) - 1;                 \
     STATIC_ASSERT(keyword_length >= kMinLength);                    \
     STATIC_ASSERT(keyword_length <= kMaxLength);                    \
     if (input_length == keyword_length && input[1] == keyword[1] && \
         (keyword_length <= 2 || input[2] == keyword[2]) &&          \
         (keyword_length <= 3 || input[3] == keyword[3]) &&          \
         (keyword_length <= 4 || input[4] == keyword[4]) &&          \
         (keyword_length <= 5 || input[5] == keyword[5]) &&          \
         (keyword_length <= 6 || input[6] == keyword[6]) &&          \
         (keyword_length <= 7 || input[7] == keyword[7]) &&          \
         (keyword_length <= 8 || input[8] == keyword[8]) &&          \
         (keyword_length <= 9 || input[9] == keyword[9])) {          \
       if (escaped) {                                                \
         return token == Token::FUTURE_STRICT_RESERVED_WORD          \
                    ? Token::ESCAPED_STRICT_RESERVED_WORD            \
                    : Token::ESCAPED_KEYWORD;                        \
       }                                                             \
       return token;                                                 \
     }                                                               \
   }
-    KEYWORDS(KEYWORD_GROUP_CASE, KEYWORD)
+      KEYWORDS(KEYWORD_GROUP_CASE, KEYWORD)
   }
   return Token::IDENTIFIER;
 }
 
 
 bool Scanner::IdentifierIsFutureStrictReserved(
     const AstRawString* string) const {
   // Keywords are always 1-byte strings.
   if (!string->is_one_byte()) return false;
   if (string->IsOneByteEqualTo("let") || string->IsOneByteEqualTo("static") ||
@@ skipping 48 matching lines @@
     if (c0_ <= kMaxAscii && c0_ != '\\') {
       literal.Complete();
       return Token::IDENTIFIER;
     }
 
     HandleLeadSurrogate();
   } else if (c0_ == '\\') {
     // Scan identifier start character.
     uc32 c = ScanIdentifierUnicodeEscape();
     // Only allow legal identifier start characters.
-    if (c < 0 ||
-        c == '\\' ||  // No recursive escapes.
+    if (c < 0 || c == '\\' ||  // No recursive escapes.
         !unicode_cache_->IsIdentifierStart(c)) {
       return Token::ILLEGAL;
     }
     AddLiteralChar(c);
     return ScanIdentifierSuffix(&literal, true);
   } else {
     uc32 first_char = c0_;
     Advance();
     AddLiteralChar(first_char);
   }
@@ skipping 21 matching lines @@
 
 
 Token::Value Scanner::ScanIdentifierSuffix(LiteralScope* literal,
                                            bool escaped) {
   // Scan the rest of the identifier characters.
   while (c0_ >= 0 && unicode_cache_->IsIdentifierPart(c0_)) {
     if (c0_ == '\\') {
       uc32 c = ScanIdentifierUnicodeEscape();
       escaped = true;
       // Only allow legal identifier part characters.
-      if (c < 0 ||
-          c == '\\' ||
-          !unicode_cache_->IsIdentifierPart(c)) {
+      if (c < 0 || c == '\\' || !unicode_cache_->IsIdentifierPart(c)) {
         return Token::ILLEGAL;
       }
       AddLiteralChar(c);
     } else {
       AddLiteralChar(c0_);
       Advance();
     }
   }
   literal->Complete();
 
@@ skipping 111 matching lines @@
   if (is_raw_literal_one_byte()) {
     return ast_value_factory->GetOneByteString(raw_literal_one_byte_string());
   }
   return ast_value_factory->GetTwoByteString(raw_literal_two_byte_string());
 }
 
 
 double Scanner::DoubleValue() {
   DCHECK(is_literal_one_byte());
   return StringToDouble(
-      unicode_cache_,
-      literal_one_byte_string(),
+      unicode_cache_, literal_one_byte_string(),
       ALLOW_HEX | ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL | ALLOW_BINARY);
 }
 
 
 bool Scanner::ContainsDot() {
   DCHECK(is_literal_one_byte());
   Vector<const uint8_t> str = literal_one_byte_string();
   return std::find(str.begin(), str.end(), '.') != str.end();
 }
 
@@ skipping 59 matching lines @@
 int DuplicateFinder::AddOneByteSymbol(Vector<const uint8_t> key, int value) {
   return AddSymbol(key, true, value);
 }
 
 
 int DuplicateFinder::AddTwoByteSymbol(Vector<const uint16_t> key, int value) {
   return AddSymbol(Vector<const uint8_t>::cast(key), false, value);
 }
 
 
-int DuplicateFinder::AddSymbol(Vector<const uint8_t> key,
-                               bool is_one_byte,
+int DuplicateFinder::AddSymbol(Vector<const uint8_t> key, bool is_one_byte,
                                int value) {
   uint32_t hash = Hash(key, is_one_byte);
   byte* encoding = BackupKey(key, is_one_byte);
   HashMap::Entry* entry = map_.LookupOrInsert(encoding, hash);
   int old_value = static_cast<int>(reinterpret_cast<intptr_t>(entry->value));
   entry->value =
-    reinterpret_cast<void*>(static_cast<intptr_t>(value | old_value));
+      reinterpret_cast<void*>(static_cast<intptr_t>(value | old_value));
   return old_value;
 }
 
 
 int DuplicateFinder::AddNumber(Vector<const uint8_t> key, int value) {
   DCHECK(key.length() > 0);
   // Quick check for already being in canonical form.
   if (IsNumberCanonical(key)) {
     return AddOneByteSymbol(key, value);
   }
 
   int flags = ALLOW_HEX | ALLOW_OCTAL | ALLOW_IMPLICIT_OCTAL | ALLOW_BINARY;
-  double double_value = StringToDouble(
-      unicode_constants_, key, flags, 0.0);
+  double double_value = StringToDouble(unicode_constants_, key, flags, 0.0);
   int length;
   const char* string;
   if (!std::isfinite(double_value)) {
     string = "Infinity";
     length = 8;  // strlen("Infinity");
   } else {
     string = DoubleToCString(double_value,
                              Vector<char>(number_buffer_, kBufferSize));
     length = StrLength(string);
   }
-  return AddSymbol(Vector<const byte>(reinterpret_cast<const byte*>(string),
-                                      length), true, value);
+  return AddSymbol(
+      Vector<const byte>(reinterpret_cast<const byte*>(string), length), true,
+      value);
 }
 
 
 bool DuplicateFinder::IsNumberCanonical(Vector<const uint8_t> number) {
   // Test for a safe approximation of number literals that are already
   // in canonical form: max 15 digits, no leading zeroes, except an
   // integer part that is a single zero, and no trailing zeros below
   // the decimal point.
   int pos = 0;
   int length = number.length();
   if (number.length() > 15) return false;
   if (number[pos] == '0') {
     pos++;
   } else {
     while (pos < length &&
-           static_cast<unsigned>(number[pos] - '0') <= ('9' - '0')) pos++;
+           static_cast<unsigned>(number[pos] - '0') <= ('9' - '0'))
+      pos++;
   }
   if (length == pos) return true;
   if (number[pos] != '.') return false;
   pos++;
   bool invalid_last_digit = true;
   while (pos < length) {
     uint8_t digit = number[pos] - '0';
     if (digit > '9' - '0') return false;
     invalid_last_digit = (digit == 0);
     pos++;
@@ skipping 47 matching lines @@
   if (one_byte_length >= (1 << 7)) {
     if (one_byte_length >= (1 << 14)) {
       if (one_byte_length >= (1 << 21)) {
         if (one_byte_length >= (1 << 28)) {
           backing_store_.Add(
               static_cast<uint8_t>((one_byte_length >> 28) | 0x80));
         }
         backing_store_.Add(
             static_cast<uint8_t>((one_byte_length >> 21) | 0x80u));
       }
-      backing_store_.Add(
-          static_cast<uint8_t>((one_byte_length >> 14) | 0x80u));
+      backing_store_.Add(static_cast<uint8_t>((one_byte_length >> 14) | 0x80u));
     }
     backing_store_.Add(static_cast<uint8_t>((one_byte_length >> 7) | 0x80u));
   }
   backing_store_.Add(static_cast<uint8_t>(one_byte_length & 0x7f));
 
   backing_store_.AddBlock(bytes);
   return backing_store_.EndSequence().start();
 }
 
 }  // namespace internal
 }  // namespace v8