A SpaceTraders Agent
outsource pretty printing
+7
-462
+2
build.zig
+2
build.zig
···
8
8
const options = b.addOptions();
9
9
10
10
const known_folders = b.dependency("known_folders", .{}).module("known-folders");
11
+
const pretty = b.dependency("pretty", .{}).module("pretty");
11
12
12
13
const meta = b.createModule(.{
13
14
.root_source_file = b.path("src/meta/root.zig"),
···
46
47
.{ .name = "st", .module = st },
47
48
.{ .name = "agent", .module = agent },
48
49
.{ .name = "meta", .module = meta },
50
+
.{ .name = "pretty", .module = pretty },
49
51
},
50
52
});
51
53
+4
build.zig.zon
+4
build.zig.zon
···
6
6
.url = "git+https://github.com/ziglibs/known-folders.git?ref=master#82027007c0eb199a3242c167a5cffd83b6ee571b",
7
7
.hash = "known_folders-0.0.0-Fy-PJqHJAAB43zDJmOdlr3nViu69IFI9pNFt7hkHjKk4",
8
8
},
9
+
.pretty = .{
10
+
.url = "git+https://git.sr.ht/~altagos/pretty?ref=main#a025f81f4b9a1a6be483a4c33fafc6e0ef5cae6f",
11
+
.hash = "pretty-0.1.0--Y3D26JKAAABPfRqFy6oUakwiYAawqqbU6xF0_5ziP-l",
12
+
},
9
13
},
10
14
.minimum_zig_version = "0.16.0-dev.1246+4b593a6c2",
11
15
.paths = .{
+1
-1
src/main.zig
+1
-1
src/main.zig
-457
src/meta/fmt.zig
-457
src/meta/fmt.zig
···
1
-
const std = @import("std");
2
-
const Io = std.Io;
3
-
const Type = std.builtin.Type;
4
-
5
-
pub fn pretty(value: anytype) Pretty(@TypeOf(value)) {
6
-
return Pretty(@TypeOf(value)).init(value);
7
-
}
8
-
9
-
fn Context(comptime runtime: bool) type {
10
-
if (runtime) {
11
-
return struct {
12
-
indent_width: u8 = 2,
13
-
indent_level: usize = 0,
14
-
};
15
-
} else {
16
-
return struct {
17
-
indent_width: comptime_int = 2,
18
-
indent_level: comptime_int = 0,
19
-
};
20
-
}
21
-
}
22
-
23
-
const Options = struct {
24
-
type_name: bool = true,
25
-
last_layer_type_name: bool = true,
26
-
27
-
follow_pointers: bool = true,
28
-
};
29
-
30
-
pub fn Pretty(comptime T: type) type {
31
-
const global = struct {
32
-
var conf: ?std.Io.Terminal = null;
33
-
};
34
-
return struct {
35
-
value: T,
36
-
pub fn init(val: T) @This() {
37
-
return .{ .value = val };
38
-
}
39
-
pub fn format(this: *const @This(), w: *std.Io.Writer) error{WriteFailed}!void {
40
-
if (global.conf == null) {
41
-
var buffer: [64]u8 = undefined;
42
-
const stderr = std.debug.lockStderr(&buffer).terminal();
43
-
global.conf = stderr;
44
-
global.conf.?.writer = w;
45
-
std.debug.unlockStderr();
46
-
}
47
-
std.log.debug("", .{});
48
-
return innerFmt(w, global.conf.?, T, this.value, !@inComptime(), .{}, .{});
49
-
}
50
-
};
51
-
}
52
-
53
-
const Color = enum {
54
-
dim,
55
-
reset,
56
-
text,
57
-
field,
58
-
value,
59
-
};
60
-
61
-
fn setColor(
62
-
tty: Io.Terminal,
63
-
color: Color,
64
-
) void {
65
-
switch (color) {
66
-
.dim => {
67
-
tty.setColor(.dim) catch {};
68
-
},
69
-
.reset => {
70
-
tty.setColor(.reset) catch {};
71
-
},
72
-
.text => {
73
-
// tty.setColor(.italic) catch {};
74
-
tty.setColor(.dim) catch {};
75
-
tty.setColor(.blue) catch {};
76
-
},
77
-
.field => {
78
-
tty.setColor(.green) catch {};
79
-
},
80
-
.value => {
81
-
// tty.setColor(.italic) catch {};
82
-
tty.setColor(.blue) catch {};
83
-
},
84
-
}
85
-
}
86
-
87
-
fn innerFmt(
88
-
w: *std.Io.Writer,
89
-
tty: std.Io.Terminal,
90
-
comptime T: type,
91
-
value: T,
92
-
comptime runtime: bool,
93
-
ctx: Context(runtime),
94
-
opts: Options,
95
-
) error{WriteFailed}!void {
96
-
const info = @typeInfo(T);
97
-
98
-
switch (info) {
99
-
.bool => try printBool(w, tty, value, opts),
100
-
.int => |int| try printInt(w, tty, int, value, opts),
101
-
.float => |float| try printFloat(w, tty, float, value, opts),
102
-
.@"enum", .enum_literal => try printEnum(w, tty, value, opts),
103
-
.optional => |optional| try printOptional(w, tty, optional, value, runtime, ctx, opts),
104
-
.pointer => |ptr| {
105
-
if (opts.follow_pointers) {
106
-
try printPointer(w, tty, ptr, value, runtime, ctx, opts);
107
-
} else {}
108
-
},
109
-
.array => |array| try printArray(w, tty, array, value, runtime, ctx, opts),
110
-
.@"struct" => |str| try printStruct(T, w, tty, str, value, runtime, ctx, opts),
111
-
else => {
112
-
tty.setColor(.red) catch {};
113
-
try w.print("Unimplemented! ({})", .{info});
114
-
setColor(tty, .reset);
115
-
},
116
-
}
117
-
}
118
-
119
-
fn printBool(
120
-
w: *Io.Writer,
121
-
tty: Io.Terminal,
122
-
value: bool,
123
-
opts: Options,
124
-
) !void {
125
-
if (opts.type_name) {
126
-
setColor(tty, .dim);
127
-
try w.print("bool => ", .{});
128
-
setColor(tty, .reset);
129
-
} else {
130
-
tty.setColor(.dim) catch {};
131
-
try w.print("=> ", .{});
132
-
setColor(tty, .reset);
133
-
}
134
-
setColor(tty, .value);
135
-
if (value) {
136
-
tty.setColor(.bright_green) catch {};
137
-
} else {
138
-
tty.setColor(.bright_red) catch {};
139
-
}
140
-
try w.print("{}", .{value});
141
-
setColor(tty, .reset);
142
-
}
143
-
144
-
fn printInt(
145
-
w: *Io.Writer,
146
-
tty: Io.Terminal,
147
-
int: Type.Int,
148
-
value: anytype,
149
-
opts: Options,
150
-
) !void {
151
-
if (opts.type_name) {
152
-
tty.setColor(.dim) catch {};
153
-
try w.print("{s}{} => ", .{ if (int.signedness == .signed) "i" else "u", int.bits });
154
-
setColor(tty, .reset);
155
-
} else {
156
-
tty.setColor(.dim) catch {};
157
-
try w.print("=> ", .{});
158
-
setColor(tty, .reset);
159
-
}
160
-
setColor(tty, .value);
161
-
try w.print("{}", .{value});
162
-
setColor(tty, .reset);
163
-
}
164
-
165
-
fn printFloat(
166
-
w: *Io.Writer,
167
-
tty: Io.Terminal,
168
-
float: Type.Float,
169
-
value: anytype,
170
-
opts: Options,
171
-
) !void {
172
-
if (opts.type_name) {
173
-
tty.setColor(.dim) catch {};
174
-
try w.print("f{} => ", .{float.bits});
175
-
setColor(tty, .reset);
176
-
} else {
177
-
tty.setColor(.dim) catch {};
178
-
try w.print("=> ", .{});
179
-
setColor(tty, .reset);
180
-
}
181
-
setColor(tty, .value);
182
-
try w.print("{}", .{value});
183
-
setColor(tty, .reset);
184
-
}
185
-
186
-
fn printEnum(
187
-
w: *Io.Writer,
188
-
tty: Io.Terminal,
189
-
value: anytype,
190
-
opts: Options,
191
-
) !void {
192
-
if (opts.type_name) {
193
-
tty.setColor(.dim) catch {};
194
-
try w.print("{s} => ", .{@typeName(@TypeOf(value))});
195
-
setColor(tty, .reset);
196
-
} else {
197
-
tty.setColor(.dim) catch {};
198
-
try w.print("=> ", .{});
199
-
setColor(tty, .reset);
200
-
}
201
-
setColor(tty, .value);
202
-
try w.print("{}", .{value});
203
-
setColor(tty, .reset);
204
-
}
205
-
206
-
fn printOptional(
207
-
w: *Io.Writer,
208
-
tty: Io.Terminal,
209
-
optional: Type.Optional,
210
-
value: anytype,
211
-
comptime runtime: bool,
212
-
ctx: Context(runtime),
213
-
opts: Options,
214
-
) !void {
215
-
var next_opts = opts;
216
-
next_opts.type_name = if (!opts.type_name and !opts.last_layer_type_name) false else true;
217
-
next_opts.last_layer_type_name = opts.type_name;
218
-
219
-
if (opts.type_name) {
220
-
tty.setColor(.dim) catch {};
221
-
try w.print("?", .{});
222
-
setColor(tty, .reset);
223
-
}
224
-
225
-
if (value) |val| {
226
-
try innerFmt(w, tty, optional.child, val, runtime, ctx, next_opts);
227
-
} else {
228
-
if (opts.type_name) {
229
-
tty.setColor(.dim) catch {};
230
-
try w.print("{s} => ", .{@typeName(optional.child)});
231
-
setColor(tty, .reset);
232
-
} else {
233
-
tty.setColor(.dim) catch {};
234
-
try w.print("=> ", .{});
235
-
setColor(tty, .reset);
236
-
}
237
-
238
-
tty.setColor(.blue) catch {};
239
-
try w.writeAll("null");
240
-
setColor(tty, .reset);
241
-
}
242
-
}
243
-
244
-
fn printArray(
245
-
w: *Io.Writer,
246
-
tty: Io.Terminal,
247
-
array: Type.Array,
248
-
value: anytype,
249
-
comptime runtime: bool,
250
-
ctx: Context(runtime),
251
-
opts: Options,
252
-
) !void {
253
-
comptime var next_ctx = ctx;
254
-
255
-
var next_opts = opts;
256
-
next_opts.type_name = if (!opts.type_name and !opts.last_layer_type_name) false else true;
257
-
next_opts.last_layer_type_name = opts.type_name;
258
-
259
-
if (opts.type_name) {
260
-
tty.setColor(.dim) catch {};
261
-
try w.print("[{}]{s} =>", .{ array.len, @typeName(array.child) });
262
-
setColor(tty, .reset);
263
-
} else {
264
-
tty.setColor(.dim) catch {};
265
-
try w.print("=> ", .{});
266
-
setColor(tty, .reset);
267
-
}
268
-
269
-
inline for (value, 0..) |item, idx| {
270
-
try indent(w, runtime, ctx);
271
-
272
-
setColor(tty, .field);
273
-
try w.print("[{}] ", .{idx});
274
-
setColor(tty, .reset);
275
-
276
-
next_ctx.indent_level = ctx.indent_level + 1;
277
-
next_opts.type_name = false;
278
-
279
-
try innerFmt(w, tty, @TypeOf(item), item, runtime, next_ctx, next_opts);
280
-
}
281
-
}
282
-
283
-
fn printPointer(
284
-
w: *Io.Writer,
285
-
tty: Io.Terminal,
286
-
ptr: Type.Pointer,
287
-
value: anytype,
288
-
comptime runtime: bool,
289
-
ctx: Context(runtime),
290
-
opts: Options,
291
-
) !void {
292
-
var next_opts = opts;
293
-
next_opts.type_name = if (!opts.type_name and !opts.last_layer_type_name) false else true;
294
-
next_opts.last_layer_type_name = opts.type_name;
295
-
296
-
switch (ptr.size) {
297
-
.one => {
298
-
if (opts.type_name) {
299
-
tty.setColor(.dim) catch {};
300
-
try w.print("*{s}", .{if (ptr.is_const) "const " else ""});
301
-
setColor(tty, .reset);
302
-
}
303
-
304
-
if (ptr.child == anyopaque or @typeInfo(ptr.child) == .@"fn")
305
-
return;
306
-
307
-
try innerFmt(w, tty, ptr.child, value, runtime, ctx, next_opts);
308
-
},
309
-
.slice => {
310
-
if (opts.type_name) {
311
-
setColor(tty, .dim);
312
-
try w.print("[]{s}", .{if (ptr.is_const) "const " else ""});
313
-
setColor(tty, .reset);
314
-
}
315
-
316
-
if (ptr.child == u8) {
317
-
tty.setColor(.dim) catch {};
318
-
try w.print("{s}=>", .{if (opts.type_name) "u8 " else ""});
319
-
setColor(tty, .reset);
320
-
321
-
try indent(w, runtime, ctx);
322
-
323
-
setColor(tty, .text);
324
-
try w.print("\"{s}\"", .{value});
325
-
setColor(tty, .reset);
326
-
return;
327
-
}
328
-
329
-
setColor(tty, .dim);
330
-
try w.print("{s}{s}", .{
331
-
if (opts.type_name) @typeName(ptr.child) else "",
332
-
if (opts.type_name) " =>" else "=>",
333
-
});
334
-
setColor(tty, .reset);
335
-
336
-
const run_ctx: Context(true) = .{ .indent_width = ctx.indent_width, .indent_level = ctx.indent_level };
337
-
var next_ctx: Context(true) = .{ .indent_width = ctx.indent_width, .indent_level = ctx.indent_level };
338
-
339
-
var count: usize = 0;
340
-
for (value, 0..) |item, idx| {
341
-
try indent(w, true, run_ctx);
342
-
343
-
setColor(tty, .field);
344
-
try w.print("[{}] ", .{idx});
345
-
setColor(tty, .reset);
346
-
347
-
next_ctx.indent_level = ctx.indent_level + 1;
348
-
next_opts.type_name = false;
349
-
350
-
try innerFmt(w, tty, @TypeOf(item), item, true, next_ctx, next_opts);
351
-
count += 1;
352
-
}
353
-
354
-
if (count == 0) {
355
-
setColor(tty, .dim);
356
-
try w.writeAll(" empty");
357
-
setColor(tty, .reset);
358
-
}
359
-
},
360
-
else => {
361
-
try w.print("unimplemented {}", .{ptr});
362
-
},
363
-
}
364
-
}
365
-
366
-
fn printStruct(
367
-
comptime T: type,
368
-
w: *Io.Writer,
369
-
tty: Io.Terminal,
370
-
str: Type.Struct,
371
-
value: anytype,
372
-
comptime runtime: bool,
373
-
ctx: Context(runtime),
374
-
opts: Options,
375
-
) !void {
376
-
var next_opts = opts;
377
-
next_opts.type_name = if (!opts.type_name and !opts.last_layer_type_name) false else true;
378
-
next_opts.last_layer_type_name = opts.type_name;
379
-
380
-
setColor(tty, .dim);
381
-
if (opts.type_name) {
382
-
try w.print("{s} =>", .{@typeName(T)});
383
-
} else {
384
-
try w.print("=>", .{});
385
-
}
386
-
setColor(tty, .reset);
387
-
388
-
if (runtime) {
389
-
var next_ctx: Context(true) = ctx;
390
-
391
-
inline for (str.fields) |field| {
392
-
try indent(w, runtime, ctx);
393
-
394
-
setColor(tty, .field);
395
-
try w.print(".{s}", .{field.name});
396
-
setColor(tty, .reset);
397
-
398
-
setColor(tty, .dim);
399
-
if (opts.type_name) {
400
-
try w.writeAll(": ");
401
-
} else try w.writeByte(' ');
402
-
setColor(tty, .reset);
403
-
404
-
next_ctx.indent_level = ctx.indent_level + 1;
405
-
406
-
try innerFmt(
407
-
w,
408
-
tty,
409
-
field.type,
410
-
@field(value, field.name),
411
-
runtime,
412
-
next_ctx,
413
-
next_opts,
414
-
);
415
-
}
416
-
} else {
417
-
comptime var next_ctx: Context(false) = ctx;
418
-
419
-
inline for (str.fields) |field| {
420
-
try indent(w, runtime, ctx);
421
-
422
-
setColor(tty, .field);
423
-
try w.print(".{s}", .{field.name});
424
-
setColor(tty, .reset);
425
-
426
-
setColor(tty, .dim);
427
-
if (opts.type_name) {
428
-
try w.writeAll(": ");
429
-
} else try w.writeByte(' ');
430
-
setColor(tty, .reset);
431
-
432
-
next_ctx.indent_level = ctx.indent_level + 1;
433
-
434
-
try innerFmt(
435
-
w,
436
-
tty,
437
-
field.type,
438
-
@field(value, field.name),
439
-
runtime,
440
-
next_ctx,
441
-
next_opts,
442
-
);
443
-
}
444
-
}
445
-
}
446
-
447
-
fn indent(w: *Io.Writer, comptime runtime: bool, ctx: Context(runtime)) !void {
448
-
try w.writeByte('\n');
449
-
if (runtime) {
450
-
for (0..((ctx.indent_level + 1) * ctx.indent_width)) |_| {
451
-
try w.writeByte(' ');
452
-
}
453
-
} else {
454
-
const text: [(ctx.indent_level + 1) * ctx.indent_width]u8 = @splat(' ');
455
-
try w.writeAll(&text);
456
-
}
457
-
}