helvetica/readarg
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

fix some clang-format rules

Browse source
This commit is contained in:
Lukas Wurzinger 2022-12-04 11:48:34 +01:00
parent f0705dbefc
commit 9a694f3ff5
3 changed files with 149 additions and 265 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

44
.clang-format
View file

@ -1,30 +1,38 @@
AlignConsecutiveMacros: true
AlignEscapedNewlines: Left
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
BasedOnStyle: LLVM BasedOnStyle: LLVM
BreakBeforeBinaryOperators: None
BreakStringLiterals: false ColumnLimit: 160
BreakBeforeBraces: Allman IndentWidth: 4
ColumnLimit: 0 UseTab: Never
ReflowComments: true
SortIncludes: true
IncludeBlocks: Regroup IncludeBlocks: Regroup
IncludeCategories: IncludeCategories:
- Regex: '^<.*>$' - Regex: '^<.*>$'
Priority: 1 Priority: 1
- Regex: '^".*"$' - Regex: '^".*"$'
Priority: 2 Priority: 2
AlignConsecutiveMacros: true
AlignEscapedNewlines: Left
IndentCaseLabels: false IndentCaseLabels: false
IndentWidth: 4
PointerAlignment: Right 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 SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1 SpacesBeforeTrailingComments: 1
SpacesInContainerLiterals: true SpacesInContainerLiterals: true

307
readarg.h
View file

