clang-format runtime/vm

runtime/vm/scanner.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/scanner.h"
 
 #include "platform/assert.h"
 #include "vm/dart.h"
 #include "vm/flags.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/symbols.h"
 #include "vm/token.h"
 #include "vm/unicode.h"
 
 namespace dart {
 
 // Quick access to the locally defined zone() and thread() methods.
 #define Z (zone())
 #define T (thread())
 
 
 class ScanContext : public ZoneAllocated {
  public:
   explicit ScanContext(Scanner* scanner)
-      :  next_(scanner->saved_context_),
-         string_delimiter_(scanner->string_delimiter_),
-         string_is_multiline_(scanner->string_is_multiline_),
-         brace_level_(scanner->brace_level_) {}
+      : next_(scanner->saved_context_),
+        string_delimiter_(scanner->string_delimiter_),
+        string_is_multiline_(scanner->string_is_multiline_),
+        brace_level_(scanner->brace_level_) {}
 
   void CopyTo(Scanner* scanner) {
     scanner->string_delimiter_ = string_delimiter_;
     scanner->string_is_multiline_ = string_is_multiline_;
     scanner->brace_level_ = brace_level_;
   }
 
   ScanContext* next() const { return next_; }
 
  private:
@@ skipping 53 matching lines @@
 void Scanner::ErrorMsg(const char* msg) {
   current_token_.kind = Token::kERROR;
   current_token_.literal = &String::ZoneHandle(Z, Symbols::New(T, msg));
   current_token_.position = c0_pos_;
   token_start_ = lookahead_pos_;
   current_token_.offset = lookahead_pos_;
 }
 
 
 void Scanner::PushContext() {
-  ScanContext* ctx = new(Z) ScanContext(this);
+  ScanContext* ctx = new (Z) ScanContext(this);
   saved_context_ = ctx;
   string_delimiter_ = '\0';
   string_is_multiline_ = false;
   brace_level_ = 1;  // Account for the opening ${ token.
 }
 
 
 void Scanner::PopContext() {
   ASSERT(saved_context_ != NULL);
   ASSERT(brace_level_ == 0);
@@ skipping 25 matching lines @@
   return '0' <= c && c <= '9';
 }
 
 
 bool Scanner::IsNumberStart(int32_t ch) {
   return IsDecimalDigit(ch) || ch == '.';
 }
 
 
 bool Scanner::IsHexDigit(int32_t c) {
-  return IsDecimalDigit(c)
-         || (('A' <= c) && (c <= 'F'))
-         || (('a' <= c) && (c <= 'f'));
+  return IsDecimalDigit(c) || (('A' <= c) && (c <= 'F')) ||
+         (('a' <= c) && (c <= 'f'));
 }
 
 
 bool Scanner::IsIdentStartChar(int32_t c) {
   return IsLetter(c) || (c == '_') || (c == '$');
 }
 
 
 bool Scanner::IsIdentChar(int32_t c) {
   return IsLetter(c) || IsDecimalDigit(c) || (c == '_') || (c == '$');
 }
 
 
 bool Scanner::IsIdent(const String& str) {
   if (!str.IsOneByteString()) {
     return false;
   }
   if (str.Length() == 0 || !IsIdentStartChar(CallCharAt()(str, 0))) {
     return false;
   }
-  for (int i =  1; i < str.Length(); i++) {
+  for (int i = 1; i < str.Length(); i++) {
     if (!IsIdentChar(CallCharAt()(str, i))) {
       return false;
     }
   }
   return true;
 }
 
 
 // This method is used when parsing integers in Dart code. We
 // are reusing the Scanner's handling of number literals in that situation.
 bool Scanner::IsValidInteger(const String& str,
                              bool* is_positive,
                              const String** value) {
   Scanner s(str, Symbols::Empty());
   TokenDescriptor tokens[3];
   s.Scan();
   tokens[0] = s.current_token();
   s.Scan();
   tokens[1] = s.current_token();
   s.Scan();
   tokens[2] = s.current_token();
 
-  if ((tokens[0].kind == Token::kINTEGER) &&
-      (tokens[1].kind == Token::kEOS)) {
+  if ((tokens[0].kind == Token::kINTEGER) && (tokens[1].kind == Token::kEOS)) {
     *is_positive = true;
     *value = tokens[0].literal;
     return true;
   }
-  if (((tokens[0].kind == Token::kADD) ||
-       (tokens[0].kind == Token::kSUB)) &&
-      (tokens[1].kind == Token::kINTEGER) &&
-      (tokens[2].kind == Token::kEOS)) {
+  if (((tokens[0].kind == Token::kADD) || (tokens[0].kind == Token::kSUB)) &&
+      (tokens[1].kind == Token::kINTEGER) && (tokens[2].kind == Token::kEOS)) {
     // Check there is no space between "+/-" and number.
     if ((tokens[0].offset + 1) != tokens[1].offset) {
       return false;
     }
     *is_positive = tokens[0].kind == Token::kADD;
     *value = tokens[1].literal;
     return true;
   }
   return false;
 }
@@ skipping 69 matching lines @@
       ReadChar();  // Consume asterisk.
     } else if (c == '*' && c0_ == '/') {
       nesting_level--;
       ReadChar();  // Consume slash.
       if (nesting_level == 0) {
         break;
       }
     }
   }
   current_token_.kind =
-    (nesting_level == 0) ? Token::kWHITESP : Token::kILLEGAL;
+      (nesting_level == 0) ? Token::kWHITESP : Token::kILLEGAL;
 }
 
 
 void Scanner::ScanIdentChars(bool allow_dollar) {
   ASSERT(IsIdentStartChar(c0_));
   ASSERT(allow_dollar || (c0_ != '$'));
   int ident_length = 0;
   int ident_pos = lookahead_pos_;
   int32_t ident_char0 = CallCharAt()(source_, ident_pos);
   while (IsIdentChar(c0_) && (allow_dollar || (c0_ != '$'))) {
     ReadChar();
     ident_length++;
   }
 
   // Check whether the characters we read are a known keyword.
   // Note, can't use strcmp since token_chars is not null-terminated.
   if (('a' <= ident_char0) && (ident_char0 <= 'z')) {
     int i = keywords_char_offset_[ident_char0 - 'a'];
     while ((i < Token::kNumKeywords) &&
            (keywords_[i].keyword_chars[0] <= ident_char0)) {
       if (keywords_[i].keyword_len == ident_length) {
         const char* keyword = keywords_[i].keyword_chars;
         int char_pos = 1;
         while ((char_pos < ident_length) &&
                (keyword[char_pos] ==
-                   CallCharAt()(source_, ident_pos + char_pos))) {
+                CallCharAt()(source_, ident_pos + char_pos))) {
           char_pos++;
         }
         if (char_pos == ident_length) {
           current_token_.literal = keywords_[i].keyword_symbol;
           current_token_.kind = keywords_[i].kind;
           return;
         }
       }
       i++;
     }
@@ skipping 36 matching lines @@
     while (IsDecimalDigit(c0_)) {
       ReadChar();
     }
     if (c0_ == '.' && !dec_point_seen && IsDecimalDigit(LookaheadChar(1))) {
       Recognize(Token::kDOUBLE);
       while (IsDecimalDigit(c0_)) {
         ReadChar();
       }
     }
     if (((c0_ == 'e') || (c0_ == 'E')) &&
-        (IsDecimalDigit(LookaheadChar(1)) ||
-         (LookaheadChar(1) == '-') ||
+        (IsDecimalDigit(LookaheadChar(1)) || (LookaheadChar(1) == '-') ||
          (LookaheadChar(1) == '+'))) {
       Recognize(Token::kDOUBLE);
       if ((c0_ == '-') || (c0_ == '+')) {
         ReadChar();
       }
       if (!IsDecimalDigit(c0_)) {
         ErrorMsg("missing exponent digits");
         return;
       }
       while (IsDecimalDigit(c0_)) {
@@ skipping 148 matching lines @@
             return;
           }
           escape_char = c0_;
           break;
       }
       string_chars.Add(escape_char);
     } else if (c0_ == '$' && !is_raw) {
       // Scanned a string piece.
       ASSERT(string_chars.data() != NULL);
       // Strings are canonicalized: Allocate a symbol.
-      current_token_.literal = &String::ZoneHandle(Z,
-          Symbols::FromUTF32(T, string_chars.data(), string_chars.length()));
+      current_token_.literal = &String::ZoneHandle(
+          Z, Symbols::FromUTF32(T, string_chars.data(), string_chars.length()));
       // Preserve error tokens.
       if (current_token_.kind != Token::kERROR) {
         current_token_.kind = Token::kSTRING;
       }
       return;
     } else if (c0_ == string_delimiter_) {
       // Check if we are at the end of the string literal.
-      if (!string_is_multiline_ ||
-          ((LookaheadChar(1) == string_delimiter_) &&
-           (LookaheadChar(2) == string_delimiter_))) {
+      if (!string_is_multiline_ || ((LookaheadChar(1) == string_delimiter_) &&
+                                    (LookaheadChar(2) == string_delimiter_))) {
         if (string_is_multiline_) {
           ReadChar();  // Skip two string delimiters.
           ReadChar();
         }
         // Preserve error tokens.
         if (current_token_.kind == Token::kERROR) {
           ReadChar();
         } else {
           Recognize(Token::kSTRING);
           ASSERT(string_chars.data() != NULL);
           // Strings are canonicalized: Allocate a symbol.
-          current_token_.literal = &String::ZoneHandle(Z,
-              Symbols::FromUTF32(T,
-                                 string_chars.data(), string_chars.length()));
+          current_token_.literal =
+              &String::ZoneHandle(Z, Symbols::FromUTF32(T, string_chars.data(),
+                                                        string_chars.length()));
         }
         EndStringLiteral();
         return;
       } else {
         string_chars.Add(string_delimiter_);
       }
     } else {
       // Test for a two part utf16 sequence, and decode to a code point
       // if we find one.
       int32_t ch1 = c0_;
@@ skipping 287 matching lines @@
       default:
         if (IsIdentStartChar(c0_)) {
           ScanIdent();
         } else if (IsDecimalDigit(c0_)) {
           ScanNumber(false);
         } else {
           char msg[128];
           char utf8_char[5];
           int len = Utf8::Encode(c0_, utf8_char);
           utf8_char[len] = '\0';
-          OS::SNPrint(msg, sizeof(msg),
-                      "unexpected character: '%s' (U+%04X)\n", utf8_char, c0_);
+          OS::SNPrint(msg, sizeof(msg), "unexpected character: '%s' (U+%04X)\n",
+                      utf8_char, c0_);
           ErrorMsg(msg);
           ReadChar();
         }
     }
   } while (current_token_.kind == Token::kWHITESP);
 }
 
 
 void Scanner::ScanAll(TokenCollector* collector) {
   Reset();
   do {
     Scan();
     bool inserted_new_lines = false;
     for (intptr_t diff = current_token_.position.line - prev_token_line_;
-         diff > 0;
-         diff--) {
+         diff > 0; diff--) {
       newline_token_.position.line = current_token_.position.line - diff;
       collector->AddToken(newline_token_);
       inserted_new_lines = true;
     }
     if (inserted_new_lines &&
         ((current_token_.kind == Token::kINTERPOL_VAR) ||
          (current_token_.kind == Token::kINTERPOL_START))) {
-          // NOTE: If this changes, be sure to update
-          // Script::GenerateLineNumberArray to stay in sync.
-          empty_string_token_.position.line = current_token_.position.line;
-          collector->AddToken(empty_string_token_);
-        }
+      // NOTE: If this changes, be sure to update
+      // Script::GenerateLineNumberArray to stay in sync.
+      empty_string_token_.position.line = current_token_.position.line;
+      collector->AddToken(empty_string_token_);
+    }
     collector->AddToken(current_token_);
     prev_token_line_ = current_token_.position.line;
   } while (current_token_.kind != Token::kEOS);
 }
 
 
 void Scanner::ScanTo(intptr_t token_index) {
   ASSERT(token_index >= 0);
   intptr_t index = 0;
   Reset();
   do {
     Scan();
     bool inserted_new_lines = false;
     for (intptr_t diff = current_token_.position.line - prev_token_line_;
-         diff > 0;
-         diff--) {
+         diff > 0; diff--) {
       // Advance the index to account for tokens added in ScanAll.
       index++;
       inserted_new_lines = true;
     }
     if (inserted_new_lines &&
         ((current_token_.kind == Token::kINTERPOL_VAR) ||
          (current_token_.kind == Token::kINTERPOL_START))) {
-          // Advance the index to account for tokens added in ScanAll.
-          index++;
+      // Advance the index to account for tokens added in ScanAll.
+      index++;
     }
     index++;
     prev_token_line_ = current_token_.position.line;
   } while ((token_index >= index) && (current_token_.kind != Token::kEOS));
 }
 
 
 void Scanner::InitOnce() {
   ASSERT(Isolate::Current() == Dart::vm_isolate());
   for (int i = 0; i < kNumLowercaseChars; i++) {
     keywords_char_offset_[i] = Token::kNumKeywords;
   }
   for (int i = 0; i < Token::kNumKeywords; i++) {
     Token::Kind token = static_cast<Token::Kind>(Token::kFirstKeyword + i);
     keywords_[i].kind = token;
     keywords_[i].keyword_chars = Token::Str(token);
     keywords_[i].keyword_len = strlen(Token::Str(token));
     keywords_[i].keyword_symbol = &Symbols::Token(token);
 
     int ch = keywords_[i].keyword_chars[0] - 'a';
     if (keywords_char_offset_[ch] == Token::kNumKeywords) {
       keywords_char_offset_[ch] = i;
     }
   }
 }
 
 }  // namespace dart