arrange to create prototypes for generators

src/bootstrapper.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 1303 matching lines @@
 
   if (FLAG_harmony_typed_arrays) {
     { // -- A r r a y B u f f e r
       Handle<JSObject> prototype =
           factory()->NewJSObject(isolate()->object_function(), TENURED);
       InstallFunction(global, "__ArrayBuffer", JS_ARRAY_BUFFER_TYPE,
                       JSArrayBuffer::kSize, prototype,
                       Builtins::kIllegal, true);
     }
   }
+
+  if (FLAG_harmony_generators) {
+    // Fetch Function, Function.prototype, Object.prototype, and some maps from
+    // the environment.
+    Handle<String> function_string = factory()->function_class_string();
+    Handle<JSFunction> function = Handle<JSFunction>::cast(
+        GetProperty(isolate(), isolate()->global_object(), function_string));
+    Handle<JSObject> function_prototype(JSObject::cast(
+        function->instance_prototype()));
+    Handle<JSObject> object_prototype(isolate()->initial_object_prototype());
+    Handle<Map> function_map(native_context()->function_map());
+    Handle<Map> strict_mode_function_map(
+        native_context()->strict_mode_function_map());
+    Handle<Map> object_map(native_context()->object_function()->initial_map());
+
+    // Create generator meta-objects and install them on the builtins object.
+    Handle<JSObject> builtins(native_context()->builtins());
+    Handle<JSObject> generator_object_prototype =
+        factory()->NewJSObject(isolate()->object_function(), TENURED);
+    Handle<JSFunction> generator_function_prototype =
+        InstallFunction(builtins, "GeneratorFunctionPrototype",
+                        JS_FUNCTION_TYPE, JSFunction::kHeaderSize,
+                        generator_object_prototype, Builtins::kIllegal,
+                        false);
+    SetPrototype(Handle<JSObject>::cast(generator_function_prototype),
+                 function_prototype);
+    Handle<JSFunction> generator_function =
+        InstallFunction(builtins, "GeneratorFunction", JS_FUNCTION_TYPE,
+                        JSFunction::kSize, generator_function_prototype,
+                        Builtins::kIllegal, false);
+    SetPrototype(Handle<JSObject>::cast(generator_function),
+                 function);
+
+    // Create maps for generator functions and their prototypes.  Store those
+    // maps in the native context.
+    Handle<Map> generator_function_map = factory()->CopyMap(function_map);
+    generator_function_map->set_prototype(*generator_function_prototype);
+    native_context()->set_generator_function_map(*generator_function_map);
+
+    Handle<Map> strict_mode_generator_function_map = factory()->CopyMap(
+        strict_mode_function_map);
+    strict_mode_generator_function_map->set_prototype(
+        *generator_function_prototype);
+    native_context()->set_strict_mode_generator_function_map(
+        *strict_mode_generator_function_map);
+
+    Handle<Map> generator_object_prototype_map = factory()->CopyMap(
+        object_map, 0);
+    generator_object_prototype_map->set_prototype(
+        *generator_object_prototype);
+    native_context()->set_generator_object_prototype_map(
+        *generator_object_prototype_map);
+  }
 }
 
 
 bool Genesis::CompileBuiltin(Isolate* isolate, int index) {
   Vector<const char> name = Natives::GetScriptName(index);
   Handle<String> source_code =
       isolate->bootstrapper()->NativesSourceLookup(index);
   return CompileNative(isolate, name, source_code);
 }
 
@@ skipping 592 matching lines @@
     if (FLAG_harmony_observation &&
         strcmp(ExperimentalNatives::GetScriptName(i).start(),
                "native object-observe.js") == 0) {
       if (!CompileExperimentalBuiltin(isolate(), i)) return false;
     }
     if (FLAG_harmony_typed_arrays &&
         strcmp(ExperimentalNatives::GetScriptName(i).start(),
                "native typedarray.js") == 0) {
       if (!CompileExperimentalBuiltin(isolate(), i)) return false;
     }
+    if (FLAG_harmony_generators &&
+        strcmp(ExperimentalNatives::GetScriptName(i).start(),
+               "native generator.js") == 0) {
+      if (!CompileExperimentalBuiltin(isolate(), i)) return false;
+    }
   }
 
   InstallExperimentalNativeFunctions();
 
   return true;
 }
 
 
 static Handle<JSObject> ResolveBuiltinIdHolder(
     Handle<Context> native_context,
@@ skipping 564 matching lines @@
   return from + sizeof(NestingCounterType);
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   ASSERT(!IsActive());
 }
 
 } }  // namespace v8::internal