Rudimentary assertion expansion

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 304 matching lines @@
       return unibrow::Space::Is(c);
   }
 }
 
 
 static bool NotWhiteSpace(uc16 c) {
   return !IsWhiteSpace(c);
 }
 
 
-static bool IsWord(uc16 c) {
-  return ('a' <= c && c <= 'z')
-      || ('A' <= c && c <= 'Z')
-      || ('0' <= c && c <= '9')
-      || (c == '_');
-}
-
-
 static bool NotWord(uc16 c) {

[Lasse Reichstein, 2008/12/01 11:55:47]

Symmetry suggests NotRegExpWord.

-  return !IsWord(c);
+  return !IsRegExpWord(c);
 }
 
 
-static bool Dot(uc16 c) {
-  switch (c) {
-    //   CR           LF           LS           PS
-    case 0x000A: case 0x000D: case 0x2028: case 0x2029:
-      return false;
-    default:
-      return true;
-  }
-}
-
-
 static void TestCharacterClassEscapes(uc16 c, bool (pred)(uc16 c)) {
   ZoneScope scope(DELETE_ON_EXIT);
   ZoneList<CharacterRange>* ranges = new ZoneList<CharacterRange>(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);
   }
 }
 
 
 TEST(CharacterClassEscapes) {
-  TestCharacterClassEscapes('.', Dot);
+  TestCharacterClassEscapes('.', IsRegExpNewline);

[Lasse Reichstein, 2008/12/01 11:55:47]

Shouldn't this be IsNOTRegExpNewline?

   TestCharacterClassEscapes('d', IsDigit);
   TestCharacterClassEscapes('D', NotDigit);
   TestCharacterClassEscapes('s', IsWhiteSpace);
   TestCharacterClassEscapes('S', NotWhiteSpace);
-  TestCharacterClassEscapes('w', IsWord);
+  TestCharacterClassEscapes('w', IsRegExpWord);
   TestCharacterClassEscapes('W', NotWord);
 }
 
 
 static RegExpNode* Compile(const char* input, bool multiline) {
   FlatStringReader reader(CStrVector(input));
   RegExpParseResult result;
   if (!v8::internal::ParseRegExp(&reader, multiline, &result))
     return NULL;
   RegExpNode* node = NULL;
   RegExpEngine::Compile(&result, &node, false, multiline);
   return node;
 }
 
 
 static void Execute(const char* input,
                     bool multiline,
                     bool dot_output = false) {
   v8::HandleScope scope;
   ZoneScope zone_scope(DELETE_ON_EXIT);
   RegExpNode* node = Compile(input, multiline);
   USE(node);
 #ifdef DEBUG
   if (dot_output) {
-    RegExpEngine::DotPrint(input, node);
+    RegExpEngine::DotPrint(input, node, false);
     exit(0);
   }
 #endif  // DEBUG
 }
 
 
 class TestConfig {
  public:
   typedef int Key;
   typedef int Value;
@@ skipping 475 matching lines @@
     ZoneScope zone_scope(DELETE_ON_EXIT);
     ZoneList<CharacterRange>* ranges =
         new ZoneList<CharacterRange>(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);
+    DispatchTableConstructor cons(&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(DELETE_ON_EXIT);
   ZoneList<CharacterRange>* ranges =
           new ZoneList<CharacterRange>(1);
   ranges->Add(CharacterRange(0xFFF0, 0xFFFE));
   DispatchTable table;
-  DispatchTableConstructor cons(&table);
+  DispatchTableConstructor cons(&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 161 matching lines @@
   TestSimpleRangeCaseIndependence(CharacterRange('A' - 1, 'Z' + 1),
                                   CharacterRange('a', 'z'));
   // Here we need to add [l-z] to complete the case independence of
   // [A-Za-z] but we expect [a-z] to be added since we always add a
   // whole block at a time.
   TestSimpleRangeCaseIndependence(CharacterRange('A', 'k'),
                                   CharacterRange('a', 'z'));
 }
 
 
+static bool InClass(uc16 c, ZoneList<CharacterRange>* ranges) {
+  if (ranges == NULL)
+    return false;
+  for (int i = 0; i < ranges->length(); i++) {
+    CharacterRange range = ranges->at(i);
+    if (range.from() <= c && c <= range.to())
+      return true;
+  }
+  return false;
+}
+
+
+TEST(CharClassDifference) {
+  ZoneScope zone_scope(DELETE_ON_EXIT);
+  ZoneList<CharacterRange>* base = new ZoneList<CharacterRange>(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);
+  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(Graph) {
   V8::Initialize(NULL);
-  Execute("foo$(?!bar)", false, true);
+  Execute("\\b\\w", false, true);
 }