* Issue 227 Fix.

src/jsregexp.cc

 // Copyright 2006-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 2209 matching lines @@
     char_mask = String::kMaxUC16CharCode;
     char_shift = 16;
   }
   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];
+        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
+          // vice versa.
+          details->set_cannot_match();
+          return;
+        }
         if (compiler->ignore_case()) {
           unibrow::uchar chars[unibrow::Ecma262UnCanonicalize::kMaxWidth];
-          uc16 c = quarks[i];
           int length = uncanonicalize.get(c, '\0', chars);
           if (length < 2) {
             // 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;
             pos->value = c;
             pos->determines_perfectly = true;
           } else {
             uint32_t common_bits = char_mask;
@@ skipping 12 matching lines @@
               pos->determines_perfectly = true;
             }
             pos->mask = common_bits;
             pos->value = bits;
           }
         } else {
           // Don't ignore case.  Nice simple case where the mask-compare will
           // determine definitely whether we have a match at this character
           // position.
           pos->mask = char_mask;
-          pos->value = quarks[i];
+          pos->value = c;
           pos->determines_perfectly = true;
         }
         characters_filled_in++;
         ASSERT(characters_filled_in <= details->characters());
         if (characters_filled_in == details->characters()) {
           return;
         }
       }
     } else {
       QuickCheckDetails::Position* pos =
@@ skipping 375 matching lines @@
     TextElement elm = elms_->at(i);
     int cp_offset = trace->cp_offset() + elm.cp_offset;
     if (elm.type == TextElement::ATOM) {
       if (pass == NON_ASCII_MATCH ||
           pass == CHARACTER_MATCH ||
           pass == CASE_CHARACTER_MATCH) {
         Vector<const uc16> quarks = elm.data.u_atom->data();
         for (int j = preloaded ? 0 : quarks.length() - 1; j >= 0; j--) {
           bool bound_checked = true;  // Most ops will check their bounds.
           if (first_element_checked && i == 0 && j == 0) continue;
-          if (quick_check != NULL &&
-              elm.cp_offset + j < quick_check->characters() &&
-              quick_check->positions(elm.cp_offset + j)->determines_perfectly) {
-            continue;
-          }
           if (pass == NON_ASCII_MATCH) {
             ASSERT(ascii);
             if (quarks[j] > String::kMaxAsciiCharCode) {
               assembler->GoTo(backtrack);
               return;
             }
-          } else if (pass == CHARACTER_MATCH) {
-            if (compiler->ignore_case()) {
-              bound_checked = EmitAtomNonLetter(assembler,
-                                                quarks[j],
-                                                backtrack,
-                                                cp_offset + j,
-                                                *checked_up_to < cp_offset + j,
-                                                preloaded);
+          } else {

[Christian Plesner Hansen, 2009/02/11 11:46:54]

This code is disgustingly complicated.  Your code is not to blame but this code
should have been rejected in an earlier code review for having too many special
cases.

+            if (quick_check != NULL &&
+                elm.cp_offset + j < quick_check->characters() &&
+                quick_check->positions(elm.cp_offset + j)->
+                    determines_perfectly) {
+              continue;
+            }
+            if (pass == CHARACTER_MATCH) {
+              if (compiler->ignore_case()) {
+                bound_checked = EmitAtomNonLetter(
+                    assembler,
+                    quarks[j],
+                    backtrack,
+                    cp_offset + j,
+                    *checked_up_to < cp_offset + j,
+                    preloaded);
+              } else {
+                if (!preloaded) {
+                  assembler->LoadCurrentCharacter(
+                      cp_offset + j,
+                      backtrack,
+                      *checked_up_to < cp_offset + j);
+                }
+                assembler->CheckNotCharacter(quarks[j], backtrack);
+              }
             } else {
-              if (!preloaded) {
-                assembler->LoadCurrentCharacter(cp_offset + j,
-                                                backtrack,
-                                                *checked_up_to < cp_offset + j);
+              ASSERT_EQ(pass, CASE_CHARACTER_MATCH);
+              ASSERT(compiler->ignore_case());
+              bound_checked = EmitAtomLetter(assembler,
+                                             compiler->ascii(),
+                                             quarks[j],
+                                             backtrack,
+                                             cp_offset + j,
+                                             *checked_up_to < cp_offset + j,
+                                             preloaded);
+            }
+            if (bound_checked) {
+              if (cp_offset + j > *checked_up_to) {
+                *checked_up_to = cp_offset + j;
               }
-              assembler->CheckNotCharacter(quarks[j], backtrack);
-            }
-          } else {
-            ASSERT_EQ(pass, CASE_CHARACTER_MATCH);
-            ASSERT(compiler->ignore_case());
-            bound_checked = EmitAtomLetter(assembler,
-                                           compiler->ascii(),
-                                           quarks[j],
-                                           backtrack,
-                                           cp_offset + j,
-                                           *checked_up_to < cp_offset + j,
-                                           preloaded);
-          }
-          if (pass != NON_ASCII_MATCH && bound_checked) {
-            if (cp_offset + j > *checked_up_to) {
-              *checked_up_to = cp_offset + j;
             }
           }
         }
       }
     } else {
       ASSERT_EQ(elm.type, TextElement::CHAR_CLASS);
       if (first_element_checked && i == 0) continue;
       if (quick_check != NULL &&
           elm.cp_offset < quick_check->characters() &&
           quick_check->positions(elm.cp_offset)->determines_perfectly) {
@@ skipping 2155 matching lines @@
   EmbeddedVector<byte, 1024> codes;
   RegExpMacroAssemblerIrregexp macro_assembler(codes);
   return compiler.Assemble(&macro_assembler,
                            node,
                            data->capture_count,
                            pattern);
 }
 
 
 }}  // namespace v8::internal