Changed statement ZoneList to a ZoneChunkList

src/regexp/jsregexp.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_REGEXP_JSREGEXP_H_
 #define V8_REGEXP_JSREGEXP_H_
 
 #include "src/allocation.h"
 #include "src/assembler.h"
 #include "src/regexp/regexp-ast.h"
@@ skipping 164 matching lines @@
 enum ElementInSetsRelation {
   kInsideNone = 0,
   kInsideFirst = 1,
   kInsideSecond = 2,
   kInsideBoth = 3
 };
 
 
 // A set of unsigned integers that behaves especially well on small
 // integers (< 32).  May do zone-allocation.
-class OutSet: public ZoneObject {
+class OutSet : public ZoneObject {
  public:
   OutSet() : first_(0), remaining_(NULL), successors_(NULL) { }
   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.
@@ skipping 226 matching lines @@
   uint32_t mask_;
   uint32_t value_;
   // 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_;
 };
 
 
 extern int kUninitializedRegExpNodePlaceHolder;
 
-
-class RegExpNode: public ZoneObject {
+class RegExpNode : public ZoneObject {
  public:
   explicit RegExpNode(Zone* zone)
       : replacement_(NULL), on_work_list_(false), 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
@@ skipping 401 matching lines @@
         clear_capture_start_(clear_capture_start) { }
   virtual void Emit(RegExpCompiler* compiler, Trace* trace);
 
  private:
   int stack_pointer_register_;
   int current_position_register_;
   int clear_capture_count_;
   int clear_capture_start_;
 };
 
-
-class Guard: public ZoneObject {
+class Guard : public ZoneObject {
  public:
   enum Relation { LT, GEQ };
   Guard(int reg, Relation op, int value)
       : reg_(reg),
         op_(op),
         value_(value) { }
   int reg() { return reg_; }
   Relation op() { return op_; }
   int value() { return value_; }
 
@@ skipping 208 matching lines @@
 inline ContainedInLattice Combine(ContainedInLattice a, ContainedInLattice b) {
   return static_cast<ContainedInLattice>(a | b);
 }
 
 
 ContainedInLattice AddRange(ContainedInLattice a,
                             const int* ranges,
                             int ranges_size,
                             Interval new_range);
 
-
 class BoyerMoorePositionInfo : public ZoneObject {
  public:
   explicit BoyerMoorePositionInfo(Zone* zone)
       : map_(new(zone) ZoneList<bool>(kMapSize, zone)),
         map_count_(0),
         w_(kNotYet),
         s_(kNotYet),
         d_(kNotYet),
         surrogate_(kNotYet) {
      for (int i = 0; i < kMapSize; i++) {
@@ skipping 16 matching lines @@
 
  private:
   ZoneList<bool>* map_;
   int map_count_;  // Number of set bits in the map.
   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 ZoneObject {
  public:
   BoyerMooreLookahead(int length, RegExpCompiler* compiler, Zone* zone);
 
   int length() { return length_; }
   int max_char() { return max_char_; }
   RegExpCompiler* compiler() { return compiler_; }
 
   int Count(int map_number) {
     return bitmaps_->at(map_number)->map_count();
@@ skipping 402 matching lines @@
   static const int kStringOffset = 0;
   static const int kPatternOffset = 1;
   static const int kArrayOffset = 2;
   static const int kLastMatchOffset = 3;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_REGEXP_JSREGEXP_H_