split up CLI handler

Author: NullDev

src/cli.zig

@@ -0,0 +1,67 @@
+const std = @import("std");
+
+// ========================= //
+// = Copyright (c) NullDev = //
+// ========================= //
+
+pub const CliOptions = struct {
+    exe_path: ?[]const u8,
+    out_dir_path: ?[]const u8,
+};
+
+pub fn printUsage(writer: anytype) !void {
+    try writer.writeAll(
+        \\SimSymSrv is a tool to download PDB files from Microsoft's Symbol Server.
+        \\Copyright (c) 2025 NullDev
+        \\
+        \\Usage: SimSymSrv [options]
+        \\
+        \\Options:
+        \\  -i, --input <PATH>   Path to EXE/DLL/SYS file
+        \\  -o, --output <PATH>  Path to output folder
+        \\  -h, --help           Print this help message
+        \\
+        \\If options are not provided, you will be prompted for the missing input.
+        \\
+    );
+}
+
+pub fn parseArgs(allocator: std.mem.Allocator) !CliOptions {
+    var args = try std.process.argsWithAllocator(allocator);
+    defer args.deinit();
+
+    var options = CliOptions{
+        .exe_path = null,
+        .out_dir_path = null,
+    };
+
+    // Skip the program name argv[0]
+    _ = args.skip();
+
+    while (args.next()) |arg| {
+        if (std.mem.eql(u8, arg, "-h") or std.mem.eql(u8, arg, "--help")) {
+            try printUsage(std.io.getStdOut().writer());
+            std.process.exit(0);
+        } else if (std.mem.eql(u8, arg, "-i") or std.mem.eql(u8, arg, "--input")) {
+            const path = args.next() orelse {
+                try std.io.getStdErr().writer().writeAll("Error: -i/--input requires a path argument\n");
+                try printUsage(std.io.getStdErr().writer());
+                return error.InvalidArgument;
+            };
+            options.exe_path = try allocator.dupe(u8, path);
+        } else if (std.mem.eql(u8, arg, "-o") or std.mem.eql(u8, arg, "--output")) {
+            const path = args.next() orelse {
+                try std.io.getStdErr().writer().writeAll("Error: -o/--output requires a path argument\n");
+                try printUsage(std.io.getStdErr().writer());
+                return error.InvalidArgument;
+            };
+            options.out_dir_path = try allocator.dupe(u8, path);
+        } else {
+            try std.io.getStdErr().writer().print("Error: Unknown argument '{s}'\n", .{arg});
+            try printUsage(std.io.getStdErr().writer());
+            return error.InvalidArgument;
+        }
+    }
+
+    return options;
+}

src/main.zig

@@ -2,6 +2,7 @@ const std = @import("std");
 const pe = @import("pe.zig");
 const downloader = @import("downloader/downloader.zig");
 const h = @import("headers.zig");
+const cli = @import("cli.zig");
 
 // ========================= //
 // = Copyright (c) NullDev = //
@@ -13,78 +14,34 @@ fn readLineAlloc(alloc: std.mem.Allocator, r: anytype) ![]u8 {
     return alloc.dupe(u8, std.mem.trim(u8, bytes, " \r\n"));
 }
 
-fn printUsage(writer: anytype) !void {
-    try writer.writeAll(
-        \\SimSymSrv is a tool to download PDB files from Microsoft's Symbol Server.
-        \\Copyright (c) 2025 NullDev
-        \\
-        \\Usage: SimSymSrv [options]
-        \\
-        \\Options:
-        \\  -i, --input <PATH>   Path to EXE/DLL/SYS file
-        \\  -o, --output <PATH>  Path to output folder
-        \\  -h, --help           Print this help message
-        \\
-        \\If options are not provided, you will be prompted for the missing input.
-        \\
-    );
-}
-
 pub fn main() !void {
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     defer std.debug.assert(gpa.deinit() == .ok);
     // abort if the leak checker reports anything but ".ok"
     const alloc = gpa.allocator();
 
     const stdout = std.io.getStdOut().writer();
-    const stderr = std.io.getStdErr().writer();
-    var args = try std.process.argsWithAllocator(alloc);
-    defer args.deinit();
 
-    var exe_path: ?[]const u8 = null;
-    var out_dir_path: ?[]const u8 = null;
-
-    // Skip the program name
-    _ = args.skip();
-
-    // Parse arguments
-    while (args.next()) |arg| {
-        if (std.mem.eql(u8, arg, "-h") or std.mem.eql(u8, arg, "--help")) {
-            try printUsage(stdout);
-            return;
-        } else if (std.mem.eql(u8, arg, "-i") or std.mem.eql(u8, arg, "--input")) {
-            exe_path = args.next() orelse {
-                try stderr.writeAll("Error: -i/--input requires a path argument\n");
-                try printUsage(stderr);
-                return error.InvalidArgument;
-            };
-        } else if (std.mem.eql(u8, arg, "-o") or std.mem.eql(u8, arg, "--output")) {
-            out_dir_path = args.next() orelse {
-                try stderr.writeAll("Error: -o/--output requires a path argument\n");
-                try printUsage(stderr);
-                return error.InvalidArgument;
-            };
-        } else {
-            try stderr.print("Error: Unknown argument '{s}'\n", .{arg});
-            try printUsage(stderr);
-            return error.InvalidArgument;
-        }
+    const options = try cli.parseArgs(alloc);
+    defer {
+        if (options.exe_path) |path| alloc.free(path);
+        if (options.out_dir_path) |path| alloc.free(path);
     }
 
     const stdin = std.io.getStdIn().reader();
 
     // If arguments weren't provided, prompt for them
-    const final_exe_path = if (exe_path) |path| path else blk: {
+    const final_exe_path = if (options.exe_path) |path| path else blk: {
         try stdout.print("Path to EXE/DLL/SYS: ", .{});
         break :blk try readLineAlloc(alloc, stdin);
     };
-    defer if (exe_path == null) alloc.free(final_exe_path);
+    defer if (options.exe_path == null) alloc.free(final_exe_path);
 
-    const final_out_dir = if (out_dir_path) |path| path else blk: {
+    const final_out_dir = if (options.out_dir_path) |path| path else blk: {
         try stdout.print("Path to Output Folder: ", .{});
         break :blk try readLineAlloc(alloc, stdin);
     };
-    defer if (out_dir_path == null) alloc.free(final_out_dir);
+    defer if (options.out_dir_path == null) alloc.free(final_out_dir);
 
     // open and load the PE
     const pe_file = try std.fs.openFileAbsolute(final_exe_path, .{});