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

runtime/vm/regexp_parser.cc

 // Copyright (c) 2014, 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/longjump.h"
 #include "vm/object_store.h"
 #include "vm/regexp_parser.h"
 
 namespace dart {
 
-#define I isolate()
+#define Z zone()
 
 // Enables possessive quantifier syntax for testing.
 static const bool FLAG_regexp_possessive_quantifier = false;
 
 RegExpBuilder::RegExpBuilder()
-    : isolate_(Isolate::Current()),
+    : zone_(Thread::Current()->zone()),
       pending_empty_(false),
       characters_(NULL),
       terms_(),
       text_(),
       alternatives_()
 #ifdef DEBUG
     , last_added_(ADD_NONE)
 #endif
   {}
 
 
 void RegExpBuilder::FlushCharacters() {
   pending_empty_ = false;
   if (characters_ != NULL) {
-    RegExpTree* atom = new(I) RegExpAtom(characters_);
+    RegExpTree* atom = new(Z) RegExpAtom(characters_);
     characters_ = NULL;
     text_.Add(atom);
     LAST(ADD_ATOM);
   }
 }
 
 
 void RegExpBuilder::FlushText() {
   FlushCharacters();
   intptr_t num_text = text_.length();
   if (num_text == 0) {
     return;
   } else if (num_text == 1) {
     terms_.Add(text_.Last());
   } else {
-    RegExpText* text = new(I) RegExpText();
+    RegExpText* text = new(Z) RegExpText();
     for (intptr_t i = 0; i < num_text; i++)
       text_[i]->AppendToText(text);
     terms_.Add(text);
   }
   text_.Clear();
 }
 
 
 void RegExpBuilder::AddCharacter(uint16_t c) {
   pending_empty_ = false;
   if (characters_ == NULL) {
-    characters_ = new(I) ZoneGrowableArray<uint16_t>(4);
+    characters_ = new(Z) ZoneGrowableArray<uint16_t>(4);
   }
   characters_->Add(c);
   LAST(ADD_CHAR);
 }
 
 
 void RegExpBuilder::AddEmpty() {
   pending_empty_ = true;
 }
 
@@ skipping 29 matching lines @@
 void RegExpBuilder::FlushTerms() {
   FlushText();
   intptr_t num_terms = terms_.length();
   RegExpTree* alternative;
   if (num_terms == 0) {
     alternative = RegExpEmpty::GetInstance();
   } else if (num_terms == 1) {
     alternative = terms_.Last();
   } else {
     ZoneGrowableArray<RegExpTree*>* terms =
-        new(I) ZoneGrowableArray<RegExpTree*>();
+        new(Z) ZoneGrowableArray<RegExpTree*>();
     for (intptr_t i = 0; i < terms_.length(); i++) {
       terms->Add(terms_[i]);
     }
-    alternative = new(I) RegExpAlternative(terms);
+    alternative = new(Z) RegExpAlternative(terms);
   }
   alternatives_.Add(alternative);
   terms_.Clear();
   LAST(ADD_NONE);
 }
 
 
 RegExpTree* RegExpBuilder::ToRegExp() {
   FlushTerms();
   intptr_t num_alternatives = alternatives_.length();
   if (num_alternatives == 0) {
     return RegExpEmpty::GetInstance();
   }
   if (num_alternatives == 1) {
     return alternatives_.Last();
   }
   ZoneGrowableArray<RegExpTree*>* alternatives =
-      new(I) ZoneGrowableArray<RegExpTree*>();
+      new(Z) ZoneGrowableArray<RegExpTree*>();
   for (intptr_t i = 0; i < alternatives_.length(); i++) {
     alternatives->Add(alternatives_[i]);
   }
-  return new(I) RegExpDisjunction(alternatives);
+  return new(Z) RegExpDisjunction(alternatives);
 }
 
 
 void RegExpBuilder::AddQuantifierToAtom(
     intptr_t min,
     intptr_t max,
     RegExpQuantifier::QuantifierType quantifier_type) {
   if (pending_empty_) {
     pending_empty_ = false;
     return;
   }
   RegExpTree* atom;
   if (characters_ != NULL) {
     DEBUG_ASSERT(last_added_ == ADD_CHAR);
     // Last atom was character.
 
     ZoneGrowableArray<uint16_t> *char_vector =
-        new(I) ZoneGrowableArray<uint16_t>();
+        new(Z) ZoneGrowableArray<uint16_t>();
     char_vector->AddArray(*characters_);
     intptr_t num_chars = char_vector->length();
     if (num_chars > 1) {
       ZoneGrowableArray<uint16_t> *prefix =
-          new(I) ZoneGrowableArray<uint16_t>();
+          new(Z) ZoneGrowableArray<uint16_t>();
       for (intptr_t i = 0; i < num_chars - 1; i++) {
         prefix->Add(char_vector->At(i));
       }
-      text_.Add(new(I) RegExpAtom(prefix));
-      ZoneGrowableArray<uint16_t> *tail = new(I) ZoneGrowableArray<uint16_t>();
+      text_.Add(new(Z) RegExpAtom(prefix));
+      ZoneGrowableArray<uint16_t> *tail = new(Z) ZoneGrowableArray<uint16_t>();
       tail->Add(char_vector->At(num_chars - 1));
       char_vector = tail;
     }
     characters_ = NULL;
-    atom = new(I) RegExpAtom(char_vector);
+    atom = new(Z) RegExpAtom(char_vector);
     FlushText();
   } else if (text_.length() > 0) {
     DEBUG_ASSERT(last_added_ == ADD_ATOM);
     atom = text_.RemoveLast();
     FlushText();
   } else if (terms_.length() > 0) {
     DEBUG_ASSERT(last_added_ == ADD_ATOM);
     atom = terms_.RemoveLast();
     if (atom->max_match() == 0) {
       // Guaranteed to only match an empty string.
       LAST(ADD_TERM);
       if (min == 0) {
         return;
       }
       terms_.Add(atom);
       return;
     }
   } else {
     // Only call immediately after adding an atom or character!
     UNREACHABLE();
     return;
   }
-  terms_.Add(new(I) RegExpQuantifier(min, max, quantifier_type, atom));
+  terms_.Add(new(Z) RegExpQuantifier(min, max, quantifier_type, atom));
   LAST(ADD_TERM);
 }
 
 // ----------------------------------------------------------------------------
 // Implementation of Parser
 
 RegExpParser::RegExpParser(const String& in,
                            String* error,
                            bool multiline)
-    : isolate_(Isolate::Current()),
+    : zone_(Thread::Current()->zone()),
       error_(error),
       captures_(NULL),
       in_(in),
       current_(kEndMarker),
       next_pos_(0),
       capture_count_(0),
       has_more_(true),
       multiline_(multiline),
       simple_(false),
       contains_anchor_(false),
       is_scanned_for_captures_(false),
       failed_(false) {
   Advance();
 }
 
 
 bool RegExpParser::ParseFunction(ParsedFunction *parsed_function) {
-  Isolate* isolate = parsed_function->isolate();
+  Zone* zone = parsed_function->zone();
   JSRegExp& regexp = JSRegExp::Handle(parsed_function->function().regexp());
 
   const String& pattern = String::Handle(regexp.pattern());
   const bool multiline = regexp.is_multi_line();
 
-  RegExpCompileData* compile_data = new(isolate) RegExpCompileData();
+  RegExpCompileData* compile_data = new(zone) RegExpCompileData();
   if (!RegExpParser::ParseRegExp(pattern, multiline, compile_data)) {
     // Parsing failures are handled in the JSRegExp factory constructor.
     UNREACHABLE();
   }
 
   regexp.set_num_bracket_expressions(compile_data->capture_count);
   if (compile_data->simple) {
     regexp.set_is_simple();
   } else {
     regexp.set_is_complex();
@@ skipping 75 matching lines @@
 //   Alternative | Disjunction
 // Alternative ::
 //   [empty]
 //   Term Alternative
 // Term ::
 //   Assertion
 //   Atom
 //   Atom Quantifier
 RegExpTree* RegExpParser::ParseDisjunction() {
   // Used to store current state while parsing subexpressions.
-  RegExpParserState initial_state(NULL, INITIAL, 0, I);
+  RegExpParserState initial_state(NULL, INITIAL, 0, Z);
   RegExpParserState* stored_state = &initial_state;
   // Cache the builder in a local variable for quick access.
   RegExpBuilder* builder = initial_state.builder();
   while (true) {
     switch (current()) {
     case kEndMarker:
       if (stored_state->IsSubexpression()) {
         // Inside a parenthesized group when hitting end of input.
         ReportError("Unterminated group");
         UNREACHABLE();
@@ skipping 17 matching lines @@
 
       intptr_t capture_index = stored_state->capture_index();
       SubexpressionType group_type = stored_state->group_type();
 
       // Restore previous state.
       stored_state = stored_state->previous_state();
       builder = stored_state->builder();
 
       // Build result of subexpression.
       if (group_type == CAPTURE) {
-        RegExpCapture* capture = new(I) RegExpCapture(body, capture_index);
+        RegExpCapture* capture = new(Z) RegExpCapture(body, capture_index);
         (*captures_)[capture_index - 1] = capture;
         body = capture;
       } else if (group_type != GROUPING) {
         ASSERT(group_type == POSITIVE_LOOKAHEAD ||
                group_type == NEGATIVE_LOOKAHEAD);
         bool is_positive = (group_type == POSITIVE_LOOKAHEAD);
-        body = new(I) RegExpLookahead(body,
+        body = new(Z) RegExpLookahead(body,
                                       is_positive,
                                       end_capture_index - capture_index,
                                       capture_index);
       }
       builder->AddAtom(body);
       // For compatibility with JSC and ES3, we allow quantifiers after
       // lookaheads, and break in all cases.
       break;
     }
     case '|': {
       Advance();
       builder->NewAlternative();
       continue;
     }
     case '*':
     case '+':
     case '?':
       ReportError("Nothing to repeat");
       UNREACHABLE();
     case '^': {
       Advance();
       if (multiline_) {
         builder->AddAssertion(
-            new(I) RegExpAssertion(RegExpAssertion::START_OF_LINE));
+            new(Z) RegExpAssertion(RegExpAssertion::START_OF_LINE));
       } else {
         builder->AddAssertion(
-            new(I) RegExpAssertion(RegExpAssertion::START_OF_INPUT));
+            new(Z) RegExpAssertion(RegExpAssertion::START_OF_INPUT));
         set_contains_anchor();
       }
       continue;
     }
     case '$': {
       Advance();
       RegExpAssertion::AssertionType assertion_type =
           multiline_ ? RegExpAssertion::END_OF_LINE :
                        RegExpAssertion::END_OF_INPUT;
       builder->AddAssertion(new RegExpAssertion(assertion_type));
@@ skipping 33 matching lines @@
           captures_ = new ZoneGrowableArray<RegExpCapture*>(2);
         }
         if (captures_started() >= kMaxCaptures) {
           ReportError("Too many captures");
           UNREACHABLE();
         }
         captures_->Add(NULL);
       }
       // Store current state and begin new disjunction parsing.
       stored_state = new RegExpParserState(stored_state, subexpr_type,
-                                           captures_started(), I);
+                                           captures_started(), Z);
       builder = stored_state->builder();
       continue;
     }
     case '[': {
       RegExpTree* atom = ParseCharacterClass();
       builder->AddAtom(atom);
       break;
     }
     // Atom ::
     //   \ AtomEscape
@@ skipping 530 matching lines @@
   static const char* kRangeOutOfOrder = "Range out of order in character class";
 
   ASSERT(current() == '[');
   Advance();
   bool is_negated = false;
   if (current() == '^') {
     is_negated = true;
     Advance();
   }
   ZoneGrowableArray<CharacterRange>* ranges =
-      new(I) ZoneGrowableArray<CharacterRange>(2);
+      new(Z) ZoneGrowableArray<CharacterRange>(2);
   while (has_more() && current() != ']') {
     uint16_t char_class = kNoCharClass;
     CharacterRange first = ParseClassAtom(&char_class);
     if (current() == '-') {
       Advance();
       if (current() == kEndMarker) {
         // If we reach the end we break out of the loop and let the
         // following code report an error.
         break;
       } else if (current() == ']') {
@@ skipping 21 matching lines @@
   }
   if (!has_more()) {
     ReportError(kUnterminated);
     UNREACHABLE();
   }
   Advance();
   if (ranges->length() == 0) {
     ranges->Add(CharacterRange::Everything());
     is_negated = !is_negated;
   }
-  return new(I) RegExpCharacterClass(ranges, is_negated);
+  return new(Z) RegExpCharacterClass(ranges, is_negated);
 }
 
 
 // ----------------------------------------------------------------------------
 // The Parser interface.
 
 bool RegExpParser::ParseRegExp(const String& input,
                                bool multiline,
                                RegExpCompileData* result) {
   ASSERT(result != NULL);
@@ skipping 17 matching lines @@
           String::Concat(result->error, input));
     const Array& args = Array::Handle(Array::New(1));
     args.SetAt(0, message);
 
     Exceptions::ThrowByType(Exceptions::kFormat, args);
   }
   return !parser.failed();
 }
 
 }  // namespace dart