use strlen for literals

.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
+ColumnLimit: 240
-BreakBeforeBraces: Allman
+IndentWidth: 4
-ColumnLimit: 0
+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
+AllowShortBlocksOnASingleLine: Empty
-SortUsingDeclarations: true
+AllowShortCaseLabelsOnASingleLine: false
-SpaceBeforeParens: ControlStatements
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+
+AlwaysBreakAfterReturnType: None
+BreakBeforeBinaryOperators: All
+BreakBeforeTernaryOperators: true
+BreakStringLiterals: false
+BreakBeforeBraces: Attach
+
+SpaceBeforeParens: ControlStatementsExceptControlMacros
 SpaceInEmptyParentheses: false
 SpacesBeforeTrailingComments: 1
 SpacesInContainerLiterals: true

.gitignore

@@ -1,4 +1,5 @@
 *.o
 test
+!test/
 .ninja_deps
 .ninja_log

README.md

@@ -24,8 +24,7 @@ It is required that one file in your project defines the
 as with any other single-header library.
 
 An example for how to use readarg can be found in `test/test.c`. If you want to
-see how readarg represents options and operands, execute `test.sh` in the same
+see how readarg represents options and operands, run `test.bash`.
-directory.
 
 ## Terminology
 
@@ -41,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`.

readarg.h

@@ -4,64 +4,54 @@
 
 #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];
-
-    int req;
-
     struct readarg_arg arg;
 };
 
-struct readarg_parser
+struct readarg_parser {
-{
+    size_t nopts;
     struct readarg_opt *opts;
+    size_t nopers;
     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;
@@ -74,14 +64,7 @@ struct readarg_parser
     enum readarg_error error;
 };
 
-enum readarg_helpgen_format
+struct readarg_helpgen_writer {
-{
-    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);
     void *ctx;
@@ -90,18 +73,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);
-/* Check whether the argument is a valid option. */
+/* Output usage information. */
-int readarg_validate_opt(struct readarg_opt *opt);
+int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_writer *writer, const char *progname, const char *usage);
-/* Check whether the argument is a valid argument. */
+/* Assign operands from the operand list to operands defined for the parser. */
-int readarg_validate_arg(struct readarg_arg *arg);
+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'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
 
@@ -110,6 +94,14 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
 #undef NDEBUG
 #endif
 
+#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_STR(writer, s) READARG_HELPGEN_TRY_BUF((writer), (s), (strlen((s))))
+
 #include <assert.h>
 #include <string.h>
 
@@ -118,13 +110,10 @@ 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);
 
-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);
@@ -135,34 +124,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 (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 (rp->state.pending) {
-        {
-            if (!readarg_validate_within(&rp->opts[i].arg))
-            {
-                rp->error = READARG_ERANGEOPT;
-                return 0;
-            }
-        }
-
-        readarg_assign_opers(rp);
-        return 0;
-    }
-
-    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;
@@ -177,41 +150,236 @@ int readarg_parse(struct readarg_parser *rp)
     return !rp->error;
 }
 
-static void readarg_parse_arg(struct readarg_parser *rp, const char *arg)
+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_STR(writer, ":\n");
+
+    READARG_HELPGEN_TRY_STR(writer, progname);
+    READARG_HELPGEN_TRY_STR(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_STR(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_STR(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_STR(writer, "-");
+                            }
+
+                            if (k == READARG_FORM_LONG) {
+                                READARG_HELPGEN_TRY_STR(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_STR(writer, ", ");
+                            continue;
+                        } else if (k + 1 < nforms || opts[i].names[k][l + 1]) {
+                            READARG_HELPGEN_TRY_STR(writer, ", ");
+                        } else if (opts[i].arg.name) {
+                            READARG_HELPGEN_TRY_STR(writer, " ");
+                            READARG_HELPGEN_TRY_STR(writer, opts[i].arg.name);
+
+                            if (inf)
+                                READARG_HELPGEN_TRY_STR(writer, "...");
+                        }
+                    }
+                }
+            }
+
+            if (j >= lower)
+                READARG_HELPGEN_TRY_STR(writer, "]");
+
+            if (next)
+                READARG_HELPGEN_TRY_STR(writer, "\n  ");
+        }
+    }
+
+    if (optwritten)
+        READARG_HELPGEN_TRY_STR(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_STR(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_STR(writer, "...");
+
+            if (next)
+                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_STR(writer, "[");
+
+            READARG_HELPGEN_TRY_STR(writer, opers[i].name);
+
+            if (inf && j + 1 == amt)
+                READARG_HELPGEN_TRY_STR(writer, "...");
+
+            READARG_HELPGEN_TRY_STR(writer, "]");
+
+            if (next)
+                READARG_HELPGEN_TRY_STR(writer, "\n  ");
+        }
+    }
+
+    if (operwritten)
+        READARG_HELPGEN_TRY_STR(writer, "\n");
+
+    return 1;
+}
+
+
+void readarg_assign_opers(struct readarg_parser *rp) {
+    size_t count = rp->state.curr.ioper.len;
+
+    size_t nlower = 0;
+    for (size_t i = 0; i < rp->nopers; i++)
+        nlower += readarg_select_lower(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)
+    if (rp->state.grppos) {
-    {
         readarg_parse_opt(rp, READARG_FORM_SHORT, &rp->state.grppos);
         if (!*rp->state.grppos)
-        {
             rp->state.grppos = NULL;
-        }
         return;
     }
 
     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)
-                {
                     /* No operands after the "--". */
                     return;
-                }
 
                 readarg_update_oper(rp, (struct readarg_view_strings){
                                             .len = off - 1,
@@ -237,42 +405,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->req && *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)
+        if (match) {
-        {
+            switch (**pos) {
-            switch (**pos)
-            {
             case '\0':
                 readarg_update_opt(rp, NULL, match);
                 break;
@@ -284,30 +440,24 @@ 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. */
         struct readarg_opt *opt;
     } loose = {0};
 
-    struct readarg_opt *haystack = rp->opts;
+    for (size_t i = 0; i < rp->nopts; 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];
+        char **names = rp->opts[i].names[form];
 
         if (!names)
             /* Ignore the option as it does not have names in the required form. */
@@ -315,169 +465,89 @@ 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);
 
             if (!cmp)
                 continue;
 
-            if (!*cmp)
+            if (!*cmp) {
                 /* A guaranteed match. */
-                return readarg_match_finish(rp, needle, cmp, haystack + i);
+                *needle = cmp;
-            else if ((cmp - *needle) > (loose.adv - *needle))
+                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 = haystack + i;
+                loose.adv = cmp, loose.opt = rp->opts + i;
         }
     }
 
-    return readarg_match_finish(rp, needle, loose.adv, loose.opt);
+    if (loose.adv)
+        *needle = loose.adv;
+
+    if (loose.opt)
+        return rp->state.curr.opt = loose.opt;
+
+    return NULL;
 }
 
-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) {
-{
+    if (opt->arg.name) {
-    if (adv)
+        if (attach) {
-        *needle = adv;
-
-    if (opt)
-        rp->state.curr.opt = opt;
-
-    return opt;
-}
-
-static void readarg_update_opt(struct readarg_parser *rp, const char *attach, struct readarg_opt *opt)
-{
-    if (opt->req)
-    {
-        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_add_val(struct readarg_parser *rp, struct readarg_arg *arg, const char *string, int end) {
-{
-    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;
 
-    if (!readarg_validate_within(arg))
+    if (!readarg_validate_arg(arg))
         rp->error = READARG_ERANGEOPT;
     else
         readarg_permute_val(rp, &arg->val, string, end);
 }
 
-static const char *readarg_skip_incl(const char *outer, const char *inner)
+static const char *readarg_skip_incl(const char *outer, const char *inner) {
-{
+    for (; *inner && *inner == *outer; ++inner, ++outer);
-    while (*inner == *outer)
-    {
-        if (!*inner)
-            return outer;
-        ++inner, ++outer;
-    }
     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);
 
-    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);
 
@@ -489,249 +559,21 @@ 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);
 }
 
-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)
-{
-    *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].req)
-                            {
-                                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");
-                                }
-
-                                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

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  =
 

test/test.bash

@@ -1,4 +1,7 @@
-#!/bin/sh
+#!/usr/bin/env bash
+
+cd -- "$(dirname -- "${BASH_SOURCE[0]}")" &> /dev/null
+
 ./test \
 	-e a \
 	--expr b \
@@ -26,9 +29,7 @@
 	--sort \
 	u \
 	v \
-	--help \
 	w \
-	--version \
 	-- \
 	x \
 	y \

test/test.c

@@ -5,16 +5,21 @@
 
 #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) {
-{
+    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 = {
@@ -38,18 +43,19 @@ int main(int argc, char **argv)
                 [READARG_FORM_SHORT] = READARG_STRINGS("e", "x"),
                 [READARG_FORM_LONG] = READARG_STRINGS("expr", "expression"),
             },
-            .req = 1,
+            .arg = {
-            .arg.bounds.val = {
+                .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 = {
@@ -62,16 +68,20 @@ int main(int argc, char **argv)
                 [READARG_FORM_SHORT] = READARG_STRINGS("i"),
                 [READARG_FORM_LONG] = READARG_STRINGS("uri"),
             },
-            .req = 1,
+            .arg = {
-            .arg.bounds.inf = 1,
+                .name = "uri",
+                .bounds.inf = 1,
+            },
         },
         {
             .names = {
                 [READARG_FORM_SHORT] = READARG_STRINGS("b"),
                 [READARG_FORM_LONG] = READARG_STRINGS("backup", "backup-file"),
             },
-            .req = 1,
+            .arg = {
-            .arg.bounds.inf = 1,
+                .name = "file",
+                .bounds.inf = 1,
+            },
         },
         {
             .names = {
@@ -89,9 +99,6 @@ int main(int argc, char **argv)
             },
             .arg.bounds.inf = 1,
         },
-        {
-            0,
-        },
     };
 
     struct readarg_arg opers[] = {
@@ -117,70 +124,61 @@ int main(int argc, char **argv)
                 .inf = 1,
             },
         },
-        {
-            0,
-        },
     };
 
     struct readarg_parser rp;
-    readarg_parser_init(
+    readarg_parser_init(&rp, opts, sizeof opts / sizeof *opts, opers, sizeof opers / sizeof *opers,
-        &rp,
-        opts,
-        opers,
                         (struct readarg_view_strings){
                             .strings = (const char **)argv + 1,
                             .len = argc - 1,
                         });
 
-    while (readarg_parse(&rp))
+    while (readarg_parse(&rp));
-        ;
+    if (rp.error != READARG_ESUCCESS) {
-
-    const char *progname = argv[0] == NULL ? "test" : argv[0];
-    struct readarg_helpgen_writer writer = {
-        .write = write_callback,
-        .ctx = NULL,
-    };
-
-    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;
     }
 
+    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;
+    }
+
+    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;
-        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++) {
-            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++) {
-                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].req)
+            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]);
                 }
             }
@@ -191,11 +189,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; 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++)
+            for (size_t j = 0; j < curr[i].val.len; j++) {
-            {
                 printf("%s ", curr[i].val.strings[j]);
             }
             printf("}\n");
@@ -205,8 +201,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;
 }