lib/tldr/src/profiling/collect/command/entry.zig

daab053ee43316e1809a84551d573ddd1e5bf3d2

 1 const collect = @import("../root.zig");
 2 const alloc = @import("alloc");
 3 const alloc_arena = @import("alloc_arena");
 4 const std = collect.base.std;
 5 const sys = collect.base.sys;
 6 
 7 const common = @import("common.zig");
 8 const dispatch = @import("dispatch.zig");
 9 const model = collect.model;
10 
11 pub fn main(init: sys.process.Init) u8 {
12     var process_memory = alloc.ProcessAllocatorOwner.init();
13     const exit_code = mainWithAllocator(process_memory.allocator(), init.minimal.args, init.io, init.environ_map) catch |err| failure: {
14         writeFatalWithAllocator(process_memory.allocator(), err);
15         break :failure 1;
16     };
17     const finish = process_memory.finish();
18     return if (exit_code == 0) finish.exitCode() else exit_code;
19 }
20 
21 pub fn mainWithArgs(process_args: sys.process.Args, process_io: std.Io, environ_map: *const sys.process.Environ.Map) !u8 {
22     return mainWithAllocator(alloc.standaloneProcessAllocator(), process_args, process_io, environ_map);
23 }
24 
25 fn mainWithAllocator(backing_allocator: std.mem.Allocator, process_args: sys.process.Args, process_io: std.Io, environ_map: *const sys.process.Environ.Map) !u8 {
26     var arena = alloc_arena.Arena.init(backing_allocator);
27     defer arena.deinit();
28     const allocator = arena.allocator();
29 
30     const args_z = try process_args.toSlice(allocator);
31     var args_list: std.ArrayList([]const u8) = .empty;
32     for (args_z) |arg_z| try args_list.append(allocator, arg_z[0..arg_z.len]);
33 
34     var stdout_buffer: [8192]u8 = undefined;
35     var stdout_writer = sys.stdio.stdout().writer(sys.stdio.debugIo(), &stdout_buffer);
36     const stdout = &stdout_writer.interface;
37     defer stdout.flush() catch {};
38 
39     var stderr_buffer: [8192]u8 = undefined;
40     var stderr_writer = sys.stdio.stderr().writer(sys.stdio.debugIo(), &stderr_buffer);
41     const stderr = &stderr_writer.interface;
42     defer stderr.flush() catch {};
43 
44     return dispatch.runWithIo(allocator, args_list.items[1..], stdout, stderr, process_io, environ_map);
45 }
46 
47 pub fn run(allocator: model.Allocator, args: []const []const u8, stdout: *std.Io.Writer, stderr: *std.Io.Writer) !u8 {
48     var env = sys.process.Environ.Map.init(allocator);
49     return dispatch.runWithIo(allocator, args, stdout, stderr, model.fs_io, &env);
50 }
51 
52 pub fn writeFatal(err: anyerror) void {
53     writeFatalWithAllocator(alloc.standaloneProcessAllocator(), err);
54 }
55 
56 fn writeFatalWithAllocator(allocator: std.mem.Allocator, err: anyerror) void {
57     var buffer: [1024]u8 = undefined;
58     var stderr_writer = sys.stdio.stderr().writer(sys.stdio.debugIo(), &buffer);
59     const stderr = &stderr_writer.interface;
60     defer stderr.flush() catch {};
61     common.writeFmt(allocator, stderr, "tldr-suite: {s}\n", .{@errorName(err)}) catch {};
62 }