Refactor allocation policies.

test/cctest/test-regexp.cc

 // Copyright 2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 449 matching lines @@
 }
 
 
 static bool NotWord(uc16 c) {
   return !IsRegExpWord(c);
 }
 
 
 static void TestCharacterClassEscapes(uc16 c, bool (pred)(uc16 c)) {
   ZoneScope scope(Isolate::Current(), DELETE_ON_EXIT);
-  ZoneList<CharacterRange>* ranges = new ZoneList<CharacterRange>(2);
+  ZoneList<CharacterRange>* ranges = ZoneList<CharacterRange>::New(ZONE, 2);
   CharacterRange::AddClassEscape(c, ranges);
   for (unsigned i = 0; i < (1 << 16); i++) {
     bool in_class = false;
     for (int j = 0; !in_class && j < ranges->length(); j++) {
       CharacterRange& range = ranges->at(j);
       in_class = (range.from() <= i && i <= range.to());
     }
     CHECK_EQ(pred(i), in_class);
   }
 }
@@ skipping 66 matching lines @@
 
 static unsigned PseudoRandom(int i, int j) {
   return ~(~((i * 781) ^ (j * 329)));
 }
 
 
 TEST(SplayTreeSimple) {
   v8::internal::V8::Initialize(NULL);
   static const unsigned kLimit = 1000;
   ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT);
-  ZoneSplayTree<TestConfig> tree;
+  ZoneSplayTree<TestConfig> tree(ZONE);
   bool seen[kLimit];
   for (unsigned i = 0; i < kLimit; i++) seen[i] = false;
 #define CHECK_MAPS_EQUAL() do {                                      \
     for (unsigned k = 0; k < kLimit; k++)                            \
       CHECK_EQ(seen[k], tree.Find(k, &loc));                         \
   } while (false)
   for (int i = 0; i < 50; i++) {
     for (int j = 0; j < 50; j++) {
       unsigned next = PseudoRandom(i, j) % kLimit;
       if (seen[next]) {
@@ skipping 47 matching lines @@
     for (int j = 0; j < 2 * kRangeSize; j++) {
       range[j] = PseudoRandom(i + 25, j + 87) % kLimit;
     }
     range.Sort();
     for (int j = 1; j < 2 * kRangeSize; j++) {
       CHECK(range[j-1] <= range[j]);
     }
   }
   // Enter test data into dispatch table.
   ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT);
-  DispatchTable table;
+  DispatchTable table(ZONE);
   for (int i = 0; i < kRangeCount; i++) {
     uc16* range = ranges[i];
     for (int j = 0; j < 2 * kRangeSize; j += 2)
       table.AddRange(CharacterRange(range[j], range[j + 1]), i);
   }
   // Check that the table looks as we would expect
   for (int p = 0; p < kLimit; p++) {
     OutSet* outs = table.Get(p);
     for (int j = 0; j < kRangeCount; j++) {
       uc16* range = ranges[j];
@@ skipping 742 matching lines @@
 #endif  // V8_INTERPRETED_REGEXP
 
 
 TEST(AddInverseToTable) {
   v8::internal::V8::Initialize(NULL);
   static const int kLimit = 1000;
   static const int kRangeCount = 16;
   for (int t = 0; t < 10; t++) {
     ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT);
     ZoneList<CharacterRange>* ranges =
-        new ZoneList<CharacterRange>(kRangeCount);
+        ZoneList<CharacterRange>::New(ZONE, kRangeCount);
     for (int i = 0; i < kRangeCount; i++) {
       int from = PseudoRandom(t + 87, i + 25) % kLimit;
       int to = from + (PseudoRandom(i + 87, t + 25) % (kLimit / 20));
       if (to > kLimit) to = kLimit;
       ranges->Add(CharacterRange(from, to));
     }
-    DispatchTable table;
-    DispatchTableConstructor cons(&table, false);
+    DispatchTable table(ZONE);
+    DispatchTableConstructor cons(ZONE, &table, false);
     cons.set_choice_index(0);
     cons.AddInverse(ranges);
     for (int i = 0; i < kLimit; i++) {
       bool is_on = false;
       for (int j = 0; !is_on && j < kRangeCount; j++)
         is_on = ranges->at(j).Contains(i);
       OutSet* set = table.Get(i);
       CHECK_EQ(is_on, set->Get(0) == false);
     }
   }
   ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT);
   ZoneList<CharacterRange>* ranges =
-          new ZoneList<CharacterRange>(1);
+      ZoneList<CharacterRange>::New(ZONE, 1);
   ranges->Add(CharacterRange(0xFFF0, 0xFFFE));
-  DispatchTable table;
-  DispatchTableConstructor cons(&table, false);
+  DispatchTable table(ZONE);
+  DispatchTableConstructor cons(ZONE, &table, false);
   cons.set_choice_index(0);
   cons.AddInverse(ranges);
   CHECK(!table.Get(0xFFFE)->Get(0));
   CHECK(table.Get(0xFFFF)->Get(0));
 }
 
 
 static uc32 canonicalize(uc32 c) {
   unibrow::uchar canon[unibrow::Ecma262Canonicalize::kMaxWidth];
   int count = unibrow::Ecma262Canonicalize::Convert(c, '\0', canon, NULL);
@@ skipping 89 matching lines @@
         CHECK_EQ(static_cast<int>(chars[k]), static_cast<int>(chars2[k]));
     }
   }
 }
 
 
 static void TestRangeCaseIndependence(CharacterRange input,
                                       Vector<CharacterRange> expected) {
   ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT);
   int count = expected.length();
