Assertion interest

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 1434 matching lines @@
     return ActionNode::StoreRegister(reg_ctr, 0, center);
   } else {
     return center;
   }
 }
 
 
 RegExpNode* RegExpAssertion::ToNode(RegExpCompiler* compiler,
                                     RegExpNode* on_success,
                                     RegExpNode* on_failure) {
-  // TODO(self): implement assertions.
+  switch (type()) {
+    case START_OF_LINE:
+      on_success->info()->follows_newline_interest = true;
+      break;
+    case START_OF_INPUT:
+      on_success->info()->follows_start_interest = true;
+      break;
+    case BOUNDARY: case NON_BOUNDARY:
+      on_success->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.
+      on_success->info()->follows_start_interest = true;
+  }
   return on_success;
 }
 
 
 RegExpNode* RegExpBackreference::ToNode(RegExpCompiler* compiler,
                                         RegExpNode* on_success,
                                         RegExpNode* on_failure) {
   return new BackreferenceNode(RegExpCapture::StartRegister(index()),
                                RegExpCapture::EndRegister(index()),
                                on_success,
@@ skipping 330 matching lines @@
 
 void Analysis::VisitText(TextNode* that) {
   EnsureAnalyzed(that->on_success());
   EnsureAnalyzed(that->on_failure());
 }
 
 
 void Analysis::VisitAction(ActionNode* that) {
   RegExpNode* next = that->on_success();
   EnsureAnalyzed(next);
-  that->info()->propagate_line = next->info()->propagate_line;
+  that->info()->propagate_newline = next->info()->propagate_newline;
   that->info()->propagate_word = next->info()->propagate_word;
+  that->info()->propagate_start = next->info()->propagate_start;
 }
 
 
 void Analysis::VisitChoice(ChoiceNode* that) {
   NodeInfo* info = that->info();
   for (int i = 0; i < that->alternatives()->length(); i++) {
     RegExpNode* node = that->alternatives()->at(i).node();
     EnsureAnalyzed(node);
-    info->propagate_line |= node->info()->propagate_line;
+    info->propagate_newline |= node->info()->propagate_newline;
     info->propagate_word |= node->info()->propagate_word;
+    info->propagate_start |= node->info()->propagate_start;
   }
   if (!that->table_calculated()) {
     DispatchTableConstructor cons(that->table());
     cons.BuildTable(that);
   }
   EnsureAnalyzed(that->on_failure());
 }
 
 
 void Analysis::VisitBackreference(BackreferenceNode* that) {
@@ skipping 150 matching lines @@
 }
 
 RegExpMacroAssembler::RegExpMacroAssembler() {
 }
 
 RegExpMacroAssembler::~RegExpMacroAssembler() {
 }
 
 
 }}  // namespace v8::internal