A brutal approach to V8 script liveedit

src/runtime.cc

 // Copyright 2006-2009 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 20 matching lines @@
 
 #include "accessors.h"
 #include "api.h"
 #include "arguments.h"
 #include "compiler.h"
 #include "cpu.h"
 #include "dateparser-inl.h"
 #include "debug.h"
 #include "execution.h"
 #include "jsregexp.h"
+#include "liveedit.h"
 #include "parser.h"
 #include "platform.h"
 #include "runtime.h"
 #include "scopeinfo.h"
 #include "smart-pointer.h"
 #include "stub-cache.h"
 #include "v8threads.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 7853 matching lines @@
 
 
 static Object* Runtime_FunctionGetInferredName(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
 
   CONVERT_CHECKED(JSFunction, f, args[0]);
   return f->shared()->inferred_name();
 }
 
+
+static int FindFunctionInfoForScript(Script* script,
+                                     FixedArray* buffer) {
+  AssertNoAllocation no_allocations;
+
+  int counter = 0;
+  int buffer_size = buffer->length();
+  HeapIterator iterator;
+  for (HeapObject* obj = iterator.next(); obj != NULL; obj = iterator.next()) {
+    ASSERT(obj != NULL);
+    if (!obj->IsSharedFunctionInfo()) {
+      continue;
+    }
+    SharedFunctionInfo* shared = SharedFunctionInfo::cast(obj);
+    if (shared->script() != script) {
+      continue;
+    }
+    if (counter < buffer_size) {
+      buffer->set(counter, shared, SKIP_WRITE_BARRIER);
+    }
+    counter++;
+  }
+  return counter;
+}
+
+static Object* Runtime_DebugChangeScriptLive(Arguments args) {
+  ASSERT(args.length() == 4);
+  HandleScope scope;
+  CONVERT_CHECKED(JSValue, script, args[0]);
+  CONVERT_NUMBER_CHECKED(int32_t, change_pos, Int32, args[1]);
+  CONVERT_NUMBER_CHECKED(int32_t, orig_len, Int32, args[2]);
+  CONVERT_ARG_CHECKED(String, new_str, 3);
+
+  Handle<Script> script_handle = Handle<Script>(Script::cast(script->value()));
+
+  const int kBufferSize = 32;
+
+  Handle<FixedArray> array;
+  array = Factory::NewFixedArray(kBufferSize);
+  int number = FindFunctionInfoForScript(*script_handle, *array);
+  if (number > kBufferSize) {
+    array = Factory::NewFixedArray(number);
+    FindFunctionInfoForScript(*script_handle, *array);
+  }
+
+  int new_len = new_str->length();
+
+  int diff = new_len - orig_len;
+
+  i::Handle<String> orig_source =
+      i::Handle<String>(String::cast(script_handle->source()));
+
+  int new_script_len = orig_source->length() + diff;
+
+  Object* str_object = Heap::AllocateRawTwoByteString(new_script_len);
+  if (str_object->IsFailure()) {
+    return Heap::undefined_value();
+  }
+
+  i::Handle<FixedArray> param_array = Factory::NewFixedArray(3);
+  param_array->set(0, *Factory::NewSubString(orig_source, 0, change_pos));
+  param_array->set(1, *new_str);
+  param_array->set(2, *Factory::NewSubString(orig_source, change_pos + orig_len,
+                                             orig_source->length()));
+
+  i::Handle<SeqTwoByteString> answer =
+      i::Handle<SeqTwoByteString>(SeqTwoByteString::cast(str_object));
+
+  StringBuilderConcatHelper(Heap::empty_string(),
+                            answer->GetChars(),
+                            *param_array,
+                            3);
+
+  ChangeScriptLive(script_handle, orig_source, answer,
+                   array, number,
+                   change_pos, orig_len, new_len);
+
+  return Heap::undefined_value();
+}
+
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
+
+
 #ifdef ENABLE_LOGGING_AND_PROFILING
 
 static Object* Runtime_ProfilerResume(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 2);
 
   CONVERT_CHECKED(Smi, smi_modules, args[0]);
   CONVERT_CHECKED(Smi, smi_tag, args[1]);
   v8::V8::ResumeProfilerEx(smi_modules->value(), smi_tag->value());
   return Heap::undefined_value();
@@ skipping 253 matching lines @@
   } else {
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     Counters::gc_last_resort_from_js.Increment();
     Heap::CollectAllGarbage(false);
   }
 }
 
 
 } }  // namespace v8::internal