-  ZoneList<CharacterRange>* list = new ZoneList<CharacterRange>(count);
+  ZoneList<CharacterRange>* list = ZoneList<CharacterRange>::New(ZONE, count);
   input.AddCaseEquivalents(list, false);
   CHECK_EQ(count, list->length());
   for (int i = 0; i < list->length(); i++) {
     CHECK_EQ(expected[i].from(), list->at(i).from());
     CHECK_EQ(expected[i].to(), list->at(i).to());
   }
 }
 
 
 static void TestSimpleRangeCaseIndependence(CharacterRange input,
@@ skipping 42 matching lines @@
     if (range.from() <= c && c <= range.to())
       return true;
   }
   return false;
 }
 
 
 TEST(CharClassDifference) {
   v8::internal::V8::Initialize(NULL);
   ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT);
-  ZoneList<CharacterRange>* base = new ZoneList<CharacterRange>(1);
+  ZoneList<CharacterRange>* base = ZoneList<CharacterRange>::New(ZONE, 1);
   base->Add(CharacterRange::Everything());
   Vector<const uc16> overlay = CharacterRange::GetWordBounds();
   ZoneList<CharacterRange>* included = NULL;
   ZoneList<CharacterRange>* excluded = NULL;
-  CharacterRange::Split(base, overlay, &included, &excluded);
+  CharacterRange::Split(ZONE, base, overlay, &included, &excluded);
   for (int i = 0; i < (1 << 16); i++) {
     bool in_base = InClass(i, base);
     if (in_base) {
       bool in_overlay = false;
       for (int j = 0; !in_overlay && j < overlay.length(); j += 2) {
         if (overlay[j] <= i && i <= overlay[j+1])
           in_overlay = true;
       }
       CHECK_EQ(in_overlay, InClass(i, included));
       CHECK_EQ(!in_overlay, InClass(i, excluded));
     } else {
       CHECK(!InClass(i, included));
       CHECK(!InClass(i, excluded));
     }
   }
 }
 
 
 TEST(CanonicalizeCharacterSets) {
   v8::internal::V8::Initialize(NULL);
   ZoneScope scope(Isolate::Current(), DELETE_ON_EXIT);
-  ZoneList<CharacterRange>* list = new ZoneList<CharacterRange>(4);
+  ZoneList<CharacterRange>* list = ZoneList<CharacterRange>::New(ZONE, 4);
   CharacterSet set(list);
 
   list->Add(CharacterRange(10, 20));
   list->Add(CharacterRange(30, 40));
   list->Add(CharacterRange(50, 60));
   set.Canonicalize();
   ASSERT_EQ(3, list->length());
   ASSERT_EQ(10, list->at(0).from());
   ASSERT_EQ(20, list->at(0).to());
   ASSERT_EQ(30, list->at(1).from());
@@ skipping 50 matching lines @@
     if (range.from() <= value && value <= range.to()) {
       return true;
     }
   }
   return false;
 }
 
 TEST(CharacterRangeMerge) {
   v8::internal::V8::Initialize(NULL);
   ZoneScope zone_scope(Isolate::Current(), DELETE_ON_EXIT);
-  ZoneList<CharacterRange> l1(4);
-  ZoneList<CharacterRange> l2(4);
+  ZoneList<CharacterRange> l1(ZONE, 4);
+  ZoneList<CharacterRange> l2(ZONE, 4);
   // Create all combinations of intersections of ranges, both singletons and
   // longer.
 
   int offset = 0;
 
   // The five kinds of singleton intersections:
   //     X
   //   Y      - outside before
   //    Y     - outside touching start
   //     Y    - overlap
@@ skipping 57 matching lines @@
   l1.Add(CharacterRange::Range(offset + 31, offset + 52));
   for (int i = 0; i < 6; i++) {
     l2.Add(CharacterRange::Range(offset + 2, offset + 5));
     l2.Add(CharacterRange::Singleton(offset + 8));
     offset += 9;
   }
 
   ASSERT(CharacterRange::IsCanonical(&l1));
   ASSERT(CharacterRange::IsCanonical(&l2));
 
-  ZoneList<CharacterRange> first_only(4);
-  ZoneList<CharacterRange> second_only(4);
-  ZoneList<CharacterRange> both(4);
+  ZoneList<CharacterRange> first_only(ZONE, 4);
+  ZoneList<CharacterRange> second_only(ZONE, 4);
+  ZoneList<CharacterRange> both(ZONE, 4);
 
   // Merge one direction.
   CharacterRange::Merge(&l1, &l2, &first_only, &second_only, &both);
 
   CHECK(CharacterRange::IsCanonical(&first_only));
   CHECK(CharacterRange::IsCanonical(&second_only));
   CHECK(CharacterRange::IsCanonical(&both));
 
   for (uc16 i = 0; i < offset; i++) {
     bool in_first = CharacterInSet(&l1, i);
@@ skipping 31 matching lines @@
 
   CHECK(CharacterRange::IsCanonical(&both));
 
   for (uc16 i = 0; i < offset; i++) {
     bool in_first = CharacterInSet(&l1, i);
     bool in_second = CharacterInSet(&l2, i);
     CHECK((in_first && in_second) == CharacterInSet(&both, i));
   }
 
   // Merge into same set.
-  ZoneList<CharacterRange> all(4);
+  ZoneList<CharacterRange> all(ZONE, 4);
   CharacterRange::Merge(&l1, &l2, &all, &all, &all);
 
   CHECK(CharacterRange::IsCanonical(&all));
 
   for (uc16 i = 0; i < offset; i++) {
     bool in_first = CharacterInSet(&l1, i);
     bool in_second = CharacterInSet(&l2, i);
     CHECK((in_first || in_second) == CharacterInSet(&all, i));
   }
 }
 
 
 TEST(Graph) {
   V8::Initialize(NULL);
   Execute("\\b\\w+\\b", false, true, true);
 }