- Refactor Symbol allocation to expect a thread parameter.

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 zone() method.
+// 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_) {}
 
@@ 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()),
-      zone_(Thread::Current()->zone()) {
+      thread_(Thread::Current()),
+      zone_(thread_->zone()) {
   Reset();
 }
 
 
 Scanner::~Scanner() {}
 
 
 void Scanner::ErrorMsg(const char* msg) {
   current_token_.kind = Token::kERROR;
-  current_token_.literal = &String::ZoneHandle(Z, Symbols::New(msg));
+  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);
   saved_context_ = ctx;
   string_delimiter_ = '\0';
@@ skipping 214 matching lines @@
           return;
         }
       }
       i++;
     }
   }
 
   // We did not read a keyword.
   current_token_.kind = Token::kIDENT;
   String& literal =
-      String::ZoneHandle(Z, Symbols::New(source_, ident_pos, ident_length));
+      String::ZoneHandle(Z, Symbols::New(T, source_, ident_pos, ident_length));
   if (ident_char0 == Library::kPrivateIdentifierStart) {
     // Private identifiers are mangled on a per library basis.
-    literal = Symbols::FromConcat(literal, private_key_);
+    literal = Symbols::FromConcat(T, literal, private_key_);
   }
   current_token_.literal = &literal;
 }
 
 
 // Parse integer or double number literal of format:
 // NUMBER = INTEGER | DOUBLE
 // INTEGER = D+ | (("0x" | "0X") H+)
 // DOUBLE = ((D+ ["." D*]) | ("." D+)) [ EXPONENT ]
 // EXPONENT = ("e" | "E") ["+" | "-"] D+
@@ skipping 34 matching lines @@
         return;
       }
       while (IsDecimalDigit(c0_)) {
         ReadChar();
       }
     }
   }
   if (current_token_.kind != Token::kILLEGAL) {
     intptr_t len = lookahead_pos_ - token_start_;
     const String& str =
-        String::ZoneHandle(Z, Symbols::New(source_, token_start_, len));
+        String::ZoneHandle(Z, Symbols::New(T, source_, token_start_, len));
     current_token_.literal = &str;
   }
 }
 
 
 void Scanner::SkipLine() {
   while (c0_ != '\n' && c0_ != '\0') {
     ReadChar();
   }
 }
@@ skipping 133 matching lines @@
           }
           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(string_chars.data(), string_chars.length()));
+          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_) {
           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(string_chars.data(), string_chars.length()));
+              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 386 matching lines @@
 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::Keyword(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