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

runtime/vm/regexp.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_H_
 #define VM_REGEXP_H_
 
 #include "vm/assembler.h"
 #include "vm/intermediate_language.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 33 matching lines @@
   bool Contains(uint16_t i) const { return from_ <= i && i <= to_; }
   uint16_t from() const { return from_; }
   void set_from(uint16_t value) { from_ = value; }
   uint16_t to() const { return to_; }
   void set_to(uint16_t value) { to_ = value; }
   bool is_valid() const { return from_ <= to_; }
   bool IsEverything(uint16_t max) const { return from_ == 0 && to_ >= max; }
   bool IsSingleton() const { return (from_ == to_); }
   void AddCaseEquivalents(ZoneGrowableArray<CharacterRange>* ranges,
                           bool is_one_byte,
-                          Isolate* isolate);
+                          Zone* zone);
   static void Split(ZoneGrowableArray<CharacterRange>* base,
                     GrowableArray<const intptr_t> overlay,
                     ZoneGrowableArray<CharacterRange>** included,
                     ZoneGrowableArray<CharacterRange>** excluded,
-                    Isolate* isolate);
+                    Zone* zone);
   // Whether a range list is in canonical form: Ranges ordered by from value,
   // and ranges non-overlapping and non-adjacent.
   static bool IsCanonical(ZoneGrowableArray<CharacterRange>* ranges);
   // Convert range list to canonical form. The characters covered by the ranges
   // will still be the same, but no character is in more than one range, and
   // adjacent ranges are merged. The resulting list may be shorter than the
   // original, but cannot be longer.
   static void Canonicalize(ZoneGrowableArray<CharacterRange>* ranges);
   // Negate the contents of a character range in canonical form.
   static void Negate(ZoneGrowableArray<CharacterRange>* src,
                      ZoneGrowableArray<CharacterRange>* dst);
   static const intptr_t kStartMarker = (1 << 24);
   static const intptr_t kPayloadMask = (1 << 24) - 1;
 
  private:
   uint16_t from_;
   uint16_t to_;
 
   DISALLOW_ALLOCATION();
 };
 
 
 // A set of unsigned integers that behaves especially well on small
 // integers (< 32).  May do zone-allocation.
 class OutSet: public ZoneAllocated {
  public:
   OutSet() : first_(0), remaining_(NULL), successors_(NULL) { }
-  OutSet* Extend(unsigned value, Isolate* isolate);
+  OutSet* Extend(unsigned value, Zone* zone);
   bool Get(unsigned value) const;
   static const unsigned kFirstLimit = 32;
 
  private:
   // Destructively set a value in this set.  In most cases you want
   // to use Extend instead to ensure that only one instance exists
   // that contains the same values.
-  void Set(unsigned value, Isolate* isolate);
+  void Set(unsigned value, Zone* zone);
 
   // The successors are a list of sets that contain the same values
   // as this set and the one more value that is not present in this
   // set.
   ZoneGrowableArray<OutSet*>* successors() { return successors_; }
 
   OutSet(uint32_t first, ZoneGrowableArray<unsigned>* remaining)
       : first_(first), remaining_(remaining), successors_(NULL) { }
   uint32_t first_;
   ZoneGrowableArray<unsigned>* remaining_;
@@ skipping 187 matching lines @@
   // If set to true, there is no way this quick check can match at all.
   // E.g., if it requires to be at the start of the input, and isn't.
   bool cannot_match_;
 
   DISALLOW_ALLOCATION();
 };
 
 
 class RegExpNode: public ZoneAllocated {
  public:
-  explicit RegExpNode(Isolate* isolate)
-  : replacement_(NULL), trace_count_(0), isolate_(isolate) {
+  explicit RegExpNode(Zone* zone)
+  : replacement_(NULL), trace_count_(0), zone_(zone) {
     bm_info_[0] = bm_info_[1] = NULL;
   }
   virtual ~RegExpNode();
   virtual void Accept(NodeVisitor* visitor) = 0;
   // Generates a goto to this node or actually generates the code at this point.
   virtual void Emit(RegExpCompiler* compiler, Trace* trace) = 0;
   // How many characters must this node consume at a minimum in order to
   // succeed.  If we have found at least 'still_to_find' characters that
   // must be consumed there is no need to ask any following nodes whether
   // they are sure to eat any more characters.  The not_at_start argument is
@@ skipping 76 matching lines @@
   // trace and generating generic code for a node that can be reused by flushing
   // the deferred actions in the current trace and generating a goto.
   static const intptr_t kMaxCopiesCodeGenerated = 10;
 
   NodeInfo* info() { return &info_; }
 
   BoyerMooreLookahead* bm_info(bool not_at_start) {
     return bm_info_[not_at_start ? 1 : 0];
   }
 
-  Isolate* isolate() const { return isolate_; }
+  Zone* zone() const { return zone_; }
 
  protected:
   enum LimitResult { DONE, CONTINUE };
   RegExpNode* replacement_;
 
   LimitResult LimitVersions(RegExpCompiler* compiler, Trace* trace);
 
   void set_bm_info(bool not_at_start, BoyerMooreLookahead* bm) {
     bm_info_[not_at_start ? 1 : 0] = bm;
   }
 
  private:
   static const intptr_t kFirstCharBudget = 10;
   BlockLabel label_;
   NodeInfo info_;
   // This variable keeps track of how many times code has been generated for
   // this node (in different traces).  We don't keep track of where the
   // generated code is located unless the code is generated at the start of
   // a trace, in which case it is generic and can be reused by flushing the
   // deferred operations in the current trace and generating a goto.
   intptr_t trace_count_;
   BoyerMooreLookahead* bm_info_[2];
-  Isolate* isolate_;
+  Zone* zone_;
 };
 
 
 // A simple closed interval.
 class Interval {
  public:
   Interval() : from_(kNone), to_(kNone) { }
   Interval(intptr_t from, intptr_t to) : from_(from), to_(to) { }
 
   Interval Union(Interval that) {
@@ skipping 18 matching lines @@
   intptr_t from_;
   intptr_t to_;
 
   DISALLOW_ALLOCATION();
 };
 
 
 class SeqRegExpNode: public RegExpNode {
  public:
   explicit SeqRegExpNode(RegExpNode* on_success)
-      : RegExpNode(on_success->isolate()), on_success_(on_success) { }
+      : RegExpNode(on_success->zone()), on_success_(on_success) { }
   RegExpNode* on_success() { return on_success_; }
   void set_on_success(RegExpNode* node) { on_success_ = node; }
   virtual RegExpNode* FilterOneByte(intptr_t depth, bool ignore_case);
   virtual void FillInBMInfo(intptr_t offset,
                             intptr_t budget,
                             BoyerMooreLookahead* bm,
                             bool not_at_start) {
     on_success_->FillInBMInfo(offset, budget - 1, bm, not_at_start);
     if (offset == 0) set_bm_info(not_at_start, bm);
   }
@@ skipping 96 matching lines @@
 
 class TextNode: public SeqRegExpNode {
  public:
   TextNode(ZoneGrowableArray<TextElement>* elms,
            RegExpNode* on_success)
       : SeqRegExpNode(on_success),
         elms_(elms) { }
   TextNode(RegExpCharacterClass* that,
            RegExpNode* on_success)
       : SeqRegExpNode(on_success),
-        elms_(new(isolate()) ZoneGrowableArray<TextElement>(1)) {
+        elms_(new(zone()) ZoneGrowableArray<TextElement>(1)) {
     elms_->Add(TextElement::CharClass(that));
   }
   virtual void Accept(NodeVisitor* visitor);
   virtual void Emit(RegExpCompiler* compiler, Trace* trace);
   virtual intptr_t EatsAtLeast(intptr_t still_to_find, intptr_t budget,
                                bool not_at_start);
   virtual void GetQuickCheckDetails(QuickCheckDetails* details,
                                     RegExpCompiler* compiler,
                                     intptr_t characters_filled_in,
                                     bool not_at_start);
@@ skipping 34 matching lines @@
 class AssertionNode: public SeqRegExpNode {
  public:
   enum AssertionType {
     AT_END,
     AT_START,
     AT_BOUNDARY,
     AT_NON_BOUNDARY,
     AFTER_NEWLINE
   };
   static AssertionNode* AtEnd(RegExpNode* on_success) {
-    return new(on_success->isolate()) AssertionNode(AT_END, on_success);
+    return new(on_success->zone()) AssertionNode(AT_END, on_success);
   }
   static AssertionNode* AtStart(RegExpNode* on_success) {
-    return new(on_success->isolate()) AssertionNode(AT_START, on_success);
+    return new(on_success->zone()) AssertionNode(AT_START, on_success);
   }
   static AssertionNode* AtBoundary(RegExpNode* on_success) {
-    return new(on_success->isolate()) AssertionNode(AT_BOUNDARY, on_success);
+    return new(on_success->zone()) AssertionNode(AT_BOUNDARY, on_success);
   }
   static AssertionNode* AtNonBoundary(RegExpNode* on_success) {
-    return new(on_success->isolate()) AssertionNode(AT_NON_BOUNDARY,
+    return new(on_success->zone()) AssertionNode(AT_NON_BOUNDARY,
                                                     on_success);
   }
   static AssertionNode* AfterNewline(RegExpNode* on_success) {
-    return new(on_success->isolate()) AssertionNode(AFTER_NEWLINE, on_success);
+    return new(on_success->zone()) AssertionNode(AFTER_NEWLINE, on_success);
   }
   virtual void Accept(NodeVisitor* visitor);
   virtual void Emit(RegExpCompiler* compiler, Trace* trace);
   virtual intptr_t EatsAtLeast(intptr_t still_to_find, intptr_t budget,
                                bool not_at_start);
   virtual void GetQuickCheckDetails(QuickCheckDetails* details,
                                     RegExpCompiler* compiler,
                                     intptr_t filled_in,
                                     bool not_at_start);
   virtual void FillInBMInfo(intptr_t offset,
@@ skipping 42 matching lines @@
 
  private:
   intptr_t start_reg_;
   intptr_t end_reg_;
 };
 
 
 class EndNode: public RegExpNode {
  public:
   enum Action { ACCEPT, BACKTRACK, NEGATIVE_SUBMATCH_SUCCESS };
-  explicit EndNode(Action action, Isolate* isolate)
-      : RegExpNode(isolate), action_(action) { }
+  explicit EndNode(Action action, Zone* zone)
+      : RegExpNode(zone), action_(action) { }
   virtual void Accept(NodeVisitor* visitor);
   virtual void Emit(RegExpCompiler* compiler, Trace* trace);
   virtual intptr_t EatsAtLeast(intptr_t still_to_find,
                           intptr_t recursion_depth,
                           bool not_at_start) { return 0; }
   virtual void GetQuickCheckDetails(QuickCheckDetails* details,
                                     RegExpCompiler* compiler,
                                     intptr_t characters_filled_in,
                                     bool not_at_start) {
     // Returning 0 from EatsAtLeast should ensure we never get here.
@@ skipping 11 matching lines @@
   Action action_;
 };
 
 
 class NegativeSubmatchSuccess: public EndNode {
  public:
   NegativeSubmatchSuccess(intptr_t stack_pointer_reg,
                           intptr_t position_reg,
                           intptr_t clear_capture_count,
                           intptr_t clear_capture_start,
-                          Isolate* isolate)
-      : EndNode(NEGATIVE_SUBMATCH_SUCCESS, isolate),
+                          Zone* zone)
+      : EndNode(NEGATIVE_SUBMATCH_SUCCESS, zone),
         stack_pointer_register_(stack_pointer_reg),
         current_position_register_(position_reg),
         clear_capture_count_(clear_capture_count),
         clear_capture_start_(clear_capture_start) { }
   virtual void Emit(RegExpCompiler* compiler, Trace* trace);
 
  private:
   intptr_t stack_pointer_register_;
   intptr_t current_position_register_;
   intptr_t clear_capture_count_;
@@ skipping 15 matching lines @@
  private:
   intptr_t reg_;
   Relation op_;
   intptr_t value_;
 };
 
 
 class GuardedAlternative {
  public:
   explicit GuardedAlternative(RegExpNode* node) : node_(node), guards_(NULL) { }
-  void AddGuard(Guard* guard, Isolate* isolate);
+  void AddGuard(Guard* guard, Zone* zone);
   RegExpNode* node() { return node_; }
   void set_node(RegExpNode* node) { node_ = node; }
   ZoneGrowableArray<Guard*>* guards() { return guards_; }
 
  private:
   RegExpNode* node_;
   ZoneGrowableArray<Guard*>* guards_;
 
   DISALLOW_ALLOCATION();
 };
 
 
 struct AlternativeGeneration;
 
 
 class ChoiceNode: public RegExpNode {
  public:
-  explicit ChoiceNode(intptr_t expected_size, Isolate* isolate)
-      : RegExpNode(isolate),
-        alternatives_(new(isolate)
+  explicit ChoiceNode(intptr_t expected_size, Zone* zone)
+      : RegExpNode(zone),
+        alternatives_(new(zone)
                       ZoneGrowableArray<GuardedAlternative>(expected_size)),
         not_at_start_(false),
         being_calculated_(false) { }
   virtual void Accept(NodeVisitor* visitor);
   void AddAlternative(GuardedAlternative node) {
     alternatives()->Add(node);
   }
   ZoneGrowableArray<GuardedAlternative>* alternatives() {
     return alternatives_;
   }
@@ skipping 60 matching lines @@
   // Allows a new trace to start with at_start() set to false.
   bool not_at_start_;
   bool being_calculated_;
 };
 
 
 class NegativeLookaheadChoiceNode: public ChoiceNode {
  public:
   explicit NegativeLookaheadChoiceNode(GuardedAlternative this_must_fail,
                                        GuardedAlternative then_do_this,
-                                       Isolate* isolate)
-      : ChoiceNode(2, isolate) {
+                                       Zone* zone)
+      : ChoiceNode(2, zone) {
     AddAlternative(this_must_fail);
     AddAlternative(then_do_this);
   }
   virtual intptr_t EatsAtLeast(intptr_t still_to_find, intptr_t budget,
                                bool not_at_start);
   virtual void GetQuickCheckDetails(QuickCheckDetails* details,
                                     RegExpCompiler* compiler,
                                     intptr_t characters_filled_in,
                                     bool not_at_start);
   virtual void FillInBMInfo(intptr_t offset,
@@ skipping 11 matching lines @@
   // part in that calculation (EatsAtLeast) so the assumptions don't hold.
   virtual bool try_to_emit_quick_check_for_alternative(bool is_first) {
     return !is_first;
   }
   virtual RegExpNode* FilterOneByte(intptr_t depth, bool ignore_case);
 };
 
 
 class LoopChoiceNode: public ChoiceNode {
  public:
-  explicit LoopChoiceNode(bool body_can_be_zero_length, Isolate* isolate)
-      : ChoiceNode(2, isolate),
+  explicit LoopChoiceNode(bool body_can_be_zero_length, Zone* zone)
+      : ChoiceNode(2, zone),
         loop_node_(NULL),
         continue_node_(NULL),
         body_can_be_zero_length_(body_can_be_zero_length) { }
   void AddLoopAlternative(GuardedAlternative alt);
   void AddContinueAlternative(GuardedAlternative alt);
   virtual void Emit(RegExpCompiler* compiler, Trace* trace);
   virtual intptr_t EatsAtLeast(intptr_t still_to_find,  intptr_t budget,
                                bool not_at_start);
   virtual void GetQuickCheckDetails(QuickCheckDetails* details,
                                     RegExpCompiler* compiler,
@@ skipping 62 matching lines @@
 
 
 ContainedInLattice AddRange(ContainedInLattice a,
                             const intptr_t* ranges,
                             intptr_t ranges_size,
                             Interval new_range);
 
 
 class BoyerMoorePositionInfo : public ZoneAllocated {
  public:
-  explicit BoyerMoorePositionInfo(Isolate* isolate)
-      : map_(new(isolate) ZoneGrowableArray<bool>(kMapSize)),
+  explicit BoyerMoorePositionInfo(Zone* zone)
+      : map_(new(zone) ZoneGrowableArray<bool>(kMapSize)),
         map_count_(0),
         w_(kNotYet),
         s_(kNotYet),
         d_(kNotYet),
         surrogate_(kNotYet) {
      for (intptr_t i = 0; i < kMapSize; i++) {
        map_->Add(false);
      }
   }
 
@@ skipping 16 matching lines @@
   ContainedInLattice w_;  // The \w character class.
   ContainedInLattice s_;  // The \s character class.
   ContainedInLattice d_;  // The \d character class.
   ContainedInLattice surrogate_;  // Surrogate UTF-16 code units.
 };
 
 
 class BoyerMooreLookahead : public ZoneAllocated{
  public:
   BoyerMooreLookahead(intptr_t length, RegExpCompiler* compiler,
-                      Isolate* Isolate);
+                      Zone* Zone);
 
   intptr_t length() { return length_; }
   intptr_t max_char() { return max_char_; }
   RegExpCompiler* compiler() { return compiler_; }
 
   intptr_t Count(intptr_t map_number) {
     return bitmaps_->At(map_number)->map_count();
   }
 
   BoyerMoorePositionInfo* at(intptr_t i) { return bitmaps_->At(i); }
@@ skipping 189 matching lines @@
   }
   void set_bound_checked_up_to(intptr_t to) { bound_checked_up_to_ = to; }
   void set_flush_budget(intptr_t to) { flush_budget_ = to; }
   void set_quick_check_performed(QuickCheckDetails* d) {
     quick_check_performed_ = *d;
   }
   void InvalidateCurrentCharacter();
   void AdvanceCurrentPositionInTrace(intptr_t by, RegExpCompiler* compiler);
 
  private:
-  intptr_t FindAffectedRegisters(OutSet* affected_registers, Isolate* isolate);
+  intptr_t FindAffectedRegisters(OutSet* affected_registers, Zone* zone);
   void PerformDeferredActions(RegExpMacroAssembler* macro,
                               intptr_t max_register,
                               const OutSet& affected_registers,
                               OutSet* registers_to_pop,
                               OutSet* registers_to_clear,
-                              Isolate* isolate);
+                              Zone* zone);
   void RestoreAffectedRegisters(RegExpMacroAssembler* macro,
                                 intptr_t max_register,
                                 const OutSet& registers_to_pop,
                                 const OutSet& registers_to_clear);
   intptr_t cp_offset_;
   DeferredAction* actions_;
   BlockLabel* backtrack_;
   RegExpNode* stop_node_;
   BlockLabel* loop_label_;
   intptr_t characters_preloaded_;
@@ skipping 131 matching lines @@
 
     const char* error_message;
   };
 
   static CompilationResult Compile(
       RegExpCompileData* input,
       const ParsedFunction* parsed_function,
       const ZoneGrowableArray<const ICData*>& ic_data_array);
 
   static RawJSRegExp* CreateJSRegExp(
-      Isolate* isolate,
+      Zone* zone,
       const String& pattern,
       bool multi_line,
       bool ignore_case);
 
   static void DotPrint(const char* label, RegExpNode* node, bool ignore_case);
 };
 
 }  // namespace dart
 
 #endif  // VM_REGEXP_H_