Merge pull request #126 from lightpanda-io/snapshots_v3

Snapshots v3

Author: karlseguin

src/binding.cpp

@@ -396,6 +396,14 @@ void v8__Isolate__EnqueueMicrotaskFunc(v8::Isolate* self, const v8::Function* fu
     self->EnqueueMicrotask(ptr_to_local(function));
 }
 
+const v8::Data* v8__Isolate__GetDataFromSnapshotOnce(v8::Isolate *self, size_t idx) {
+    v8::MaybeLocal<v8::Data> maybe = self->GetDataFromSnapshotOnce<v8::Data>(idx);
+    if (maybe.IsEmpty()) {
+        return nullptr;
+    }
+    return local_to_ptr(maybe.ToLocalChecked());
+}
+
 size_t v8__HeapStatistics__SIZEOF() {
     return sizeof(v8::HeapStatistics);
 }
@@ -491,6 +499,14 @@ v8::Context* v8__Context__New(
     );
 }
 
+v8::Context* v8__Context__FromSnapshot(v8::Isolate* isolate, size_t index) {
+    v8::MaybeLocal<v8::Context> maybe = v8::Context::FromSnapshot(isolate, index);
+    if (maybe.IsEmpty()) {
+        return nullptr;
+    }
+    return local_to_ptr(maybe.ToLocalChecked());
+}
+
 void v8__Context__Enter(const v8::Context& context) { ptr_to_local(&context)->Enter(); }
 
 void v8__Context__Exit(const v8::Context& context) { ptr_to_local(&context)->Exit(); }
@@ -521,6 +537,14 @@ int v8__Context__DebugContextId(const v8::Context& self) {
     return v8::debug::GetContextId(ptr_to_local(&self));
 }
 
+const v8::Data* v8__Context__GetDataFromSnapshotOnce(v8::Context *self, size_t idx) {
+    v8::MaybeLocal<v8::Data> maybe = self->GetDataFromSnapshotOnce<v8::Data>(idx);
+    if (maybe.IsEmpty()) {
+        return nullptr;
+    }
+    return local_to_ptr(maybe.ToLocalChecked());
+}
+
 // ScriptOrigin
 
 void v8__ScriptOrigin__CONSTRUCT(
@@ -2258,3 +2282,44 @@ void v8_inspector__Client__consoleAPIMessage(
 }
 
 } // extern "C"
+
+// SnapshotCreator
+extern "C" {
+
+v8::SnapshotCreator* v8__SnapshotCreator__CREATE(const v8::Isolate::CreateParams& params) {
+    return new v8::SnapshotCreator(params);
+}
+
+v8::Isolate* v8__SnapshotCreator__getIsolate(v8::SnapshotCreator* self) {
+    return self->GetIsolate();
+}
+
+size_t v8__SnapshotCreator__AddData(v8::SnapshotCreator* self, const v8::Data* data) {
+    return self->AddData(ptr_to_local(data));
+}
+
+size_t v8__SnapshotCreator__AddData2(v8::SnapshotCreator* self, const v8::Context* ctx, const v8::Data* data) {
+    return self->AddData(ptr_to_local(ctx), ptr_to_local(data));
+}
+
+void v8__SnapshotCreator__setDefaultContext(
+    v8::SnapshotCreator* self,
+    const v8::Context& ctx) {
+    return self->SetDefaultContext(ptr_to_local(&ctx));
+}
+
+v8::StartupData v8__SnapshotCreator__createBlob(
+    v8::SnapshotCreator *self,
+    v8::SnapshotCreator::FunctionCodeHandling function_code_handling) {
+  return self->CreateBlob(function_code_handling);
+}
+
+void v8__SnapshotCreator__DESTRUCT(v8::SnapshotCreator* self) {
+  delete self;
+}
+
+bool v8__StartupData__IsValid(v8::StartupData self) {
+    return self.IsValid();
+}
+
+} // extern "C"

src/binding.h

@@ -205,6 +205,9 @@ const char* v8__V8__GetVersion();
 // Microtask
 typedef enum MicrotasksPolicy { kExplicit, kScoped, kAuto } MicrotasksPolicy;
 
+// Snapshot
+typedef enum FunctionCodeHandling { kClear, kKeep } FunctionCodeHandling;
+
 // Isolate
 Isolate* v8__Isolate__New(CreateParams* params);
 void v8__Isolate__Enter(Isolate* isolate);
@@ -269,6 +272,7 @@ void v8__Isolate__SetData(Isolate* self, int idx, void* val);
 typedef void (*MicrotaskCallback)(void* data);
 void v8__Isolate__EnqueueMicrotask(Isolate* self, MicrotaskCallback callback, void* data);
 void v8__Isolate__EnqueueMicrotaskFunc(Isolate* self, const Function* function);
