aboutsummaryrefslogtreecommitdiff
path: root/vendor/libghostty-vt/src/os/i18n.zig
diff options
context:
space:
mode:
authorCan Celik <ogulcancelik@gmail.com>2026-04-04 19:22:04 +0300
committerCan Celik <ogulcancelik@gmail.com>2026-04-05 01:23:06 +0300
commit41dd733ca7123c9ac4bfc6c781697a660e95b052 (patch)
tree3fc91815ca139ef2e0b281bba0abda4ef15175f4 /vendor/libghostty-vt/src/os/i18n.zig
parent55c138263e190a1e79d4b997bfb9397306c0ec1f (diff)
feat: finish ghostty pane backend integration
Diffstat (limited to 'vendor/libghostty-vt/src/os/i18n.zig')
-rw-r--r--vendor/libghostty-vt/src/os/i18n.zig193
1 files changed, 193 insertions, 0 deletions
diff --git a/vendor/libghostty-vt/src/os/i18n.zig b/vendor/libghostty-vt/src/os/i18n.zig
new file mode 100644
index 00000000..0f7790fa
--- /dev/null
+++ b/vendor/libghostty-vt/src/os/i18n.zig
@@ -0,0 +1,193 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const build_config = @import("../build_config.zig");
+const locales = @import("i18n_locales.zig");
+
+const log = std.log.scoped(.i18n);
+
+/// Set for faster membership lookup of locales.
+pub const locales_map = map: {
+ var kvs: [locales.len]struct { []const u8 } = undefined;
+ for (locales, 0..) |locale, i| kvs[i] = .{locale};
+ break :map std.StaticStringMap(void).initComptime(kvs);
+};
+
+pub const InitError = error{
+ InvalidResourcesDir,
+ OutOfMemory,
+};
+
+/// Initialize i18n support for the application. This should be
+/// called automatically by the global state initialization
+/// in global.zig.
+///
+/// This calls `bindtextdomain` for gettext with the proper directory
+/// of translations. This does NOT call `textdomain` as we don't
+/// want to set the domain for the entire application since this is also
+/// used by libghostty.
+pub fn init(resources_dir: []const u8) InitError!void {
+ if (comptime !build_config.i18n) return;
+
+ switch (builtin.os.tag) {
+ // i18n is unsupported on Windows
+ .windows => return,
+
+ else => {
+ // Our resources dir is always nested below the share dir that
+ // is standard for translations.
+ const share_dir = std.fs.path.dirname(resources_dir) orelse
+ return error.InvalidResourcesDir;
+
+ // Build our locale path
+ var buf: [std.fs.max_path_bytes]u8 = undefined;
+ const path = std.fmt.bufPrintZ(&buf, "{s}/locale", .{share_dir}) catch
+ return error.OutOfMemory;
+
+ // Bind our bundle ID to the given locale path
+ log.debug("binding domain={s} path={s}", .{ build_config.bundle_id, path });
+ _ = bindtextdomain(build_config.bundle_id, path.ptr) orelse
+ return error.OutOfMemory;
+ },
+ }
+}
+
+/// Set the global gettext domain to our bundle ID, allowing unqualified
+/// `gettext` (`_`) calls to look up translations for our application.
+///
+/// This should only be called for apprts that are fully owning the
+/// Ghostty application. This should not be called for libghostty users.
+pub fn initGlobalDomain() error{OutOfMemory}!void {
+ if (comptime !build_config.i18n) return;
+ _ = textdomain(build_config.bundle_id) orelse return error.OutOfMemory;
+}
+
+/// Translate a message for the Ghostty domain.
+pub fn _(msgid: [*:0]const u8) [*:0]const u8 {
+ if (comptime !build_config.i18n) return msgid;
+ return dgettext(build_config.bundle_id, msgid);
+}
+
+/// Canonicalize a locale name from a platform-specific value to
+/// a POSIX-compliant value. This is a thin layer over the unexported
+/// gnulib-lib function in gettext that does this already.
+///
+/// The gnulib-lib function modifies the buffer in place but has
+/// zero bounds checking, so we do a bit extra to ensure we don't
+/// overflow the buffer. This is likely slightly more expensive but
+/// this isn't a hot path so it should be fine.
+///
+/// The buffer must be at least 16 bytes long. This ensures we can
+/// fit the longest possible hardcoded locale name. Additionally,
+/// it should be at least as long as locale in case the locale
+/// is unchanged.
+///
+/// Here is the logic for macOS, but other platforms also have
+/// their own canonicalization logic:
+///
+/// https://github.com/coreutils/gnulib/blob/5b92dd0a45c8d27f13a21076b57095ea5e220870/lib/localename.c#L1171
+pub fn canonicalizeLocale(
+ buf: []u8,
+ locale: []const u8,
+) error{NoSpaceLeft}![:0]const u8 {
+ if (comptime !build_config.i18n) {
+ if (buf.len < locale.len + 1) return error.NoSpaceLeft;
+ @memcpy(buf[0..locale.len], locale);
+ buf[locale.len] = 0;
+ return buf[0..locale.len :0];
+ }
+
+ // Fix zh locales for macOS
+ if (fixZhLocale(locale)) |fixed| {
+ if (buf.len < fixed.len + 1) return error.NoSpaceLeft;
+ @memcpy(buf[0..fixed.len], fixed);
+ buf[fixed.len] = 0;
+ return buf[0..fixed.len :0];
+ }
+
+ // Buffer must be 16 or at least as long as the locale and null term
+ if (buf.len < @max(16, locale.len + 1)) return error.NoSpaceLeft;
+
+ // Copy our locale into the buffer since it modifies in place.
+ // This must be null-terminated.
+ @memcpy(buf[0..locale.len], locale);
+ buf[locale.len] = 0;
+
+ _libintl_locale_name_canonicalize(buf[0..locale.len :0]);
+
+ // Convert the null-terminated result buffer into a slice. We
+ // need to search for the null terminator and slice it back.
+ // We have to use `buf` since `slice` len will exclude the
+ // null.
+ const slice = std.mem.sliceTo(buf, 0);
+ return buf[0..slice.len :0];
+}
+
+/// Handles some zh locales canonicalization because internal libintl
+/// canonicalization function doesn't handle correctly in these cases.
+fn fixZhLocale(locale: []const u8) ?[:0]const u8 {
+ var it = std.mem.splitScalar(u8, locale, '-');
+ const name = it.next() orelse return null;
+ if (!std.mem.eql(u8, name, "zh")) return null;
+
+ const script = it.next() orelse return null;
+ const region = it.next() orelse return null;
+
+ if (std.mem.eql(u8, script, "Hans")) {
+ if (std.mem.eql(u8, region, "SG")) return "zh_SG";
+ return "zh_CN";
+ }
+
+ if (std.mem.eql(u8, script, "Hant")) {
+ if (std.mem.eql(u8, region, "MO")) return "zh_MO";
+ if (std.mem.eql(u8, region, "HK")) return "zh_HK";
+ return "zh_TW";
+ }
+
+ return null;
+}
+
+/// This can be called at any point a compile-time-known locale is
+/// available. This will use comptime to verify the locale is supported.
+pub fn staticLocale(comptime v: [*:0]const u8) [*:0]const u8 {
+ comptime {
+ for (locales) |locale| {
+ if (std.mem.eql(u8, locale, v)) {
+ return locale;
+ }
+ }
+
+ @compileError("unsupported locale");
+ }
+}
+
+// Manually include function definitions for the gettext functions
+// as libintl.h isn't always easily available (e.g. in musl)
+extern fn bindtextdomain(domainname: [*:0]const u8, dirname: [*:0]const u8) ?[*:0]const u8;
+extern fn textdomain(domainname: [*:0]const u8) ?[*:0]const u8;
+extern fn dgettext(domainname: [*:0]const u8, msgid: [*:0]const u8) [*:0]const u8;
+
+// This is only available if we're building libintl from source
+// since its otherwise not exported. We only need it on macOS
+// currently but probably will on Windows as well.
+extern fn _libintl_locale_name_canonicalize(name: [*:0]u8) void;
+
+test "canonicalizeLocale darwin" {
+ if (!builtin.target.os.tag.isDarwin()) return error.SkipZigTest;
+
+ const testing = std.testing;
+ var buf: [256]u8 = undefined;
+ try testing.expectEqualStrings("en_US", try canonicalizeLocale(&buf, "en_US"));
+ try testing.expectEqualStrings("zh_CN", try canonicalizeLocale(&buf, "zh-Hans"));
+ try testing.expectEqualStrings("zh_TW", try canonicalizeLocale(&buf, "zh-Hant"));
+
+ try testing.expectEqualStrings("zh_CN", try canonicalizeLocale(&buf, "zh-Hans-CN"));
+ try testing.expectEqualStrings("zh_SG", try canonicalizeLocale(&buf, "zh-Hans-SG"));
+ try testing.expectEqualStrings("zh_TW", try canonicalizeLocale(&buf, "zh-Hant-TW"));
+ try testing.expectEqualStrings("zh_HK", try canonicalizeLocale(&buf, "zh-Hant-HK"));
+ try testing.expectEqualStrings("zh_MO", try canonicalizeLocale(&buf, "zh-Hant-MO"));
+
+ // This is just an edge case I want to make sure we're aware of:
+ // canonicalizeLocale does not handle encodings and will turn them into
+ // underscores. We should parse them out before calling this function.
+ try testing.expectEqualStrings("en_US.UTF_8", try canonicalizeLocale(&buf, "en_US.UTF-8"));
+}