1 files changed, 42 insertions, 28 deletions

diff --git a/clap/comptime.zig b/clap/comptime.zig
index 122ff16..7808f52 100644
--- a/clap/comptime.zig
+++ b/clap/comptime.zig
@@ -14,7 +14,7 @@ pub fn ComptimeClap(
     var flags: usize = 0;
     var single_options: usize = 0;
     var multi_options: usize = 0;
-    var converted_params: []const clap.Param(usize) = &[_]clap.Param(usize){};
+    var converted_params: []const clap.Param(usize) = &.{};
     for (params) |param| {
         var index: usize = 0;
         if (param.names.long != null or param.names.short != null) {
@@ -27,18 +27,18 @@ pub fn ComptimeClap(
             ptr.* += 1;
         }
 
-        const converted = clap.Param(usize){
+        converted_params = converted_params ++ [_]clap.Param(usize){.{
             .id = index,
             .names = param.names,
             .takes_value = param.takes_value,
-        };
-        converted_params = converted_params ++ [_]clap.Param(usize){converted};
+        }};
     }
 
     return struct {
-        single_options: [single_options]?[]const u8,
         multi_options: [multi_options][]const []const u8,
-        flags: [flags]bool,
+        single_options: [single_options][]const u8,
+        single_options_is_set: std.PackedIntArray(u1, single_options),
+        flags: std.PackedIntArray(u1, flags),
         pos: []const []const u8,
         allocator: *mem.Allocator,
 
@@ -52,9 +52,12 @@ pub fn ComptimeClap(
             var pos = std.ArrayList([]const u8).init(allocator);
 
             var res = @This(){
-                .single_options = [_]?[]const u8{null} ** single_options,
-                .multi_options = [_][]const []const u8{undefined} ** multi_options,
-                .flags = [_]bool{false} ** flags,
+                .multi_options = .{undefined} ** multi_options,
+                .single_options = .{undefined} ** single_options,
+                .single_options_is_set = std.PackedIntArray(u1, single_options).init(
+                    .{0} ** single_options,
+                ),
+                .flags = std.PackedIntArray(u1, flags).init(.{0} ** flags),
                 .pos = undefined,
                 .allocator = allocator,
             };
@@ -69,16 +72,18 @@ pub fn ComptimeClap(
                     try pos.append(arg.value.?);
                 } else if (param.takes_value == .one) {
                     debug.assert(res.single_options.len != 0);
-                    if (res.single_options.len != 0)
+                    if (res.single_options.len != 0) {
                         res.single_options[param.id] = arg.value.?;
+                        res.single_options_is_set.set(param.id, 1);
+                    }
                 } else if (param.takes_value == .many) {
                     debug.assert(multis.len != 0);
                     if (multis.len != 0)
                         try multis[param.id].append(arg.value.?);
                 } else {
-                    debug.assert(res.flags.len != 0);
-                    if (res.flags.len != 0)
-                        res.flags[param.id] = true;
+                    debug.assert(res.flags.len() != 0);
+                    if (res.flags.len() != 0)
+                        res.flags.set(param.id, 1);
                 }
             }
 
@@ -100,7 +105,7 @@ pub fn ComptimeClap(
             if (param.takes_value != .none)
                 @compileError(name ++ " is an option and not a flag.");
 
-            return parser.flags[param.id];
+            return parser.flags.get(param.id) != 0;
         }
 
         pub fn option(parser: @This(), comptime name: []const u8) ?[]const u8 {
@@ -109,6 +114,8 @@ pub fn ComptimeClap(
                 @compileError(name ++ " is a flag and not an option.");
             if (param.takes_value == .many)
                 @compileError(name ++ " takes many options, not one.");
+            if (parser.single_options_is_set.get(param.id) == 0)
+                return null;
             return parser.single_options[param.id];
         }
 
@@ -146,30 +153,37 @@ pub fn ComptimeClap(
 }
 
 test "" {
-    const Clap = ComptimeClap(clap.Help, comptime &[_]clap.Param(clap.Help){
-        clap.parseParam("-a, --aa    ") catch unreachable,
-        clap.parseParam("-b, --bb    ") catch unreachable,
+    const Clap = ComptimeClap(clap.Help, comptime &.{
+        clap.parseParam("-a, --aa") catch unreachable,
+        clap.parseParam("-b, --bb") catch unreachable,
         clap.parseParam("-c, --cc <V>") catch unreachable,
         clap.parseParam("-d, --dd <V>...") catch unreachable,
         clap.parseParam("<P>") catch unreachable,
     });
 
     var iter = clap.args.SliceIterator{
-        .args = &[_][]const u8{
+        .args = &.{
             "-a", "-c", "0", "something", "-d", "a", "--dd", "b",
         },
     };
     var args = try Clap.parse(&iter, .{ .allocator = testing.allocator });
     defer args.deinit();
 
-    testing.expect(args.flag("-a"));
-    testing.expect(args.flag("--aa"));
-    testing.expect(!args.flag("-b"));
-    testing.expect(!args.flag("--bb"));
-    testing.expectEqualStrings("0", args.option("-c").?);
-    testing.expectEqualStrings("0", args.option("--cc").?);
-    testing.expectEqual(@as(usize, 1), args.positionals().len);
-    testing.expectEqualStrings("something", args.positionals()[0]);
-    testing.expectEqualSlices([]const u8, &[_][]const u8{ "a", "b" }, args.options("-d"));
-    testing.expectEqualSlices([]const u8, &[_][]const u8{ "a", "b" }, args.options("--dd"));
+    try testing.expect(args.flag("-a"));
+    try testing.expect(args.flag("--aa"));
+    try testing.expect(!args.flag("-b"));
+    try testing.expect(!args.flag("--bb"));
+    try testing.expectEqualStrings("0", args.option("-c").?);
+    try testing.expectEqualStrings("0", args.option("--cc").?);
+    try testing.expectEqual(@as(usize, 1), args.positionals().len);
+    try testing.expectEqualStrings("something", args.positionals()[0]);
+    try testing.expectEqualSlices([]const u8, &.{ "a", "b" }, args.options("-d"));
+    try testing.expectEqualSlices([]const u8, &.{ "a", "b" }, args.options("--dd"));
+}
+
+test "empty" {
+    const Clap = ComptimeClap(clap.Help, comptime &.{});
+    var iter = clap.args.SliceIterator{ .args = &.{} };
+    var args = try Clap.parse(&iter, .{ .allocator = testing.allocator });
+    defer args.deinit();
 }