* Complete case independent support in Irregexp.

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 455 matching lines @@
 Handle<Object> RegExpImpl::IrregexpExecOnce(Handle<JSRegExp> regexp,
                                             int num_captures,
                                             Handle<String> two_byte_subject,
                                             int previous_index,
                                             int* offsets_vector,
                                             int offsets_vector_length) {
 #ifdef DEBUG
   if (FLAG_trace_regexp_bytecodes) {
     String* pattern = regexp->Pattern();
     PrintF("\n\nRegexp match:   /%s/\n\n", *(pattern->ToCString()));
-    PrintF("\n\nSubject string: '%s'\n\n", *(two_byte_subject->ToCString()));
+    //PrintF("\n\nSubject string: '%s'\n\n", *(two_byte_subject->ToCString()));

[Christian Plesner Hansen, 2008/11/27 06:49:39]

Either comment it back in or remove it.

   }
 #endif
   ASSERT(StringShape(*two_byte_subject).IsTwoByteRepresentation());
   ASSERT(two_byte_subject->IsFlat(StringShape(*two_byte_subject)));
   bool rc;
 
   for (int i = (num_captures + 1) * 2 - 1; i >= 0; i--) {
     offsets_vector[i] = -1;
   }
 
@@ skipping 437 matching lines @@
       is_case_independent_(ignore_case) {
   accept_ = new EndNode(EndNode::ACCEPT);
   backtrack_ = new EndNode(EndNode::BACKTRACK);
 }
 
 
 Handle<FixedArray> RegExpCompiler::Assemble(
     RegExpMacroAssembler* macro_assembler,
     RegExpNode* start,
     int capture_count) {
-  if (!FLAG_attempt_case_independent && is_case_independent_) {
-    return Handle<FixedArray>::null();
-  }
   macro_assembler_ = macro_assembler;
   List <RegExpNode*> work_list(0);
   work_list_ = &work_list;
   Label fail;
   macro_assembler->PushBacktrack(&fail);
   if (!start->GoTo(this)) {
     fail.Unuse();
     return Handle<FixedArray>::null();
   }
   while (!work_list.is_empty()) {
@@ skipping 402 matching lines @@
       cp_offset += elm.data.u_atom->data().length();
     }
   }
 
   compiler->AddWork(on_failure_);
   macro_assembler->AdvanceCurrentPosition(cp_offset);
   return on_success()->GoTo(compiler);
 }
 
 
+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);
+      }
+    }
+  }
+}
+
+
 bool ChoiceNode::Emit(RegExpCompiler* compiler) {
   int choice_count = alternatives_->length();
   RegExpMacroAssembler* macro_assembler = compiler->macro_assembler();
   Bind(macro_assembler);
   // For now we just call all choices one after the other.  The idea ultimately
   // is to use the Dispatch table to try only the relevant ones.
   for (int i = 0; i < choice_count - 1; i++) {
     GuardedAlternative alternative = alternatives_->at(i);
     Label after;
     Label after_no_pop_cp;
@@ skipping 1021 matching lines @@
   that->info()->been_analyzed = true;
 }
 
 
 void Analysis::VisitEnd(EndNode* that) {
   // nothing to do
 }
 
 
 void Analysis::VisitText(TextNode* that) {
+  if (case_independent_) {
+    that->MakeCaseIndependent();
+  }
   EnsureAnalyzed(that->on_success());
   EnsureAnalyzed(that->on_failure());
 }
 
 
 void Analysis::VisitAction(ActionNode* that) {
   RegExpNode* next = that->on_success();
   EnsureAnalyzed(next);
   that->info()->determine_newline = next->info()->prev_determine_newline();
   that->info()->determine_word = next->info()->prev_determine_word();
@@ skipping 155 matching lines @@
   //   since we don't even handle ^ yet I'm saving that optimization for
   //   later.
   RegExpNode* node = RegExpQuantifier::ToNode(0,
                                               RegExpQuantifier::kInfinity,
                                               false,
                                               new RegExpCharacterClass('*'),
                                               &compiler,
                                               captured_body,
                                               compiler.backtrack());
   if (node_return != NULL) *node_return = node;
-  Analysis analysis;
+  Analysis analysis(ignore_case);
   analysis.EnsureAnalyzed(node);
 
   if (!FLAG_irregexp) {
     return Handle<FixedArray>::null();
   }
 
 #if !(defined ARM || defined __arm__ || defined __thumb__)
   if (FLAG_irregexp_native) {  // Flag only checked in IA32 mode.
     // TODO(lrn) Move compilation to a later point in the life-cycle
     // of the RegExp. We don't know the type of input string yet.
     // For now, always assume two-byte strings.
     RegExpMacroAssemblerIA32 macro_assembler(RegExpMacroAssemblerIA32::UC16,
                                              (input->capture_count + 1) * 2);
     return compiler.Assemble(&macro_assembler,
                              node,
                              input->capture_count);
   }
 #endif
   byte codes[1024];
   IrregexpAssembler assembler(Vector<byte>(codes, 1024));
   RegExpMacroAssemblerIrregexp macro_assembler(&assembler);
   return compiler.Assemble(&macro_assembler,
                            node,
                            input->capture_count);
 }
 
 
 }}  // namespace v8::internal