Scanner cleanups: use isolates to allocate handles and zone objects

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/thread.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())
+
+
+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];
 
 
 void Scanner::Reset() {
   // Non-changing newline properties.
   newline_token_.kind = Token::kNEWLINE;
   newline_token_.literal = NULL;
   // We don't preserve the column information.
   newline_token_.position.column = 0;
 
   // Non-changing empty string token properties.
   empty_string_token_.kind = Token::kSTRING;
   empty_string_token_.literal = &Symbols::Empty();
   empty_string_token_.position.column = 0;
 
   lookahead_pos_ = -1;
   token_start_ = 0;
   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;
   c0_pos_.line = 1;
   c0_pos_.column = 0;
   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()) {
   Reset();
 }
 
 
-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_;
 }
 
 
 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.
 }
 
 
 void Scanner::PopContext() {
   ASSERT(saved_context_ != NULL);
   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;
 }
 
 
 void Scanner::BeginStringLiteral(const char delimiter) {
   string_delimiter_ = delimiter;
 }
 
 
 void Scanner::EndStringLiteral() {
   string_delimiter_ = '\0';
@@ skipping 191 matching lines @@
           return;
         }
       }
       i++;
     }
   }
 
   // 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_);
     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(
+    String& str = String::ZoneHandle(I,
         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(
+      current_token_.literal = &String::ZoneHandle(I,
           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(
+          current_token_.literal = &String::ZoneHandle(I,
               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 GrowableTokenStream(128);
+  GrowableTokenStream* ts = new(I) 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