Add back references. Since "back references" is two words...

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 1264 matching lines @@
           data_.u_submatch_stack_pointer_register.reg);
       break;
     default:
       UNREACHABLE();
       return false;
   }
   return on_success()->GoTo(compiler);
 }
 
 
+bool BackReferenceNode::Emit(RegExpCompiler* compiler) {
+  RegExpMacroAssembler* macro = compiler->macro_assembler();
+  Bind(macro);
+  // Check whether the registers are uninitialized and always
+  // succeed if they are.
+  macro->IfRegisterLT(start_reg_, 0, on_success()->label());
+  macro->IfRegisterLT(end_reg_, 0, on_success()->label());
+  ASSERT(start_reg_ + 1 == end_reg_);

[Christian Plesner Hansen, 2008/11/21 11:16:39]

ASSERT_EQ

+  macro->CheckNotBackReference(start_reg_, on_failure_->label());
+  return on_success()->GoTo(compiler);
+}
+
+
 // -------------------------------------------------------------------
 // Dot/dotty output
 
 
 #ifdef DEBUG
 
 
 class DotPrinter: public NodeVisitor {
  public:
   DotPrinter() : stream_(&alloc_) { }
@@ skipping 143 matching lines @@
         UNREACHABLE();
     }
   }
   stream()->Add("\", shape=box, peripheries=2];\n");
   stream()->Add("  n%p -> n%p;\n", that, that->on_success());
   Visit(that->on_success());
   PrintOnFailure(that, that->on_failure());
 }
 
 
-void DotPrinter::VisitBackreference(BackreferenceNode* that) {
+void DotPrinter::VisitBackReference(BackReferenceNode* that) {
   stream()->Add("  n%p [label=\"$%i..$%i\", shape=doubleoctagon];\n",
                 that,
                 that->start_register(),
                 that->end_register());
   stream()->Add("  n%p -> n%p;\n", that, that->on_success());
   Visit(that->on_success());
   PrintOnFailure(that, that->on_failure());
 }
 
 
@@ skipping 212 matching lines @@
       info.follows_word_interest = true;
       break;
     case END_OF_LINE: case END_OF_INPUT:
       // This is wrong but has the effect of making the compiler abort.
       info.follows_start_interest = true;
   }
   return on_success->PropagateInterest(&info);
 }
 
 
-RegExpNode* RegExpBackreference::ToNode(RegExpCompiler* compiler,
+RegExpNode* RegExpBackReference::ToNode(RegExpCompiler* compiler,
                                         RegExpNode* on_success,
                                         RegExpNode* on_failure) {
-  return new BackreferenceNode(RegExpCapture::StartRegister(index()),
+  return new BackReferenceNode(RegExpCapture::StartRegister(index()),
                                RegExpCapture::EndRegister(index()),
                                on_success,
                                on_failure);
 }
 
 
 RegExpNode* RegExpEmpty::ToNode(RegExpCompiler* compiler,
                                 RegExpNode* on_success,
                                 RegExpNode* on_failure) {
   return on_success;
@@ skipping 234 matching lines @@
   }
   return choice;
 }
 
 
 RegExpNode* EndNode::PropagateInterest(NodeInfo* info) {
   return PropagateToEndpoint(this, info);
 }
 
 
-RegExpNode* BackreferenceNode::PropagateInterest(NodeInfo* info) {
+RegExpNode* BackReferenceNode::PropagateInterest(NodeInfo* info) {
   return PropagateToEndpoint(this, info);
 }
 
 
 RegExpNode* TextNode::PropagateInterest(NodeInfo* info) {
   return PropagateToEndpoint(this, info);
 }
 
 
 // -------------------------------------------------------------------
@@ skipping 189 matching lines @@
     info->determine_start |= node->info()->prev_determine_start();
   }
   if (!that->table_calculated()) {
     DispatchTableConstructor cons(that->table());
     cons.BuildTable(that);
   }
   EnsureAnalyzed(that->on_failure());
 }
 
 
-void Analysis::VisitBackreference(BackreferenceNode* that) {
+void Analysis::VisitBackReference(BackReferenceNode* that) {
   EnsureAnalyzed(that->on_success());
   EnsureAnalyzed(that->on_failure());
 }
 
 
 // -------------------------------------------------------------------
 // Dispatch table construction
 
 
 void DispatchTableConstructor::VisitEnd(EndNode* that) {
@@ skipping 36 matching lines @@
   if (!node->table_calculated()) {
     DispatchTableConstructor constructor(node->table());
     constructor.BuildTable(node);
   }
   ASSERT(node->table_calculated());
   AddDispatchRange adder(this);
   node->table()->ForEach(&adder);
 }
 
 
-void DispatchTableConstructor::VisitBackreference(BackreferenceNode* that) {
-  // TODO(plesner): What should this do?
+void DispatchTableConstructor::VisitBackReference(BackReferenceNode* that) {
+  // TODO(plesner): Find the node that we refer back to and propagate its start
+  // set back to here.  For now we just accept anything.
+  AddRange(CharacterRange::Everything());
+  RegExpNode* next = that->on_success();
+  that->info()->determine_newline = next->info()->prev_determine_newline();

[Christian Plesner Hansen, 2008/11/21 11:16:39]

Propagating this stuff is not the dispatch table constructor's job.

+  that->info()->determine_word = next->info()->prev_determine_word();
+  that->info()->determine_start = next->info()->prev_determine_start();
 }
 
 
 
 static int CompareRangeByFrom(const CharacterRange* a,
                               const CharacterRange* b) {
   return Spaceship<uc16>(a->from(), b->from());
 }
 
 
@@ skipping 82 matching lines @@
 }
 
 RegExpMacroAssembler::RegExpMacroAssembler() {
 }
 
 RegExpMacroAssembler::~RegExpMacroAssembler() {
 }
 
 
 }}  // namespace v8::internal