From 2af370d0a1dd610f66232e2bacc75e4b40ffca0d Mon Sep 17 00:00:00 2001 From: Philippe Proulx Date: Tue, 1 Jun 2021 10:18:21 -0400 Subject: [PATCH] Rename argpar_iter_parse_next() -> argpar_iter_next() Also rename `enum argpar_iter_parse_next_status` to `enum argpar_iter_next_status` and `ARGPAR_ITER_PARSE_NEXT_STATUS_*` to `ARGPAR_ITER_NEXT_STATUS_*`. Personal preference. Signed-off-by: Philippe Proulx Change-Id: I5e93bb9abe5e77e7e83622b3f868003a4fafb888 --- argpar/argpar.c | 48 +++++++++++++------------- argpar/argpar.h | 48 +++++++++++++------------- tests/test_argpar.c | 84 ++++++++++++++++++++++----------------------- 3 files changed, 90 insertions(+), 90 deletions(-) diff --git a/argpar/argpar.c b/argpar/argpar.c index 0468011..5a8a302 100644 --- a/argpar/argpar.c +++ b/argpar/argpar.c @@ -33,8 +33,8 @@ /* * An argpar iterator. * - * Such a structure contains the state of an iterator between - * calls to argpar_iter_parse_next(). + * Such a structure contains the state of an iterator between calls to + * argpar_iter_next(). */ struct argpar_iter { /* @@ -47,7 +47,7 @@ struct argpar_iter { /* * Index of the argument to process in the next - * argpar_iter_parse_next() call. + * argpar_iter_next() call. */ unsigned int i; @@ -58,7 +58,7 @@ struct argpar_iter { * Current character of the current short option group: if it's * not `NULL`, the parser is in within a short option group, * therefore it must resume there in the next - * argpar_iter_parse_next() call. + * argpar_iter_next() call. */ const char *short_opt_ch; }; @@ -679,11 +679,11 @@ void argpar_iter_destroy(struct argpar_iter * const iter) } ARGPAR_HIDDEN -enum argpar_iter_parse_next_status argpar_iter_parse_next( +enum argpar_iter_next_status argpar_iter_next( struct argpar_iter * const iter, const struct argpar_item ** const item, char ** const error) { - enum argpar_iter_parse_next_status status; + enum argpar_iter_next_status status; enum parse_orig_arg_opt_ret parse_orig_arg_opt_ret; const char *orig_arg; const char *next_orig_arg; @@ -695,7 +695,7 @@ enum argpar_iter_parse_next_status argpar_iter_parse_next( } if (iter->i == iter->argc) { - status = ARGPAR_ITER_PARSE_NEXT_STATUS_END; + status = ARGPAR_ITER_NEXT_STATUS_END; goto end; } @@ -710,14 +710,14 @@ enum argpar_iter_parse_next_status argpar_iter_parse_next( iter->non_opt_index); if (!non_opt_item) { - status = ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_MEMORY; + status = ARGPAR_ITER_NEXT_STATUS_ERROR_MEMORY; goto end; } iter->non_opt_index++; iter->i++; *item = &non_opt_item->base; - status = ARGPAR_ITER_PARSE_NEXT_STATUS_OK; + status = ARGPAR_ITER_NEXT_STATUS_OK; goto end; } @@ -727,7 +727,7 @@ enum argpar_iter_parse_next_status argpar_iter_parse_next( (struct argpar_item **) item); switch (parse_orig_arg_opt_ret) { case PARSE_ORIG_ARG_OPT_RET_OK: - status = ARGPAR_ITER_PARSE_NEXT_STATUS_OK; + status = ARGPAR_ITER_NEXT_STATUS_OK; break; case PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT: case PARSE_ORIG_ARG_OPT_RET_ERROR_MISSING_OPT_ARG: @@ -738,16 +738,16 @@ enum argpar_iter_parse_next_status argpar_iter_parse_next( switch (parse_orig_arg_opt_ret) { case PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT: - status = ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT; + status = ARGPAR_ITER_NEXT_STATUS_ERROR_UNKNOWN_OPT; break; case PARSE_ORIG_ARG_OPT_RET_ERROR_MISSING_OPT_ARG: - status = ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_MISSING_OPT_ARG; + status = ARGPAR_ITER_NEXT_STATUS_ERROR_MISSING_OPT_ARG; break; case PARSE_ORIG_ARG_OPT_RET_ERROR_INVALID_ARG: - status = ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_INVALID_ARG; + status = ARGPAR_ITER_NEXT_STATUS_ERROR_INVALID_ARG; break; case PARSE_ORIG_ARG_OPT_RET_ERROR_UNEXPECTED_OPT_ARG: - status = ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNEXPECTED_OPT_ARG; + status = ARGPAR_ITER_NEXT_STATUS_ERROR_UNEXPECTED_OPT_ARG; break; default: abort(); @@ -755,7 +755,7 @@ enum argpar_iter_parse_next_status argpar_iter_parse_next( break; case PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY: - status = ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_MEMORY; + status = ARGPAR_ITER_NEXT_STATUS_ERROR_MEMORY; break; default: abort(); @@ -797,16 +797,16 @@ struct argpar_parse_ret argpar_parse(const unsigned int argc, } while (true) { - const enum argpar_iter_parse_next_status status = - argpar_iter_parse_next(iter, &item, &parse_ret.error); + const enum argpar_iter_next_status status = + argpar_iter_next(iter, &item, &parse_ret.error); switch (status) { - case ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_MISSING_OPT_ARG: - case ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_INVALID_ARG: - case ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNEXPECTED_OPT_ARG: - case ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_MEMORY: + case ARGPAR_ITER_NEXT_STATUS_ERROR_MISSING_OPT_ARG: + case ARGPAR_ITER_NEXT_STATUS_ERROR_INVALID_ARG: + case ARGPAR_ITER_NEXT_STATUS_ERROR_UNEXPECTED_OPT_ARG: + case ARGPAR_ITER_NEXT_STATUS_ERROR_MEMORY: goto error; - case ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT: + case ARGPAR_ITER_NEXT_STATUS_ERROR_UNKNOWN_OPT: if (fail_on_unknown_opt) { parse_ret.ingested_orig_args = argpar_iter_get_ingested_orig_args(iter); @@ -816,10 +816,10 @@ struct argpar_parse_ret argpar_parse(const unsigned int argc, free(parse_ret.error); parse_ret.error = NULL; goto success; - case ARGPAR_ITER_PARSE_NEXT_STATUS_END: + case ARGPAR_ITER_NEXT_STATUS_END: goto success; default: - ARGPAR_ASSERT(status == ARGPAR_ITER_PARSE_NEXT_STATUS_OK); + ARGPAR_ASSERT(status == ARGPAR_ITER_NEXT_STATUS_OK); break; } diff --git a/argpar/argpar.h b/argpar/argpar.h index bfcc422..1fb8835 100644 --- a/argpar/argpar.h +++ b/argpar/argpar.h @@ -18,8 +18,8 @@ * * Iterator API: * Create a parsing iterator with argpar_iter_create(), then - * repeatedly call argpar_iter_parse_next() to access the parsing - * results, until one of: + * repeatedly call argpar_iter_next() to access the parsing results, + * until one of: * * * There are no more arguments. * @@ -144,7 +144,7 @@ enum argpar_item_type { ARGPAR_ITEM_TYPE_NON_OPT, }; -/* Parsing item, as created by argpar_parse() and argpar_iter_parse_next() */ +/* Parsing item, as created by argpar_parse() and argpar_iter_next() */ struct argpar_item; /* @@ -286,8 +286,8 @@ void argpar_parse_ret_fini(struct argpar_parse_ret *ret); * `*argv` and `*descrs` must NOT change for the lifetime of the * returned iterator (until you call argpar_iter_destroy()). * - * Call argpar_iter_parse_next() with the returned iterator to obtain - * the next parsing result (item). + * Call argpar_iter_next() with the returned iterator to obtain the next + * parsing result (item). */ ARGPAR_HIDDEN struct argpar_iter *argpar_iter_create(unsigned int argc, @@ -301,16 +301,16 @@ ARGPAR_HIDDEN void argpar_iter_destroy(struct argpar_iter *iter); /* - * Return type of argpar_iter_parse_next(). + * Return type of argpar_iter_next(). */ -enum argpar_iter_parse_next_status { - ARGPAR_ITER_PARSE_NEXT_STATUS_OK, - ARGPAR_ITER_PARSE_NEXT_STATUS_END, - ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT, - ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_MISSING_OPT_ARG, - ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_INVALID_ARG, - ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNEXPECTED_OPT_ARG, - ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_MEMORY, +enum argpar_iter_next_status { + ARGPAR_ITER_NEXT_STATUS_OK, + ARGPAR_ITER_NEXT_STATUS_END, + ARGPAR_ITER_NEXT_STATUS_ERROR_UNKNOWN_OPT, + ARGPAR_ITER_NEXT_STATUS_ERROR_MISSING_OPT_ARG, + ARGPAR_ITER_NEXT_STATUS_ERROR_INVALID_ARG, + ARGPAR_ITER_NEXT_STATUS_ERROR_UNEXPECTED_OPT_ARG, + ARGPAR_ITER_NEXT_STATUS_ERROR_MEMORY, }; /* @@ -323,36 +323,36 @@ enum argpar_iter_parse_next_status { * * Destroy `*item` with argpar_item_destroy(). * - * * Returns `ARGPAR_ITER_PARSE_NEXT_STATUS_OK`. + * * Returns `ARGPAR_ITER_NEXT_STATUS_OK`. * * If there are no more items to return, this function returns - * `ARGPAR_ITER_PARSE_NEXT_STATUS_END`. + * `ARGPAR_ITER_NEXT_STATUS_END`. * * On failure, this function: * * * Returns one of: * - * `ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT`: + * `ARGPAR_ITER_NEXT_STATUS_ERROR_UNKNOWN_OPT`: * Unknown option (not found in `descrs` as passed to * argpar_iter_create() to create `iter`). * - * `ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_MISSING_OPT_ARG`: + * `ARGPAR_ITER_NEXT_STATUS_ERROR_MISSING_OPT_ARG`: * Missing option argument. * - * `ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_INVALID_ARG`: + * `ARGPAR_ITER_NEXT_STATUS_ERROR_INVALID_ARG`: * Invalid argument. * - * `ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNEXPECTED_OPT_ARG`: + * `ARGPAR_ITER_NEXT_STATUS_ERROR_UNEXPECTED_OPT_ARG`: * Unexpected option argument. * - * `ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_MEMORY`: + * `ARGPAR_ITER_NEXT_STATUS_ERROR_MEMORY`: * Memory error. * - * * Except for the `ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_MEMORY` status, + * * Except for the `ARGPAR_ITER_NEXT_STATUS_ERROR_MEMORY` status, * sets `*error`, if not `NULL`, to a descriptive error string. * Free `*error` with free(). */ -enum argpar_iter_parse_next_status argpar_iter_parse_next( +enum argpar_iter_next_status argpar_iter_next( struct argpar_iter *iter, const struct argpar_item **item, char **error); @@ -365,7 +365,7 @@ ARGPAR_HIDDEN unsigned int argpar_iter_get_ingested_orig_args(const struct argpar_iter *iter); /* - * Destroys `item`, as created by argpar_iter_parse_next(). + * Destroys `item`, as created by argpar_iter_next(). */ ARGPAR_HIDDEN void argpar_item_destroy(const struct argpar_item *item); diff --git a/tests/test_argpar.c b/tests/test_argpar.c index 5c4700a..f9f8f49 100644 --- a/tests/test_argpar.c +++ b/tests/test_argpar.c @@ -184,39 +184,39 @@ void test_succeed_argpar_iter(const char * const cmdline, assert(iter); for (i = 0; ; i++) { - enum argpar_iter_parse_next_status status; + enum argpar_iter_next_status status; ARGPAR_ITEM_DESTROY_AND_RESET(item); - status = argpar_iter_parse_next(iter, &item, &error); + status = argpar_iter_next(iter, &item, &error); - ok(status == ARGPAR_ITER_PARSE_NEXT_STATUS_OK || - status == ARGPAR_ITER_PARSE_NEXT_STATUS_END || - status == ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT, - "argpar_iter_parse_next() returns the expected status " + ok(status == ARGPAR_ITER_NEXT_STATUS_OK || + status == ARGPAR_ITER_NEXT_STATUS_END || + status == ARGPAR_ITER_NEXT_STATUS_ERROR_UNKNOWN_OPT, + "argpar_iter_next() returns the expected status " "(%d) for command line `%s` (call %u)", status, cmdline, i + 1); - if (status == ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) { + if (status == ARGPAR_ITER_NEXT_STATUS_ERROR_UNKNOWN_OPT) { ok(error, - "argpar_iter_parse_next() sets an error for " - "status `ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT` " + "argpar_iter_next() sets an error for " + "status `ARGPAR_ITER_NEXT_STATUS_ERROR_UNKNOWN_OPT` " "and command line `%s` (call %u)", cmdline, i + 1); } else { ok(!error, - "argpar_iter_parse_next() doesn't set an error " + "argpar_iter_next() doesn't set an error " "for other status than " - "`ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT` " + "`ARGPAR_ITER_NEXT_STATUS_ERROR_UNKNOWN_OPT` " "and command line `%s` (call %u)", cmdline, i + 1); } - if (status == ARGPAR_ITER_PARSE_NEXT_STATUS_END || - status == ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) { + if (status == ARGPAR_ITER_NEXT_STATUS_END || + status == ARGPAR_ITER_NEXT_STATUS_ERROR_UNKNOWN_OPT) { ok(!item, - "argpar_iter_parse_next() doesn't set an item " - "for status `ARGPAR_ITER_PARSE_NEXT_STATUS_END` " - "or `ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT` " + "argpar_iter_next() doesn't set an item " + "for status `ARGPAR_ITER_NEXT_STATUS_END` " + "or `ARGPAR_ITER_NEXT_STATUS_ERROR_UNKNOWN_OPT` " "and command line `%s` (call %u)", cmdline, i + 1); break; @@ -237,7 +237,7 @@ void test_succeed_argpar_iter(const char * const cmdline, } ok(strcmp(expected_cmd_line, res_str->str) == 0, - "argpar_iter_parse_next() returns the expected parsing items " + "argpar_iter_next() returns the expected parsing items " "for command line `%s`", cmdline); if (strcmp(expected_cmd_line, res_str->str) != 0) { @@ -671,7 +671,7 @@ end: /* * Parses `cmdline` with the iterator API using the option descriptors - * `descrs`, and ensures that argpar_iter_parse_next() fails with status + * `descrs`, and ensures that argpar_iter_next() fails with status * `expected_status` and that it sets an error which is equal to * `expected_error`. * @@ -681,7 +681,7 @@ end: static void test_fail_argpar_iter(const char * const cmdline, const char * const expected_error, - const enum argpar_iter_parse_next_status expected_status, + const enum argpar_iter_next_status expected_status, const struct argpar_opt_descr * const descrs) { struct argpar_iter *iter = NULL; @@ -695,46 +695,46 @@ void test_fail_argpar_iter(const char * const cmdline, assert(iter); for (i = 0; ; i++) { - enum argpar_iter_parse_next_status status; + enum argpar_iter_next_status status; ARGPAR_ITEM_DESTROY_AND_RESET(item); - status = argpar_iter_parse_next(iter, &item, &error); - ok(status == ARGPAR_ITER_PARSE_NEXT_STATUS_OK || + status = argpar_iter_next(iter, &item, &error); + ok(status == ARGPAR_ITER_NEXT_STATUS_OK || status == expected_status, - "argpar_iter_parse_next() returns the expected status " + "argpar_iter_next() returns the expected status " "(%d) for command line `%s` (call %u)", status, cmdline, i + 1); - if (status != ARGPAR_ITER_PARSE_NEXT_STATUS_OK) { + if (status != ARGPAR_ITER_NEXT_STATUS_OK) { ok(!item, - "argpar_iter_parse_next() doesn't set an item " + "argpar_iter_next() doesn't set an item " "for other status than " - "`ARGPAR_ITER_PARSE_NEXT_STATUS_OK` " + "`ARGPAR_ITER_NEXT_STATUS_OK` " "and command line `%s` (call %u)", cmdline, i + 1); ok(error, - "argpar_iter_parse_next() sets an error for " + "argpar_iter_next() sets an error for " "other status than " - " `ARGPAR_ITER_PARSE_NEXT_STATUS_OK` " + " `ARGPAR_ITER_NEXT_STATUS_OK` " "and command line `%s` (call %u)", cmdline, i + 1); break; } ok(item, - "argpar_iter_parse_next() sets an item for status " - "`ARGPAR_ITER_PARSE_NEXT_STATUS_OK` " + "argpar_iter_next() sets an item for status " + "`ARGPAR_ITER_NEXT_STATUS_OK` " "and command line `%s` (call %u)", cmdline, i + 1); ok(!error, - "argpar_iter_parse_next() doesn't set an error for status " - "`ARGPAR_ITER_PARSE_NEXT_STATUS_OK` " + "argpar_iter_next() doesn't set an error for status " + "`ARGPAR_ITER_NEXT_STATUS_OK` " "and command line `%s` (call %u)", cmdline, i + 1); } ok(strcmp(expected_error, error) == 0, - "argpar_iter_parse_next() sets the expected error string " + "argpar_iter_next() sets the expected error string " "for command line `%s`", cmdline); if (strcmp(expected_error, error) != 0) { @@ -754,7 +754,7 @@ void test_fail_argpar_iter(const char * const cmdline, */ static void test_fail(const char * const cmdline, const char * const expected_error, - const enum argpar_iter_parse_next_status expected_iter_next_status, + const enum argpar_iter_next_status expected_iter_next_status, const struct argpar_opt_descr * const descrs) { test_fail_argpar_parse(cmdline, expected_error, descrs); @@ -775,7 +775,7 @@ void fail_tests(void) test_fail( "--thumb=party --meow", "While parsing argument #2 (`--meow`): Unknown option `--meow`", - ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT, + ARGPAR_ITER_NEXT_STATUS_ERROR_UNKNOWN_OPT, descrs); } @@ -789,7 +789,7 @@ void fail_tests(void) test_fail( "--thumb=party -x", "While parsing argument #2 (`-x`): Unknown option `-x`", - ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT, + ARGPAR_ITER_NEXT_STATUS_ERROR_UNKNOWN_OPT, descrs); } @@ -803,7 +803,7 @@ void fail_tests(void) test_fail( "--thumb", "While parsing argument #1 (`--thumb`): Missing required argument for option `--thumb`", - ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_MISSING_OPT_ARG, + ARGPAR_ITER_NEXT_STATUS_ERROR_MISSING_OPT_ARG, descrs); } @@ -817,7 +817,7 @@ void fail_tests(void) test_fail( "-k", "While parsing argument #1 (`-k`): Missing required argument for option `-k`", - ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_MISSING_OPT_ARG, + ARGPAR_ITER_NEXT_STATUS_ERROR_MISSING_OPT_ARG, descrs); } @@ -833,7 +833,7 @@ void fail_tests(void) test_fail( "-abc", "While parsing argument #1 (`-abc`): Missing required argument for option `-c`", - ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_MISSING_OPT_ARG, + ARGPAR_ITER_NEXT_STATUS_ERROR_MISSING_OPT_ARG, descrs); } @@ -849,7 +849,7 @@ void fail_tests(void) test_fail( "-ab - -c", "While parsing argument #2 (`-`): Invalid argument", - ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_INVALID_ARG, + ARGPAR_ITER_NEXT_STATUS_ERROR_INVALID_ARG, descrs); } @@ -865,7 +865,7 @@ void fail_tests(void) test_fail( "-ab -- -c", "While parsing argument #2 (`--`): Invalid argument", - ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_INVALID_ARG, + ARGPAR_ITER_NEXT_STATUS_ERROR_INVALID_ARG, descrs); } @@ -878,7 +878,7 @@ void fail_tests(void) test_fail( "--chevre=fromage", "While parsing argument #1 (`--chevre=fromage`): Unexpected argument for option `--chevre`", - ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNEXPECTED_OPT_ARG, + ARGPAR_ITER_NEXT_STATUS_ERROR_UNEXPECTED_OPT_ARG, descrs); } } -- 2.34.1