Fix assert triggered in fast/regex/pcre-test-4.html We were not filtering out

src/jsregexp.cc

 // Copyright 2011 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 2408 matching lines @@
     char_mask = String::kMaxUtf16CodeUnit;
   }
   for (int k = 0; k < elms_->length(); k++) {
     TextElement elm = elms_->at(k);
     if (elm.type == TextElement::ATOM) {
       Vector<const uc16> quarks = elm.data.u_atom->data();
       for (int i = 0; i < characters && i < quarks.length(); i++) {
         QuickCheckDetails::Position* pos =
             details->positions(characters_filled_in);
         uc16 c = quarks[i];
-        // We should already have filtered out nodes that have non-ASCII
-        // characters if we are matching against an ASCII string.
-        ASSERT(c <= char_mask);
+        if (c > char_mask) {
+          // If we expect a non-ASCII character from an ASCII string,
+          // there is no way we can match. Not even case independent
+          // matching can turn an ASCII character into non-ASCII or     

[ulan, 2012/05/03 08:18:45]

Tabs and trailing spaces in this block.

+          // vice versa.        
+          details->set_cannot_match();  
+          pos->determines_perfectly = false;    
+          return;       
+        }
         if (compiler->ignore_case()) {
           unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
           int length = GetCaseIndependentLetters(isolate, c, compiler->ascii(),
                                                  chars);
           ASSERT(length != 0);  // Can only happen if c > char_mask (see above).
           if (length == 1) {
             // This letter has no case equivalents, so it's nice and simple
             // and the mask-compare will determine definitely whether we have
             // a match at this character position.
             pos->mask = char_mask;
@@ skipping 41 matching lines @@
         // A quick check uses multi-character mask and compare.  There is no
         // useful way to incorporate a negative char class into this scheme
         // so we just conservatively create a mask and value that will always
         // succeed.
         pos->mask = 0;
         pos->value = 0;
       } else {
         int first_range = 0;
         while (ranges->at(first_range).from() > char_mask) {
           first_range++;
-          // We should already have filtered out nodes that cannot match
-          // so the first range should be a valid range.
-          ASSERT(first_range != ranges->length());
+          if (first_range == ranges->length()) {
+            details->set_cannot_match();
+            pos->determines_perfectly = false;
+            return;
+          }
         }
         CharacterRange range = ranges->at(first_range);
         uc16 from = range.from();
         uc16 to = range.to();
         if (to > char_mask) {
           to = char_mask;
         }
         uint32_t differing_bits = (from ^ to);
         // A mask and compare is only perfect if the differing bits form a
         // number like 00011111 with one single block of trailing 1s.
@@ skipping 27 matching lines @@
         pos->value = bits;
       }
       characters_filled_in++;
       ASSERT(characters_filled_in <= details->characters());
       if (characters_filled_in == details->characters()) {
         return;
       }
     }
   }
   ASSERT(characters_filled_in != details->characters());
-  on_success()-> GetQuickCheckDetails(details,
-                                      compiler,
-                                      characters_filled_in,
-                                      true);
+  if (!details->cannot_match()) {
+    on_success()-> GetQuickCheckDetails(details,
+                                        compiler,
+                                        characters_filled_in,
+                                        true);
+  }
 }
 
 
 void QuickCheckDetails::Clear() {
   for (int i = 0; i < characters_; i++) {
     positions_[i].mask = 0;
     positions_[i].value = 0;
     positions_[i].determines_perfectly = false;
   }
   characters_ = 0;
@@ skipping 123 matching lines @@
     }
   }
   return FilterSuccessor(depth - 1);
 }
 
 
 RegExpNode* LoopChoiceNode::FilterASCII(int depth) {
   if (info()->replacement_calculated) return replacement();
   if (depth < 0) return this;
   if (info()->visited) return this;
-  VisitMarker marker(info());
-
-  RegExpNode* continue_replacement = continue_node_->FilterASCII(depth - 1);
-  // If we can't continue after the loop then there is no sense in doing the
-  // loop.
-  if (continue_replacement == NULL) return set_replacement(NULL);
+  {
+    VisitMarker marker(info());
+  
+    RegExpNode* continue_replacement = continue_node_->FilterASCII(depth - 1);
+    // If we can't continue after the loop then there is no sense in doing the
+    // loop.
+    if (continue_replacement == NULL) return set_replacement(NULL);
+  }
 
   return ChoiceNode::FilterASCII(depth - 1);
 }
 
 
 RegExpNode* ChoiceNode::FilterASCII(int depth) {
   if (info()->replacement_calculated) return replacement();
   if (depth < 0) return this;
   if (info()->visited) return this;
   VisitMarker marker(info());
@@ skipping 3159 matching lines @@
   }
 
   return compiler.Assemble(&macro_assembler,
                            node,
                            data->capture_count,
                            pattern);
 }
 
 
 }}  // namespace v8::internal