Fix bug 486, Cyrillic character ranges in case independent regexps....

src/jsregexp.cc

 // Copyright 2006-2009 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 2422 matching lines @@
 
 
 void TextNode::MakeCaseIndependent() {
   int element_count = elms_->length();
   for (int i = 0; i < element_count; i++) {
     TextElement elm = elms_->at(i);
     if (elm.type == TextElement::CHAR_CLASS) {
       RegExpCharacterClass* cc = elm.data.u_char_class;
       ZoneList<CharacterRange>* ranges = cc->ranges();
       int range_count = ranges->length();
-      for (int i = 0; i < range_count; i++) {
-        ranges->at(i).AddCaseEquivalents(ranges);
+      for (int j = 0; j < range_count; j++) {
+        ranges->at(j).AddCaseEquivalents(ranges);
       }
     }
   }
 }
 
 
 int TextNode::GreedyLoopTextLength() {
   TextElement elm = elms_->at(elms_->length() - 1);
   if (elm.type == TextElement::CHAR_CLASS) {
     return elm.cp_offset + 1;
@@ skipping 1499 matching lines @@
     // The start of the current block.  Note that except for the first
     // iteration 'start' is always equal to 'pos'.
     int start;
     // If it is not the start point of a block the entry contains the
     // offset of the character from the start point.
     if ((range[0] & kStartMarker) == 0) {
       start = pos - range[0];
     } else {
       start = pos;
     }
-    // Then we add the ranges on at a time, incrementing the current
+    // Then we add the ranges one at a time, incrementing the current
     // position to be after the last block each time.  The position
     // always points to the start of a block.
     while (pos < to()) {
       length = canonrange.get(start, '\0', range);
       if (length == 0) {
         range[0] = start;
       } else {
         ASSERT_EQ(1, length);
       }
       ASSERT((range[0] & kStartMarker) != 0);
       // The start point of a block contains the distance to the end
       // of the range.
       int block_end = start + (range[0] & kPayloadMask) - 1;
       int end = (block_end > to()) ? to() : block_end;
       length = uncanonicalize.get(start, '\0', range);
       for (int i = 0; i < length; i++) {
         uc32 c = range[i];
         uc16 range_from = c + (pos - start);
         uc16 range_to = c + (end - start);
         if (!(from() <= range_from && range_to <= to())) {
           ranges->Add(CharacterRange(range_from, range_to));
         }
       }
       start = pos = block_end + 1;
     }
-  } else {
-    // TODO(plesner) when we've fixed the 2^11 bug in unibrow.
+  } else if (from() > 0 || to() < String::kMaxUC16CharCode) {
+    // Unibrow ranges don't work for high characters due to the "2^11 bug".
+    // Therefore we do something dumber for these ranges.  We don't bother
+    // if the range is 0-max (as encountered at the start of an unanchored
+    // regexp).
+    ZoneList<unibrow::uchar> *characters = new ZoneList<unibrow::uchar>(100);
+    int bottom = from();
+    int top = to();
+    for (int i = bottom; i <= top; i++) {
+      int length = uncanonicalize.get(i, '\0', chars);
+      for (int j = 0; j < length; j++) {
+        uc32 chr = chars[j];
+        if (chr != i && chr < bottom || chr > top) {
+          characters->Add(chr);
+        }
+      }
+    }
+    if (characters->length() > 0) {
+      int new_from = characters->at(0);
+      int new_to = new_from;
+      for (int i = 1; i < characters->length(); i++) {
+        int chr = characters->at(i);
+        if (chr == new_to + 1) {
+          new_to++;
+        } else {
+          if (new_to == new_from) {
+            ranges->Add(CharacterRange::Singleton(new_from));
+          } else {
+            ranges->Add(CharacterRange(new_from, new_to));
+          }
+          new_from = new_to = chr;
+        }
+      }
+      if (new_to == new_from) {
+        ranges->Add(CharacterRange::Singleton(new_from));
+      } else {
+        ranges->Add(CharacterRange(new_from, new_to));
+      }
+    }
   }
 }
 
 
 ZoneList<CharacterRange>* CharacterSet::ranges() {
   if (ranges_ == NULL) {
     ranges_ = new ZoneList<CharacterRange>(2);
     CharacterRange::AddClassEscape(standard_set_type_, ranges_);
   }
   return ranges_;
@@ skipping 481 matching lines @@
   RegExpMacroAssemblerIrregexp macro_assembler(codes);
 #endif
 
   return compiler.Assemble(&macro_assembler,
                            node,
                            data->capture_count,
                            pattern);
 }
 
 }}  // namespace v8::internal