Generators can resume

src/runtime.cc

 // Copyright 2012 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 2457 matching lines @@
     // TODO(wingo): Save the operand stack and/or the stack handlers.
     UNIMPLEMENTED();
   }
 
   // The return value is the hole for a suspend return, and anything else for a
   // resume return.
   return isolate->heap()->the_hole_value();
 }
 
 
+// Note that this function is the slow path for resuming generators.  It is only
+// called if the suspended activation had operands on the stack, stack handlers
+// needing rewinding, or if the resume should throw an exception.  The fast path
+// is handled directly in FullCodeGenerator::EmitResume(), which is inlined into
+// GeneratorNext, GeneratorSend, and GeneratorThrow.  EmitResume is called in
+// any case, as it needs to reconstruct the stack frame and make space for
+// arguments and operands.
+RUNTIME_FUNCTION(MaybeObject*, Runtime_ResumeJSGeneratorObject) {
+  HandleScope scope(isolate);
+  ASSERT(args.length() == 3);
+  CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator_object, 0);
+  CONVERT_ARG_HANDLE_CHECKED(Object, value, 1);
+  CONVERT_SMI_ARG_CHECKED(resume_mode_int, 2);
+  JSGeneratorObject::ResumeMode resume_mode =

[Michael Starzinger, 2013/04/21 22:45:21]

Move the "resume_mode" local variable down to right before the switch. Local
code FTW. The CONVERT_SMI_ARG_CHECKED should stay here though.

[wingo, 2013/04/23 13:51:04]

Done.

+      static_cast<JSGeneratorObject::ResumeMode>(resume_mode_int);
+  JavaScriptFrameIterator stack_iterator(isolate);
+  JavaScriptFrame *frame = stack_iterator.frame();
+
+  ASSERT_EQ(frame->function(), generator_object->function());
+
+  byte* pc = generator_object->function()->code()->instruction_start();

[Michael Starzinger, 2013/04/21 22:45:21]

Use "Address" instead of "byte*" here.

[wingo, 2013/04/23 13:51:04]

Done.

+  int offset = generator_object->continuation();
+  ASSERT(offset > 0);
+  frame->set_pc(pc + offset);
+  generator_object->set_continuation(JSGeneratorObject::kGeneratorExecuting);
+
+  if (generator_object->operand_stack()->length() != 0) {
+    // TODO(wingo): Copy operand stack.  Rewind handlers.
+    UNIMPLEMENTED();
+  }
+
+  switch (resume_mode) {
+    default:

[Michael Starzinger, 2013/04/21 22:45:21]

Drop the default case for enums.

[wingo, 2013/04/23 13:51:04]

Done, though I still had to have an UNREACHABLE at the function's end to get the
compiler to be happy.

+      UNREACHABLE();
+    case JSGeneratorObject::kSend:
+      return *value;
+    case JSGeneratorObject::kThrow:
+      return isolate->Throw(*value);
+  }
+}
+
+
+RUNTIME_FUNCTION(MaybeObject*, Runtime_ThrowGeneratorStateError) {
+  HandleScope scope(isolate);
+  ASSERT(args.length() == 1);
+  CONVERT_ARG_HANDLE_CHECKED(JSGeneratorObject, generator, 0);
+  int continuation = generator->continuation();
+  const char *message = continuation == JSGeneratorObject::kGeneratorClosed ?
+      "generator_finished" : "generator_running";
+  Vector< Handle<Object> > argv = HandleVector<Object>(NULL, 0);
+  Handle<Object> error = isolate->factory()->NewError(message, argv);
+  return isolate->Throw(*error);
+}
+
+
 MUST_USE_RESULT static MaybeObject* CharFromCode(Isolate* isolate,
                                                  Object* char_code) {
   if (char_code->IsNumber()) {
     return isolate->heap()->LookupSingleCharacterStringFromCode(
         NumberToUint32(char_code) & 0xffff);
   }
   return isolate->heap()->empty_string();
 }
 
 
@@ skipping 10803 matching lines @@
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags,
                                        "Runtime::PerformGC");
   }
 }
 
 
 } }  // namespace v8::internal