diff options
| author | Can Celik <ogulcancelik@gmail.com> | 2026-04-04 19:22:04 +0300 |
|---|---|---|
| committer | Can Celik <ogulcancelik@gmail.com> | 2026-04-05 01:23:06 +0300 |
| commit | 41dd733ca7123c9ac4bfc6c781697a660e95b052 (patch) | |
| tree | 3fc91815ca139ef2e0b281bba0abda4ef15175f4 /vendor/libghostty-vt/src/os/i18n.zig | |
| parent | 55c138263e190a1e79d4b997bfb9397306c0ec1f (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.zig | 193 |
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")); +} |
