1 files changed, 40 insertions, 28 deletions

diff --git a/src/Config.zig b/src/Config.zig
index 4eb58cc..e559cad 100644
--- a/src/Config.zig
+++ b/src/Config.zig
@@ -3,6 +3,7 @@ const std = @import("std");
 const xdg = @import("xdg");
 
 const Allocator = std.mem.Allocator;
+const ArenaAllocator = std.heap.ArenaAllocator;
 const ArrayList = std.ArrayList;
 const Config = @This();
 const CrossTarget = std.zig.CrossTarget;
@@ -55,38 +56,49 @@ pub fn deinit(self: *Config) void {
 }
 
 fn readConfig(self: *Config, file: File) !void {
-    const allocator = self.allocator;
-    const reader = file.reader();
+    var arena = ArenaAllocator.init(self.allocator);
+    defer arena.deinit();
 
-    var json_str = try reader.readAllAlloc(allocator, std.math.maxInt(u64));
-    defer allocator.free(json_str);
+    const allocator = arena.allocator();
 
-    var parser = std.json.Parser.init(allocator, false);
-    defer parser.deinit();
-
-    var vt = try parser.parse(json_str);
-    defer vt.deinit();
-
-    if (vt.root != .Object) {
-        std.log.warn("Failed at reading config, root isn't object.", .{});
-        return;
-    }
+    const ConfigJson = struct {
+        supported_targets: [][]u8,
+    };
 
-    if (vt.root.Object.get("supported_targets")) |supported_targets| blk: {
-        if (supported_targets != .Array) {
-            break :blk;
-        }
+    var reader = std.json.reader(allocator, file.reader());
+    defer reader.deinit();
+
+    const parsed = try std.json.parseFromTokenSourceLeaky(
+        ConfigJson,
+        allocator,
+        &reader,
+        .{
+            .duplicate_field_behavior = .use_last,
+            .ignore_unknown_fields = true,
+        },
+    );
+
+    try self.supported_targets.ensureUnusedCapacity(parsed.supported_targets.len);
+
+    for (parsed.supported_targets) |target| {
+        const ct = CrossTarget.parse(.{
+            .arch_os_abi = target,
+        }) catch |e| {
+            std.log.warn(
+                "Failed to parse '{s}' as a target string: {}",
+                .{ target, e },
+            );
+            continue;
+        };
 
-        for (supported_targets.Array.items) |supported_target| {
-            if (supported_target != .String) {
-                continue;
-            }
+        const nti = NativeTargetInfo.detect(ct) catch |e| {
+            std.log.warn(
+                "Failed to detect NativeTargetInfo from '{s}': {}",
+                .{ target, e },
+            );
+            continue;
+        };
 
-            const cross_target = try CrossTarget.parse(.{
-                .arch_os_abi = supported_target.String,
-            });
-            const native_target_info = try NativeTargetInfo.detect(cross_target);
-            try self.supported_targets.append(native_target_info.target);
-        }
+        self.supported_targets.appendAssumeCapacity(nti.target);
     }
 }