Scanner cleanups: use isolates to allocate handles and zone objects

runtime/vm/scanner.cc

Index: runtime/vm/scanner.cc
===================================================================
--- runtime/vm/scanner.cc	(revision 37052)
+++ runtime/vm/scanner.cc	(working copy)
@@ -19,6 +19,34 @@
 DEFINE_FLAG(bool, print_tokens, false, "Print scanned tokens.");
 
 
+// Quick access to the locally defined isolate() method.
+#define I (isolate())
+
+
+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_) {}
+
+  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:

[hausner, 2014/06/05 21:58:54]

IMO it does not really make much sense to make this private and then have to
declare Scanner and ScanContext as fiends.  Why not simply leave everything
public and forget the accessors?
 

[srdjan, 2014/06/05 22:03:51]

Discussed offline, leaving it as it is.

+  ScanContext* next_;
+  const char string_delimiter_;
+  const bool string_is_multiline_;
+  const int brace_level_;
+};
+
+
 Scanner::KeywordTable Scanner::keywords_[Token::kNumKeywords];
 int Scanner::keywords_char_offset_[Scanner::kNumLowercaseChars];
 
@@ -40,11 +68,7 @@
   c0_ = '\0';
   newline_seen_ = false;
   prev_token_line_ = 1;
-  while (saved_context_ != NULL) {
-    ScanContext* ctx = saved_context_;
-    saved_context_ = ctx->next;
-    delete ctx;
-  }
+  saved_context_ = NULL;
   string_delimiter_ = '\0';
   string_is_multiline_ = false;
   brace_level_ = 0;
@@ -65,18 +89,12 @@
 }
 
 
-Scanner::~Scanner() {
-  while (saved_context_ != NULL) {
-    ScanContext* ctx = saved_context_;
-    saved_context_ = ctx->next;
-    delete ctx;
-  }
-}
+Scanner::~Scanner() {}
 
 
 void Scanner::ErrorMsg(const char* msg) {
   current_token_.kind = Token::kERROR;
-  current_token_.literal = &String::ZoneHandle(Symbols::New(msg));
+  current_token_.literal = &String::ZoneHandle(I, Symbols::New(msg));
   current_token_.position = c0_pos_;
   token_start_ = lookahead_pos_;
   current_token_.offset = lookahead_pos_;
@@ -84,12 +102,8 @@
 
 
 void Scanner::PushContext() {
-  ScanContext* ctx = new ScanContext;
-  ctx->next = saved_context_;
+  ScanContext* ctx = new(I) ScanContext(this);
   saved_context_ = ctx;
-  ctx->string_delimiter = string_delimiter_;
-  ctx->string_is_multiline = string_is_multiline_;
-  ctx->brace_level = brace_level_;
   string_delimiter_ = '\0';
   string_is_multiline_ = false;
   brace_level_ = 1;  // Account for the opening ${ token.
@@ -101,12 +115,9 @@
   ASSERT(brace_level_ == 0);
   ASSERT(string_delimiter_ == '\0');
   ScanContext* ctx = saved_context_;
-  saved_context_ = ctx->next;
-  string_delimiter_ = ctx->string_delimiter;
+  ctx->CopyTo(this);
+  saved_context_ = ctx->next();
   ASSERT(string_delimiter_ != '\0');
-  string_is_multiline_ = ctx->string_is_multiline;
-  brace_level_ = ctx->brace_level;
-  delete ctx;
 }
 
 
@@ -318,7 +329,7 @@
   // We did not read a keyword.
   current_token_.kind = Token::kIDENT;
   String& literal =
-      String::ZoneHandle(Symbols::New(source_, ident_pos, ident_length));
+      String::ZoneHandle(I, 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_);
@@ -376,7 +387,7 @@
   }
   if (current_token_.kind != Token::kILLEGAL) {
     intptr_t len = lookahead_pos_ - token_start_;
-    String& str = String::ZoneHandle(
+    String& str = String::ZoneHandle(I,
         String::SubString(source_, token_start_, len, Heap::kOld));
     str = Symbols::New(str);
     current_token_.literal = &str;
@@ -531,7 +542,7 @@
       // Scanned a string piece.
       ASSERT(string_chars.data() != NULL);
       // Strings are canonicalized: Allocate a symbol.
-      current_token_.literal = &String::ZoneHandle(
+      current_token_.literal = &String::ZoneHandle(I,
           Symbols::FromUTF32(string_chars.data(), string_chars.length()));
       // Preserve error tokens.
       if (current_token_.kind != Token::kERROR) {
@@ -554,7 +565,7 @@
           Recognize(Token::kSTRING);
           ASSERT(string_chars.data() != NULL);
           // Strings are canonicalized: Allocate a symbol.
-          current_token_.literal = &String::ZoneHandle(
+          current_token_.literal = &String::ZoneHandle(I,
               Symbols::FromUTF32(string_chars.data(), string_chars.length()));
         }
         EndStringLiteral();
@@ -919,7 +930,7 @@
 
 
 const Scanner::GrowableTokenStream& Scanner::GetStream() {
-  GrowableTokenStream* ts = new GrowableTokenStream(128);
+  GrowableTokenStream* ts = new(I) GrowableTokenStream(128);
   ScanAll(ts);
   if (FLAG_print_tokens) {
     Scanner::PrintTokens(*ts);