X-Git-Url: http://git.efficios.com/?p=argpar.git;a=blobdiff_plain;f=argpar%2Fargpar.c;h=45658a5b3e914e538cb47848281a1ffcdc1b178d;hp=8cc20cd77490f37a24f169b8d07d7feb2f564ade;hb=4d6198b505eaeb2e60a14331ccb52f90ea397bb4;hpb=1c9a6bde7e12e1978e8e47764913a91b7407e9b5 diff --git a/argpar/argpar.c b/argpar/argpar.c index 8cc20cd..45658a5 100644 --- a/argpar/argpar.c +++ b/argpar/argpar.c @@ -1,23 +1,8 @@ /* - * Copyright 2019 Philippe Proulx + * SPDX-License-Identifier: MIT * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. + * Copyright (c) 2019-2021 Philippe Proulx + * Copyright (c) 2020-2021 Simon Marchi */ #include @@ -29,21 +14,105 @@ #include "argpar.h" -#define argpar_realloc(_ptr, _type, _nmemb) ((_type *) realloc(_ptr, (_nmemb) * sizeof(_type))) -#define argpar_calloc(_type, _nmemb) ((_type *) calloc((_nmemb), sizeof(_type))) -#define argpar_zalloc(_type) argpar_calloc(_type, 1) +#define ARGPAR_REALLOC(_ptr, _type, _nmemb) \ + ((_type *) realloc(_ptr, (_nmemb) * sizeof(_type))) + +#define ARGPAR_CALLOC(_type, _nmemb) \ + ((_type *) calloc((_nmemb), sizeof(_type))) + +#define ARGPAR_ZALLOC(_type) ARGPAR_CALLOC(_type, 1) #define ARGPAR_ASSERT(_cond) assert(_cond) -static -char *argpar_vasprintf(const char *fmt, va_list args) +#ifdef __MINGW_PRINTF_FORMAT +# define ARGPAR_PRINTF_FORMAT __MINGW_PRINTF_FORMAT +#else +# define ARGPAR_PRINTF_FORMAT printf +#endif + +/* + * An argpar iterator. + * + * Such a structure contains the state of an iterator between calls to + * argpar_iter_next(). + */ +struct argpar_iter { + /* + * Data provided by the user to argpar_iter_create(); immutable + * afterwards. + */ + unsigned int argc; + const char * const *argv; + const struct argpar_opt_descr *descrs; + + /* + * Index of the argument to process in the next + * argpar_iter_next() call. + */ + unsigned int i; + + /* Counter of non-option arguments */ + int non_opt_index; + + /* + * 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_next() call. + */ + const char *short_opt_ch; + + /* Temporary character buffer which only grows */ + struct { + size_t size; + char *data; + } tmp_buf; +}; + +/* Base parsing item */ +struct argpar_item { + enum argpar_item_type type; +}; + +/* Option parsing item */ +struct argpar_item_opt { + struct argpar_item base; + + /* Corresponding descriptor */ + const struct argpar_opt_descr *descr; + + /* Argument, or `NULL` if none; owned by this */ + char *arg; +}; + +/* Non-option parsing item */ +struct argpar_item_non_opt { + struct argpar_item base; + + /* + * Complete argument, pointing to one of the entries of the + * original arguments (`argv`). + */ + const char *arg; + + /* + * Index of this argument amongst all original arguments + * (`argv`). + */ + unsigned int orig_index; + + /* Index of this argument amongst other non-option arguments */ + unsigned int non_opt_index; +}; + +static __attribute__((format(ARGPAR_PRINTF_FORMAT, 1, 0))) +char *argpar_vasprintf(const char * const fmt, va_list args) { int len1, len2; char *str; va_list args2; va_copy(args2, args); - len1 = vsnprintf(NULL, 0, fmt, args); if (len1 < 0) { str = NULL; @@ -56,16 +125,16 @@ char *argpar_vasprintf(const char *fmt, va_list args) } len2 = vsnprintf(str, len1 + 1, fmt, args2); - ARGPAR_ASSERT(len1 == len2); end: + va_end(args2); return str; } -static -char *argpar_asprintf(const char *fmt, ...) +static __attribute__((format(ARGPAR_PRINTF_FORMAT, 1, 2))) +char *argpar_asprintf(const char * const fmt, ...) { va_list args; char *str; @@ -73,20 +142,23 @@ char *argpar_asprintf(const char *fmt, ...) va_start(args, fmt); str = argpar_vasprintf(fmt, args); va_end(args); - return str; } -static -bool argpar_string_append_printf(char **str, const char *fmt, ...) +static __attribute__((format(ARGPAR_PRINTF_FORMAT, 2, 3))) +bool try_append_string_printf(char ** const str, const char *fmt, ...) { char *new_str = NULL; - char *addendum; + char *addendum = NULL; bool success; va_list args; - ARGPAR_ASSERT(str); + if (!str) { + success = true; + goto end; + } + ARGPAR_ASSERT(str); va_start(args, fmt); addendum = argpar_vasprintf(fmt, args); va_end(args); @@ -104,108 +176,81 @@ bool argpar_string_append_printf(char **str, const char *fmt, ...) free(*str); *str = new_str; - success = true; end: free(addendum); - return success; } -static -void destroy_item(struct argpar_item * const item) +ARGPAR_HIDDEN +enum argpar_item_type argpar_item_type(const struct argpar_item * const item) { - if (!item) { - goto end; - } - - if (item->type == ARGPAR_ITEM_TYPE_OPT) { - struct argpar_item_opt * const opt_item = (void *) item; - - free((void *) opt_item->arg); - } - - free(item); - -end: - return; + ARGPAR_ASSERT(item); + return item->type; } -static -bool push_item(struct argpar_item_array * const array, - struct argpar_item * const item) +ARGPAR_HIDDEN +const struct argpar_opt_descr *argpar_item_opt_descr( + const struct argpar_item * const item) { - bool success; - - ARGPAR_ASSERT(array); ARGPAR_ASSERT(item); - - if (array->n_items == array->n_alloc) { - unsigned int new_n_alloc = array->n_alloc * 2; - struct argpar_item **new_items; - - new_items = argpar_realloc(array->items, - struct argpar_item *, new_n_alloc); - if (!new_items) { - success = false; - goto end; - } - - array->n_alloc = new_n_alloc; - array->items = new_items; - } - - array->items[array->n_items] = item; - array->n_items++; - - success = true; - -end: - return success; + ARGPAR_ASSERT(item->type == ARGPAR_ITEM_TYPE_OPT); + return ((const struct argpar_item_opt *) item)->descr; } -static -void destroy_item_array(struct argpar_item_array * const array) +ARGPAR_HIDDEN +const char *argpar_item_opt_arg(const struct argpar_item * const item) { - if (array) { - unsigned int i; + ARGPAR_ASSERT(item); + ARGPAR_ASSERT(item->type == ARGPAR_ITEM_TYPE_OPT); + return ((const struct argpar_item_opt *) item)->arg; +} - for (i = 0; i < array->n_items; i++) { - destroy_item(array->items[i]); - } +ARGPAR_HIDDEN +const char *argpar_item_non_opt_arg(const struct argpar_item * const item) +{ + ARGPAR_ASSERT(item); + ARGPAR_ASSERT(item->type == ARGPAR_ITEM_TYPE_NON_OPT); + return ((const struct argpar_item_non_opt *) item)->arg; +} - free(array->items); - free(array); - } +ARGPAR_HIDDEN +unsigned int argpar_item_non_opt_orig_index( + const struct argpar_item * const item) +{ + ARGPAR_ASSERT(item); + ARGPAR_ASSERT(item->type == ARGPAR_ITEM_TYPE_NON_OPT); + return ((const struct argpar_item_non_opt *) item)->orig_index; } -static -struct argpar_item_array *new_item_array(void) +ARGPAR_HIDDEN +unsigned int argpar_item_non_opt_non_opt_index( + const struct argpar_item * const item) { - struct argpar_item_array *ret; - const int initial_size = 10; + ARGPAR_ASSERT(item); + ARGPAR_ASSERT(item->type == ARGPAR_ITEM_TYPE_NON_OPT); + return ((const struct argpar_item_non_opt *) item)->non_opt_index; +} - ret = argpar_zalloc(struct argpar_item_array); - if (!ret) { +ARGPAR_HIDDEN +void argpar_item_destroy(const struct argpar_item * const item) +{ + if (!item) { goto end; } - ret->items = argpar_calloc(struct argpar_item *, initial_size); - if (!ret->items) { - goto error; - } - - ret->n_alloc = initial_size; + if (item->type == ARGPAR_ITEM_TYPE_OPT) { + struct argpar_item_opt * const opt_item = + (struct argpar_item_opt *) item; - goto end; + free(opt_item->arg); + } -error: - destroy_item_array(ret); - ret = NULL; + free((void *) item); end: - return ret; + return; } static @@ -214,7 +259,7 @@ struct argpar_item_opt *create_opt_item( const char * const arg) { struct argpar_item_opt *opt_item = - argpar_zalloc(struct argpar_item_opt); + ARGPAR_ZALLOC(struct argpar_item_opt); if (!opt_item) { goto end; @@ -233,7 +278,7 @@ struct argpar_item_opt *create_opt_item( goto end; error: - destroy_item(&opt_item->base); + argpar_item_destroy(&opt_item->base); opt_item = NULL; end: @@ -246,7 +291,7 @@ struct argpar_item_non_opt *create_non_opt_item(const char * const arg, const unsigned int non_opt_index) { struct argpar_item_non_opt * const non_opt_item = - argpar_zalloc(struct argpar_item_non_opt); + ARGPAR_ZALLOC(struct argpar_item_non_opt); if (!non_opt_item) { goto end; @@ -286,88 +331,90 @@ end: enum parse_orig_arg_opt_ret { PARSE_ORIG_ARG_OPT_RET_OK, - PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT = -2, - PARSE_ORIG_ARG_OPT_RET_ERROR = -1, + PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT = -1, + PARSE_ORIG_ARG_OPT_RET_ERROR_MISSING_OPT_ARG = -2, + PARSE_ORIG_ARG_OPT_RET_ERROR_UNEXPECTED_OPT_ARG = -4, + PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY = -5, }; static enum parse_orig_arg_opt_ret parse_short_opts(const char * const short_opts, const char * const next_orig_arg, const struct argpar_opt_descr * const descrs, - struct argpar_parse_ret * const parse_ret, - bool * const used_next_orig_arg) + struct argpar_iter * const iter, + char ** const error, struct argpar_item ** const item) { enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK; - const char *short_opt_ch = short_opts; + bool used_next_orig_arg = false; + const char *opt_arg = NULL; + const struct argpar_opt_descr *descr; + struct argpar_item_opt *opt_item; - if (strlen(short_opts) == 0) { - argpar_string_append_printf(&parse_ret->error, "Invalid argument"); - goto error; - } + ARGPAR_ASSERT(strlen(short_opts) != 0); - while (*short_opt_ch) { - const char *opt_arg = NULL; - const struct argpar_opt_descr *descr; - struct argpar_item_opt *opt_item; - - /* Find corresponding option descriptor */ - descr = find_descr(descrs, *short_opt_ch, NULL); - if (!descr) { - ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT; - argpar_string_append_printf(&parse_ret->error, - "Unknown option `-%c`", *short_opt_ch); - goto error; - } + if (!iter->short_opt_ch) { + iter->short_opt_ch = short_opts; + } - if (descr->with_arg) { - if (short_opt_ch[1]) { - /* `-oarg` form */ - opt_arg = &short_opt_ch[1]; - } else { - /* `-o arg` form */ - opt_arg = next_orig_arg; - *used_next_orig_arg = true; - } + /* Find corresponding option descriptor */ + descr = find_descr(descrs, *iter->short_opt_ch, NULL); + if (!descr) { + try_append_string_printf(error, "Unknown option `-%c`", + *iter->short_opt_ch); + ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT; + goto error; + } - /* - * We accept `-o ''` (empty option's argument), - * but not `-o` alone if an option's argument is - * expected. - */ - if (!opt_arg || (short_opt_ch[1] && strlen(opt_arg) == 0)) { - argpar_string_append_printf(&parse_ret->error, - "Missing required argument for option `-%c`", - *short_opt_ch); - *used_next_orig_arg = false; - goto error; - } + if (descr->with_arg) { + if (iter->short_opt_ch[1]) { + /* `-oarg` form */ + opt_arg = &iter->short_opt_ch[1]; + } else { + /* `-o arg` form */ + opt_arg = next_orig_arg; + used_next_orig_arg = true; } - /* Create and append option argument */ - opt_item = create_opt_item(descr, opt_arg); - if (!opt_item) { + /* + * We accept `-o ''` (empty option argument), but not + * `-o` alone if an option argument is expected. + */ + if (!opt_arg || (iter->short_opt_ch[1] && + strlen(opt_arg) == 0)) { + try_append_string_printf(error, + "Missing required argument for option `-%c`", + *iter->short_opt_ch); + used_next_orig_arg = false; + ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MISSING_OPT_ARG; goto error; } + } - if (!push_item(parse_ret->items, &opt_item->base)) { - goto error; - } + /* Create and append option argument */ + opt_item = create_opt_item(descr, opt_arg); + if (!opt_item) { + ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY; + goto error; + } - if (descr->with_arg) { - /* Option has an argument: no more options */ - break; - } + *item = &opt_item->base; + iter->short_opt_ch++; + + if (descr->with_arg || !*iter->short_opt_ch) { + /* Option has an argument: no more options */ + iter->short_opt_ch = NULL; - /* Go to next short option */ - short_opt_ch++; + if (used_next_orig_arg) { + iter->i += 2; + } else { + iter->i++; + } } goto end; error: - if (ret == PARSE_ORIG_ARG_OPT_RET_OK) { - ret = PARSE_ORIG_ARG_OPT_RET_ERROR; - } + ARGPAR_ASSERT(ret != PARSE_ORIG_ARG_OPT_RET_OK); end: return ret; @@ -377,13 +424,13 @@ static enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg, const char * const next_orig_arg, const struct argpar_opt_descr * const descrs, - struct argpar_parse_ret * const parse_ret, - bool * const used_next_orig_arg) + struct argpar_iter * const iter, + char ** const error, struct argpar_item ** const item) { - const size_t max_len = 127; enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK; const struct argpar_opt_descr *descr; struct argpar_item_opt *opt_item; + bool used_next_orig_arg = false; /* Option's argument, if any */ const char *opt_arg = NULL; @@ -391,17 +438,10 @@ enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg, /* Position of first `=`, if any */ const char *eq_pos; - /* Buffer holding option name when `long_opt_arg` contains `=` */ - char buf[max_len + 1]; - /* Option name */ const char *long_opt_name = long_opt_arg; - if (strlen(long_opt_arg) == 0) { - argpar_string_append_printf(&parse_ret->error, - "Invalid argument"); - goto error; - } + ARGPAR_ASSERT(strlen(long_opt_arg) != 0); /* Find the first `=` in original argument */ eq_pos = strchr(long_opt_arg, '='); @@ -409,22 +449,26 @@ enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg, const size_t long_opt_name_size = eq_pos - long_opt_arg; /* Isolate the option name */ - if (long_opt_name_size > max_len) { - argpar_string_append_printf(&parse_ret->error, - "Invalid argument `--%s`", long_opt_arg); - goto error; + while (long_opt_name_size > iter->tmp_buf.size - 1) { + iter->tmp_buf.size *= 2; + iter->tmp_buf.data = ARGPAR_REALLOC(iter->tmp_buf.data, + char, iter->tmp_buf.size); + if (!iter->tmp_buf.data) { + ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY; + goto error; + } } - memcpy(buf, long_opt_arg, long_opt_name_size); - buf[long_opt_name_size] = '\0'; - long_opt_name = buf; + memcpy(iter->tmp_buf.data, long_opt_arg, long_opt_name_size); + iter->tmp_buf.data[long_opt_name_size] = '\0'; + long_opt_name = iter->tmp_buf.data; } /* Find corresponding option descriptor */ descr = find_descr(descrs, '\0', long_opt_name); if (!descr) { - argpar_string_append_printf(&parse_ret->error, - "Unknown option `--%s`", long_opt_name); + try_append_string_printf(error, "Unknown option `--%s`", + long_opt_name); ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT; goto error; } @@ -437,15 +481,25 @@ enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg, } else { /* `--long-opt arg` style */ if (!next_orig_arg) { - argpar_string_append_printf(&parse_ret->error, + try_append_string_printf(error, "Missing required argument for option `--%s`", long_opt_name); + ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MISSING_OPT_ARG; goto error; } opt_arg = next_orig_arg; - *used_next_orig_arg = true; + used_next_orig_arg = true; } + } else if (eq_pos) { + /* + * Unexpected `--opt=arg` style for a long option which + * doesn't accept an argument. + */ + try_append_string_printf(error, + "Unexpected argument for option `--%s`", long_opt_name); + ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNEXPECTED_OPT_ARG; + goto error; } /* Create and append option argument */ @@ -454,16 +508,17 @@ enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg, goto error; } - if (!push_item(parse_ret->items, &opt_item->base)) { - goto error; + if (used_next_orig_arg) { + iter->i += 2; + } else { + iter->i++; } + *item = &opt_item->base; goto end; error: - if (ret == PARSE_ORIG_ARG_OPT_RET_OK) { - ret = PARSE_ORIG_ARG_OPT_RET_ERROR; - } + ARGPAR_ASSERT(ret != PARSE_ORIG_ARG_OPT_RET_OK); end: return ret; @@ -473,8 +528,8 @@ static enum parse_orig_arg_opt_ret parse_orig_arg_opt(const char * const orig_arg, const char * const next_orig_arg, const struct argpar_opt_descr * const descrs, - struct argpar_parse_ret * const parse_ret, - bool * const used_next_orig_arg) + struct argpar_iter * const iter, char ** const error, + struct argpar_item ** const item) { enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK; @@ -483,28 +538,29 @@ enum parse_orig_arg_opt_ret parse_orig_arg_opt(const char * const orig_arg, if (orig_arg[1] == '-') { /* Long option */ ret = parse_long_opt(&orig_arg[2], - next_orig_arg, descrs, parse_ret, - used_next_orig_arg); + next_orig_arg, descrs, iter, error, item); } else { /* Short option */ ret = parse_short_opts(&orig_arg[1], - next_orig_arg, descrs, parse_ret, - used_next_orig_arg); + next_orig_arg, descrs, iter, error, item); } return ret; } static -bool prepend_while_parsing_arg_to_error(char **error, +bool try_prepend_while_parsing_arg_to_error(char ** const error, const unsigned int i, const char * const arg) { char *new_error; bool success; - ARGPAR_ASSERT(error); - ARGPAR_ASSERT(*error); + if (!error) { + success = true; + goto end; + } + ARGPAR_ASSERT(*error); new_error = argpar_asprintf("While parsing argument #%u (`%s`): %s", i + 1, arg, *error); if (!new_error) { @@ -521,104 +577,127 @@ end: } ARGPAR_HIDDEN -struct argpar_parse_ret argpar_parse(unsigned int argc, - const char * const *argv, - const struct argpar_opt_descr * const descrs, - bool fail_on_unknown_opt) +struct argpar_iter *argpar_iter_create(const unsigned int argc, + const char * const * const argv, + const struct argpar_opt_descr * const descrs) { - struct argpar_parse_ret parse_ret = { 0 }; - unsigned int i; - unsigned int non_opt_index = 0; + struct argpar_iter *iter = ARGPAR_ZALLOC(struct argpar_iter); - parse_ret.items = new_item_array(); - if (!parse_ret.items) { - goto error; + if (!iter) { + goto end; } - for (i = 0; i < argc; i++) { - enum parse_orig_arg_opt_ret parse_orig_arg_opt_ret; - bool used_next_orig_arg = false; - const char * const orig_arg = argv[i]; - const char * const next_orig_arg = - i < argc - 1 ? argv[i + 1] : NULL; + iter->argc = argc; + iter->argv = argv; + iter->descrs = descrs; + iter->tmp_buf.size = 128; + iter->tmp_buf.data = ARGPAR_CALLOC(char, iter->tmp_buf.size); + if (!iter->tmp_buf.data) { + argpar_iter_destroy(iter); + iter = NULL; + goto end; + } - if (orig_arg[0] != '-') { - /* Non-option argument */ - struct argpar_item_non_opt *non_opt_item = - create_non_opt_item(orig_arg, i, non_opt_index); +end: + return iter; +} - if (!non_opt_item) { - goto error; - } +ARGPAR_HIDDEN +void argpar_iter_destroy(struct argpar_iter * const iter) +{ + if (iter) { + free(iter->tmp_buf.data); + free(iter); + } +} - non_opt_index++; +ARGPAR_HIDDEN +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_next_status status; + enum parse_orig_arg_opt_ret parse_orig_arg_opt_ret; + const char *orig_arg; + const char *next_orig_arg; - if (!push_item(parse_ret.items, &non_opt_item->base)) { - goto error; - } + ARGPAR_ASSERT(iter->i <= iter->argc); - continue; - } + if (error) { + *error = NULL; + } - /* Option argument */ - parse_orig_arg_opt_ret = parse_orig_arg_opt(orig_arg, - next_orig_arg, descrs, &parse_ret, &used_next_orig_arg); - switch (parse_orig_arg_opt_ret) { - case PARSE_ORIG_ARG_OPT_RET_OK: - break; - case PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT: - ARGPAR_ASSERT(!used_next_orig_arg); + if (iter->i == iter->argc) { + status = ARGPAR_ITER_NEXT_STATUS_END; + goto end; + } - if (fail_on_unknown_opt) { - prepend_while_parsing_arg_to_error( - &parse_ret.error, i, orig_arg); - goto error; - } + orig_arg = iter->argv[iter->i]; + next_orig_arg = + iter->i < (iter->argc - 1) ? iter->argv[iter->i + 1] : NULL; - /* - * The current original argument is not - * considered ingested because it triggered an - * unknown option. - */ - parse_ret.ingested_orig_args = i; - free(parse_ret.error); - parse_ret.error = NULL; + if (strcmp(orig_arg, "-") == 0 || strcmp(orig_arg, "--") == 0 || + orig_arg[0] != '-') { + /* Non-option argument */ + const struct argpar_item_non_opt * const non_opt_item = + create_non_opt_item(orig_arg, iter->i, + iter->non_opt_index); + + if (!non_opt_item) { + status = ARGPAR_ITER_NEXT_STATUS_ERROR_MEMORY; goto end; - case PARSE_ORIG_ARG_OPT_RET_ERROR: - prepend_while_parsing_arg_to_error( - &parse_ret.error, i, orig_arg); - goto error; - default: - abort(); } - if (used_next_orig_arg) { - i++; - } + iter->non_opt_index++; + iter->i++; + *item = &non_opt_item->base; + status = ARGPAR_ITER_NEXT_STATUS_OK; + goto end; } - parse_ret.ingested_orig_args = argc; - free(parse_ret.error); - parse_ret.error = NULL; - goto end; + /* Option argument */ + parse_orig_arg_opt_ret = parse_orig_arg_opt(orig_arg, + next_orig_arg, iter->descrs, iter, error, + (struct argpar_item **) item); + switch (parse_orig_arg_opt_ret) { + case PARSE_ORIG_ARG_OPT_RET_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: + case PARSE_ORIG_ARG_OPT_RET_ERROR_UNEXPECTED_OPT_ARG: + try_prepend_while_parsing_arg_to_error(error, iter->i, + orig_arg); -error: - /* That's how we indicate that an error occured */ - destroy_item_array(parse_ret.items); - parse_ret.items = NULL; + switch (parse_orig_arg_opt_ret) { + case PARSE_ORIG_ARG_OPT_RET_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_NEXT_STATUS_ERROR_MISSING_OPT_ARG; + break; + case PARSE_ORIG_ARG_OPT_RET_ERROR_UNEXPECTED_OPT_ARG: + status = ARGPAR_ITER_NEXT_STATUS_ERROR_UNEXPECTED_OPT_ARG; + break; + default: + abort(); + } + + break; + case PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY: + status = ARGPAR_ITER_NEXT_STATUS_ERROR_MEMORY; + break; + default: + abort(); + } end: - return parse_ret; + return status; } ARGPAR_HIDDEN -void argpar_parse_ret_fini(struct argpar_parse_ret *ret) +unsigned int argpar_iter_ingested_orig_args( + const struct argpar_iter * const iter) { - ARGPAR_ASSERT(ret); - - destroy_item_array(ret->items); - ret->items = NULL; - - free(ret->error); - ret->error = NULL; + return iter->i; }