diff --git a/.clang-format b/.clang-format index 4d5565d..78711fc 100644 --- a/.clang-format +++ b/.clang-format @@ -1,38 +1,30 @@ +AlignConsecutiveMacros: true +AlignEscapedNewlines: Left +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: All +AllowShortIfStatementsOnASingleLine: false +AllowShortLoopsOnASingleLine: false +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None BasedOnStyle: LLVM - -ColumnLimit: 240 -IndentWidth: 4 -UseTab: Never - -ReflowComments: true - -SortIncludes: true +BreakBeforeBinaryOperators: None +BreakStringLiterals: false +BreakBeforeBraces: Allman +ColumnLimit: 0 IncludeBlocks: Regroup IncludeCategories: - Regex: '^<.*>$' Priority: 1 - Regex: '^".*"$' Priority: 2 - -AlignConsecutiveMacros: true -AlignEscapedNewlines: Left - IndentCaseLabels: false +IndentWidth: 4 PointerAlignment: Right - -AllowShortBlocksOnASingleLine: Empty -AllowShortCaseLabelsOnASingleLine: false -AllowShortFunctionsOnASingleLine: Empty -AllowShortIfStatementsOnASingleLine: Never -AllowShortLoopsOnASingleLine: false - -AlwaysBreakAfterReturnType: None -BreakBeforeBinaryOperators: All -BreakBeforeTernaryOperators: true -BreakStringLiterals: false -BreakBeforeBraces: Attach - -SpaceBeforeParens: ControlStatementsExceptControlMacros +ReflowComments: true +SortIncludes: true +SortUsingDeclarations: true +SpaceBeforeParens: ControlStatements SpaceInEmptyParentheses: false SpacesBeforeTrailingComments: 1 SpacesInContainerLiterals: true diff --git a/README.md b/README.md index 159fe75..fecefd4 100644 --- a/README.md +++ b/README.md @@ -40,3 +40,5 @@ 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 f0a0a84..9c70386 100644 --- a/readarg.h +++ b/readarg.h @@ -4,54 +4,64 @@ #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 { - size_t nopts; +struct readarg_parser +{ 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; @@ -64,7 +74,14 @@ struct readarg_parser { enum readarg_error error; }; -struct readarg_helpgen_writer { +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); void *ctx; @@ -73,19 +90,18 @@ 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, 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's values are within the defined limits. */ +void readarg_parser_init(struct readarg_parser *rp, struct readarg_opt *opts, struct readarg_arg *opers, struct readarg_view_strings args); +/* 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); /* 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 @@ -94,14 +110,6 @@ size_t readarg_select_lower(struct readarg_bounds bounds); #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 #include @@ -110,10 +118,13 @@ 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); @@ -124,18 +135,34 @@ 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 (!readarg_validate_within(&rp->opts[i].arg)) + { + rp->error = READARG_ERANGEOPT; + return 0; + } + } + + readarg_assign_opers(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; @@ -150,236 +177,41 @@ 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_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) { +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, @@ -405,30 +237,42 @@ 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->req && *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; @@ -440,24 +284,30 @@ 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}; - for (size_t i = 0; i < rp->nopts; i++) { + struct readarg_opt *haystack = rp->opts; + for (size_t i = 0; readarg_validate_opt(haystack + i); i++) + { /* Iterate through all short or long names of the current option. */ - char **names = rp->opts[i].names[form]; + char **names = haystack[i].names[form]; if (!names) /* Ignore the option as it does not have names in the required form. */ @@ -465,89 +315,169 @@ 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. */ - *needle = cmp; - return rp->state.curr.opt = rp->opts + i; - } else if ((cmp - *needle) > (loose.adv - *needle)) + return readarg_match_finish(rp, needle, cmp, haystack + i); + else if ((cmp - *needle) > (loose.adv - *needle)) /* Maybe a match, maybe not. */ - loose.adv = cmp, loose.opt = rp->opts + i; + loose.adv = cmp, loose.opt = haystack + i; } } - if (loose.adv) - *needle = loose.adv; - - if (loose.opt) - return rp->state.curr.opt = loose.opt; - - return NULL; + return readarg_match_finish(rp, needle, loose.adv, loose.opt); } -static void readarg_update_opt(struct readarg_parser *rp, const char *attach, struct readarg_opt *opt) { - if (opt->arg.name) { - if (attach) { +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 (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_add_val(struct readarg_parser *rp, struct readarg_arg *arg, const char *string, int end) { +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; - if (!readarg_validate_arg(arg)) + if (!readarg_validate_within(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) { - for (; *inner && *inner == *outer; ++inner, ++outer); +static const char *readarg_skip_incl(const char *outer, const char *inner) +{ + 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); @@ -559,21 +489,246 @@ 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; i < rp->nopts; i++) + for (size_t i = 0; readarg_validate_opt(rp->opts + i); 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 diff --git a/test/config.ninja b/test/config.ninja index d3c013d..ec05418 100644 --- a/test/config.ninja +++ b/test/config.ninja @@ -1,6 +1,6 @@ cc = cc macros = -D NDEBUG -cflags = -std=c99 -Wno-missing-braces -Wall -Wextra -Wpedantic -g $macros -O2 +cflags = -std=c99 -Wall -Wextra -Wpedantic -g $macros -O2 ldflags = ldlibs = diff --git a/test/test.bash b/test/test.bash index 7c60236..85a03b4 100755 --- a/test/test.bash +++ b/test/test.bash @@ -34,3 +34,7 @@ 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 7228b51..5925c85 100644 --- a/test/test.c +++ b/test/test.c @@ -5,21 +5,16 @@ #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) { - const char *progname = argv[0] == NULL ? "test" : argv[0]; - - struct readarg_helpgen_writer writer = { - .write = write_callback, - .ctx = NULL, - }; - +int main(int argc, char **argv) +{ struct readarg_opt opts[] = { [OPT_HELP] = { .names = { @@ -43,12 +38,10 @@ int main(int argc, char **argv) { [READARG_FORM_SHORT] = READARG_STRINGS("e", "x"), [READARG_FORM_LONG] = READARG_STRINGS("expr", "expression"), }, - .arg = { - .name = "expression", - .bounds.val = { - 1, - 4, - }, + .req = 1, + .arg.bounds.val = { + 1, + 4, }, }, { @@ -56,6 +49,7 @@ int main(int argc, char **argv) { [READARG_FORM_SHORT] = READARG_STRINGS("c"), [READARG_FORM_LONG] = READARG_STRINGS("config"), }, + .req = 1, .arg = { .name = "file", .bounds.val = { @@ -68,20 +62,16 @@ int main(int argc, char **argv) { [READARG_FORM_SHORT] = READARG_STRINGS("i"), [READARG_FORM_LONG] = READARG_STRINGS("uri"), }, - .arg = { - .name = "uri", - .bounds.inf = 1, - }, + .req = 1, + .arg.bounds.inf = 1, }, { .names = { [READARG_FORM_SHORT] = READARG_STRINGS("b"), [READARG_FORM_LONG] = READARG_STRINGS("backup", "backup-file"), }, - .arg = { - .name = "file", - .bounds.inf = 1, - }, + .req = 1, + .arg.bounds.inf = 1, }, { .names = { @@ -99,6 +89,11 @@ int main(int argc, char **argv) { }, .arg.bounds.inf = 1, }, + { + { + 0, + }, + }, }; struct readarg_arg opers[] = { @@ -124,61 +119,70 @@ int main(int argc, char **argv) { .inf = 1, }, }, + { + 0, + }, }; struct readarg_parser rp; - 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, - }); + readarg_parser_init( + &rp, + opts, + opers, + (struct readarg_view_strings){ + .strings = (const char **)argv + 1, + .len = argc - 1, + }); - while (readarg_parse(&rp)); - if (rp.error != READARG_ESUCCESS) { + while (readarg_parse(&rp)) + ; + + 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; 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++) { + 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].req) + { 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]); } } @@ -189,9 +193,11 @@ int main(int argc, char **argv) { printf("oper:\n"); { struct readarg_arg *curr = rp.opers; - for (size_t i = 0; i < rp.nopers; 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"); @@ -201,7 +207,8 @@ 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; }