1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
const std = @import("std");
const assert = std.debug.assert;
const cli = @import("../cli.zig");
const inputpkg = @import("../input.zig");
const state = &@import("../global.zig").state;
const c = @import("../main_c.zig");
const Config = @import("Config.zig");
const c_get = @import("c_get.zig");
const edit = @import("edit.zig");
const Key = @import("key.zig").Key;
const log = std.log.scoped(.config);
/// Create a new configuration filled with the initial default values.
export fn ghostty_config_new() ?*Config {
const result = state.alloc.create(Config) catch |err| {
log.err("error allocating config err={}", .{err});
return null;
};
result.* = Config.default(state.alloc) catch |err| {
log.err("error creating config err={}", .{err});
state.alloc.destroy(result);
return null;
};
return result;
}
export fn ghostty_config_free(ptr: ?*Config) void {
if (ptr) |v| {
v.deinit();
state.alloc.destroy(v);
}
}
/// Deep clone the configuration.
export fn ghostty_config_clone(self: *Config) ?*Config {
const result = state.alloc.create(Config) catch |err| {
log.err("error allocating config err={}", .{err});
return null;
};
result.* = self.clone(state.alloc) catch |err| {
log.err("error cloning config err={}", .{err});
state.alloc.destroy(result);
return null;
};
return result;
}
/// Load the configuration from the CLI args.
export fn ghostty_config_load_cli_args(self: *Config) void {
self.loadCliArgs(state.alloc) catch |err| {
log.err("error loading config err={}", .{err});
};
}
/// Load the configuration from the default file locations. This
/// is usually done first. The default file locations are locations
/// such as the home directory.
export fn ghostty_config_load_default_files(self: *Config) void {
self.loadDefaultFiles(state.alloc) catch |err| {
log.err("error loading config err={}", .{err});
};
}
/// Load the configuration from the user-specified configuration
/// file locations in the previously loaded configuration. This will
/// recursively continue to load up to a built-in limit.
export fn ghostty_config_load_recursive_files(self: *Config) void {
self.loadRecursiveFiles(state.alloc) catch |err| {
log.err("error loading config err={}", .{err});
};
}
export fn ghostty_config_finalize(self: *Config) void {
self.finalize() catch |err| {
log.err("error finalizing config err={}", .{err});
};
}
export fn ghostty_config_get(
self: *Config,
ptr: *anyopaque,
key_str: [*]const u8,
len: usize,
) bool {
@setEvalBranchQuota(10_000);
const key = std.meta.stringToEnum(Key, key_str[0..len]) orelse return false;
return c_get.get(self, key, ptr);
}
export fn ghostty_config_trigger(
self: *Config,
str: [*]const u8,
len: usize,
) inputpkg.Binding.Trigger.C {
return config_trigger_(self, str[0..len]) catch |err| err: {
log.err("error finding trigger err={}", .{err});
break :err .{};
};
}
fn config_trigger_(
self: *Config,
str: []const u8,
) !inputpkg.Binding.Trigger.C {
const action = try inputpkg.Binding.Action.parse(str);
const trigger: inputpkg.Binding.Trigger = self.keybind.set.getTrigger(action) orelse .{};
return trigger.cval();
}
export fn ghostty_config_diagnostics_count(self: *Config) u32 {
return @intCast(self._diagnostics.items().len);
}
export fn ghostty_config_get_diagnostic(self: *Config, idx: u32) Diagnostic {
const items = self._diagnostics.items();
if (idx >= items.len) return .{};
const message = self._diagnostics.precompute.messages.items[idx];
return .{ .message = message.ptr };
}
export fn ghostty_config_open_path() c.String {
const path = edit.openPath(state.alloc) catch |err| {
log.err("error opening config in editor err={}", .{err});
return .empty;
};
return .fromSlice(path);
}
/// Sync with ghostty_diagnostic_s
const Diagnostic = extern struct {
message: [*:0]const u8 = "",
};
|
