diff --git a/.clang-format b/.clang-format index 78711fc..4d5565d 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: 240 +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/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 9c70386..f0a0a84 100644 --- a/readarg.h +++ b/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 -{ - 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; @@ -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); -/* 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); +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. */ -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 #include @@ -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 (!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; @@ -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) - { - switch (**pos) - { + if (match) { + 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; 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. */ @@ -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); - 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 = 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) -{ - 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) - { +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) -{ - 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) -{ +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) -{ - while (*inner == *outer) - { - if (!*inner) - return outer; - ++inner, ++outer; - } +static const char *readarg_skip_incl(const char *outer, const char *inner) { + for (; *inner && *inner == *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,246 +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 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.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 5925c85..7228b51 100644 --- a/test/test.c +++ b/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,10 +43,12 @@ 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, + }, }, }, { @@ -49,7 +56,6 @@ 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 = { @@ -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.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 = { @@ -89,11 +99,6 @@ int main(int argc, char **argv) }, .arg.bounds.inf = 1, }, - { - { - 0, - }, - }, }; struct readarg_arg opers[] = { @@ -119,70 +124,61 @@ int main(int argc, char **argv) .inf = 1, }, }, - { - 0, - }, }; 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, sizeof opts / sizeof *opts, opers, sizeof opers / sizeof *opers, + (struct readarg_view_strings){ + .strings = (const char **)argv + 1, + .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, - }; - - if (rp.error != READARG_ESUCCESS) - { + while (readarg_parse(&rp)); + 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 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; 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++) { 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]); } } @@ -193,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"); @@ -207,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; }