From cd5acee3bdb908908de3f0010ad5e6bb5d5737a9 Mon Sep 17 00:00:00 2001
From: Lukas Wurzinger <lukas@wrz.one>
Date: Mon, 21 Nov 2022 18:09:59 +0100
Subject: [PATCH 01/10] make arg.name imply that an argument is required

---
 readarg.h   | 18 ++++--------------
 test/test.c | 29 +++++++++++++++++------------
 2 files changed, 21 insertions(+), 26 deletions(-)

diff --git a/readarg.h b/readarg.h
index 9c70386..52dd00e 100644
--- a/readarg.h
+++ b/readarg.h
@@ -45,9 +45,6 @@ struct readarg_opt
 {
     /* Two null-terminated arrays of either long or short option names. */
     char **names[2];
-
-    int req;
-
     struct readarg_arg arg;
 };
 
@@ -249,7 +246,7 @@ static void readarg_parse_opt(struct readarg_parser *rp, enum readarg_form form,
         {
             const char *strpos = *pos;
 
-            if (!match->req && *strpos)
+            if (!match->arg.name && *strpos)
             {
                 rp->state.grppos = strpos;
                 readarg_update_opt(rp, NULL, match);
@@ -348,7 +345,7 @@ static struct readarg_opt *readarg_match_finish(struct readarg_parser *rp, const
 
 static void readarg_update_opt(struct readarg_parser *rp, const char *attach, struct readarg_opt *opt)
 {
-    if (opt->req)
+    if (opt->arg.name)
     {
         if (attach)
         {
@@ -630,17 +627,10 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
                         {
                             READARG_HELPGEN_TRY_LIT(writer, ", ");
                         }
-                        else if (opts[i].req)
+                        else if (opts[i].arg.name)
                         {
                             READARG_HELPGEN_TRY_LIT(writer, " ");
-                            if (opts[i].arg.name)
-                            {
-                                READARG_HELPGEN_TRY_STR(writer, opts[i].arg.name);
-                            }
-                            else
-                            {
-                                READARG_HELPGEN_TRY_LIT(writer, "value");
-                            }
+                            READARG_HELPGEN_TRY_STR(writer, opts[i].arg.name);
 
                             if (inf)
                             {
diff --git a/test/test.c b/test/test.c
index 5925c85..463c3b9 100644
--- a/test/test.c
+++ b/test/test.c
@@ -38,40 +38,45 @@ int main(int argc, char **argv)
                 [READARG_FORM_SHORT] = READARG_STRINGS("e", "x"),
                 [READARG_FORM_LONG] = READARG_STRINGS("expr", "expression"),
             },
-            .req = 1,
-            .arg.bounds.val = {
-                1,
-                4,
-            },
+            .arg = {
+                .name = "expression",
+                .bounds.val = {
+                    1,
+                    4,
+                },
+            }
         },
         {
             .names = {
                 [READARG_FORM_SHORT] = READARG_STRINGS("c"),
                 [READARG_FORM_LONG] = READARG_STRINGS("config"),
             },
-            .req = 1,
             .arg = {
                 .name = "file",
                 .bounds.val = {
                     2,
                 },
-            },
+            }
         },
         {
             .names = {
                 [READARG_FORM_SHORT] = READARG_STRINGS("i"),
                 [READARG_FORM_LONG] = READARG_STRINGS("uri"),
             },
-            .req = 1,
-            .arg.bounds.inf = 1,
+            .arg = {
+                .name = "uri",
+                .bounds.inf = 1,
+            }
         },
         {
             .names = {
                 [READARG_FORM_SHORT] = READARG_STRINGS("b"),
                 [READARG_FORM_LONG] = READARG_STRINGS("backup", "backup-file"),
             },
-            .req = 1,
-            .arg.bounds.inf = 1,
+            .arg = {
+                .name = "file",
+                .bounds.inf = 1,
+            }
         },
         {
             .names = {
@@ -178,7 +183,7 @@ int main(int argc, char **argv)
                 }
             }
             printf("{ [%zu] ", curr[i].arg.val.len);
-            if (curr[i].req)
+            if (curr[i].arg.name)
             {
                 struct readarg_view_strings val = curr[i].arg.val;
                 for (size_t j = 0; j < val.len; j++)

From f0705dbefc979d9fb47a1a9cf2e16a6f396cdbc5 Mon Sep 17 00:00:00 2001
From: Lukas Wurzinger <lukas@wrz.one>
Date: Sat, 3 Dec 2022 12:53:50 +0100
Subject: [PATCH 02/10] fix warnings from GCC and Clang

---
 test/config.ninja | 2 +-
 test/test.c       | 4 +---
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/test/config.ninja b/test/config.ninja
index ec05418..d3c013d 100644
--- a/test/config.ninja
+++ b/test/config.ninja
@@ -1,6 +1,6 @@
 cc      = cc
 macros  = -D NDEBUG
-cflags  = -std=c99 -Wall -Wextra -Wpedantic -g $macros -O2
+cflags  = -std=c99 -Wno-missing-braces -Wall -Wextra -Wpedantic -g $macros -O2
 ldflags =
 ldlibs  =
 
diff --git a/test/test.c b/test/test.c
index 463c3b9..5afcd34 100644
--- a/test/test.c
+++ b/test/test.c
@@ -95,9 +95,7 @@ int main(int argc, char **argv)
             .arg.bounds.inf = 1,
         },
         {
-            {
-                0,
-            },
+            0,
         },
     };
 

From 9a694f3ff5cead416afb796276394c92c017ba60 Mon Sep 17 00:00:00 2001
From: Lukas Wurzinger <lukas@wrz.one>
Date: Sun, 4 Dec 2022 11:48:34 +0100
Subject: [PATCH 03/10] fix some clang-format rules

---
 .clang-format |  44 +++++---
 readarg.h     | 307 ++++++++++++++++----------------------------------
 test/test.c   |  63 ++++-------
 3 files changed, 149 insertions(+), 265 deletions(-)

diff --git a/.clang-format b/.clang-format
index 78711fc..7ee983e 100644
--- a/.clang-format
+++ b/.clang-format
@@ -1,30 +1,38 @@
-AlignConsecutiveMacros: true
-AlignEscapedNewlines: Left
-AllowShortBlocksOnASingleLine: false
-AllowShortCaseLabelsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: All
-AllowShortIfStatementsOnASingleLine: false
-AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterDefinitionReturnType: None
-AlwaysBreakAfterReturnType: None
 BasedOnStyle: LLVM
-BreakBeforeBinaryOperators: None
-BreakStringLiterals: false
-BreakBeforeBraces: Allman
-ColumnLimit: 0
+
+ColumnLimit: 160
+IndentWidth: 4
+UseTab: Never
+
+ReflowComments: true
+
+SortIncludes: true
 IncludeBlocks: Regroup
 IncludeCategories:
     - Regex: '^<.*>$'
       Priority: 1
     - Regex: '^".*"$'
       Priority: 2
+
+AlignConsecutiveMacros: true
+AlignEscapedNewlines: Left
+
 IndentCaseLabels: false
-IndentWidth: 4
 PointerAlignment: Right
-ReflowComments:  true
-SortIncludes: true
-SortUsingDeclarations: true
-SpaceBeforeParens: ControlStatements
+
+AllowShortBlocksOnASingleLine: Empty
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+
+AlwaysBreakAfterReturnType: None
+BreakBeforeBinaryOperators: All
+BreakBeforeTernaryOperators: true
+BreakStringLiterals: false
+BreakBeforeBraces: Attach
+
+SpaceBeforeParens: ControlStatementsExceptControlMacros
 SpaceInEmptyParentheses: false
 SpacesBeforeTrailingComments: 1
 SpacesInContainerLiterals: true
diff --git a/readarg.h b/readarg.h
index 52dd00e..91e8d4b 100644
--- a/readarg.h
+++ b/readarg.h
@@ -4,61 +4,52 @@
 
 #define READARG_STRINGS(...) ((char *[]){__VA_ARGS__, NULL})
 
-enum readarg_error
-{
+enum readarg_error {
     READARG_ESUCCESS,
     READARG_ENOVAL,
     READARG_ENOTREQ,
     READARG_ENOTOPT,
     READARG_ERANGEOPT,
-    READARG_ERANGEOPER
+    READARG_ERANGEOPER,
 };
 
-enum readarg_form
-{
+enum readarg_form {
     READARG_FORM_SHORT,
-    READARG_FORM_LONG
+    READARG_FORM_LONG,
 };
 
-struct readarg_view_strings
-{
+struct readarg_view_strings {
     const char **strings;
     size_t len;
 };
 
-struct readarg_bounds
-{
+struct readarg_bounds {
     /* The upper value will be ignored if inf is non-zero. */
     size_t val[2];
     int inf;
 };
 
 /* An argument in this case may either be an option argument or an operand. */
-struct readarg_arg
-{
+struct readarg_arg {
     char *name;
     struct readarg_bounds bounds;
     struct readarg_view_strings val;
 };
 
-struct readarg_opt
-{
+struct readarg_opt {
     /* Two null-terminated arrays of either long or short option names. */
     char **names[2];
     struct readarg_arg arg;
 };
 
-struct readarg_parser
-{
+struct readarg_parser {
     struct readarg_opt *opts;
     struct readarg_arg *opers;
     struct readarg_view_strings args;
-    struct
-    {
+    struct {
         int pending;
         const char *grppos;
-        struct
-        {
+        struct {
             struct readarg_opt *opt;
             /* Reference to the current argument being parsed. */
             const char **arg;
@@ -71,14 +62,12 @@ struct readarg_parser
     enum readarg_error error;
 };
 
-enum readarg_helpgen_format
-{
+enum readarg_helpgen_format {
     READARG_HELPGEN_FORMAT_PLAIN,
     READARG_HELPGEN_FORMAT_MDOC,
 };
 
-struct readarg_helpgen_writer
-{
+struct readarg_helpgen_writer {
     /* A falsy return value should indicate to the caller that an error occured. */
     int (*write)(void *ctx, const char *buf, size_t len);
     void *ctx;
@@ -132,23 +121,18 @@ static void readarg_permute_val(struct readarg_parser *rp, struct readarg_view_s
 static void readarg_incr_between(const char **start, const char **stop, struct readarg_view_strings *curr, struct readarg_view_strings *exclude);
 static void readarg_permute_rest(const char **target, struct readarg_view_strings start);
 
-int readarg_parse(struct readarg_parser *rp)
-{
+int readarg_parse(struct readarg_parser *rp) {
     /* Check whether the current offset is at the end of argv. */
     size_t off = rp->state.curr.arg - rp->args.strings;
-    if (off >= rp->args.len)
-    {
-        if (rp->state.pending)
-        {
+    if (off >= rp->args.len) {
+        if (rp->state.pending) {
             /* The last specified option required an argument, but no argument has been provided. */
             rp->error = READARG_ENOVAL;
             return 0;
         }
 
-        for (size_t i = 0; readarg_validate_opt(rp->opts + i); i++)
-        {
-            if (!readarg_validate_within(&rp->opts[i].arg))
-            {
+        for (size_t i = 0; readarg_validate_opt(rp->opts + i); i++) {
+            if (!readarg_validate_within(&rp->opts[i].arg)) {
                 rp->error = READARG_ERANGEOPT;
                 return 0;
             }
@@ -158,8 +142,7 @@ int readarg_parse(struct readarg_parser *rp)
         return 0;
     }
 
-    if (rp->state.pending)
-    {
+    if (rp->state.pending) {
         readarg_add_val(rp, &rp->state.curr.opt->arg, *rp->state.curr.arg, 0);
         ++rp->state.curr.arg;
         return !rp->error;
@@ -174,14 +157,11 @@ int readarg_parse(struct readarg_parser *rp)
     return !rp->error;
 }
 
-static void readarg_parse_arg(struct readarg_parser *rp, const char *arg)
-{
+static void readarg_parse_arg(struct readarg_parser *rp, const char *arg) {
     /* Parse the next option in the grouped option string, which automatically advances it. */
-    if (rp->state.grppos)
-    {
+    if (rp->state.grppos) {
         readarg_parse_opt(rp, READARG_FORM_SHORT, &rp->state.grppos);
-        if (!*rp->state.grppos)
-        {
+        if (!*rp->state.grppos) {
             rp->state.grppos = NULL;
         }
         return;
@@ -189,23 +169,19 @@ static void readarg_parse_arg(struct readarg_parser *rp, const char *arg)
 
     const char *pos = arg;
 
-    switch (*pos)
-    {
+    switch (*pos) {
     case '-':
         ++pos;
-        switch (*pos)
-        {
+        switch (*pos) {
         case '-':
             ++pos;
-            switch (*pos)
-            {
+            switch (*pos) {
                 size_t off;
             case '\0':
                 /* "--" denotes the end of options. */
                 off = rp->args.len - (rp->state.curr.arg - rp->args.strings);
                 assert(off);
-                if (off == 1)
-                {
+                if (off == 1) {
                     /* No operands after the "--". */
                     return;
                 }
@@ -234,42 +210,30 @@ static void readarg_parse_arg(struct readarg_parser *rp, const char *arg)
     }
 }
 
-static void readarg_parse_opt(struct readarg_parser *rp, enum readarg_form form, const char **pos)
-{
+static void readarg_parse_opt(struct readarg_parser *rp, enum readarg_form form, const char **pos) {
     struct readarg_opt *match;
     assert(form == READARG_FORM_SHORT || form == READARG_FORM_LONG);
 
-    if (form == READARG_FORM_SHORT)
-    {
+    if (form == READARG_FORM_SHORT) {
         match = readarg_match_opt(rp, form, pos);
-        if (match)
-        {
+        if (match) {
             const char *strpos = *pos;
 
-            if (!match->arg.name && *strpos)
-            {
+            if (!match->arg.name && *strpos) {
                 rp->state.grppos = strpos;
                 readarg_update_opt(rp, NULL, match);
-            }
-            else
-            {
+            } else {
                 readarg_update_opt(rp, *strpos ? strpos : NULL, match);
             }
-        }
-        else
-        {
+        } else {
             rp->error = READARG_ENOTOPT;
         }
-    }
-    else
-    {
+    } else {
         /* Match and advance pos to the end of the match. */
         match = readarg_match_opt(rp, form, pos);
 
-        if (match)
-        {
-            switch (**pos)
-            {
+        if (match) {
+            switch (**pos) {
             case '\0':
                 readarg_update_opt(rp, NULL, match);
                 break;
@@ -281,19 +245,15 @@ static void readarg_parse_opt(struct readarg_parser *rp, enum readarg_form form,
                 rp->error = READARG_ENOTOPT;
                 break;
             }
-        }
-        else
-        {
+        } else {
             rp->error = READARG_ENOTOPT;
         }
     }
 }
 
-static struct readarg_opt *readarg_match_opt(struct readarg_parser *rp, enum readarg_form form, const char **needle)
-{
+static struct readarg_opt *readarg_match_opt(struct readarg_parser *rp, enum readarg_form form, const char **needle) {
     /* This represents the last inexact match. */
-    struct
-    {
+    struct {
         /* The current advanced string. */
         const char *adv;
         /* The current option. */
@@ -301,8 +261,7 @@ static struct readarg_opt *readarg_match_opt(struct readarg_parser *rp, enum rea
     } loose = {0};
 
     struct readarg_opt *haystack = rp->opts;
-    for (size_t i = 0; readarg_validate_opt(haystack + i); i++)
-    {
+    for (size_t i = 0; readarg_validate_opt(haystack + i); i++) {
         /* Iterate through all short or long names of the current option. */
         char **names = haystack[i].names[form];
 
@@ -312,8 +271,7 @@ static struct readarg_opt *readarg_match_opt(struct readarg_parser *rp, enum rea
 
         const char *cmp = loose.adv;
 
-        for (size_t j = 0; names[j]; j++)
-        {
+        for (size_t j = 0; names[j]; j++) {
             char *name = names[j];
             cmp = readarg_skip_incl(*needle, name);
 
@@ -332,8 +290,7 @@ static struct readarg_opt *readarg_match_opt(struct readarg_parser *rp, enum rea
     return readarg_match_finish(rp, needle, loose.adv, loose.opt);
 }
 
-static struct readarg_opt *readarg_match_finish(struct readarg_parser *rp, const char **needle, const char *adv, struct readarg_opt *opt)
-{
+static struct readarg_opt *readarg_match_finish(struct readarg_parser *rp, const char **needle, const char *adv, struct readarg_opt *opt) {
     if (adv)
         *needle = adv;
 
@@ -343,68 +300,53 @@ static struct readarg_opt *readarg_match_finish(struct readarg_parser *rp, const
     return opt;
 }
 
-static void readarg_update_opt(struct readarg_parser *rp, const char *attach, struct readarg_opt *opt)
-{
-    if (opt->arg.name)
-    {
-        if (attach)
-        {
+static void readarg_update_opt(struct readarg_parser *rp, const char *attach, struct readarg_opt *opt) {
+    if (opt->arg.name) {
+        if (attach) {
             /* --opt=value, --opt=, -ovalue */
             struct readarg_arg *curr = &rp->state.curr.opt->arg;
             readarg_occ_opt(rp, opt);
             readarg_add_val(rp, curr, attach, 0);
-        }
-        else
-        {
+        } else {
             /* --opt value, -o value */
             rp->state.pending = 1;
             readarg_occ_opt(rp, opt);
         }
-    }
-    else
-    {
+    } else {
         readarg_occ_opt(rp, opt);
         if (attach)
             rp->error = READARG_ENOTREQ;
     }
 }
 
-static void readarg_update_oper(struct readarg_parser *rp, struct readarg_view_strings val)
-{
+static void readarg_update_oper(struct readarg_parser *rp, struct readarg_view_strings val) {
     assert(val.len && val.strings);
 
-    if (val.len == 1)
-    {
+    if (val.len == 1) {
         ++rp->state.curr.ioper.len;
         readarg_permute_val(rp, &rp->state.curr.ioper, val.strings[0], 1);
-    }
-    else
-    {
+    } else {
         readarg_permute_rest(rp->state.curr.eoval, val);
         rp->state.curr.ioper.len += val.len;
     }
 }
 
-static void readarg_assign_opers(struct readarg_parser *rp)
-{
+static void readarg_assign_opers(struct readarg_parser *rp) {
     size_t count = rp->state.curr.ioper.len;
 
     size_t nlower = 0;
     size_t nupper = 0;
-    for (size_t i = 0; readarg_validate_arg(rp->opers + i); i++)
-    {
+    for (size_t i = 0; readarg_validate_arg(rp->opers + i); i++) {
         nlower += readarg_select_lower(rp->opers[i].bounds);
         nupper += readarg_select_upper(rp->opers[i].bounds);
     }
 
-    if (count < nlower)
-    {
+    if (count < nlower) {
         rp->error = READARG_ERANGEOPER;
         return;
     }
 
-    struct
-    {
+    struct {
         size_t extra;
         size_t req;
     } rest = {
@@ -412,10 +354,8 @@ static void readarg_assign_opers(struct readarg_parser *rp)
         nlower,
     };
 
-    for (size_t i = 0; readarg_validate_arg(rp->opers + i); i++)
-    {
-        if (count == 0 || !rp->opers[i].val.strings)
-        {
+    for (size_t i = 0; readarg_validate_arg(rp->opers + i); i++) {
+        if (count == 0 || !rp->opers[i].val.strings) {
             size_t off = count - (rest.extra + rest.req);
             rp->opers[i].val.strings = rp->state.curr.ioper.strings + off;
         }
@@ -431,8 +371,7 @@ static void readarg_assign_opers(struct readarg_parser *rp)
         rp->opers[i].val.len += add, rest.req -= add;
 
         /* Add optional elements. */
-        add = inf ? rest.extra : rest.extra > upper ? upper
-                                                    : rest.extra;
+        add = inf ? rest.extra : rest.extra > upper ? upper : rest.extra;
         rp->opers[i].val.len += add, rest.extra -= add;
     }
 
@@ -440,8 +379,7 @@ static void readarg_assign_opers(struct readarg_parser *rp)
         rp->error = READARG_ERANGEOPER;
 }
 
-static void readarg_add_val(struct readarg_parser *rp, struct readarg_arg *arg, const char *string, int end)
-{
+static void readarg_add_val(struct readarg_parser *rp, struct readarg_arg *arg, const char *string, int end) {
     rp->state.pending = 0;
 
     if (!readarg_validate_within(arg))
@@ -450,10 +388,8 @@ static void readarg_add_val(struct readarg_parser *rp, struct readarg_arg *arg,
         readarg_permute_val(rp, &arg->val, string, end);
 }
 
-static const char *readarg_skip_incl(const char *outer, const char *inner)
-{
-    while (*inner == *outer)
-    {
+static const char *readarg_skip_incl(const char *outer, const char *inner) {
+    while (*inner == *outer) {
         if (!*inner)
             return outer;
         ++inner, ++outer;
@@ -461,15 +397,13 @@ static const char *readarg_skip_incl(const char *outer, const char *inner)
     return !*inner ? outer : NULL;
 }
 
-static void readarg_occ_opt(struct readarg_parser *rp, struct readarg_opt *opt)
-{
+static void readarg_occ_opt(struct readarg_parser *rp, struct readarg_opt *opt) {
     assert(opt);
     rp->state.curr.opt = opt;
     ++rp->state.curr.opt->arg.val.len;
 }
 
-static void readarg_permute_val(struct readarg_parser *rp, struct readarg_view_strings *target, const char *val, int end)
-{
+static void readarg_permute_val(struct readarg_parser *rp, struct readarg_view_strings *target, const char *val, int end) {
     if (!target->strings)
         /* Fallback position when no value has yet been set. */
         target->strings = rp->state.curr.eoval - (end ? 0 : rp->state.curr.ioper.len);
@@ -492,19 +426,16 @@ static void readarg_permute_val(struct readarg_parser *rp, struct readarg_view_s
     readarg_incr_between(start, stop, &rp->state.curr.ioper, target);
 }
 
-static void readarg_incr_between(const char **start, const char **stop, struct readarg_view_strings *curr, struct readarg_view_strings *exclude)
-{
+static void readarg_incr_between(const char **start, const char **stop, struct readarg_view_strings *curr, struct readarg_view_strings *exclude) {
     if (curr->strings >= start && curr->strings <= stop && curr != exclude)
         ++curr->strings;
 }
 
-static void readarg_permute_rest(const char **target, struct readarg_view_strings start)
-{
+static void readarg_permute_rest(const char **target, struct readarg_view_strings start) {
     memmove(target, start.strings, start.len * sizeof *start.strings);
 }
 
-void readarg_parser_init(struct readarg_parser *rp, struct readarg_opt *opts, struct readarg_arg *opers, struct readarg_view_strings args)
-{
+void readarg_parser_init(struct readarg_parser *rp, struct readarg_opt *opts, struct readarg_arg *opers, struct readarg_view_strings args) {
     *rp = (struct readarg_parser){
         .args = args,
         .opts = opts,
@@ -516,40 +447,33 @@ void readarg_parser_init(struct readarg_parser *rp, struct readarg_opt *opts, st
     };
 }
 
-int readarg_validate_opt(struct readarg_opt *opt)
-{
+int readarg_validate_opt(struct readarg_opt *opt) {
     assert(opt);
     return opt->names[0] || opt->names[1];
 }
 
-int readarg_validate_arg(struct readarg_arg *arg)
-{
+int readarg_validate_arg(struct readarg_arg *arg) {
     assert(arg);
     return !!arg->name;
 }
 
-int readarg_validate_within(struct readarg_arg *arg)
-{
+int readarg_validate_within(struct readarg_arg *arg) {
     size_t occ = arg->val.len;
     size_t upper = readarg_select_upper(arg->bounds);
     size_t lower = readarg_select_lower(arg->bounds);
     return occ >= lower && (occ <= upper || arg->bounds.inf);
 }
 
-size_t readarg_select_upper(struct readarg_bounds bounds)
-{
+size_t readarg_select_upper(struct readarg_bounds bounds) {
     return bounds.val[0] > bounds.val[1] ? bounds.val[0] : bounds.val[1];
 }
 
-size_t readarg_select_lower(struct readarg_bounds bounds)
-{
-    return bounds.inf ? readarg_select_upper(bounds) : bounds.val[0] < bounds.val[1] ? bounds.val[0]
-                                                                                     : bounds.val[1];
+size_t readarg_select_lower(struct readarg_bounds bounds) {
+    return bounds.inf ? readarg_select_upper(bounds) : bounds.val[0] < bounds.val[1] ? bounds.val[0] : bounds.val[1];
 }
 
 #define READARG_HELPGEN_TRY(writer, buf, len)                                  \
-    do                                                                         \
-    {                                                                          \
+    do {                                                                       \
         int readarg_helpgen_rv = (writer)->write((writer)->ctx, (buf), (len)); \
         if (!readarg_helpgen_rv)                                               \
             return readarg_helpgen_rv;                                         \
@@ -557,8 +481,7 @@ size_t readarg_select_lower(struct readarg_bounds bounds)
 #define READARG_HELPGEN_TRY_LIT(writer, s) READARG_HELPGEN_TRY((writer), (s), (sizeof(s) - 1))
 #define READARG_HELPGEN_TRY_STR(writer, s) READARG_HELPGEN_TRY((writer), (s), (strlen((s))))
 
-int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_writer *writer, const char *progname, const char *usage)
-{
+int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_writer *writer, const char *progname, const char *usage) {
     READARG_HELPGEN_TRY_STR(writer, usage);
     READARG_HELPGEN_TRY_LIT(writer, ":\n");
 
@@ -570,12 +493,10 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
 
     struct readarg_opt *opts = rp->opts;
     nxvalid = readarg_validate_opt(opts);
-    for (size_t i = 0; nxvalid; i++)
-    {
+    for (size_t i = 0; nxvalid; i++) {
         optwritten = 1;
 
-        if (i == 0)
-        {
+        if (i == 0) {
             READARG_HELPGEN_TRY_LIT(writer, "  ");
         }
 
@@ -585,55 +506,40 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
         int inf = opts[i].arg.bounds.inf;
         size_t nforms = sizeof opts[i].names / sizeof *opts[i].names;
 
-        for (size_t j = 0; j < (upper ? upper : !!inf); j++)
-        {
-            if (j >= lower)
-            {
+        for (size_t j = 0; j < (upper ? upper : !!inf); j++) {
+            if (j >= lower) {
                 READARG_HELPGEN_TRY_LIT(writer, "[");
             }
 
-            for (size_t k = 0; k < nforms; k++)
-            {
+            for (size_t k = 0; k < nforms; k++) {
                 int grp = 0;
-                if (opts[i].names[k])
-                {
-                    for (size_t l = 0; opts[i].names[k][l]; l++)
-                    {
-                        if (!grp)
-                        {
-                            if (k == READARG_FORM_SHORT)
-                            {
+                if (opts[i].names[k]) {
+                    for (size_t l = 0; opts[i].names[k][l]; l++) {
+                        if (!grp) {
+                            if (k == READARG_FORM_SHORT) {
                                 READARG_HELPGEN_TRY_LIT(writer, "-");
                             }
 
-                            if (k == READARG_FORM_LONG)
-                            {
+                            if (k == READARG_FORM_LONG) {
                                 READARG_HELPGEN_TRY_LIT(writer, "--");
                             }
                         }
 
                         READARG_HELPGEN_TRY_STR(writer, opts[i].names[k][l]);
 
-                        if (k == READARG_FORM_SHORT)
-                        {
+                        if (k == READARG_FORM_SHORT) {
                             grp = 1;
-                            if (!opts[i].names[k][l + 1])
-                            {
+                            if (!opts[i].names[k][l + 1]) {
                                 READARG_HELPGEN_TRY_LIT(writer, ", ");
                             }
                             continue;
-                        }
-                        else if (k + 1 < nforms || opts[i].names[k][l + 1])
-                        {
+                        } else if (k + 1 < nforms || opts[i].names[k][l + 1]) {
                             READARG_HELPGEN_TRY_LIT(writer, ", ");
-                        }
-                        else if (opts[i].arg.name)
-                        {
+                        } else if (opts[i].arg.name) {
                             READARG_HELPGEN_TRY_LIT(writer, " ");
                             READARG_HELPGEN_TRY_STR(writer, opts[i].arg.name);
 
-                            if (inf)
-                            {
+                            if (inf) {
                                 READARG_HELPGEN_TRY_LIT(writer, "...");
                             }
                         }
@@ -641,31 +547,26 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
                 }
             }
 
-            if (j >= lower)
-            {
+            if (j >= lower) {
                 READARG_HELPGEN_TRY_LIT(writer, "]");
             }
 
-            if (nxvalid)
-            {
+            if (nxvalid) {
                 READARG_HELPGEN_TRY_LIT(writer, "\n  ");
             }
         }
     }
 
-    if (optwritten)
-    {
+    if (optwritten) {
         READARG_HELPGEN_TRY_LIT(writer, "\n");
     }
 
     struct readarg_arg *opers = rp->opers;
     nxvalid = readarg_validate_arg(opers);
-    for (size_t i = 0; nxvalid; i++)
-    {
+    for (size_t i = 0; nxvalid; i++) {
         operwritten = 1;
 
-        if (i == 0)
-        {
+        if (i == 0) {
             READARG_HELPGEN_TRY_LIT(writer, "  ");
         }
 
@@ -674,45 +575,37 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
         size_t upper = readarg_select_upper(opers[i].bounds);
         int inf = opers[i].bounds.inf;
 
-        for (size_t j = 0; j < lower; j++)
-        {
+        for (size_t j = 0; j < lower; j++) {
             READARG_HELPGEN_TRY_STR(writer, opers[i].name);
 
-            if (inf && j + 1 == lower)
-            {
+            if (inf && j + 1 == lower) {
                 READARG_HELPGEN_TRY_LIT(writer, "...");
             }
 
-            if (nxvalid)
-            {
+            if (nxvalid) {
                 READARG_HELPGEN_TRY_LIT(writer, "\n  ");
             }
         }
 
-        size_t amt = upper ? upper : inf ? lower + 1
-                                         : 0;
-        for (size_t j = lower; j < amt; j++)
-        {
+        size_t amt = upper ? upper : inf ? lower + 1 : 0;
+        for (size_t j = lower; j < amt; j++) {
             READARG_HELPGEN_TRY_LIT(writer, "[");
 
             READARG_HELPGEN_TRY_STR(writer, opers[i].name);
 
-            if (inf && j + 1 == amt)
-            {
+            if (inf && j + 1 == amt) {
                 READARG_HELPGEN_TRY_LIT(writer, "...");
             }
 
             READARG_HELPGEN_TRY_LIT(writer, "]");
 
-            if (nxvalid)
-            {
+            if (nxvalid) {
                 READARG_HELPGEN_TRY_LIT(writer, "\n  ");
             }
         }
     }
 
-    if (operwritten)
-    {
+    if (operwritten) {
         READARG_HELPGEN_TRY_LIT(writer, "\n");
     }
 
diff --git a/test/test.c b/test/test.c
index 5afcd34..52e7e10 100644
--- a/test/test.c
+++ b/test/test.c
@@ -5,16 +5,14 @@
 
 #include "../readarg.h"
 
-enum opt
-{
+enum opt {
     OPT_HELP,
     OPT_VERSION,
 };
 
 static int write_callback(void *ctx, const char *buf, size_t len);
 
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
     struct readarg_opt opts[] = {
         [OPT_HELP] = {
             .names = {
@@ -44,7 +42,7 @@ int main(int argc, char **argv)
                     1,
                     4,
                 },
-            }
+            },
         },
         {
             .names = {
@@ -56,7 +54,7 @@ int main(int argc, char **argv)
                 .bounds.val = {
                     2,
                 },
-            }
+            },
         },
         {
             .names = {
@@ -66,7 +64,7 @@ int main(int argc, char **argv)
             .arg = {
                 .name = "uri",
                 .bounds.inf = 1,
-            }
+            },
         },
         {
             .names = {
@@ -76,7 +74,7 @@ int main(int argc, char **argv)
             .arg = {
                 .name = "file",
                 .bounds.inf = 1,
-            }
+            },
         },
         {
             .names = {
@@ -128,14 +126,11 @@ int main(int argc, char **argv)
     };
 
     struct readarg_parser rp;
-    readarg_parser_init(
-        &rp,
-        opts,
-        opers,
-        (struct readarg_view_strings){
-            .strings = (const char **)argv + 1,
-            .len = argc - 1,
-        });
+    readarg_parser_init(&rp, opts, opers,
+                        (struct readarg_view_strings){
+                            .strings = (const char **)argv + 1,
+                            .len = argc - 1,
+                        });
 
     while (readarg_parse(&rp))
         ;
@@ -146,21 +141,18 @@ int main(int argc, char **argv)
         .ctx = NULL,
     };
 
-    if (rp.error != READARG_ESUCCESS)
-    {
+    if (rp.error != READARG_ESUCCESS) {
         fprintf(stderr, "Error: %d\n", rp.error);
         readarg_helpgen_put_usage(&rp, &writer, progname, "Usage");
         return 1;
     }
 
-    if (rp.opts[OPT_HELP].arg.val.len >= 1)
-    {
+    if (rp.opts[OPT_HELP].arg.val.len >= 1) {
         readarg_helpgen_put_usage(&rp, &writer, progname, "Usage");
         return 0;
     }
 
-    if (rp.opts[OPT_VERSION].arg.val.len >= 1)
-    {
+    if (rp.opts[OPT_VERSION].arg.val.len >= 1) {
         printf("0.0.0\n");
         return 0;
     }
@@ -168,24 +160,18 @@ int main(int argc, char **argv)
     printf("opt:\n");
     {
         struct readarg_opt *curr = rp.opts;
-        for (size_t i = 0; readarg_validate_opt(curr + i); i++)
-        {
-            for (size_t j = 0; j < sizeof curr[i].names / sizeof *curr[i].names; j++)
-            {
-                if (curr[i].names[j])
-                {
-                    for (size_t k = 0; curr[i].names[j][k]; k++)
-                    {
+        for (size_t i = 0; readarg_validate_opt(curr + i); i++) {
+            for (size_t j = 0; j < sizeof curr[i].names / sizeof *curr[i].names; j++) {
+                if (curr[i].names[j]) {
+                    for (size_t k = 0; curr[i].names[j][k]; k++) {
                         printf("%s ", curr[i].names[j][k]);
                     }
                 }
             }
             printf("{ [%zu] ", curr[i].arg.val.len);
-            if (curr[i].arg.name)
-            {
+            if (curr[i].arg.name) {
                 struct readarg_view_strings val = curr[i].arg.val;
-                for (size_t j = 0; j < val.len; j++)
-                {
+                for (size_t j = 0; j < val.len; j++) {
                     printf("%s ", val.strings[j]);
                 }
             }
@@ -196,11 +182,9 @@ int main(int argc, char **argv)
     printf("oper:\n");
     {
         struct readarg_arg *curr = rp.opers;
-        for (size_t i = 0; readarg_validate_arg(curr + i); i++)
-        {
+        for (size_t i = 0; readarg_validate_arg(curr + i); i++) {
             printf("%s { [%zu] ", curr[i].name, curr[i].val.len);
-            for (size_t j = 0; j < curr[i].val.len; j++)
-            {
+            for (size_t j = 0; j < curr[i].val.len; j++) {
                 printf("%s ", curr[i].val.strings[j]);
             }
             printf("}\n");
@@ -210,8 +194,7 @@ int main(int argc, char **argv)
     return 0;
 }
 
-static int write_callback(void *ctx, const char *buf, size_t len)
-{
+static int write_callback(void *ctx, const char *buf, size_t len) {
     (void)ctx;
     return fwrite(buf, 1, len, stderr) == len;
 }

From 18fefa2aaae0193ade4585e320afcf9c9ec10571 Mon Sep 17 00:00:00 2001
From: Lukas Wurzinger <lukas@wrz.one>
Date: Sun, 11 Dec 2022 14:10:42 +0100
Subject: [PATCH 04/10] make option validation optional

---
 readarg.h         | 122 ++++++++++++++++++++++++----------------------
 test/help.bash    |   5 ++
 test/test.bash    |   4 --
 test/test.c       |   7 +++
 test/version.bash |   5 ++
 5 files changed, 80 insertions(+), 63 deletions(-)
 create mode 100755 test/help.bash
 create mode 100755 test/version.bash

diff --git a/readarg.h b/readarg.h
index 91e8d4b..31e69da 100644
--- a/readarg.h
+++ b/readarg.h
@@ -77,6 +77,10 @@ struct readarg_helpgen_writer {
 int readarg_parse(struct readarg_parser *rp);
 /* args should always exclude the first element. */
 void readarg_parser_init(struct readarg_parser *rp, struct readarg_opt *opts, struct readarg_arg *opers, struct readarg_view_strings args);
+/* Assign operands from the operand list to operands defined for the parser. */
+void readarg_assign_opers(struct readarg_parser *rp);
+/* Validate that all options meet their requirements. */
+struct readarg_opt *readarg_validate_opts(struct readarg_parser *rp);
 /* Check whether the argument is a valid option. */
 int readarg_validate_opt(struct readarg_opt *opt);
 /* Check whether the argument is a valid argument. */
@@ -109,8 +113,6 @@ static struct readarg_opt *readarg_match_finish(struct readarg_parser *rp, const
 static void readarg_update_opt(struct readarg_parser *rp, const char *attach, struct readarg_opt *opt);
 static void readarg_update_oper(struct readarg_parser *rp, struct readarg_view_strings val);
 
-static void readarg_assign_opers(struct readarg_parser *rp);
-
 static void readarg_add_val(struct readarg_parser *rp, struct readarg_arg *arg, const char *string, int end);
 
 static const char *readarg_skip_incl(const char *outer, const char *inner);
@@ -121,6 +123,65 @@ static void readarg_permute_val(struct readarg_parser *rp, struct readarg_view_s
 static void readarg_incr_between(const char **start, const char **stop, struct readarg_view_strings *curr, struct readarg_view_strings *exclude);
 static void readarg_permute_rest(const char **target, struct readarg_view_strings start);
 
+struct readarg_opt *readarg_validate_opts(struct readarg_parser *rp) {
+    for (size_t i = 0; readarg_validate_opt(rp->opts + i); i++) {
+        if (!readarg_validate_within(&rp->opts[i].arg)) {
+            rp->error = READARG_ERANGEOPT;
+            return &rp->opts[i];
+        }
+    }
+
+    return NULL;
+}
+
+void readarg_assign_opers(struct readarg_parser *rp) {
+    size_t count = rp->state.curr.ioper.len;
+
+    size_t nlower = 0;
+    size_t nupper = 0;
+    for (size_t i = 0; readarg_validate_arg(rp->opers + i); i++) {
+        nlower += readarg_select_lower(rp->opers[i].bounds);
+        nupper += readarg_select_upper(rp->opers[i].bounds);
+    }
+
+    if (count < nlower) {
+        rp->error = READARG_ERANGEOPER;
+        return;
+    }
+
+    struct {
+        size_t extra;
+        size_t req;
+    } rest = {
+        count - nlower,
+        nlower,
+    };
+
+    for (size_t i = 0; readarg_validate_arg(rp->opers + i); i++) {
+        if (count == 0 || !rp->opers[i].val.strings) {
+            size_t off = count - (rest.extra + rest.req);
+            rp->opers[i].val.strings = rp->state.curr.ioper.strings + off;
+        }
+
+        size_t lower = readarg_select_lower(rp->opers[i].bounds);
+        size_t upper = readarg_select_upper(rp->opers[i].bounds);
+        int inf = rp->opers[i].bounds.inf;
+
+        size_t add;
+
+        /* Add required elements. */
+        add = rest.req > lower ? lower : rest.req;
+        rp->opers[i].val.len += add, rest.req -= add;
+
+        /* Add optional elements. */
+        add = inf ? rest.extra : rest.extra > upper ? upper : rest.extra;
+        rp->opers[i].val.len += add, rest.extra -= add;
+    }
+
+    if (rest.extra || rest.req)
+        rp->error = READARG_ERANGEOPER;
+}
+
 int readarg_parse(struct readarg_parser *rp) {
     /* Check whether the current offset is at the end of argv. */
     size_t off = rp->state.curr.arg - rp->args.strings;
@@ -128,17 +189,8 @@ int readarg_parse(struct readarg_parser *rp) {
         if (rp->state.pending) {
             /* The last specified option required an argument, but no argument has been provided. */
             rp->error = READARG_ENOVAL;
-            return 0;
         }
 
-        for (size_t i = 0; readarg_validate_opt(rp->opts + i); i++) {
-            if (!readarg_validate_within(&rp->opts[i].arg)) {
-                rp->error = READARG_ERANGEOPT;
-                return 0;
-            }
-        }
-
-        readarg_assign_opers(rp);
         return 0;
     }
 
@@ -331,54 +383,6 @@ static void readarg_update_oper(struct readarg_parser *rp, struct readarg_view_s
     }
 }
 
-static void readarg_assign_opers(struct readarg_parser *rp) {
-    size_t count = rp->state.curr.ioper.len;
-
-    size_t nlower = 0;
-    size_t nupper = 0;
-    for (size_t i = 0; readarg_validate_arg(rp->opers + i); i++) {
-        nlower += readarg_select_lower(rp->opers[i].bounds);
-        nupper += readarg_select_upper(rp->opers[i].bounds);
-    }
-
-    if (count < nlower) {
-        rp->error = READARG_ERANGEOPER;
-        return;
-    }
-
-    struct {
-        size_t extra;
-        size_t req;
-    } rest = {
-        count - nlower,
-        nlower,
-    };
-
-    for (size_t i = 0; readarg_validate_arg(rp->opers + i); i++) {
-        if (count == 0 || !rp->opers[i].val.strings) {
-            size_t off = count - (rest.extra + rest.req);
-            rp->opers[i].val.strings = rp->state.curr.ioper.strings + off;
-        }
-
-        size_t lower = readarg_select_lower(rp->opers[i].bounds);
-        size_t upper = readarg_select_upper(rp->opers[i].bounds);
-        int inf = rp->opers[i].bounds.inf;
-
-        size_t add;
-
-        /* Add required elements. */
-        add = rest.req > lower ? lower : rest.req;
-        rp->opers[i].val.len += add, rest.req -= add;
-
-        /* Add optional elements. */
-        add = inf ? rest.extra : rest.extra > upper ? upper : rest.extra;
-        rp->opers[i].val.len += add, rest.extra -= add;
-    }
-
-    if (rest.extra || rest.req)
-        rp->error = READARG_ERANGEOPER;
-}
-
 static void readarg_add_val(struct readarg_parser *rp, struct readarg_arg *arg, const char *string, int end) {
     rp->state.pending = 0;
 
diff --git a/test/help.bash b/test/help.bash
new file mode 100755
index 0000000..fee2cdc
--- /dev/null
+++ b/test/help.bash
@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &> /dev/null
+
+./test -e a b c --help
diff --git a/test/test.bash b/test/test.bash
index 85a03b4..7c60236 100755
--- a/test/test.bash
+++ b/test/test.bash
@@ -34,7 +34,3 @@ cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &> /dev/null
 	x \
 	y \
 	z
-
-./test -e a b c --help
-
-./test -e a b c --version
diff --git a/test/test.c b/test/test.c
index 52e7e10..fa109aa 100644
--- a/test/test.c
+++ b/test/test.c
@@ -147,6 +147,13 @@ int main(int argc, char **argv) {
         return 1;
     }
 
+    struct readarg_opt *erropt = readarg_validate_opts(&rp);
+    if (erropt != NULL) {
+        fprintf(stderr, "Error: %d\n", rp.error);
+        readarg_helpgen_put_usage(&rp, &writer, progname, "Usage");
+        return 1;
+    }
+
     if (rp.opts[OPT_HELP].arg.val.len >= 1) {
         readarg_helpgen_put_usage(&rp, &writer, progname, "Usage");
         return 0;
diff --git a/test/version.bash b/test/version.bash
new file mode 100755
index 0000000..a814b33
--- /dev/null
+++ b/test/version.bash
@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &> /dev/null
+
+./test -e a b c --version

From 6b74bfb234f0858c136ecc3acf4a0ab6f672272d Mon Sep 17 00:00:00 2001
From: Lukas Wurzinger <lukas@wrz.one>
Date: Mon, 12 Dec 2022 18:36:20 +0100
Subject: [PATCH 05/10] use lengths for options and operands rather than
 sentinels

---
 .clang-format     |   2 +-
 README.md         |   2 -
 readarg.h         | 493 +++++++++++++++++++++++-----------------------
 test/help.bash    |   5 -
 test/test.c       |  26 +--
 test/version.bash |   5 -
 6 files changed, 253 insertions(+), 280 deletions(-)
 delete mode 100755 test/help.bash
 delete mode 100755 test/version.bash

diff --git a/.clang-format b/.clang-format
index 7ee983e..4d5565d 100644
--- a/.clang-format
+++ b/.clang-format
@@ -1,6 +1,6 @@
 BasedOnStyle: LLVM
 
-ColumnLimit: 160
+ColumnLimit: 240
 IndentWidth: 4
 UseTab: Never
 
diff --git a/README.md b/README.md
index fecefd4..159fe75 100644
--- a/README.md
+++ b/README.md
@@ -40,5 +40,3 @@ values to operands. The advantage of this approach is as follows:
 * Allocations are not needed because the memory provided by `argv` is reused
 * It's fairly simple to represent all of this data in an intuitive data
   structure (in my opinion anyway)
-  * For example, looping through operands is as simple as incrementing
-    `parser.oper` until `readarg_validate_arg` returns `0`.
diff --git a/readarg.h b/readarg.h
index 31e69da..6ee6891 100644
--- a/readarg.h
+++ b/readarg.h
@@ -43,7 +43,9 @@ struct readarg_opt {
 };
 
 struct readarg_parser {
+    size_t nopts;
     struct readarg_opt *opts;
+    size_t nopers;
     struct readarg_arg *opers;
     struct readarg_view_strings args;
     struct {
@@ -76,22 +78,19 @@ struct readarg_helpgen_writer {
 /* Iteratively parse the arguments. */
 int readarg_parse(struct readarg_parser *rp);
 /* args should always exclude the first element. */
-void readarg_parser_init(struct readarg_parser *rp, struct readarg_opt *opts, struct readarg_arg *opers, struct readarg_view_strings args);
+void readarg_parser_init(struct readarg_parser *rp, struct readarg_opt *opts, size_t nopts, struct readarg_arg *opers, size_t nopers, struct readarg_view_strings args);
+/* Output usage information. */
+int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_writer *writer, const char *progname, const char *usage);
 /* Assign operands from the operand list to operands defined for the parser. */
 void readarg_assign_opers(struct readarg_parser *rp);
 /* Validate that all options meet their requirements. */
 struct readarg_opt *readarg_validate_opts(struct readarg_parser *rp);
-/* Check whether the argument is a valid option. */
-int readarg_validate_opt(struct readarg_opt *opt);
-/* Check whether the argument is a valid argument. */
-int readarg_validate_arg(struct readarg_arg *arg);
 /* Check whether the argument's values are within the defined limits. */
-int readarg_validate_within(struct readarg_arg *arg);
+int readarg_validate_arg(struct readarg_arg *arg);
 /* Get the upper limit. */
 size_t readarg_select_upper(struct readarg_bounds bounds);
 /* Get the lower limit. This does not always return the minimum. */
 size_t readarg_select_lower(struct readarg_bounds bounds);
-int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_writer *writer, const char *progname, const char *usage);
 
 #ifdef READARG_IMPLEMENTATION
 
@@ -100,6 +99,15 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
 #undef NDEBUG
 #endif
 
+#define READARG_HELPGEN_TRY(writer, buf, len)                                  \
+    do {                                                                       \
+        int readarg_helpgen_rv = (writer)->write((writer)->ctx, (buf), (len)); \
+        if (!readarg_helpgen_rv)                                               \
+            return readarg_helpgen_rv;                                         \
+    } while (0)
+#define READARG_HELPGEN_TRY_LIT(writer, s) READARG_HELPGEN_TRY((writer), (s), (sizeof(s) - 1))
+#define READARG_HELPGEN_TRY_STR(writer, s) READARG_HELPGEN_TRY((writer), (s), (strlen((s))))
+
 #include <assert.h>
 #include <string.h>
 
@@ -123,65 +131,6 @@ static void readarg_permute_val(struct readarg_parser *rp, struct readarg_view_s
 static void readarg_incr_between(const char **start, const char **stop, struct readarg_view_strings *curr, struct readarg_view_strings *exclude);
 static void readarg_permute_rest(const char **target, struct readarg_view_strings start);
 
-struct readarg_opt *readarg_validate_opts(struct readarg_parser *rp) {
-    for (size_t i = 0; readarg_validate_opt(rp->opts + i); i++) {
-        if (!readarg_validate_within(&rp->opts[i].arg)) {
-            rp->error = READARG_ERANGEOPT;
-            return &rp->opts[i];
-        }
-    }
-
-    return NULL;
-}
-
-void readarg_assign_opers(struct readarg_parser *rp) {
-    size_t count = rp->state.curr.ioper.len;
-
-    size_t nlower = 0;
-    size_t nupper = 0;
-    for (size_t i = 0; readarg_validate_arg(rp->opers + i); i++) {
-        nlower += readarg_select_lower(rp->opers[i].bounds);
-        nupper += readarg_select_upper(rp->opers[i].bounds);
-    }
-
-    if (count < nlower) {
-        rp->error = READARG_ERANGEOPER;
-        return;
-    }
-
-    struct {
-        size_t extra;
-        size_t req;
-    } rest = {
-        count - nlower,
-        nlower,
-    };
-
-    for (size_t i = 0; readarg_validate_arg(rp->opers + i); i++) {
-        if (count == 0 || !rp->opers[i].val.strings) {
-            size_t off = count - (rest.extra + rest.req);
-            rp->opers[i].val.strings = rp->state.curr.ioper.strings + off;
-        }
-
-        size_t lower = readarg_select_lower(rp->opers[i].bounds);
-        size_t upper = readarg_select_upper(rp->opers[i].bounds);
-        int inf = rp->opers[i].bounds.inf;
-
-        size_t add;
-
-        /* Add required elements. */
-        add = rest.req > lower ? lower : rest.req;
-        rp->opers[i].val.len += add, rest.req -= add;
-
-        /* Add optional elements. */
-        add = inf ? rest.extra : rest.extra > upper ? upper : rest.extra;
-        rp->opers[i].val.len += add, rest.extra -= add;
-    }
-
-    if (rest.extra || rest.req)
-        rp->error = READARG_ERANGEOPER;
-}
-
 int readarg_parse(struct readarg_parser *rp) {
     /* Check whether the current offset is at the end of argv. */
     size_t off = rp->state.curr.arg - rp->args.strings;
@@ -209,6 +158,226 @@ int readarg_parse(struct readarg_parser *rp) {
     return !rp->error;
 }
 
+void readarg_parser_init(struct readarg_parser *rp, struct readarg_opt *opts, size_t nopts, struct readarg_arg *opers, size_t nopers, struct readarg_view_strings args) {
+    *rp = (struct readarg_parser){
+        .args = args,
+        .opts = opts,
+        .nopts = nopts,
+        .opers = opers,
+        .nopers = nopers,
+        .state.curr = {
+            .arg = args.strings,
+            .eoval = args.strings,
+        },
+    };
+}
+
+int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_writer *writer, const char *progname, const char *usage) {
+    READARG_HELPGEN_TRY_STR(writer, usage);
+    READARG_HELPGEN_TRY_LIT(writer, ":\n");
+
+    READARG_HELPGEN_TRY_STR(writer, progname);
+    READARG_HELPGEN_TRY_LIT(writer, "\n");
+
+    int optwritten = 0, operwritten = 0;
+    int next;
+
+    struct readarg_opt *opts = rp->opts;
+    next = !!rp->nopts;
+    for (size_t i = 0; next; i++) {
+        optwritten = 1;
+
+        if (i == 0) {
+            READARG_HELPGEN_TRY_LIT(writer, "  ");
+        }
+
+        next = i + 1 < rp->nopts;
+        size_t lower = readarg_select_lower(opts[i].arg.bounds);
+        size_t upper = readarg_select_upper(opts[i].arg.bounds);
+        int inf = opts[i].arg.bounds.inf;
+        size_t nforms = sizeof opts[i].names / sizeof *opts[i].names;
+
+        for (size_t j = 0; j < (upper ? upper : !!inf); j++) {
+            if (j >= lower) {
+                READARG_HELPGEN_TRY_LIT(writer, "[");
+            }
+
+            for (size_t k = 0; k < nforms; k++) {
+                int grp = 0;
+                if (opts[i].names[k]) {
+                    for (size_t l = 0; opts[i].names[k][l]; l++) {
+                        if (!grp) {
+                            if (k == READARG_FORM_SHORT) {
+                                READARG_HELPGEN_TRY_LIT(writer, "-");
+                            }
+
+                            if (k == READARG_FORM_LONG) {
+                                READARG_HELPGEN_TRY_LIT(writer, "--");
+                            }
+                        }
+
+                        READARG_HELPGEN_TRY_STR(writer, opts[i].names[k][l]);
+
+                        if (k == READARG_FORM_SHORT) {
+                            grp = 1;
+                            if (!opts[i].names[k][l + 1]) {
+                                READARG_HELPGEN_TRY_LIT(writer, ", ");
+                            }
+                            continue;
+                        } else if (k + 1 < nforms || opts[i].names[k][l + 1]) {
+                            READARG_HELPGEN_TRY_LIT(writer, ", ");
+                        } else if (opts[i].arg.name) {
+                            READARG_HELPGEN_TRY_LIT(writer, " ");
+                            READARG_HELPGEN_TRY_STR(writer, opts[i].arg.name);
+
+                            if (inf) {
+                                READARG_HELPGEN_TRY_LIT(writer, "...");
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (j >= lower) {
+                READARG_HELPGEN_TRY_LIT(writer, "]");
+            }
+
+            if (next) {
+                READARG_HELPGEN_TRY_LIT(writer, "\n  ");
+            }
+        }
+    }
+
+    if (optwritten) {
+        READARG_HELPGEN_TRY_LIT(writer, "\n");
+    }
+
+    struct readarg_arg *opers = rp->opers;
+    next = !!rp->nopers;
+    for (size_t i = 0; next; i++) {
+        operwritten = 1;
+
+        if (i == 0) {
+            READARG_HELPGEN_TRY_LIT(writer, "  ");
+        }
+
+        next = i + 1 < rp->nopers;
+        size_t lower = readarg_select_lower(opers[i].bounds);
+        size_t upper = readarg_select_upper(opers[i].bounds);
+        int inf = opers[i].bounds.inf;
+
+        for (size_t j = 0; j < lower; j++) {
+            READARG_HELPGEN_TRY_STR(writer, opers[i].name);
+
+            if (inf && j + 1 == lower) {
+                READARG_HELPGEN_TRY_LIT(writer, "...");
+            }
+
+            if (next) {
+                READARG_HELPGEN_TRY_LIT(writer, "\n  ");
+            }
+        }
+
+        size_t amt = upper ? upper : inf ? lower + 1 : 0;
+        for (size_t j = lower; j < amt; j++) {
+            READARG_HELPGEN_TRY_LIT(writer, "[");
+
+            READARG_HELPGEN_TRY_STR(writer, opers[i].name);
+
+            if (inf && j + 1 == amt) {
+                READARG_HELPGEN_TRY_LIT(writer, "...");
+            }
+
+            READARG_HELPGEN_TRY_LIT(writer, "]");
+
+            if (next) {
+                READARG_HELPGEN_TRY_LIT(writer, "\n  ");
+            }
+        }
+    }
+
+    if (operwritten) {
+        READARG_HELPGEN_TRY_LIT(writer, "\n");
+    }
+
+    return 1;
+}
+
+
+void readarg_assign_opers(struct readarg_parser *rp) {
+    size_t count = rp->state.curr.ioper.len;
+
+    size_t nlower = 0;
+    size_t nupper = 0;
+    for (size_t i = 0; i < rp->nopers; i++) {
+        nlower += readarg_select_lower(rp->opers[i].bounds);
+        nupper += readarg_select_upper(rp->opers[i].bounds);
+    }
+
+    if (count < nlower) {
+        rp->error = READARG_ERANGEOPER;
+        return;
+    }
+
+    struct {
+        size_t extra;
+        size_t req;
+    } rest = {
+        count - nlower,
+        nlower,
+    };
+
+    for (size_t i = 0; i < rp->nopers; i++) {
+        if (count == 0 || !rp->opers[i].val.strings) {
+            size_t off = count - (rest.extra + rest.req);
+            rp->opers[i].val.strings = rp->state.curr.ioper.strings + off;
+        }
+
+        size_t lower = readarg_select_lower(rp->opers[i].bounds);
+        size_t upper = readarg_select_upper(rp->opers[i].bounds);
+        int inf = rp->opers[i].bounds.inf;
+
+        size_t add;
+
+        /* Add required elements. */
+        add = rest.req > lower ? lower : rest.req;
+        rp->opers[i].val.len += add, rest.req -= add;
+
+        /* Add optional elements. */
+        add = inf ? rest.extra : rest.extra > upper ? upper : rest.extra;
+        rp->opers[i].val.len += add, rest.extra -= add;
+    }
+
+    if (rest.extra || rest.req)
+        rp->error = READARG_ERANGEOPER;
+}
+
+struct readarg_opt *readarg_validate_opts(struct readarg_parser *rp) {
+    for (size_t i = 0; i < rp->nopts; i++) {
+        if (!readarg_validate_arg(&rp->opts[i].arg)) {
+            rp->error = READARG_ERANGEOPT;
+            return &rp->opts[i];
+        }
+    }
+
+    return NULL;
+}
+
+int readarg_validate_arg(struct readarg_arg *arg) {
+    size_t occ = arg->val.len;
+    size_t upper = readarg_select_upper(arg->bounds);
+    size_t lower = readarg_select_lower(arg->bounds);
+    return occ >= lower && (occ <= upper || arg->bounds.inf);
+}
+
+size_t readarg_select_upper(struct readarg_bounds bounds) {
+    return bounds.val[0] > bounds.val[1] ? bounds.val[0] : bounds.val[1];
+}
+
+size_t readarg_select_lower(struct readarg_bounds bounds) {
+    return bounds.inf ? readarg_select_upper(bounds) : bounds.val[0] < bounds.val[1] ? bounds.val[0] : bounds.val[1];
+}
+
 static void readarg_parse_arg(struct readarg_parser *rp, const char *arg) {
     /* Parse the next option in the grouped option string, which automatically advances it. */
     if (rp->state.grppos) {
@@ -312,10 +481,9 @@ static struct readarg_opt *readarg_match_opt(struct readarg_parser *rp, enum rea
         struct readarg_opt *opt;
     } loose = {0};
 
-    struct readarg_opt *haystack = rp->opts;
-    for (size_t i = 0; readarg_validate_opt(haystack + i); i++) {
+    for (size_t i = 0; i < rp->nopts; i++) {
         /* Iterate through all short or long names of the current option. */
-        char **names = haystack[i].names[form];
+        char **names = rp->opts[i].names[form];
 
         if (!names)
             /* Ignore the option as it does not have names in the required form. */
@@ -332,10 +500,10 @@ static struct readarg_opt *readarg_match_opt(struct readarg_parser *rp, enum rea
 
             if (!*cmp)
                 /* A guaranteed match. */
-                return readarg_match_finish(rp, needle, cmp, haystack + i);
+                return readarg_match_finish(rp, needle, cmp, rp->opts + i);
             else if ((cmp - *needle) > (loose.adv - *needle))
                 /* Maybe a match, maybe not. */
-                loose.adv = cmp, loose.opt = haystack + i;
+                loose.adv = cmp, loose.opt = rp->opts + i;
         }
     }
 
@@ -386,7 +554,7 @@ static void readarg_update_oper(struct readarg_parser *rp, struct readarg_view_s
 static void readarg_add_val(struct readarg_parser *rp, struct readarg_arg *arg, const char *string, int end) {
     rp->state.pending = 0;
 
-    if (!readarg_validate_within(arg))
+    if (!readarg_validate_arg(arg))
         rp->error = READARG_ERANGEOPT;
     else
         readarg_permute_val(rp, &arg->val, string, end);
@@ -412,7 +580,7 @@ static void readarg_permute_val(struct readarg_parser *rp, struct readarg_view_s
         /* Fallback position when no value has yet been set. */
         target->strings = rp->state.curr.eoval - (end ? 0 : rp->state.curr.ioper.len);
 
-    const char **pos = target->strings + (target->len - 1);
+    const char **pos = target->strings + target->len - 1;
 
     assert(rp->state.curr.arg >= rp->state.curr.eoval);
 
@@ -424,7 +592,7 @@ static void readarg_permute_val(struct readarg_parser *rp, struct readarg_view_s
     const char **start = pos, **stop = rp->state.curr.eoval;
 
     /* Increment all value pointers in the options which are between start and stop (inclusive). */
-    for (size_t i = 0; readarg_validate_opt(rp->opts + i); i++)
+    for (size_t i = 0; i < rp->nopts; i++)
         readarg_incr_between(start, stop, &rp->opts[i].arg.val, target);
 
     readarg_incr_between(start, stop, &rp->state.curr.ioper, target);
@@ -439,183 +607,6 @@ static void readarg_permute_rest(const char **target, struct readarg_view_string
     memmove(target, start.strings, start.len * sizeof *start.strings);
 }
 
-void readarg_parser_init(struct readarg_parser *rp, struct readarg_opt *opts, struct readarg_arg *opers, struct readarg_view_strings args) {
-    *rp = (struct readarg_parser){
-        .args = args,
-        .opts = opts,
-        .opers = opers,
-        .state.curr = {
-            .arg = args.strings,
-            .eoval = args.strings,
-        },
-    };
-}
-
-int readarg_validate_opt(struct readarg_opt *opt) {
-    assert(opt);
-    return opt->names[0] || opt->names[1];
-}
-
-int readarg_validate_arg(struct readarg_arg *arg) {
-    assert(arg);
-    return !!arg->name;
-}
-
-int readarg_validate_within(struct readarg_arg *arg) {
-    size_t occ = arg->val.len;
-    size_t upper = readarg_select_upper(arg->bounds);
-    size_t lower = readarg_select_lower(arg->bounds);
-    return occ >= lower && (occ <= upper || arg->bounds.inf);
-}
-
-size_t readarg_select_upper(struct readarg_bounds bounds) {
-    return bounds.val[0] > bounds.val[1] ? bounds.val[0] : bounds.val[1];
-}
-
-size_t readarg_select_lower(struct readarg_bounds bounds) {
-    return bounds.inf ? readarg_select_upper(bounds) : bounds.val[0] < bounds.val[1] ? bounds.val[0] : bounds.val[1];
-}
-
-#define READARG_HELPGEN_TRY(writer, buf, len)                                  \
-    do {                                                                       \
-        int readarg_helpgen_rv = (writer)->write((writer)->ctx, (buf), (len)); \
-        if (!readarg_helpgen_rv)                                               \
-            return readarg_helpgen_rv;                                         \
-    } while (0)
-#define READARG_HELPGEN_TRY_LIT(writer, s) READARG_HELPGEN_TRY((writer), (s), (sizeof(s) - 1))
-#define READARG_HELPGEN_TRY_STR(writer, s) READARG_HELPGEN_TRY((writer), (s), (strlen((s))))
-
-int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_writer *writer, const char *progname, const char *usage) {
-    READARG_HELPGEN_TRY_STR(writer, usage);
-    READARG_HELPGEN_TRY_LIT(writer, ":\n");
-
-    READARG_HELPGEN_TRY_STR(writer, progname);
-    READARG_HELPGEN_TRY_LIT(writer, "\n");
-
-    int optwritten = 0, operwritten = 0;
-    int nxvalid;
-
-    struct readarg_opt *opts = rp->opts;
-    nxvalid = readarg_validate_opt(opts);
-    for (size_t i = 0; nxvalid; i++) {
-        optwritten = 1;
-
-        if (i == 0) {
-            READARG_HELPGEN_TRY_LIT(writer, "  ");
-        }
-
-        nxvalid = readarg_validate_opt(opts + i + 1);
-        size_t lower = readarg_select_lower(opts[i].arg.bounds);
-        size_t upper = readarg_select_upper(opts[i].arg.bounds);
-        int inf = opts[i].arg.bounds.inf;
-        size_t nforms = sizeof opts[i].names / sizeof *opts[i].names;
-
-        for (size_t j = 0; j < (upper ? upper : !!inf); j++) {
-            if (j >= lower) {
-                READARG_HELPGEN_TRY_LIT(writer, "[");
-            }
-
-            for (size_t k = 0; k < nforms; k++) {
-                int grp = 0;
-                if (opts[i].names[k]) {
-                    for (size_t l = 0; opts[i].names[k][l]; l++) {
-                        if (!grp) {
-                            if (k == READARG_FORM_SHORT) {
-                                READARG_HELPGEN_TRY_LIT(writer, "-");
-                            }
-
-                            if (k == READARG_FORM_LONG) {
-                                READARG_HELPGEN_TRY_LIT(writer, "--");
-                            }
-                        }
-
-                        READARG_HELPGEN_TRY_STR(writer, opts[i].names[k][l]);
-
-                        if (k == READARG_FORM_SHORT) {
-                            grp = 1;
-                            if (!opts[i].names[k][l + 1]) {
-                                READARG_HELPGEN_TRY_LIT(writer, ", ");
-                            }
-                            continue;
-                        } else if (k + 1 < nforms || opts[i].names[k][l + 1]) {
-                            READARG_HELPGEN_TRY_LIT(writer, ", ");
-                        } else if (opts[i].arg.name) {
-                            READARG_HELPGEN_TRY_LIT(writer, " ");
-                            READARG_HELPGEN_TRY_STR(writer, opts[i].arg.name);
-
-                            if (inf) {
-                                READARG_HELPGEN_TRY_LIT(writer, "...");
-                            }
-                        }
-                    }
-                }
-            }
-
-            if (j >= lower) {
-                READARG_HELPGEN_TRY_LIT(writer, "]");
-            }
-
-            if (nxvalid) {
-                READARG_HELPGEN_TRY_LIT(writer, "\n  ");
-            }
-        }
-    }
-
-    if (optwritten) {
-        READARG_HELPGEN_TRY_LIT(writer, "\n");
-    }
-
-    struct readarg_arg *opers = rp->opers;
-    nxvalid = readarg_validate_arg(opers);
-    for (size_t i = 0; nxvalid; i++) {
-        operwritten = 1;
-
-        if (i == 0) {
-            READARG_HELPGEN_TRY_LIT(writer, "  ");
-        }
-
-        nxvalid = readarg_validate_arg(opers + i + 1);
-        size_t lower = readarg_select_lower(opers[i].bounds);
-        size_t upper = readarg_select_upper(opers[i].bounds);
-        int inf = opers[i].bounds.inf;
-
-        for (size_t j = 0; j < lower; j++) {
-            READARG_HELPGEN_TRY_STR(writer, opers[i].name);
-
-            if (inf && j + 1 == lower) {
-                READARG_HELPGEN_TRY_LIT(writer, "...");
-            }
-
-            if (nxvalid) {
-                READARG_HELPGEN_TRY_LIT(writer, "\n  ");
-            }
-        }
-
-        size_t amt = upper ? upper : inf ? lower + 1 : 0;
-        for (size_t j = lower; j < amt; j++) {
-            READARG_HELPGEN_TRY_LIT(writer, "[");
-
-            READARG_HELPGEN_TRY_STR(writer, opers[i].name);
-
-            if (inf && j + 1 == amt) {
-                READARG_HELPGEN_TRY_LIT(writer, "...");
-            }
-
-            READARG_HELPGEN_TRY_LIT(writer, "]");
-
-            if (nxvalid) {
-                READARG_HELPGEN_TRY_LIT(writer, "\n  ");
-            }
-        }
-    }
-
-    if (operwritten) {
-        READARG_HELPGEN_TRY_LIT(writer, "\n");
-    }
-
-    return 1;
-}
-
 #ifdef READARG_DEBUG
 #pragma pop_macro("NDEBUG")
 #endif
diff --git a/test/help.bash b/test/help.bash
deleted file mode 100755
index fee2cdc..0000000
--- a/test/help.bash
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-
-cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &> /dev/null
-
-./test -e a b c --help
diff --git a/test/test.c b/test/test.c
index fa109aa..c747dcb 100644
--- a/test/test.c
+++ b/test/test.c
@@ -92,9 +92,6 @@ int main(int argc, char **argv) {
             },
             .arg.bounds.inf = 1,
         },
-        {
-            0,
-        },
     };
 
     struct readarg_arg opers[] = {
@@ -120,13 +117,10 @@ int main(int argc, char **argv) {
                 .inf = 1,
             },
         },
-        {
-            0,
-        },
     };
 
     struct readarg_parser rp;
-    readarg_parser_init(&rp, opts, opers,
+    readarg_parser_init(&rp, opts, sizeof opts / sizeof *opts, opers, sizeof opers / sizeof *opers,
                         (struct readarg_view_strings){
                             .strings = (const char **)argv + 1,
                             .len = argc - 1,
@@ -147,13 +141,6 @@ int main(int argc, char **argv) {
         return 1;
     }
 
-    struct readarg_opt *erropt = readarg_validate_opts(&rp);
-    if (erropt != NULL) {
-        fprintf(stderr, "Error: %d\n", rp.error);
-        readarg_helpgen_put_usage(&rp, &writer, progname, "Usage");
-        return 1;
-    }
-
     if (rp.opts[OPT_HELP].arg.val.len >= 1) {
         readarg_helpgen_put_usage(&rp, &writer, progname, "Usage");
         return 0;
@@ -164,10 +151,17 @@ int main(int argc, char **argv) {
         return 0;
     }
 
+    struct readarg_opt *erropt = readarg_validate_opts(&rp);
+    if (erropt != NULL) {
+        fprintf(stderr, "Error: %d\n", rp.error);
+        readarg_helpgen_put_usage(&rp, &writer, progname, "Usage");
+        return 1;
+    }
+
     printf("opt:\n");
     {
         struct readarg_opt *curr = rp.opts;
-        for (size_t i = 0; readarg_validate_opt(curr + i); i++) {
+        for (size_t i = 0; i < rp.nopts; i++) {
             for (size_t j = 0; j < sizeof curr[i].names / sizeof *curr[i].names; j++) {
                 if (curr[i].names[j]) {
                     for (size_t k = 0; curr[i].names[j][k]; k++) {
@@ -189,7 +183,7 @@ int main(int argc, char **argv) {
     printf("oper:\n");
     {
         struct readarg_arg *curr = rp.opers;
-        for (size_t i = 0; readarg_validate_arg(curr + i); i++) {
+        for (size_t i = 0; i < rp.nopers; i++) {
             printf("%s { [%zu] ", curr[i].name, curr[i].val.len);
             for (size_t j = 0; j < curr[i].val.len; j++) {
                 printf("%s ", curr[i].val.strings[j]);
diff --git a/test/version.bash b/test/version.bash
deleted file mode 100755
index a814b33..0000000
--- a/test/version.bash
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-
-cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &> /dev/null
-
-./test -e a b c --version

From 278098189deb377c0e43e93b4155c17620e01959 Mon Sep 17 00:00:00 2001
From: Lukas Wurzinger <lukas@wrz.one>
Date: Mon, 12 Dec 2022 19:54:26 +0100
Subject: [PATCH 06/10] remove nupper

---
 readarg.h | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/readarg.h b/readarg.h
index 6ee6891..73a5e1c 100644
--- a/readarg.h
+++ b/readarg.h
@@ -308,11 +308,8 @@ void readarg_assign_opers(struct readarg_parser *rp) {
     size_t count = rp->state.curr.ioper.len;
 
     size_t nlower = 0;
-    size_t nupper = 0;
-    for (size_t i = 0; i < rp->nopers; i++) {
+    for (size_t i = 0; i < rp->nopers; i++)
         nlower += readarg_select_lower(rp->opers[i].bounds);
-        nupper += readarg_select_upper(rp->opers[i].bounds);
-    }
 
     if (count < nlower) {
         rp->error = READARG_ERANGEOPER;

From 162498be5a6ccbcf107c8a976f09632ce5493e90 Mon Sep 17 00:00:00 2001
From: Lukas Wurzinger <lukas@wrz.one>
Date: Mon, 12 Dec 2022 21:05:23 +0100
Subject: [PATCH 07/10] remove some unnecessary code

---
 readarg.h | 70 ++++++++++++++++++++-----------------------------------
 1 file changed, 25 insertions(+), 45 deletions(-)

diff --git a/readarg.h b/readarg.h
index 73a5e1c..7156434 100644
--- a/readarg.h
+++ b/readarg.h
@@ -116,7 +116,6 @@ static void readarg_parse_arg(struct readarg_parser *rp, const char *arg);
 static void readarg_parse_opt(struct readarg_parser *rp, enum readarg_form form, const char **pos);
 
 static struct readarg_opt *readarg_match_opt(struct readarg_parser *rp, enum readarg_form form, const char **needle);
-static struct readarg_opt *readarg_match_finish(struct readarg_parser *rp, const char **needle, const char *adv, struct readarg_opt *opt);
 
 static void readarg_update_opt(struct readarg_parser *rp, const char *attach, struct readarg_opt *opt);
 static void readarg_update_oper(struct readarg_parser *rp, struct readarg_view_strings val);
@@ -135,10 +134,9 @@ int readarg_parse(struct readarg_parser *rp) {
     /* Check whether the current offset is at the end of argv. */
     size_t off = rp->state.curr.arg - rp->args.strings;
     if (off >= rp->args.len) {
-        if (rp->state.pending) {
+        if (rp->state.pending)
             /* The last specified option required an argument, but no argument has been provided. */
             rp->error = READARG_ENOVAL;
-        }
 
         return 0;
     }
@@ -187,9 +185,8 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
     for (size_t i = 0; next; i++) {
         optwritten = 1;
 
-        if (i == 0) {
+        if (i == 0)
             READARG_HELPGEN_TRY_LIT(writer, "  ");
-        }
 
         next = i + 1 < rp->nopts;
         size_t lower = readarg_select_lower(opts[i].arg.bounds);
@@ -198,9 +195,8 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
         size_t nforms = sizeof opts[i].names / sizeof *opts[i].names;
 
         for (size_t j = 0; j < (upper ? upper : !!inf); j++) {
-            if (j >= lower) {
+            if (j >= lower)
                 READARG_HELPGEN_TRY_LIT(writer, "[");
-            }
 
             for (size_t k = 0; k < nforms; k++) {
                 int grp = 0;
@@ -220,9 +216,8 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
 
                         if (k == READARG_FORM_SHORT) {
                             grp = 1;
-                            if (!opts[i].names[k][l + 1]) {
+                            if (!opts[i].names[k][l + 1])
                                 READARG_HELPGEN_TRY_LIT(writer, ", ");
-                            }
                             continue;
                         } else if (k + 1 < nforms || opts[i].names[k][l + 1]) {
                             READARG_HELPGEN_TRY_LIT(writer, ", ");
@@ -230,36 +225,31 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
                             READARG_HELPGEN_TRY_LIT(writer, " ");
                             READARG_HELPGEN_TRY_STR(writer, opts[i].arg.name);
 
-                            if (inf) {
+                            if (inf)
                                 READARG_HELPGEN_TRY_LIT(writer, "...");
-                            }
                         }
                     }
                 }
             }
 
-            if (j >= lower) {
+            if (j >= lower)
                 READARG_HELPGEN_TRY_LIT(writer, "]");
-            }
 
-            if (next) {
+            if (next)
                 READARG_HELPGEN_TRY_LIT(writer, "\n  ");
-            }
         }
     }
 
-    if (optwritten) {
+    if (optwritten)
         READARG_HELPGEN_TRY_LIT(writer, "\n");
-    }
 
     struct readarg_arg *opers = rp->opers;
     next = !!rp->nopers;
     for (size_t i = 0; next; i++) {
         operwritten = 1;
 
-        if (i == 0) {
+        if (i == 0)
             READARG_HELPGEN_TRY_LIT(writer, "  ");
-        }
 
         next = i + 1 < rp->nopers;
         size_t lower = readarg_select_lower(opers[i].bounds);
@@ -269,13 +259,11 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
         for (size_t j = 0; j < lower; j++) {
             READARG_HELPGEN_TRY_STR(writer, opers[i].name);
 
-            if (inf && j + 1 == lower) {
+            if (inf && j + 1 == lower)
                 READARG_HELPGEN_TRY_LIT(writer, "...");
-            }
 
-            if (next) {
+            if (next)
                 READARG_HELPGEN_TRY_LIT(writer, "\n  ");
-            }
         }
 
         size_t amt = upper ? upper : inf ? lower + 1 : 0;
@@ -284,21 +272,18 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
 
             READARG_HELPGEN_TRY_STR(writer, opers[i].name);
 
-            if (inf && j + 1 == amt) {
+            if (inf && j + 1 == amt)
                 READARG_HELPGEN_TRY_LIT(writer, "...");
-            }
 
             READARG_HELPGEN_TRY_LIT(writer, "]");
 
-            if (next) {
+            if (next)
                 READARG_HELPGEN_TRY_LIT(writer, "\n  ");
-            }
         }
     }
 
-    if (operwritten) {
+    if (operwritten)
         READARG_HELPGEN_TRY_LIT(writer, "\n");
-    }
 
     return 1;
 }
@@ -379,9 +364,8 @@ static void readarg_parse_arg(struct readarg_parser *rp, const char *arg) {
     /* Parse the next option in the grouped option string, which automatically advances it. */
     if (rp->state.grppos) {
         readarg_parse_opt(rp, READARG_FORM_SHORT, &rp->state.grppos);
-        if (!*rp->state.grppos) {
+        if (!*rp->state.grppos)
             rp->state.grppos = NULL;
-        }
         return;
     }
 
@@ -399,10 +383,9 @@ static void readarg_parse_arg(struct readarg_parser *rp, const char *arg) {
                 /* "--" denotes the end of options. */
                 off = rp->args.len - (rp->state.curr.arg - rp->args.strings);
                 assert(off);
-                if (off == 1) {
+                if (off == 1)
                     /* No operands after the "--". */
                     return;
-                }
 
                 readarg_update_oper(rp, (struct readarg_view_strings){
                                             .len = off - 1,
@@ -495,26 +478,23 @@ static struct readarg_opt *readarg_match_opt(struct readarg_parser *rp, enum rea
             if (!cmp)
                 continue;
 
-            if (!*cmp)
+            if (!*cmp) {
                 /* A guaranteed match. */
-                return readarg_match_finish(rp, needle, cmp, rp->opts + i);
-            else if ((cmp - *needle) > (loose.adv - *needle))
+                *needle = cmp;
+                return rp->state.curr.opt = rp->opts + i;
+            } else if ((cmp - *needle) > (loose.adv - *needle))
                 /* Maybe a match, maybe not. */
                 loose.adv = cmp, loose.opt = rp->opts + i;
         }
     }
 
-    return readarg_match_finish(rp, needle, loose.adv, loose.opt);
-}
+    if (loose.adv)
+        *needle = loose.adv;
 
-static struct readarg_opt *readarg_match_finish(struct readarg_parser *rp, const char **needle, const char *adv, struct readarg_opt *opt) {
-    if (adv)
-        *needle = adv;
+    if (loose.opt)
+        return rp->state.curr.opt = loose.opt;
 
-    if (opt)
-        rp->state.curr.opt = opt;
-
-    return opt;
+    return NULL;
 }
 
 static void readarg_update_opt(struct readarg_parser *rp, const char *attach, struct readarg_opt *opt) {

From 8a59e08b6c09b48be8dee11fbbd4dc5f0e82b3da Mon Sep 17 00:00:00 2001
From: Lukas Wurzinger <lukas@wrz.one>
Date: Tue, 13 Dec 2022 21:41:34 +0100
Subject: [PATCH 08/10] remove readarg_helpgen_format

---
 readarg.h | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/readarg.h b/readarg.h
index 7156434..1d3a317 100644
--- a/readarg.h
+++ b/readarg.h
@@ -64,11 +64,6 @@ struct readarg_parser {
     enum readarg_error error;
 };
 
-enum readarg_helpgen_format {
-    READARG_HELPGEN_FORMAT_PLAIN,
-    READARG_HELPGEN_FORMAT_MDOC,
-};
-
 struct readarg_helpgen_writer {
     /* A falsy return value should indicate to the caller that an error occured. */
     int (*write)(void *ctx, const char *buf, size_t len);

From 8d92ad399315d86f01b9f52ba20b1d952297748c Mon Sep 17 00:00:00 2001
From: Lukas Wurzinger <lukas@wrz.one>
Date: Sun, 19 Feb 2023 14:37:44 +0100
Subject: [PATCH 09/10] assign operands

---
 readarg.h   |  6 +-----
 test/test.c | 24 +++++++++++++++---------
 2 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/readarg.h b/readarg.h
index 1d3a317..fc56c0b 100644
--- a/readarg.h
+++ b/readarg.h
@@ -533,11 +533,7 @@ static void readarg_add_val(struct readarg_parser *rp, struct readarg_arg *arg,
 }
 
 static const char *readarg_skip_incl(const char *outer, const char *inner) {
-    while (*inner == *outer) {
-        if (!*inner)
-            return outer;
-        ++inner, ++outer;
-    }
+    for (; *inner && *inner == *outer; ++inner, ++outer);
     return !*inner ? outer : NULL;
 }
 
diff --git a/test/test.c b/test/test.c
index c747dcb..7228b51 100644
--- a/test/test.c
+++ b/test/test.c
@@ -13,6 +13,13 @@ enum opt {
 static int write_callback(void *ctx, const char *buf, size_t len);
 
 int main(int argc, char **argv) {
+    const char *progname = argv[0] == NULL ? "test" : argv[0];
+
+    struct readarg_helpgen_writer writer = {
+        .write = write_callback,
+        .ctx = NULL,
+    };
+
     struct readarg_opt opts[] = {
         [OPT_HELP] = {
             .names = {
@@ -126,15 +133,7 @@ int main(int argc, char **argv) {
                             .len = argc - 1,
                         });
 
-    while (readarg_parse(&rp))
-        ;
-
-    const char *progname = argv[0] == NULL ? "test" : argv[0];
-    struct readarg_helpgen_writer writer = {
-        .write = write_callback,
-        .ctx = NULL,
-    };
-
+    while (readarg_parse(&rp));
     if (rp.error != READARG_ESUCCESS) {
         fprintf(stderr, "Error: %d\n", rp.error);
         readarg_helpgen_put_usage(&rp, &writer, progname, "Usage");
@@ -158,6 +157,13 @@ int main(int argc, char **argv) {
         return 1;
     }
 
+    readarg_assign_opers(&rp);
+    if (rp.error != READARG_ESUCCESS) {
+        fprintf(stderr, "Error: %d\n", rp.error);
+        readarg_helpgen_put_usage(&rp, &writer, progname, "Usage");
+        return 1;
+    }
+
     printf("opt:\n");
     {
         struct readarg_opt *curr = rp.opts;

From 762a5c602cf676bc76ac3a2d4088d582cb02ccfc Mon Sep 17 00:00:00 2001
From: Lukas Wurzinger <lukas@wrz.one>
Date: Thu, 8 Aug 2024 01:59:19 +0200
Subject: [PATCH 10/10] use strlen for literals

---
 readarg.h | 47 +++++++++++++++++++++++------------------------
 1 file changed, 23 insertions(+), 24 deletions(-)

diff --git a/readarg.h b/readarg.h
index fc56c0b..f0a0a84 100644
--- a/readarg.h
+++ b/readarg.h
@@ -94,14 +94,13 @@ size_t readarg_select_lower(struct readarg_bounds bounds);
 #undef NDEBUG
 #endif
 
-#define READARG_HELPGEN_TRY(writer, buf, len)                                  \
+#define READARG_HELPGEN_TRY_BUF(writer, buf, len)                              \
     do {                                                                       \
         int readarg_helpgen_rv = (writer)->write((writer)->ctx, (buf), (len)); \
         if (!readarg_helpgen_rv)                                               \
             return readarg_helpgen_rv;                                         \
     } while (0)
-#define READARG_HELPGEN_TRY_LIT(writer, s) READARG_HELPGEN_TRY((writer), (s), (sizeof(s) - 1))
-#define READARG_HELPGEN_TRY_STR(writer, s) READARG_HELPGEN_TRY((writer), (s), (strlen((s))))
+#define READARG_HELPGEN_TRY_STR(writer, s) READARG_HELPGEN_TRY_BUF((writer), (s), (strlen((s))))
 
 #include <assert.h>
 #include <string.h>
@@ -167,10 +166,10 @@ void readarg_parser_init(struct readarg_parser *rp, struct readarg_opt *opts, si
 
 int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_writer *writer, const char *progname, const char *usage) {
     READARG_HELPGEN_TRY_STR(writer, usage);
-    READARG_HELPGEN_TRY_LIT(writer, ":\n");
+    READARG_HELPGEN_TRY_STR(writer, ":\n");
 
     READARG_HELPGEN_TRY_STR(writer, progname);
-    READARG_HELPGEN_TRY_LIT(writer, "\n");
+    READARG_HELPGEN_TRY_STR(writer, "\n");
 
     int optwritten = 0, operwritten = 0;
     int next;
@@ -181,7 +180,7 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
         optwritten = 1;
 
         if (i == 0)
-            READARG_HELPGEN_TRY_LIT(writer, "  ");
+            READARG_HELPGEN_TRY_STR(writer, "  ");
 
         next = i + 1 < rp->nopts;
         size_t lower = readarg_select_lower(opts[i].arg.bounds);
@@ -191,7 +190,7 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
 
         for (size_t j = 0; j < (upper ? upper : !!inf); j++) {
             if (j >= lower)
-                READARG_HELPGEN_TRY_LIT(writer, "[");
+                READARG_HELPGEN_TRY_STR(writer, "[");
 
             for (size_t k = 0; k < nforms; k++) {
                 int grp = 0;
@@ -199,11 +198,11 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
                     for (size_t l = 0; opts[i].names[k][l]; l++) {
                         if (!grp) {
                             if (k == READARG_FORM_SHORT) {
-                                READARG_HELPGEN_TRY_LIT(writer, "-");
+                                READARG_HELPGEN_TRY_STR(writer, "-");
                             }
 
                             if (k == READARG_FORM_LONG) {
-                                READARG_HELPGEN_TRY_LIT(writer, "--");
+                                READARG_HELPGEN_TRY_STR(writer, "--");
                             }
                         }
 
@@ -212,31 +211,31 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
                         if (k == READARG_FORM_SHORT) {
                             grp = 1;
                             if (!opts[i].names[k][l + 1])
-                                READARG_HELPGEN_TRY_LIT(writer, ", ");
+                                READARG_HELPGEN_TRY_STR(writer, ", ");
                             continue;
                         } else if (k + 1 < nforms || opts[i].names[k][l + 1]) {
-                            READARG_HELPGEN_TRY_LIT(writer, ", ");
+                            READARG_HELPGEN_TRY_STR(writer, ", ");
                         } else if (opts[i].arg.name) {
-                            READARG_HELPGEN_TRY_LIT(writer, " ");
+                            READARG_HELPGEN_TRY_STR(writer, " ");
                             READARG_HELPGEN_TRY_STR(writer, opts[i].arg.name);
 
                             if (inf)
-                                READARG_HELPGEN_TRY_LIT(writer, "...");
+                                READARG_HELPGEN_TRY_STR(writer, "...");
                         }
                     }
                 }
             }
 
             if (j >= lower)
-                READARG_HELPGEN_TRY_LIT(writer, "]");
+                READARG_HELPGEN_TRY_STR(writer, "]");
 
             if (next)
-                READARG_HELPGEN_TRY_LIT(writer, "\n  ");
+                READARG_HELPGEN_TRY_STR(writer, "\n  ");
         }
     }
 
     if (optwritten)
-        READARG_HELPGEN_TRY_LIT(writer, "\n");
+        READARG_HELPGEN_TRY_STR(writer, "\n");
 
     struct readarg_arg *opers = rp->opers;
     next = !!rp->nopers;
@@ -244,7 +243,7 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
         operwritten = 1;
 
         if (i == 0)
-            READARG_HELPGEN_TRY_LIT(writer, "  ");
+            READARG_HELPGEN_TRY_STR(writer, "  ");
 
         next = i + 1 < rp->nopers;
         size_t lower = readarg_select_lower(opers[i].bounds);
@@ -255,30 +254,30 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
             READARG_HELPGEN_TRY_STR(writer, opers[i].name);
 
             if (inf && j + 1 == lower)
-                READARG_HELPGEN_TRY_LIT(writer, "...");
+                READARG_HELPGEN_TRY_STR(writer, "...");
 
             if (next)
-                READARG_HELPGEN_TRY_LIT(writer, "\n  ");
+                READARG_HELPGEN_TRY_STR(writer, "\n  ");
         }
 
         size_t amt = upper ? upper : inf ? lower + 1 : 0;
         for (size_t j = lower; j < amt; j++) {
-            READARG_HELPGEN_TRY_LIT(writer, "[");
+            READARG_HELPGEN_TRY_STR(writer, "[");
 
             READARG_HELPGEN_TRY_STR(writer, opers[i].name);
 
             if (inf && j + 1 == amt)
-                READARG_HELPGEN_TRY_LIT(writer, "...");
+                READARG_HELPGEN_TRY_STR(writer, "...");
 
-            READARG_HELPGEN_TRY_LIT(writer, "]");
+            READARG_HELPGEN_TRY_STR(writer, "]");
 
             if (next)
-                READARG_HELPGEN_TRY_LIT(writer, "\n  ");
+                READARG_HELPGEN_TRY_STR(writer, "\n  ");
         }
     }
 
     if (operwritten)
-        READARG_HELPGEN_TRY_LIT(writer, "\n");
+        READARG_HELPGEN_TRY_STR(writer, "\n");
 
     return 1;
 }