Generate code for choice nodes.

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 848 matching lines @@
 bool RegExpNode::GoTo(RegExpCompiler* compiler) {
   if (label.is_bound()) {
     compiler->macro_assembler()->GoTo(&label);
     return true;
   } else {
     return Emit(compiler);
   }
 }
 
 
-void RegExpNode::EmitAddress(RegExpCompiler* compiler) {
-  compiler->macro_assembler()->EmitOrLink(&label);
+Label* RegExpNode::GetLabel() {
+  return &label;
 }
 
 
 EndNode EndNode::kAccept(ACCEPT);
 EndNode EndNode::kBacktrack(BACKTRACK);
 
 
 bool EndNode::Emit(RegExpCompiler* compiler) {
   switch (action_) {
     case ACCEPT:
@@ skipping 75 matching lines @@
     visitor->Visit##Type(this);                                      \
   }
 FOR_EACH_NODE_TYPE(DEFINE_ACCEPT)
 #undef DEFINE_ACCEPT
 
 
 // -------------------------------------------------------------------
 // Emit code.
 
 
-bool ChoiceNode::Emit(RegExpCompiler* compiler) {
-  // TODO(erikcorry): Implement this.
-  return false;
+void ChoiceNode::GenerateGuard(RegExpCompiler* compiler,
+                               Guard *guard,
+                               Label* on_failure) {
+
 }
 
 
+bool ChoiceNode::Emit(RegExpCompiler* compiler) {
+  int choice_count = choices_->length();
+  RegExpMacroAssembler* macro_assembler = compiler->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; i++) {
+    GuardedAlternative alternative = (*choices_)[i];
+    Label after;
+    Label* next_alternative;
+    if (i < choice_count - 1) {
+      next_alternative = &after;
+    } else {
+      next_alternative = on_failure_->GetLabel();
+    }
+    ZoneList<Guard*>* guards = alternative.guards();
+    if (guards != NULL) {
+      int guard_count = guards->length();
+      for (int j = 0; j < guard_count; j++) {
+        GenerateGuard(compiler, (*guards)[i], next_alternative);
+      }
+    }
+    macro_assembler->PushBacktrack(next_alternative);
+    if (!alternative.node()->Emit(compiler)) {
+      after.Unuse();
+      if (next_alternative != &after) {
+        next_alternative->Unuse();
+      }
+      return false;
+    }
+    if (i < choice_count - 1) {
+      macro_assembler->Bind(&after);
+    } else {
+      after.Unuse();
+    }
+  }
+  compiler->AddWork(on_failure_);
+  return true;
+}
+
+
 bool ActionNode::Emit(RegExpCompiler* compiler) {
   RegExpMacroAssembler* macro = compiler->macro_assembler();
   switch (type_) {
     case STORE_REGISTER:
       macro->SetRegister(data_.u_store_register.reg,
                          data_.u_store_register.value);
       break;
     case INCREMENT_REGISTER:
       macro->AdvanceRegister(data_.u_increment_register.reg, 1);
       break;
@@ skipping 845 matching lines @@
 RegExpMacroAssembler::RegExpMacroAssembler() {
 
 }
 
 RegExpMacroAssembler::~RegExpMacroAssembler() {
 
 }
 
 
 }}  // namespace v8::internal