Create frequently used symbols in the vm isolate

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/flags.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
+#include "vm/symbols.h"
 #include "vm/thread.h"
 #include "vm/token.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, disable_privacy, false, "Disable library privacy.");
 DEFINE_FLAG(bool, print_tokens, false, "Print scanned tokens.");
 
 void Scanner::InitKeywordTable() {
   ObjectStore* object_store = Isolate::Current()->object_store();
@@ skipping 46 matching lines @@
   while (saved_context_ != NULL) {
     ScanContext* ctx = saved_context_;
     saved_context_ = ctx->next;
     delete ctx;
   }
 }
 
 
 void Scanner::ErrorMsg(const char* msg) {
   current_token_.kind = Token::kERROR;
-  current_token_.literal = &String::ZoneHandle(String::NewSymbol(msg));
+  current_token_.literal = &String::ZoneHandle(Symbols::New(msg));
   current_token_.position = c0_pos_;
   token_start_ = lookahead_pos_;
   current_token_.offset = lookahead_pos_;
 }
 
 
 void Scanner::PushContext() {
   ScanContext* ctx = new ScanContext;
   ctx->next = saved_context_;
   saved_context_ = ctx;
@@ skipping 181 matching lines @@
       int char_pos = 0;
       while ((char_pos < ident_length) &&
              (keyword[char_pos] == source_.CharAt(ident_pos + char_pos))) {
         char_pos++;
       }
       if (char_pos == ident_length) {
         if (keywords_[i].keyword_symbol == NULL) {
           String& symbol = String::ZoneHandle();
           symbol ^= keyword_symbol_table_.At(i);
           if (symbol.IsNull()) {
-            symbol = String::NewSymbol(source_, ident_pos, ident_length);
+            symbol = Symbols::New(source_, ident_pos, ident_length);
             keyword_symbol_table_.SetAt(i, symbol);
           }
           keywords_[i].keyword_symbol = &symbol;
         }
         current_token_.literal = keywords_[i].keyword_symbol;
         current_token_.kind = keywords_[i].kind;
         return;
       }
     }
     i++;
   }
 
   // We did not read a keyword.
   current_token_.kind = Token::kIDENT;
   String& literal =
-      String::ZoneHandle(String::NewSymbol(source_, ident_pos, ident_length));
+      String::ZoneHandle(Symbols::New(source_, ident_pos, ident_length));
   if ((ident_char0 == kPrivateIdentifierStart) && !FLAG_disable_privacy) {
     // Private identifiers are mangled on a per script basis.
     literal = String::Concat(literal, private_key_);
-    literal = String::NewSymbol(literal);
+    literal = Symbols::New(literal);
   }
   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 49 matching lines @@
 
 RawString* Scanner::ConsumeIdentChars(bool allow_dollar) {
   ASSERT(IsIdentStartChar(c0_));
   ASSERT(allow_dollar || (c0_ != '$'));
   int ident_length = 0;
   int32_t ident_pos = lookahead_pos_;
   while (IsIdentChar(c0_) && (allow_dollar || (c0_ != '$'))) {
     ReadChar();
     ident_length++;
   }
-  return String::NewSymbol(source_, ident_pos, ident_length);
+  return Symbols::New(source_, ident_pos, ident_length);
 }
 
 
 void Scanner::SkipLine() {
   while (c0_ != '\n' && c0_ != '\0') {
     ReadChar();
   }
 }
 
 
 void Scanner::ScanLibraryTag() {
   ReadChar();
   if (c0_ == '!') {
     Recognize(Token::kSCRIPTTAG);
     // The script tag extends to the end of the line. Just treat this
     // similar to a line comment.
     SkipLine();
     return;
   }
   if (!IsLetter(c0_)) {
     ErrorMsg("Unrecognized library tag");
     SkipLine();
     return;
   }
-  const String& kLibrary = String::Handle(String::NewSymbol("library"));
-  const String& kImport = String::Handle(String::NewSymbol("import"));
-  const String& kSource = String::Handle(String::NewSymbol("source"));
-  const String& kResource = String::Handle(String::NewSymbol("resource"));
+  const String& kLibrary = String::Handle(Symbols::New("library"));
+  const String& kImport = String::Handle(Symbols::New("import"));
+  const String& kSource = String::Handle(Symbols::New("source"));
+  const String& kResource = String::Handle(Symbols::New("resource"));
   const String& ident = String::Handle(ConsumeIdentChars(false));
   if (ident.Equals(kLibrary)) {
     current_token_.kind = Token::kLIBRARY;
     return;
   }
   if (ident.Equals(kImport)) {
     current_token_.kind = Token::kIMPORT;
     return;
   }
   if (ident.Equals(kSource)) {
@@ skipping 138 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(
-          String::NewSymbol(string_chars.data(), string_chars.length()));
+          Symbols::New(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(
-              String::NewSymbol(string_chars.data(), string_chars.length()));
+              Symbols::New(string_chars.data(), string_chars.length()));
         }
         EndStringLiteral();
         return;
       } else {
         string_chars.Add(string_delimiter_);
       }
     } else {
       string_chars.Add(c0_);
     }
     ReadChar();
@@ skipping 354 matching lines @@
               "%c%"PRIxPTR, kPrivateKeySeparator, key_value);
   const String& result = String::Handle(String::New(private_key, Heap::kOld));
   return result.raw();
 }
 
 
 void Scanner::InitOnce() {
 }
 
 }  // namespace dart