aboutsummaryrefslogtreecommitdiff
path: root/vendor/libghostty-vt/src/synthetic/Utf8.zig
diff options
context:
space:
mode:
authorOgulcan Celik <ogulcancelik@gmail.com>2026-05-07 18:29:21 +0300
committerOgulcan Celik <ogulcancelik@gmail.com>2026-05-07 18:29:21 +0300
commitdcfe11a7588fcd42471159453810abc9b7720a57 (patch)
treec32a77266028e73ca2382b96c96f8438a5fcd621 /vendor/libghostty-vt/src/synthetic/Utf8.zig
parent2dfed860103c4e4505ac7f25def9fe37da1e1e6a (diff)
build: update libghostty-vt vendor
vendor ghostty 063ac3e and remove the musl libc++ link workaround. expose the new selection formatter and hyperlink uri apis for follow-up rendering work. add manual artifact validation for static linux builds.
Diffstat (limited to 'vendor/libghostty-vt/src/synthetic/Utf8.zig')
-rw-r--r--vendor/libghostty-vt/src/synthetic/Utf8.zig151
1 files changed, 136 insertions, 15 deletions
diff --git a/vendor/libghostty-vt/src/synthetic/Utf8.zig b/vendor/libghostty-vt/src/synthetic/Utf8.zig
index 0d72a8bb..282532dc 100644
--- a/vendor/libghostty-vt/src/synthetic/Utf8.zig
+++ b/vendor/libghostty-vt/src/synthetic/Utf8.zig
@@ -17,6 +17,27 @@ pub const Utf8Len = enum(u3) {
four = 4,
};
+const InvalidSequence = struct {
+ len: u3,
+ bytes: [4]u8,
+
+ fn slice(self: *const InvalidSequence) []const u8 {
+ return self.bytes[0..self.len];
+ }
+};
+
+const invalid_sequences = [_]InvalidSequence{
+ .{ .len = 1, .bytes = .{ 0x80, 0x00, 0x00, 0x00 } },
+ .{ .len = 1, .bytes = .{ 0xC0, 0x00, 0x00, 0x00 } },
+ .{ .len = 1, .bytes = .{ 0xFF, 0x00, 0x00, 0x00 } },
+ .{ .len = 2, .bytes = .{ 0xC2, 0x20, 0x00, 0x00 } },
+ .{ .len = 2, .bytes = .{ 0xC0, 0xAF, 0x00, 0x00 } },
+ .{ .len = 2, .bytes = .{ 0x80, 0x80, 0x00, 0x00 } },
+ .{ .len = 3, .bytes = .{ 0xED, 0xA0, 0x80, 0x00 } },
+ .{ .len = 3, .bytes = .{ 0xE2, 0x28, 0x7A, 0x00 } },
+ .{ .len = 4, .bytes = .{ 0xF0, 0x90, 0x28, 0x7A } },
+};
+
/// Random number generator.
rand: std.Random,
@@ -37,6 +58,13 @@ max_len: usize = std.math.maxInt(usize),
/// skew the distribution of lengths.
p_length: std.enums.EnumArray(Utf8Len, f64) = .initFill(1.0),
+/// If true, ASCII codepoints are limited to printable ASCII.
+ascii_printable_only: bool = false,
+
+/// Probability that the next generated sequence is malformed UTF-8.
+/// This is checked for each emitted sequence while filling a buffer.
+invalid_rate: f64 = 0,
+
pub fn generator(self: *Utf8) Generator {
return .init(self, next);
}
@@ -49,23 +77,44 @@ pub fn next(self: *Utf8, writer: *std.Io.Writer, max_len: usize) Generator.Error
var rem: usize = len;
while (rem > 0) {
- // Pick a utf8 byte count to generate.
- const utf8_len: Utf8Len = len: {
- const Indexer = @TypeOf(self.p_length).Indexer;
- const idx = self.rand.weightedIndex(f64, &self.p_length.values);
- var utf8_len = Indexer.keyForIndex(idx);
- assert(rem > 0);
- while (@intFromEnum(utf8_len) > rem) {
- // If the chosen length can't fit into the remaining buffer,
- // choose a smaller length.
- utf8_len = @enumFromInt(@intFromEnum(utf8_len) - 1);
- }
- break :len utf8_len;
- };
+ if (try self.writeInvalid(writer, rem)) |written| {
+ rem -= written;
+ continue;
+ }
+
+ const written = try self.writeValid(writer, rem);
+ rem -= written;
+ }
+}
+
+fn writeInvalid(
+ self: *Utf8,
+ writer: *std.Io.Writer,
+ rem: usize,
+) Generator.Error!?usize {
+ if (self.invalid_rate <= 0 or self.rand.float(f64) >= self.invalid_rate) {
+ return null;
+ }
+
+ const seq = self.invalidSequence(rem) orelse return null;
+ try writer.writeAll(seq.slice());
+ return seq.len;
+}
+
+fn writeValid(
+ self: *Utf8,
+ writer: *std.Io.Writer,
+ rem: usize,
+) Generator.Error!usize {
+ while (true) {
+ const utf8_len = self.utf8Len(rem);
// Generate a UTF-8 sequence that encodes to this length.
const cp: u21 = switch (utf8_len) {
- .one => self.rand.intRangeAtMostBiased(u21, 0x00, 0x7F),
+ .one => if (self.ascii_printable_only)
+ self.rand.intRangeAtMostBiased(u21, 0x20, 0x7E)
+ else
+ self.rand.intRangeAtMostBiased(u21, 0x00, 0x7F),
.two => self.rand.intRangeAtMostBiased(u21, 0x80, 0x7FF),
.three => self.rand.intRangeAtMostBiased(u21, 0x800, 0xFFFF),
.four => self.rand.intRangeAtMostBiased(u21, 0x10000, 0x10FFFF),
@@ -87,9 +136,38 @@ pub fn next(self: *Utf8, writer: *std.Io.Writer, max_len: usize) Generator.Error
// Possible, in which case we redo the loop and encode nothing.
error.Utf8CannotEncodeSurrogateHalf => continue,
};
+
try writer.writeAll(buf[0..l]);
- rem -= l;
+ return l;
+ }
+}
+
+fn utf8Len(self: *Utf8, rem: usize) Utf8Len {
+ const Indexer = @TypeOf(self.p_length).Indexer;
+ const idx = self.rand.weightedIndex(f64, &self.p_length.values);
+ var utf8_len = Indexer.keyForIndex(idx);
+ assert(rem > 0);
+ while (@intFromEnum(utf8_len) > rem) {
+ // If the chosen length can't fit into the remaining buffer,
+ // choose a smaller length.
+ utf8_len = @enumFromInt(@intFromEnum(utf8_len) - 1);
}
+ return utf8_len;
+}
+
+fn invalidSequence(self: *Utf8, rem: usize) ?InvalidSequence {
+ const candidates = &invalid_sequences;
+
+ var valid_idx: [candidates.len]usize = undefined;
+ var valid_len: usize = 0;
+ for (candidates, 0..) |candidate, i| {
+ if (candidate.len > rem) continue;
+ valid_idx[valid_len] = i;
+ valid_len += 1;
+ }
+
+ if (valid_len == 0) return null;
+ return candidates[valid_idx[self.rand.uintLessThan(usize, valid_len)]];
}
test "utf8" {
@@ -106,3 +184,46 @@ test "utf8" {
try testing.expectEqual(256, result.len);
try testing.expect(std.unicode.utf8ValidateSlice(result));
}
+
+test "utf8 printable ascii only" {
+ const testing = std.testing;
+ var prng = std.Random.DefaultPrng.init(0);
+ var buf: [256]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&buf);
+ var v: Utf8 = .{
+ .rand = prng.random(),
+ .ascii_printable_only = true,
+ };
+ v.min_len = buf.len;
+ v.max_len = buf.len;
+ v.p_length.set(.one, 1.0);
+ v.p_length.set(.two, 0.0);
+ v.p_length.set(.three, 0.0);
+ v.p_length.set(.four, 0.0);
+
+ const gen = v.generator();
+ try gen.next(&writer, buf.len);
+ const result = writer.buffered();
+ try testing.expectEqual(256, result.len);
+ try testing.expect(std.unicode.utf8ValidateSlice(result));
+ for (result) |c| try testing.expect(std.ascii.isPrint(c));
+}
+
+test "utf8 malformed output" {
+ const testing = std.testing;
+ var prng = std.Random.DefaultPrng.init(0);
+ var buf: [256]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&buf);
+ var v: Utf8 = .{
+ .rand = prng.random(),
+ .invalid_rate = 1.0,
+ };
+ v.min_len = buf.len;
+ v.max_len = buf.len;
+
+ const gen = v.generator();
+ try gen.next(&writer, buf.len);
+ const result = writer.buffered();
+ try testing.expectEqual(256, result.len);
+ try testing.expect(!std.unicode.utf8ValidateSlice(result));
+}