Thread/Isolate refactoring: new(Isolate) -> new(Zone)

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 {
 
 DEFINE_FLAG(bool, print_tokens, false, "Print scanned tokens.");
 
 
-// Quick access to the locally defined isolate() method.
-#define I (isolate())
+// Quick access to the locally defined zone() method.
+#define Z (zone())
 
 
 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_) {}
 
@@ skipping 43 matching lines @@
   ReadChar();
 }
 
 
 Scanner::Scanner(const String& src, const String& private_key)
     : source_(src),
       source_length_(src.Length()),
       saved_context_(NULL),
       private_key_(String::ZoneHandle(private_key.raw())),
       char_at_func_(src.CharAtFunc()),
-      isolate_(Isolate::Current()) {
+      zone_(Thread::Current()->zone()) {
   Reset();
 }
 
 
 Scanner::~Scanner() {}
 
 
 void Scanner::ErrorMsg(const char* msg) {
   current_token_.kind = Token::kERROR;
-  current_token_.literal = &String::ZoneHandle(I, Symbols::New(msg));
+  current_token_.literal = &String::ZoneHandle(Z, Symbols::New(msg));
   current_token_.position = c0_pos_;
   token_start_ = lookahead_pos_;
   current_token_.offset = lookahead_pos_;
 }
 
 
 void Scanner::PushContext() {
-  ScanContext* ctx = new(I) 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 206 matching lines @@
           return;
         }
       }
       i++;
     }
   }
 
   // We did not read a keyword.
   current_token_.kind = Token::kIDENT;
   String& literal =
-      String::ZoneHandle(I, Symbols::New(source_, ident_pos, ident_length));
+      String::ZoneHandle(Z, Symbols::New(source_, ident_pos, ident_length));
   if (ident_char0 == Library::kPrivateIdentifierStart) {
     // Private identifiers are mangled on a per library basis.
     literal = String::Concat(literal, private_key_);
     literal = Symbols::New(literal);
   }
   current_token_.literal = &literal;
 }
 
 
 // Parse integer or double number literal of format:
@@ skipping 37 matching lines @@
         ErrorMsg("missing exponent digits");
         return;
       }
       while (IsDecimalDigit(c0_)) {
         ReadChar();
       }
     }
   }
   if (current_token_.kind != Token::kILLEGAL) {
     intptr_t len = lookahead_pos_ - token_start_;
-    String& str = String::ZoneHandle(I,
+    String& str = String::ZoneHandle(Z,
         String::SubString(source_, token_start_, len, Heap::kOld));
     str = Symbols::New(str);
     current_token_.literal = &str;
   }
 }
 
 
 void Scanner::SkipLine() {
   while (c0_ != '\n' && c0_ != '\0') {
     ReadChar();
@@ skipping 134 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(I,
+      current_token_.literal = &String::ZoneHandle(Z,
           Symbols::FromUTF32(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_) {
           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(I,
+          current_token_.literal = &String::ZoneHandle(Z,
               Symbols::FromUTF32(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.
@@ skipping 344 matching lines @@
          (current_token_.kind == Token::kINTERPOL_START))) {
           index++;  // Advance the index to account for tokens added in ScanAll.
     }
     index++;
     prev_token_line_ = current_token_.position.line;
   } while ((token_index >= index) && (current_token_.kind != Token::kEOS));
 }
 
 
 const Scanner::GrowableTokenStream& Scanner::GetStream() {
-  GrowableTokenStream* ts = new(I) GrowableTokenStream(128);
+  GrowableTokenStream* ts = new(Z) GrowableTokenStream(128);
   ScanAll(ts);
   if (FLAG_print_tokens) {
     Scanner::PrintTokens(*ts);
   }
   return *ts;
 }
 
 
 void Scanner::PrintTokens(const GrowableTokenStream& ts) {
   int currentLine = -1;
@@ skipping 22 matching lines @@
     keywords_[i].keyword_symbol = &Symbols::Keyword(token);
 
     int ch = keywords_[i].keyword_chars[0] - 'a';
     if (keywords_char_offset_[ch] == Token::kNumKeywords) {
       keywords_char_offset_[ch] = i;
     }
   }
 }
 
 }  // namespace dart