cbor

Author: karlseguin

src/binding.cpp

@@ -1724,15 +1724,14 @@ static inline v8_inspector::StringView toStringView(const std::string &str) {
     return toStringView(str.c_str(), str.length());
 }
 
-static inline std::string fromStringView(v8::Isolate* isolate, const v8_inspector::StringView stringView) {
+static v8::Local<v8::String> fromStringView(v8::Isolate* isolate, const v8_inspector::StringView stringView) {
   int length = static_cast<int>(stringView.length());
   v8::Local<v8::String> message = (
         stringView.is8Bit()
           ? v8::String::NewFromOneByte(isolate, stringView.characters8(), v8::NewStringType::kNormal, length)
           : v8::String::NewFromTwoByte(isolate, stringView.characters16(), v8::NewStringType::kNormal, length)
       ).ToLocalChecked();
-  v8::String::Utf8Value result(isolate, message);
-  return *result;
+  return message;
 }
 
 /// Allocates a string as utf8 on the allocator without \0 terminator, for use in Zig.
@@ -1997,24 +1996,24 @@ void v8_inspector__Channel__IMPL__SET_DATA(v8_inspector__Channel__IMPL *self, vo
 // NOTE: zig project should provide those implementations with C-ABI functions
 void v8_inspector__Channel__IMPL__sendResponse(
     v8_inspector__Channel__IMPL* self, void* data,
-    int callId, const char* message, size_t length);
+    int callId, v8::Local<v8::String> resp);
 void v8_inspector__Channel__IMPL__sendNotification(
     v8_inspector__Channel__IMPL* self, void *data,
-    const char* msg, size_t length);
+    v8::Local<v8::String> notif);
 void v8_inspector__Channel__IMPL__flushProtocolNotifications(
     v8_inspector__Channel__IMPL* self, void *data);
 
 // c++ implementation (just wrappers around the C/zig functions)
 } // extern "C"
 void v8_inspector__Channel__IMPL::sendResponse(
     int callId, std::unique_ptr<v8_inspector::StringBuffer> message) {
-  const std::string resp = fromStringView(this->isolate, message->string());
-  return v8_inspector__Channel__IMPL__sendResponse(this, this->data, callId, resp.c_str(), resp.length());
+  const v8::Local<v8::String> resp = fromStringView(this->isolate, message->string());
+  return v8_inspector__Channel__IMPL__sendResponse(this, this->data, callId, resp);
 }
 void v8_inspector__Channel__IMPL::sendNotification(
     std::unique_ptr<v8_inspector::StringBuffer> message) {
-  const std::string notif = fromStringView(this->isolate, message->string());
-   return v8_inspector__Channel__IMPL__sendNotification(this, this->data, notif.c_str(), notif.length());
+  const v8::Local<v8::String> notif = fromStringView(this->isolate, message->string());
+   return v8_inspector__Channel__IMPL__sendNotification(this, this->data, notif);
 }
 void v8_inspector__Channel__IMPL::flushProtocolNotifications() {
   return v8_inspector__Channel__IMPL__flushProtocolNotifications(this, this->data);

src/binding.h

@@ -1098,10 +1098,10 @@ void v8_inspector__Channel__IMPL__SET_DATA(InspectorChannelImpl* self, void *dat
 
 void v8_inspector__Channel__IMPL__sendResponse(
     InspectorChannelImpl *self, void *data,
-    int callId, char *message, size_t length);
+    int callId, String resp);
 void v8_inspector__Channel__IMPL__sendNotification(
     InspectorChannelImpl *self, void *data,
-    char *message, size_t length);
+    String notif);
 void v8_inspector__Channel__IMPL__flushProtocolNotifications(
     InspectorChannelImpl *self, void *data);
 

src/v8.zig

@@ -501,6 +501,26 @@ pub const HandleScope = struct {
     }
 };
 
+pub const SealHandleScope = struct {
+    const Self = @This();
+
+    inner: c.SealHandleScope,
+
+    /// [Notes]
+    /// This starts a new stack frame to record local objects created.
+    /// Since deinit depends on the inner pointer being the same, init should construct in place.
+    pub fn init(self: *Self, isolate: Isolate) void {
+        c.v8__SealHandleScope__CONSTRUCT(&self.inner, isolate.handle);
+    }
+
+    /// [Notes]
+    /// This pops the scope frame and allows V8 to mark/free local objects created since SealHandleScope.init.
+    /// In C++ code, this would happen automatically when the SealHandleScope var leaves the current scope.
+    pub fn deinit(self: *Self) void {
+        c.v8__SealHandleScope__DESTRUCT(&self.inner);
+    }
+};
+
 pub const Context = struct {
     const Self = @This();
 
@@ -2886,8 +2906,8 @@ pub const InspectorChannel = struct {
     onNotif: onNotifFn = undefined,
     onResp: onRespFn = undefined,
 
-    pub const onNotifFn = *const fn (ctx: *anyopaque, msg: []const u8) void;
-    pub const onRespFn = *const fn (ctx: *anyopaque, call_id: u32, msg: []const u8) void;
+    pub const onNotifFn = *const fn (ctx: *anyopaque, msg: *const c.String) void;
+    pub const onRespFn = *const fn (ctx: *anyopaque, call_id: u32, msg: *const c.String) void;
 
     pub fn init(
         ctx: *anyopaque,
@@ -2912,11 +2932,11 @@ pub const InspectorChannel = struct {
         c.v8_inspector__Channel__IMPL__SET_DATA(self.handle, inspector);
     }
 
-    fn resp(self: InspectorChannel, call_id: u32, msg: []const u8) void {
+    fn resp(self: InspectorChannel, call_id: u32, msg: *const c.String) void {
         self.onResp(self.ctx, call_id, msg);
     }
 
-    fn notif(self: InspectorChannel, msg: []const u8) void {
+    fn notif(self: InspectorChannel, msg: *const c.String) void {
         self.onNotif(self.ctx, msg);
     }
 };
@@ -2925,21 +2945,19 @@ pub export fn v8_inspector__Channel__IMPL__sendResponse(
     _: *c.InspectorChannelImpl,
     data: *anyopaque,
     call_id: c_int,
-    msg: [*c]u8,
-    length: usize,
+    msg: *const c.String,
 ) callconv(.C) void {
     const inspector = Inspector.fromData(data);
-    inspector.channel.resp(@as(u32, @intCast(call_id)), msg[0..length]);
+    inspector.channel.resp(@as(u32, @intCast(call_id)), msg);
 }
 
 pub export fn v8_inspector__Channel__IMPL__sendNotification(
     _: *c.InspectorChannelImpl,
     data: *anyopaque,
-    msg: [*c]u8,
-    length: usize,
+    msg: *const c.String,
 ) callconv(.C) void {
     const inspector = Inspector.fromData(data);
-    inspector.channel.notif(msg[0..length]);
+    inspector.channel.notif(msg);
 }
 
 pub export fn v8_inspector__Channel__IMPL__flushProtocolNotifications(