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

runtime/vm/regexp_parser.h

 // 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.
 
 #ifndef VM_REGEXP_PARSER_H_
 #define VM_REGEXP_PARSER_H_
 
 #include "vm/allocation.h"
 #include "vm/growable_array.h"
 #include "vm/regexp_ast.h"
@@ skipping 14 matching lines @@
   void NewAlternative();  // '|'
   void AddQuantifierToAtom(
       intptr_t min, intptr_t max, RegExpQuantifier::QuantifierType type);
   RegExpTree* ToRegExp();
 
  private:
   void FlushCharacters();
   void FlushText();
   void FlushTerms();
 
-  Isolate* isolate() const { return isolate_; }
+  Zone* zone() const { return zone_; }
 
-  Isolate* isolate_;
+  Zone* zone_;
   bool pending_empty_;
   ZoneGrowableArray<uint16_t>* characters_;
   GrowableArray<RegExpTree*> terms_;
   GrowableArray<RegExpTree*> text_;
   GrowableArray<RegExpTree*> alternatives_;
 #ifdef DEBUG
   enum {ADD_NONE, ADD_CHAR, ADD_TERM, ADD_ASSERT, ADD_ATOM} last_added_;
 #define LAST(x) last_added_ = x;
 #else
 #define LAST(x)
@@ skipping 63 matching lines @@
     POSITIVE_LOOKAHEAD,
     NEGATIVE_LOOKAHEAD,
     GROUPING
   };
 
   class RegExpParserState : public ZoneAllocated {
    public:
     RegExpParserState(RegExpParserState* previous_state,
                       SubexpressionType group_type,
                       intptr_t disjunction_capture_index,
-                      Isolate *isolate)
+                      Zone *zone)
         : previous_state_(previous_state),
-          builder_(new(isolate) RegExpBuilder()),
+          builder_(new(zone) RegExpBuilder()),
           group_type_(group_type),
           disjunction_capture_index_(disjunction_capture_index) {}
     // Parser state of containing expression, if any.
     RegExpParserState* previous_state() { return previous_state_; }
     bool IsSubexpression() { return previous_state_ != NULL; }
     // RegExpBuilder building this regexp's AST.
     RegExpBuilder* builder() { return builder_; }
     // Type of regexp being parsed (parenthesized group or entire regexp).
     SubexpressionType group_type() { return group_type_; }
     // Index in captures array of first capture in this sub-expression, if any.
     // Also the capture index of this sub-expression itself, if group_type
     // is CAPTURE.
     intptr_t capture_index() { return disjunction_capture_index_; }
 
    private:
     // Linked list implementation of stack of states.
     RegExpParserState* previous_state_;
     // Builder for the stored disjunction.
     RegExpBuilder* builder_;
     // Stored disjunction type (capture, look-ahead or grouping), if any.
     SubexpressionType group_type_;
     // Stored disjunction's capture index (if any).
     intptr_t disjunction_capture_index_;
   };
 
-  Isolate* isolate() { return isolate_; }
+  Zone* zone() { return zone_; }
 
   uint32_t current() { return current_; }
   bool has_more() { return has_more_; }
   bool has_next() { return next_pos_ < in().Length(); }
   uint32_t Next();
   const String& in() { return in_; }
   void ScanForCaptures();
 
-  Isolate* isolate_;
+  Zone* zone_;
   String* error_;
   ZoneGrowableArray<RegExpCapture*>* captures_;
   const String& in_;
   uint32_t current_;
   intptr_t next_pos_;
   // The capture count is only valid after we have scanned for captures.
   intptr_t capture_count_;
   bool has_more_;
   bool multiline_;
   bool simple_;
   bool contains_anchor_;
   bool is_scanned_for_captures_;
   bool failed_;
 };
 
 }  // namespace dart
 
 #endif  // VM_REGEXP_PARSER_H_