@ -4,61 +4,52 @@
#define READARG_STRINGS(...) ((char *[]){__VA_ARGS__, NULL}) #define READARG_STRINGS(...) ((char *[]){__VA_ARGS__, NULL})
enum readarg_error enum readarg_error {
{
READARG_ESUCCESS, READARG_ESUCCESS,
READARG_ENOVAL, READARG_ENOVAL,
READARG_ENOTREQ, READARG_ENOTREQ,
READARG_ENOTOPT, READARG_ENOTOPT,
READARG_ERANGEOPT, READARG_ERANGEOPT,
READARG_ERANGEOPER READARG_ERANGEOPER,
}; };
enum readarg_form enum readarg_form {
{
READARG_FORM_SHORT, READARG_FORM_SHORT,
READARG_FORM_LONG READARG_FORM_LONG,
}; };
struct readarg_view_strings struct readarg_view_strings {
{
const char **strings; const char **strings;
size_t len; size_t len;
}; };
struct readarg_bounds struct readarg_bounds {
{
/* The upper value will be ignored if inf is non-zero. */ /* The upper value will be ignored if inf is non-zero. */
size_t val[2]; size_t val[2];
int inf; int inf;
}; };
/* An argument in this case may either be an option argument or an operand. */ /* An argument in this case may either be an option argument or an operand. */
struct readarg_arg struct readarg_arg {
{
char *name; char *name;
struct readarg_bounds bounds; struct readarg_bounds bounds;
struct readarg_view_strings val; struct readarg_view_strings val;
}; };
struct readarg_opt struct readarg_opt {
{
/* Two null-terminated arrays of either long or short option names. */ /* Two null-terminated arrays of either long or short option names. */
char **names[2]; char **names[2];
struct readarg_arg arg; struct readarg_arg arg;
}; };
struct readarg_parser struct readarg_parser {
{
struct readarg_opt *opts; struct readarg_opt *opts;
struct readarg_arg *opers; struct readarg_arg *opers;
struct readarg_view_strings args; struct readarg_view_strings args;
struct struct {
{
int pending; int pending;
const char *grppos; const char *grppos;
struct struct {
{
struct readarg_opt *opt; struct readarg_opt *opt;
/* Reference to the current argument being parsed. */ /* Reference to the current argument being parsed. */
const char **arg; const char **arg;
@ -71,14 +62,12 @@ struct readarg_parser
enum readarg_error error; enum readarg_error error;
}; };
enum readarg_helpgen_format enum readarg_helpgen_format {
{
READARG_HELPGEN_FORMAT_PLAIN, READARG_HELPGEN_FORMAT_PLAIN,
READARG_HELPGEN_FORMAT_MDOC, 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. */ /* A falsy return value should indicate to the caller that an error occured. */
int (*write)(void *ctx, const char *buf, size_t len); int (*write)(void *ctx, const char *buf, size_t len);
void *ctx; void *ctx;
@ -132,23 +121,18 @@ static void readarg_permute_val(struct readarg_parser *rp, struct readarg_view_s
static void readarg_incr_between(const char **start, const char **stop, struct readarg_view_strings *curr, struct readarg_view_strings *exclude); static void readarg_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); 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. */ /* Check whether the current offset is at the end of argv. */
size_t off = rp->state.curr.arg - rp->args.strings; size_t off = rp->state.curr.arg - rp->args.strings;
if (off >= rp->args.len) if (off >= rp->args.len) {
{ if (rp->state.pending) {
if (rp->state.pending)
{
/* The last specified option required an argument, but no argument has been provided. */ /* The last specified option required an argument, but no argument has been provided. */
rp->error = READARG_ENOVAL; rp->error = READARG_ENOVAL;
return 0; return 0;
} }
for (size_t i = 0; readarg_validate_opt(rp->opts + i); i++) for (size_t i = 0; readarg_validate_opt(rp->opts + i); i++) {
{ if (!readarg_validate_within(&rp->opts[i].arg)) {
if (!readarg_validate_within(&rp->opts[i].arg))
{
rp->error = READARG_ERANGEOPT; rp->error = READARG_ERANGEOPT;
return 0; return 0;
} }
@ -158,8 +142,7 @@ int readarg_parse(struct readarg_parser *rp)
return 0; return 0;
} }
if (rp->state.pending) if (rp->state.pending) {
{
readarg_add_val(rp, &rp->state.curr.opt->arg, *rp->state.curr.arg, 0); readarg_add_val(rp, &rp->state.curr.opt->arg, *rp->state.curr.arg, 0);
++rp->state.curr.arg; ++rp->state.curr.arg;
return !rp->error; return !rp->error;
@ -174,14 +157,11 @@ int readarg_parse(struct readarg_parser *rp)
return !rp->error; return !rp->error;
} }
static void readarg_parse_arg(struct readarg_parser *rp, const char *arg) static void readarg_parse_arg(struct readarg_parser *rp, const char *arg) {
{
/* Parse the next option in the grouped option string, which automatically advances it. */ /* 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); readarg_parse_opt(rp, READARG_FORM_SHORT, &rp->state.grppos);
if (!*rp->state.grppos) if (!*rp->state.grppos) {
{
rp->state.grppos = NULL; rp->state.grppos = NULL;
} }
return; return;
@ -189,23 +169,19 @@ static void readarg_parse_arg(struct readarg_parser *rp, const char *arg)
const char *pos = arg; const char *pos = arg;
switch (*pos) switch (*pos) {
{
case '-': case '-':
++pos; ++pos;
switch (*pos) switch (*pos) {
{
case '-': case '-':
++pos; ++pos;
switch (*pos) switch (*pos) {
{
size_t off; size_t off;
case '\0': case '\0':
/* "--" denotes the end of options. */ /* "--" denotes the end of options. */
off = rp->args.len - (rp->state.curr.arg - rp->args.strings); off = rp->args.len - (rp->state.curr.arg - rp->args.strings);
assert(off); assert(off);
if (off == 1) if (off == 1) {
{
/* No operands after the "--". */ /* No operands after the "--". */
return; return;
} }
@ -234,42 +210,30 @@ static void readarg_parse_arg(struct readarg_parser *rp, const char *arg)
} }
} }
static void readarg_parse_opt(struct readarg_parser *rp, enum readarg_form form, const char **pos) static void readarg_parse_opt(struct readarg_parser *rp, enum readarg_form form, const char **pos) {
{
struct readarg_opt *match; struct readarg_opt *match;
assert(form == READARG_FORM_SHORT || form == READARG_FORM_LONG); 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); match = readarg_match_opt(rp, form, pos);
if (match) if (match) {
{
const char *strpos = *pos; const char *strpos = *pos;
if (!match->arg.name && *strpos) if (!match->arg.name && *strpos) {
{
rp->state.grppos = strpos; rp->state.grppos = strpos;
readarg_update_opt(rp, NULL, match); readarg_update_opt(rp, NULL, match);
} } else {
else
{
readarg_update_opt(rp, *strpos ? strpos : NULL, match); readarg_update_opt(rp, *strpos ? strpos : NULL, match);
} }
} } else {
else
{
rp->error = READARG_ENOTOPT; rp->error = READARG_ENOTOPT;
} }
} } else {
else
{
/* Match and advance pos to the end of the match. */ /* Match and advance pos to the end of the match. */
match = readarg_match_opt(rp, form, pos); match = readarg_match_opt(rp, form, pos);
if (match) if (match) {
{ switch (**pos) {
switch (**pos)
{
case '\0': case '\0':
readarg_update_opt(rp, NULL, match); readarg_update_opt(rp, NULL, match);
break; break;
@ -281,19 +245,15 @@ static void readarg_parse_opt(struct readarg_parser *rp, enum readarg_form form,
rp->error = READARG_ENOTOPT; rp->error = READARG_ENOTOPT;
break; break;
} }
} } else {
else
{
rp->error = READARG_ENOTOPT; 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. */ /* This represents the last inexact match. */
struct struct {
{
/* The current advanced string. */ /* The current advanced string. */
const char *adv; const char *adv;
/* The current option. */ /* The current option. */
@ -301,8 +261,7 @@ static struct readarg_opt *readarg_match_opt(struct readarg_parser *rp, enum rea
} loose = {0}; } loose = {0};
struct readarg_opt *haystack = rp->opts; struct readarg_opt *haystack = rp->opts;
for (size_t i = 0; readarg_validate_opt(haystack + i); i++) for (size_t i = 0; readarg_validate_opt(haystack + i); i++) {
{
/* Iterate through all short or long names of the current option. */ /* Iterate through all short or long names of the current option. */
char **names = haystack[i].names[form]; char **names = haystack[i].names[form];
@ -312,8 +271,7 @@ static struct readarg_opt *readarg_match_opt(struct readarg_parser *rp, enum rea
const char *cmp = loose.adv; 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]; char *name = names[j];
cmp = readarg_skip_incl(*needle, name); cmp = readarg_skip_incl(*needle, name);
@ -332,8 +290,7 @@ static struct readarg_opt *readarg_match_opt(struct readarg_parser *rp, enum rea
return readarg_match_finish(rp, needle, loose.adv, loose.opt); return readarg_match_finish(rp, needle, loose.adv, loose.opt);
} }
static struct readarg_opt *readarg_match_finish(struct readarg_parser *rp, const char **needle, const char *adv, struct readarg_opt *opt) static struct readarg_opt *readarg_match_finish(struct readarg_parser *rp, const char **needle, const char *adv, struct readarg_opt *opt) {
{
if (adv) if (adv)
*needle = adv; *needle = adv;
@ -343,68 +300,53 @@ static struct readarg_opt *readarg_match_finish(struct readarg_parser *rp, const
return opt; return opt;
} }
static void readarg_update_opt(struct readarg_parser *rp, const char *attach, 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 (opt->arg.name) if (attach) {
{
if (attach)
{
/* --opt=value, --opt=, -ovalue */ /* --opt=value, --opt=, -ovalue */
struct readarg_arg *curr = &rp->state.curr.opt->arg; struct readarg_arg *curr = &rp->state.curr.opt->arg;
readarg_occ_opt(rp, opt); readarg_occ_opt(rp, opt);
readarg_add_val(rp, curr, attach, 0); readarg_add_val(rp, curr, attach, 0);
} } else {
else
{
/* --opt value, -o value */ /* --opt value, -o value */
rp->state.pending = 1; rp->state.pending = 1;
readarg_occ_opt(rp, opt); readarg_occ_opt(rp, opt);
} }
} } else {
else
{
readarg_occ_opt(rp, opt); readarg_occ_opt(rp, opt);
if (attach) if (attach)
rp->error = READARG_ENOTREQ; 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); assert(val.len && val.strings);
if (val.len == 1) if (val.len == 1) {
{
++rp->state.curr.ioper.len; ++rp->state.curr.ioper.len;
readarg_permute_val(rp, &rp->state.curr.ioper, val.strings[0], 1); readarg_permute_val(rp, &rp->state.curr.ioper, val.strings[0], 1);
} } else {
else
{
readarg_permute_rest(rp->state.curr.eoval, val); readarg_permute_rest(rp->state.curr.eoval, val);
rp->state.curr.ioper.len += val.len; rp->state.curr.ioper.len += val.len;
} }
} }
static void readarg_assign_opers(struct readarg_parser *rp) static void readarg_assign_opers(struct readarg_parser *rp) {
{
size_t count = rp->state.curr.ioper.len; size_t count = rp->state.curr.ioper.len;
size_t nlower = 0; size_t nlower = 0;
size_t nupper = 0; size_t nupper = 0;
for (size_t i = 0; readarg_validate_arg(rp->opers + i); i++) for (size_t i = 0; readarg_validate_arg(rp->opers + i); i++) {
{
nlower += readarg_select_lower(rp->opers[i].bounds); nlower += readarg_select_lower(rp->opers[i].bounds);
nupper += readarg_select_upper(rp->opers[i].bounds); nupper += readarg_select_upper(rp->opers[i].bounds);
} }
if (count < nlower) if (count < nlower) {
{
rp->error = READARG_ERANGEOPER; rp->error = READARG_ERANGEOPER;
return; return;
} }
struct struct {
{
size_t extra; size_t extra;
size_t req; size_t req;
} rest = { } rest = {
@ -412,10 +354,8 @@ static void readarg_assign_opers(struct readarg_parser *rp)
nlower, nlower,
}; };
for (size_t i = 0; readarg_validate_arg(rp->opers + i); i++) for (size_t i = 0; readarg_validate_arg(rp->opers + i); i++) {
{ if (count == 0 || !rp->opers[i].val.strings) {
if (count == 0 || !rp->opers[i].val.strings)
{
size_t off = count - (rest.extra + rest.req); size_t off = count - (rest.extra + rest.req);
rp->opers[i].val.strings = rp->state.curr.ioper.strings + off; rp->opers[i].val.strings = rp->state.curr.ioper.strings + off;
} }
@ -431,8 +371,7 @@ static void readarg_assign_opers(struct readarg_parser *rp)
rp->opers[i].val.len += add, rest.req -= add; rp->opers[i].val.len += add, rest.req -= add;
/* Add optional elements. */ /* Add optional elements. */
add = inf ? rest.extra : rest.extra > upper ? upper add = inf ? rest.extra : rest.extra > upper ? upper : rest.extra;
: rest.extra;
rp->opers[i].val.len += add, rest.extra -= add; rp->opers[i].val.len += add, rest.extra -= add;
} }
@ -440,8 +379,7 @@ static void readarg_assign_opers(struct readarg_parser *rp)
rp->error = READARG_ERANGEOPER; 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; rp->state.pending = 0;
if (!readarg_validate_within(arg)) if (!readarg_validate_within(arg))
@ -450,10 +388,8 @@ static void readarg_add_val(struct readarg_parser *rp, struct readarg_arg *arg,
readarg_permute_val(rp, &arg->val, string, end); 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) {
{ while (*inner == *outer) {
while (*inner == *outer)
{
if (!*inner) if (!*inner)
return outer; return outer;
++inner, ++outer; ++inner, ++outer;
@ -461,15 +397,13 @@ static const char *readarg_skip_incl(const char *outer, const char *inner)
return !*inner ? outer : NULL; 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); assert(opt);
rp->state.curr.opt = opt; rp->state.curr.opt = opt;
++rp->state.curr.opt->arg.val.len; ++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) if (!target->strings)
/* Fallback position when no value has yet been set. */ /* Fallback position when no value has yet been set. */
target->strings = rp->state.curr.eoval - (end ? 0 : rp->state.curr.ioper.len); target->strings = rp->state.curr.eoval - (end ? 0 : rp->state.curr.ioper.len);
@ -492,19 +426,16 @@ static void readarg_permute_val(struct readarg_parser *rp, struct readarg_view_s
readarg_incr_between(start, stop, &rp->state.curr.ioper, target); 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) if (curr->strings >= start && curr->strings <= stop && curr != exclude)
++curr->strings; ++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); memmove(target, start.strings, start.len * sizeof *start.strings);
} }
void readarg_parser_init(struct readarg_parser *rp, struct readarg_opt *opts, struct readarg_arg *opers, struct readarg_view_strings args) void readarg_parser_init(struct readarg_parser *rp, struct readarg_opt *opts, struct readarg_arg *opers, struct readarg_view_strings args) {
{
*rp = (struct readarg_parser){ *rp = (struct readarg_parser){
.args = args, .args = args,
.opts = opts, .opts = opts,
@ -516,40 +447,33 @@ void readarg_parser_init(struct readarg_parser *rp, struct readarg_opt *opts, st
}; };
} }
int readarg_validate_opt(struct readarg_opt *opt) int readarg_validate_opt(struct readarg_opt *opt) {
{
assert(opt); assert(opt);
return opt->names[0] || opt->names[1]; return opt->names[0] || opt->names[1];
} }
int readarg_validate_arg(struct readarg_arg *arg) int readarg_validate_arg(struct readarg_arg *arg) {
{
assert(arg); assert(arg);
return !!arg->name; return !!arg->name;
} }
int readarg_validate_within(struct readarg_arg *arg) int readarg_validate_within(struct readarg_arg *arg) {
{
size_t occ = arg->val.len; size_t occ = arg->val.len;
size_t upper = readarg_select_upper(arg->bounds); size_t upper = readarg_select_upper(arg->bounds);
size_t lower = readarg_select_lower(arg->bounds); size_t lower = readarg_select_lower(arg->bounds);
return occ >= lower && (occ <= upper || arg->bounds.inf); return occ >= lower && (occ <= upper || arg->bounds.inf);
} }
size_t readarg_select_upper(struct readarg_bounds bounds) size_t readarg_select_upper(struct readarg_bounds bounds) {
{
return bounds.val[0] > bounds.val[1] ? bounds.val[0] : bounds.val[1]; return bounds.val[0] > bounds.val[1] ? bounds.val[0] : bounds.val[1];
} }
size_t readarg_select_lower(struct readarg_bounds bounds) 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];
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) \ #define READARG_HELPGEN_TRY(writer, buf, len) \
do \ do { \
{ \
int readarg_helpgen_rv = (writer)->write((writer)->ctx, (buf), (len)); \ int readarg_helpgen_rv = (writer)->write((writer)->ctx, (buf), (len)); \
if (!readarg_helpgen_rv) \ if (!readarg_helpgen_rv) \
return readarg_helpgen_rv; \ return readarg_helpgen_rv; \
@ -557,8 +481,7 @@ size_t readarg_select_lower(struct readarg_bounds bounds)
#define READARG_HELPGEN_TRY_LIT(writer, s) READARG_HELPGEN_TRY((writer), (s), (sizeof(s) - 1)) #define READARG_HELPGEN_TRY_LIT(writer, s) READARG_HELPGEN_TRY((writer), (s), (sizeof(s) - 1))
#define READARG_HELPGEN_TRY_STR(writer, s) READARG_HELPGEN_TRY((writer), (s), (strlen((s)))) #define READARG_HELPGEN_TRY_STR(writer, s) READARG_HELPGEN_TRY((writer), (s), (strlen((s))))
int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_writer *writer, const char *progname, const char *usage) int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_writer *writer, const char *progname, const char *usage) {
{
READARG_HELPGEN_TRY_STR(writer, usage); READARG_HELPGEN_TRY_STR(writer, usage);
READARG_HELPGEN_TRY_LIT(writer, ":\n"); READARG_HELPGEN_TRY_LIT(writer, ":\n");
@ -570,12 +493,10 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
struct readarg_opt *opts = rp->opts; struct readarg_opt *opts = rp->opts;
nxvalid = readarg_validate_opt(opts); nxvalid = readarg_validate_opt(opts);
for (size_t i = 0; nxvalid; i++) for (size_t i = 0; nxvalid; i++) {
{
optwritten = 1; optwritten = 1;
if (i == 0) if (i == 0) {
{
READARG_HELPGEN_TRY_LIT(writer, " "); READARG_HELPGEN_TRY_LIT(writer, " ");
} }
@ -585,55 +506,40 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
int inf = opts[i].arg.bounds.inf; int inf = opts[i].arg.bounds.inf;
size_t nforms = sizeof opts[i].names / sizeof *opts[i].names; size_t nforms = sizeof opts[i].names / sizeof *opts[i].names;
for (size_t j = 0; j < (upper ? upper : !!inf); j++) for (size_t j = 0; j < (upper ? upper : !!inf); j++) {
{ if (j >= lower) {
if (j >= lower)
{
READARG_HELPGEN_TRY_LIT(writer, "["); READARG_HELPGEN_TRY_LIT(writer, "[");
} }
for (size_t k = 0; k < nforms; k++) for (size_t k = 0; k < nforms; k++) {
{
int grp = 0; int grp = 0;
if (opts[i].names[k]) if (opts[i].names[k]) {
{ for (size_t l = 0; opts[i].names[k][l]; l++) {
for (size_t l = 0; opts[i].names[k][l]; l++) if (!grp) {
{ if (k == READARG_FORM_SHORT) {
if (!grp)
{
if (k == READARG_FORM_SHORT)
{
READARG_HELPGEN_TRY_LIT(writer, "-"); READARG_HELPGEN_TRY_LIT(writer, "-");
} }
if (k == READARG_FORM_LONG) if (k == READARG_FORM_LONG) {
{
READARG_HELPGEN_TRY_LIT(writer, "--"); READARG_HELPGEN_TRY_LIT(writer, "--");
} }
} }
READARG_HELPGEN_TRY_STR(writer, opts[i].names[k][l]); READARG_HELPGEN_TRY_STR(writer, opts[i].names[k][l]);
if (k == READARG_FORM_SHORT) if (k == READARG_FORM_SHORT) {
{
grp = 1; grp = 1;
if (!opts[i].names[k][l + 1]) if (!opts[i].names[k][l + 1]) {
{
READARG_HELPGEN_TRY_LIT(writer, ", "); READARG_HELPGEN_TRY_LIT(writer, ", ");
} }
continue; continue;
} } else if (k + 1 < nforms || opts[i].names[k][l + 1]) {
else if (k + 1 < nforms || opts[i].names[k][l + 1])
{
READARG_HELPGEN_TRY_LIT(writer, ", "); READARG_HELPGEN_TRY_LIT(writer, ", ");
} } else if (opts[i].arg.name) {
else if (opts[i].arg.name)
{
READARG_HELPGEN_TRY_LIT(writer, " "); READARG_HELPGEN_TRY_LIT(writer, " ");
READARG_HELPGEN_TRY_STR(writer, opts[i].arg.name); READARG_HELPGEN_TRY_STR(writer, opts[i].arg.name);
if (inf) if (inf) {
{
READARG_HELPGEN_TRY_LIT(writer, "..."); READARG_HELPGEN_TRY_LIT(writer, "...");
} }
} }
@ -641,31 +547,26 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
} }
} }
if (j >= lower) if (j >= lower) {
{
READARG_HELPGEN_TRY_LIT(writer, "]"); READARG_HELPGEN_TRY_LIT(writer, "]");
} }
if (nxvalid) if (nxvalid) {
{
READARG_HELPGEN_TRY_LIT(writer, "\n "); READARG_HELPGEN_TRY_LIT(writer, "\n ");
} }
} }
} }
if (optwritten) if (optwritten) {
{
READARG_HELPGEN_TRY_LIT(writer, "\n"); READARG_HELPGEN_TRY_LIT(writer, "\n");
} }
struct readarg_arg *opers = rp->opers; struct readarg_arg *opers = rp->opers;
nxvalid = readarg_validate_arg(opers); nxvalid = readarg_validate_arg(opers);
for (size_t i = 0; nxvalid; i++) for (size_t i = 0; nxvalid; i++) {
{
operwritten = 1; operwritten = 1;
if (i == 0) if (i == 0) {
{
READARG_HELPGEN_TRY_LIT(writer, " "); READARG_HELPGEN_TRY_LIT(writer, " ");
} }
@ -674,45 +575,37 @@ int readarg_helpgen_put_usage(struct readarg_parser *rp, struct readarg_helpgen_
size_t upper = readarg_select_upper(opers[i].bounds); size_t upper = readarg_select_upper(opers[i].bounds);
int inf = opers[i].bounds.inf; int inf = opers[i].bounds.inf;
for (size_t j = 0; j < lower; j++) for (size_t j = 0; j < lower; j++) {
{
READARG_HELPGEN_TRY_STR(writer, opers[i].name); READARG_HELPGEN_TRY_STR(writer, opers[i].name);
if (inf && j + 1 == lower) if (inf && j + 1 == lower) {
{
READARG_HELPGEN_TRY_LIT(writer, "..."); READARG_HELPGEN_TRY_LIT(writer, "...");
} }
if (nxvalid) if (nxvalid) {
{
READARG_HELPGEN_TRY_LIT(writer, "\n "); READARG_HELPGEN_TRY_LIT(writer, "\n ");
} }
} }
size_t amt = upper ? upper : inf ? lower + 1 size_t amt = upper ? upper : inf ? lower + 1 : 0;
: 0; for (size_t j = lower; j < amt; j++) {
for (size_t j = lower; j < amt; j++)
{
READARG_HELPGEN_TRY_LIT(writer, "["); READARG_HELPGEN_TRY_LIT(writer, "[");
READARG_HELPGEN_TRY_STR(writer, opers[i].name); READARG_HELPGEN_TRY_STR(writer, opers[i].name);
if (inf && j + 1 == amt) if (inf && j + 1 == amt) {
{
READARG_HELPGEN_TRY_LIT(writer, "..."); READARG_HELPGEN_TRY_LIT(writer, "...");
} }
READARG_HELPGEN_TRY_LIT(writer, "]"); READARG_HELPGEN_TRY_LIT(writer, "]");
if (nxvalid) if (nxvalid) {
{
READARG_HELPGEN_TRY_LIT(writer, "\n "); READARG_HELPGEN_TRY_LIT(writer, "\n ");
} }
} }
} }
if (operwritten) if (operwritten) {
{
READARG_HELPGEN_TRY_LIT(writer, "\n"); READARG_HELPGEN_TRY_LIT(writer, "\n");
} }

55
test/test.c
View file

@ -5,16 +5,14 @@
#include "../readarg.h" #include "../readarg.h"
enum opt enum opt {
{
OPT_HELP, OPT_HELP,
OPT_VERSION, OPT_VERSION,
}; };
static int write_callback(void *ctx, const char *buf, size_t len); static int write_callback(void *ctx, const char *buf, size_t len);
int main(int argc, char **argv) int main(int argc, char **argv) {
{
struct readarg_opt opts[] = { struct readarg_opt opts[] = {
[OPT_HELP] = { [OPT_HELP] = {
.names = { .names = {
@ -44,7 +42,7 @@ int main(int argc, char **argv)
1, 1,
4, 4,
}, },
} },
}, },
{ {
.names = { .names = {
@ -56,7 +54,7 @@ int main(int argc, char **argv)
.bounds.val = { .bounds.val = {
2, 2,
}, },
} },
}, },
{ {
.names = { .names = {
@ -66,7 +64,7 @@ int main(int argc, char **argv)
.arg = { .arg = {
.name = "uri", .name = "uri",
.bounds.inf = 1, .bounds.inf = 1,
} },
}, },
{ {
.names = { .names = {
@ -76,7 +74,7 @@ int main(int argc, char **argv)
.arg = { .arg = {
.name = "file", .name = "file",
.bounds.inf = 1, .bounds.inf = 1,
} },
}, },
{ {
.names = { .names = {
@ -128,10 +126,7 @@ int main(int argc, char **argv)
}; };
struct readarg_parser rp; struct readarg_parser rp;
readarg_parser_init( readarg_parser_init(&rp, opts, opers,
&rp,
opts,
opers,
(struct readarg_view_strings){ (struct readarg_view_strings){
.strings = (const char **)argv + 1, .strings = (const char **)argv + 1,
.len = argc - 1, .len = argc - 1,
@ -146,21 +141,18 @@ int main(int argc, char **argv)
.ctx = NULL, .ctx = NULL,
}; };
if (rp.error != READARG_ESUCCESS) if (rp.error != READARG_ESUCCESS) {
{
fprintf(stderr, "Error: %d\n", rp.error); fprintf(stderr, "Error: %d\n", rp.error);
readarg_helpgen_put_usage(&rp, &writer, progname, "Usage"); readarg_helpgen_put_usage(&rp, &writer, progname, "Usage");
return 1; 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"); readarg_helpgen_put_usage(&rp, &writer, progname, "Usage");
return 0; 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"); printf("0.0.0\n");
return 0; return 0;
} }
@ -168,24 +160,18 @@ int main(int argc, char **argv)
printf("opt:\n"); printf("opt:\n");
{ {
struct readarg_opt *curr = rp.opts; struct readarg_opt *curr = rp.opts;
for (size_t i = 0; readarg_validate_opt(curr + i); i++) 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++) {
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("%s ", curr[i].names[j][k]);
} }
} }
} }
printf("{ [%zu] ", curr[i].arg.val.len); printf("{ [%zu] ", curr[i].arg.val.len);
if (curr[i].arg.name) if (curr[i].arg.name) {
{
struct readarg_view_strings val = curr[i].arg.val; 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]); printf("%s ", val.strings[j]);
} }
} }
@ -196,11 +182,9 @@ int main(int argc, char **argv)
printf("oper:\n"); printf("oper:\n");
{ {
struct readarg_arg *curr = rp.opers; struct readarg_arg *curr = rp.opers;
for (size_t i = 0; readarg_validate_arg(curr + i); i++) for (size_t i = 0; readarg_validate_arg(curr + i); i++) {
{
printf("%s { [%zu] ", curr[i].name, curr[i].val.len); 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("%s ", curr[i].val.strings[j]);
} }
printf("}\n"); printf("}\n");
@ -210,8 +194,7 @@ int main(int argc, char **argv)
return 0; 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; (void)ctx;
return fwrite(buf, 1, len, stderr) == len; return fwrite(buf, 1, len, stderr) == len;
} }