Count occurrences of flags (was "Add .count type for flags") (#96)

Breaking change: parseEx now counts the number of occurrences of flag
parameters (those with takes_value == .none) and returns the count as a
u8.  Users of the library will need to change

    if (arg_result.my_flag)

to

    if (arg_result.my_flag != 0)

1 files changed, 21 insertions, 5 deletions

diff --git a/clap.zig b/clap.zig
index 50b8c1c..8a9b961 100644
--- a/clap.zig
+++ b/clap.zig
@@ -803,7 +803,7 @@ fn parseArg(
     const longest = comptime param.names.longest();
     switch (longest.kind) {
         .short, .long => switch (param.takes_value) {
-            .none => @field(arguments, longest.name) = true,
+            .none => @field(arguments, longest.name) +|= 1,
             .one => @field(arguments, longest.name) = try parser(arg.value.?),
             .many => {
                 const value = try parser(arg.value.?);
@@ -912,7 +912,7 @@ fn Arguments(
 
         const T = ParamType(Id, param, value_parsers);
         const default_value = switch (param.takes_value) {
-            .none => false,
+            .none => @as(u8, 0),
             .one => @as(?T, null),
             .many => switch (multi_arg_kind) {
                 .slice => @as([]const T, &[_]T{}),
@@ -965,21 +965,37 @@ test "everything" {
     );
 
     var iter = args.SliceIterator{
-        .args = &.{ "-a", "-c", "0", "something", "-d", "1", "--dd", "2" },
+        .args = &.{ "-a", "--aa", "-c", "0", "something", "-d", "1", "--dd", "2" },
     };
     var res = try parseEx(Help, &params, parsers.default, &iter, .{
         .allocator = testing.allocator,
     });
     defer res.deinit();
 
-    try testing.expect(res.args.aa);
-    try testing.expect(!res.args.bb);
+    try testing.expect(res.args.aa == 2);
+    try testing.expect(res.args.bb == 0);
     try testing.expectEqualStrings("0", res.args.cc.?);
     try testing.expectEqual(@as(usize, 1), res.positionals.len);
     try testing.expectEqualStrings("something", res.positionals[0]);
     try testing.expectEqualSlices(usize, &.{ 1, 2 }, res.args.dd);
 }
 
+test "overflow-safe" {
+    const params = comptime parseParamsComptime(
+        \\-a, --aa
+    );
+
+    var iter = args.SliceIterator{
+        .args = &(.{"-" ++ ("a" ** 300)}),
+    };
+
+    // This just needs to not crash
+    var res = try parseEx(Help, &params, parsers.default, &iter, .{
+        .allocator = testing.allocator,
+    });
+    defer res.deinit();
+}
+
 test "empty" {
     var iter = args.SliceIterator{ .args = &.{} };
     var res = try parseEx(u8, &[_]Param(u8){}, parsers.default, &iter, .{