+const Data* v8__Isolate__GetDataFromSnapshotOnce(const Isolate *self, size_t idx);
 
 typedef struct StartupData {
     const char* data;
@@ -410,6 +414,7 @@ bool v8__StackFrame__IsUserJavaScript(const StackFrame* self);
 typedef struct Context Context;
 typedef struct ObjectTemplate ObjectTemplate;
 Context* v8__Context__New(Isolate* isolate, const ObjectTemplate* global_tmpl, const Value* global_obj);
+Context* v8__Context__FromSnapshot(Isolate*, size_t);
 void v8__Context__Enter(const Context* context);
 void v8__Context__Exit(const Context* context);
 Isolate* v8__Context__GetIsolate(const Context* context);
@@ -422,6 +427,7 @@ void v8__Context__SetEmbedderData(
     int idx,
     const Value* val);
 int v8__Context__DebugContextId(const Context* self);
+const Data* v8__Context__GetDataFromSnapshotOnce(const Context *self, size_t idx);
 
 // Boolean
 const Boolean* v8__Boolean__New(
@@ -1267,3 +1273,15 @@ void v8_inspector__RemoteObject__setPreview(RemoteObject* self, ObjectPreview* p
 bool v8_inspector__RemoteObject__hasCustomPreview(RemoteObject* self);
 const CustomPreview* v8_inspector__RemoteObject__getCustomPreview(RemoteObject* self);
 void v8_inspector__RemoteObject__setCustomPreview(RemoteObject* self, CustomPreview* customPreview);
+
+// SnapshotCreator
+typedef struct SnapshotCreator SnapshotCreator;
+
+SnapshotCreator* v8__SnapshotCreator__CREATE(const CreateParams*);
+Isolate* v8__SnapshotCreator__getIsolate(SnapshotCreator*);
+void v8__SnapshotCreator__setDefaultContext(SnapshotCreator*, const Context*);
+size_t v8__SnapshotCreator__AddData(SnapshotCreator*, const Data* data);
+size_t v8__SnapshotCreator__AddData2(SnapshotCreator*, const Context* ctx, const Data* data);
+StartupData v8__SnapshotCreator__createBlob(SnapshotCreator*, FunctionCodeHandling);
+void v8__SnapshotCreator__DESTRUCT(SnapshotCreator*);
+bool v8__StartupData__IsValid(StartupData);

src/v8.zig

@@ -52,6 +52,11 @@ pub const MicrotasksPolicy = struct {
     pub const kAuto = c.kAuto;
 };
 
+pub const FunctionCodeHandling = struct {
+    pub const kClear = c.kClear;
+    pub const kKeep = c.kKeep;
+};
+
 // Currently, user callback functions passed into FunctionTemplate will need to have this declared as a param and then
 // converted to FunctionCallbackInfo to get a nicer interface.
 pub const C_FunctionCallbackInfo = c.FunctionCallbackInfo;
@@ -508,6 +513,10 @@ pub const Isolate = struct {
     pub fn enqueueMicrotaskFunc(self: Self, function: Function) void {
         c.v8__Isolate__EnqueueMicrotaskFunc(self.handle, function.handle);
     }
+
+    pub fn getDataFromSnapshotOnce(self: Self, idx: usize) ?*const c.Data {
+        return c.v8__Isolate__GetDataFromSnapshotOnce(self.handle, idx);
+    }
 };
 
 pub const HandleScope = struct {
@@ -558,6 +567,11 @@ pub const Context = struct {
         };
     }
 
+    pub fn fromSnapshot(isolate: Isolate, index: usize) ?Self {
+        const handle = c.v8__Context__FromSnapshot(isolate.handle, index) orelse return null;
+        return .{.handle = handle};
+    }
+
     /// [V8]
     /// Enter this context.  After entering a context, all code compiled
     /// and run is compiled and run in this context.  If another context
@@ -601,6 +615,10 @@ pub const Context = struct {
     pub fn debugContextId(self: Self) i32 {
         return c.v8__Context__DebugContextId(self.handle);
     }
+
+    pub fn getDataFromSnapshotOnce(self: Self, idx: usize) ?*const c.Data {
+        return c.v8__Context__GetDataFromSnapshotOnce(self.handle, idx);
+    }
 };
 
 pub const PropertyCallbackInfo = struct {
@@ -3217,3 +3235,43 @@ pub export fn zigAlloc(self: *anyopaque, bytes: usize) callconv(.c) ?[*]u8 {
     const allocated_bytes = allocator.alloc(u8, bytes) catch return null;
     return allocated_bytes.ptr;
 }
+
+pub const StartupData = c.StartupData;
+
+pub const SnapshotCreator = struct {
+    handle: *c.SnapshotCreator = undefined,
+
+    pub fn init(self: *SnapshotCreator, params: *const c.CreateParams) void {
+        self.handle = c.v8__SnapshotCreator__CREATE(params).?;
+    }
+
+    pub fn getIsolate(self: *SnapshotCreator) Isolate {
+        return .{
+            .handle = c.v8__SnapshotCreator__getIsolate(self.handle).?,
+        };
+    }
+
+    pub fn setDefaultContext(self: *SnapshotCreator, context: Context) void {
+        c.v8__SnapshotCreator__setDefaultContext(self.handle, context.handle);
+    }
+
+    pub fn addData(self: *SnapshotCreator, data: *const c.Data) usize {
+        return c.v8__SnapshotCreator__AddData(self.handle, data);
+    }
+
+    pub fn addDataWithContext(self: *SnapshotCreator, ctx: Context, data: *const c.Data) usize {
+        return c.v8__SnapshotCreator__AddData2(self.handle, ctx.handle, data);
+    }
+
+    pub fn createBlob(self: *SnapshotCreator, function_code_handling: c_uint) StartupData {
+        return c.v8__SnapshotCreator__createBlob(self.handle, function_code_handling);
+    }
+
+    pub fn deinit(self: *SnapshotCreator) void {
+        c.v8__SnapshotCreator__DESTRUCT(self.handle);
+    }
+
+    pub fn startupDataIsValid(data: StartupData) bool {
+        return c.v8__StartupData__IsValid(data);
+    }
+};