Applied-Software/ghostty
5
0
Fork 0
mirror of https://github.com/ghostty-org/ghostty.git synced 2025-07-17 01:06:08 +03:00
Code Issues Packages Projects Releases Wiki Activity

rename termio thread message struct

Browse Source
This commit is contained in:
Mitchell Hashimoto
2022-11-05 19:34:41 -07:00
parent cd705359e8
commit 8f1fcc64e8
4 changed files with 43 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/Window.zig
View File

@ -611,7 +611,7 @@ fn charCallback(window: glfw.Window, codepoint: u21) void {
}
// Ask our IO thread to write the data
var data: termio.message.WriteReq.Small.Array = undefined;
var data: termio.Message.WriteReq.Small.Array = undefined;
data[0] = @intCast(u8, codepoint);
_ = win.io_thread.mailbox.push(.{
.write_small = .{
@ -771,7 +771,7 @@ fn keyCallback(
}, .{ .forever = {} });
}
_ = win.io_thread.mailbox.push(termio.message.IO.writeReq(
_ = win.io_thread.mailbox.push(termio.Message.writeReq(
win.alloc,
data,
) catch unreachable, .{ .forever = {} });
@ -851,7 +851,7 @@ fn keyCallback(
};
if (char > 0) {
// Ask our IO thread to write the data
var data: termio.message.WriteReq.Small.Array = undefined;
var data: termio.Message.WriteReq.Small.Array = undefined;
data[0] = @intCast(u8, char);
_ = win.io_thread.mailbox.push(.{
.write_small = .{
@ -1037,7 +1037,7 @@ fn mouseReport(
}
// + 1 below is because our x/y is 0-indexed and proto wants 1
var data: termio.message.WriteReq.Small.Array = undefined;
var data: termio.Message.WriteReq.Small.Array = undefined;
assert(data.len >= 5);
data[0] = '\x1b';
data[1] = '[';
@ -1057,7 +1057,7 @@ fn mouseReport(
.utf8 => {
// Maximum of 12 because at most we have 2 fully UTF-8 encoded chars
var data: termio.message.WriteReq.Small.Array = undefined;
var data: termio.Message.WriteReq.Small.Array = undefined;
assert(data.len >= 12);
data[0] = '\x1b';
data[1] = '[';
@ -1086,7 +1086,7 @@ fn mouseReport(
// Response always is at least 4 chars, so this leaves the
// remainder for numbers which are very large...
var data: termio.message.WriteReq.Small.Array = undefined;
var data: termio.Message.WriteReq.Small.Array = undefined;
const resp = try std.fmt.bufPrint(&data, "\x1B[<{d};{d};{d}{c}", .{
button_code,
viewport_point.x + 1,
@ -1106,7 +1106,7 @@ fn mouseReport(
.urxvt => {
// Response always is at least 4 chars, so this leaves the
// remainder for numbers which are very large...
var data: termio.message.WriteReq.Small.Array = undefined;
var data: termio.Message.WriteReq.Small.Array = undefined;
const resp = try std.fmt.bufPrint(&data, "\x1B[{d};{d};{d}M", .{
32 + button_code,
viewport_point.x + 1,
@ -1128,7 +1128,7 @@ fn mouseReport(
// Response always is at least 4 chars, so this leaves the
// remainder for numbers which are very large...
var data: termio.message.WriteReq.Small.Array = undefined;
var data: termio.Message.WriteReq.Small.Array = undefined;
const resp = try std.fmt.bufPrint(&data, "\x1B[<{d};{d};{d}{c}", .{
button_code,
pos.xpos,

2
src/termio.zig
View File

@ -2,7 +2,7 @@
//! for taking the config, spinning up a child process, and handling IO
//! with the termianl.
pub const message = @import("termio/message.zig");
pub usingnamespace @import("termio/message.zig");
pub const Exec = @import("termio/Exec.zig");
pub const Options = @import("termio/Options.zig");
pub const Thread = @import("termio/Thread.zig");

2
src/termio/Thread.zig
View File

@ -14,7 +14,7 @@ const log = std.log.scoped(.io_thread);
/// The type used for sending messages to the IO thread. For now this is
/// hardcoded with a capacity. We can make this a comptime parameter in
/// the future if we want it configurable.
const Mailbox = BlockingQueue(termio.message.IO, 64);
const Mailbox = BlockingQueue(termio.Message, 64);
/// The main event loop for the thread. The user data of this loop
/// is always the allocator used to create the loop. This is a convenience

66
src/termio/message.zig
View File

@ -9,7 +9,7 @@ const terminal = @import("../terminal/main.zig");
/// This is not a tiny structure (~40 bytes at the time of writing this comment),
/// but the messages are IO thread sends are also very few. At the current size
/// we can queue 26,000 messages before consuming a MB of RAM.
pub const IO = union(enum) {
pub const Message = union(enum) {
/// Resize the window.
resize: struct {
grid_size: renderer.GridSize,
@ -28,7 +28,7 @@ pub const IO = union(enum) {
/// Return a write request for the given data. This will use
/// write_small if it fits or write_alloc otherwise. This should NOT
/// be used for stable pointers which can be manually set to write_stable.
pub fn writeReq(alloc: Allocator, data: anytype) !IO {
pub fn writeReq(alloc: Allocator, data: anytype) !Message {
switch (@typeInfo(@TypeOf(data))) {
.Pointer => |info| {
assert(info.size == .Slice);
@ -38,7 +38,7 @@ pub const IO = union(enum) {
if (data.len <= WriteReq.Small.Max) {
var buf: WriteReq.Small.Array = undefined;
std.mem.copy(u8, &buf, data);
return IO{
return Message{
.write_small = .{
.data = buf,
.len = @intCast(u8, data.len),
@ -49,7 +49,7 @@ pub const IO = union(enum) {
// Otherwise, allocate
var buf = try alloc.dupe(u8, data);
errdefer alloc.free(buf);
return IO{
return Message{
.write_alloc = .{
.alloc = alloc,
.data = buf,
@ -60,32 +60,32 @@ pub const IO = union(enum) {
else => unreachable,
}
}
};
/// Represents a write request.
pub const WriteReq = union(enum) {
pub const Small = struct {
pub const Max = 38;
pub const Array = [Max]u8;
data: Array,
len: u8,
/// Represents a write request.
pub const WriteReq = union(enum) {
pub const Small = struct {
pub const Max = 38;
pub const Array = [Max]u8;
data: Array,
len: u8,
};
pub const Alloc = struct {
alloc: Allocator,
data: []u8,
};
/// A small write where the data fits into this union size.
small: Small,
/// A stable pointer so we can just pass the slice directly through.
/// This is useful i.e. for const data.
stable: []const u8,
/// Allocated and must be freed with the provided allocator. This
/// should be rarely used.
alloc: Alloc,
};
pub const Alloc = struct {
alloc: Allocator,
data: []u8,
};
/// A small write where the data fits into this union size.
small: Small,
/// A stable pointer so we can just pass the slice directly through.
/// This is useful i.e. for const data.
stable: []const u8,
/// Allocated and must be freed with the provided allocator. This
/// should be rarely used.
alloc: Alloc,
};
test {
@ -95,24 +95,24 @@ test {
test {
// Ensure we don't grow our IO message size without explicitly wanting to.
const testing = std.testing;
try testing.expectEqual(@as(usize, 40), @sizeOf(IO));
try testing.expectEqual(@as(usize, 40), @sizeOf(Message));
}
test "IO.writeReq small" {
test "Message.writeReq small" {
const testing = std.testing;
const alloc = testing.allocator;
const input = "hello!";
const io = try IO.writeReq(alloc, @as([]const u8, input));
const io = try Message.writeReq(alloc, @as([]const u8, input));
try testing.expect(io == .write_small);
}
test "IO.writeReq alloc" {
test "Message.writeReq alloc" {
const testing = std.testing;
const alloc = testing.allocator;
const input = "hello! " ** 100;
const io = try IO.writeReq(alloc, @as([]const u8, input));
const io = try Message.writeReq(alloc, @as([]const u8, input));
try testing.expect(io == .write_alloc);
io.write_alloc.alloc.free(io.write_alloc.data);
}