argpar/argpar.c

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright (c) 2019-2021 Philippe Proulx <pproulx@efficios.com>
   5  * Copyright (c) 2020-2021 Simon Marchi <simon.marchi@efficios.com>
   6  */
   7
   8 #include <assert.h>
   9 #include <stdarg.h>
  10 #include <stdbool.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14
  15 #include "argpar.h"
  16
  17 #define ARGPAR_REALLOC(_ptr, _type, _nmemb)                             \
  18         ((_type *) realloc(_ptr, (_nmemb) * sizeof(_type)))
  19
  20 #define ARGPAR_CALLOC(_type, _nmemb)                                    \
  21         ((_type *) calloc((_nmemb), sizeof(_type)))
  22
  23 #define ARGPAR_ZALLOC(_type) ARGPAR_CALLOC(_type, 1)
  24
  25 #define ARGPAR_ASSERT(_cond) assert(_cond)
  26
  27 #ifdef __MINGW_PRINTF_FORMAT
  28 # define ARGPAR_PRINTF_FORMAT __MINGW_PRINTF_FORMAT
  29 #else
  30 # define ARGPAR_PRINTF_FORMAT printf
  31 #endif
  32
  33 /*
  34  * An argpar iterator.
  35  *
  36  * Such a structure contains the state of an iterator between calls to
  37  * argpar_iter_next().
  38  */
  39 struct argpar_iter {
  40         /*
  41          * Data provided by the user to argpar_iter_create(); immutable
  42          * afterwards.
  43          */
  44         unsigned int argc;
  45         const char * const *argv;
  46         const struct argpar_opt_descr *descrs;
  47
  48         /*
  49          * Index of the argument to process in the next
  50          * argpar_iter_next() call.
  51          */
  52         unsigned int i;
  53
  54         /* Counter of non-option arguments */
  55         int non_opt_index;
  56
  57         /*
  58          * Current character of the current short option group: if it's
  59          * not `NULL`, the parser is in within a short option group,
  60          * therefore it must resume there in the next
  61          * argpar_iter_next() call.
  62          */
  63         const char *short_opt_ch;
  64
  65         /* Temporary character buffer which only grows */
  66         struct {
  67                 size_t size;
  68                 char *data;
  69         } tmp_buf;
  70 };
  71
  72 /* Base parsing item */
  73 struct argpar_item {
  74         enum argpar_item_type type;
  75 };
  76
  77 /* Option parsing item */
  78 struct argpar_item_opt {
  79         struct argpar_item base;
  80
  81         /* Corresponding descriptor */
  82         const struct argpar_opt_descr *descr;
  83
  84         /* Argument, or `NULL` if none; owned by this */
  85         char *arg;
  86 };
  87
  88 /* Non-option parsing item */
  89 struct argpar_item_non_opt {
  90         struct argpar_item base;
  91
  92         /*
  93          * Complete argument, pointing to one of the entries of the
  94          * original arguments (`argv`).
  95          */
  96         const char *arg;
  97
  98         /*
  99          * Index of this argument amongst all original arguments
 100          * (`argv`).
 101          */
 102         unsigned int orig_index;
 103
 104         /* Index of this argument amongst other non-option arguments */
 105         unsigned int non_opt_index;
 106 };
 107
 108 static __attribute__((format(ARGPAR_PRINTF_FORMAT, 1, 0)))
 109 char *argpar_vasprintf(const char * const fmt, va_list args)
 110 {
 111         int len1, len2;
 112         char *str;
 113         va_list args2;
 114
 115         va_copy(args2, args);
 116         len1 = vsnprintf(NULL, 0, fmt, args);
 117         if (len1 < 0) {
 118                 str = NULL;
 119                 goto end;
 120         }
 121
 122         str = malloc(len1 + 1);
 123         if (!str) {
 124                 goto end;
 125         }
 126
 127         len2 = vsnprintf(str, len1 + 1, fmt, args2);
 128         ARGPAR_ASSERT(len1 == len2);
 129
 130 end:
 131         va_end(args2);
 132         return str;
 133 }
 134
 135
 136 static __attribute__((format(ARGPAR_PRINTF_FORMAT, 1, 2)))
 137 char *argpar_asprintf(const char * const fmt, ...)
 138 {
 139         va_list args;
 140         char *str;
 141
 142         va_start(args, fmt);
 143         str = argpar_vasprintf(fmt, args);
 144         va_end(args);
 145         return str;
 146 }
 147
 148 static __attribute__((format(ARGPAR_PRINTF_FORMAT, 2, 3)))
 149 bool try_append_string_printf(char ** const str, const char *fmt, ...)
 150 {
 151         char *new_str = NULL;
 152         char *addendum = NULL;
 153         bool success;
 154         va_list args;
 155
 156         if (!str) {
 157                 success = true;
 158                 goto end;
 159         }
 160
 161         ARGPAR_ASSERT(str);
 162         va_start(args, fmt);
 163         addendum = argpar_vasprintf(fmt, args);
 164         va_end(args);
 165
 166         if (!addendum) {
 167                 success = false;
 168                 goto end;
 169         }
 170
 171         new_str = argpar_asprintf("%s%s", *str ? *str : "", addendum);
 172         if (!new_str) {
 173                 success = false;
 174                 goto end;
 175         }
 176
 177         free(*str);
 178         *str = new_str;
 179         success = true;
 180
 181 end:
 182         free(addendum);
 183         return success;
 184 }
 185
 186 ARGPAR_HIDDEN
 187 enum argpar_item_type argpar_item_type(const struct argpar_item * const item)
 188 {
 189         ARGPAR_ASSERT(item);
 190         return item->type;
 191 }
 192
 193 ARGPAR_HIDDEN
 194 const struct argpar_opt_descr *argpar_item_opt_descr(
 195                 const struct argpar_item * const item)
 196 {
 197         ARGPAR_ASSERT(item);
 198         ARGPAR_ASSERT(item->type == ARGPAR_ITEM_TYPE_OPT);
 199         return ((const struct argpar_item_opt *) item)->descr;
 200 }
 201
 202 ARGPAR_HIDDEN
 203 const char *argpar_item_opt_arg(const struct argpar_item * const item)
 204 {
 205         ARGPAR_ASSERT(item);
 206         ARGPAR_ASSERT(item->type == ARGPAR_ITEM_TYPE_OPT);
 207         return ((const struct argpar_item_opt *) item)->arg;
 208 }
 209
 210 ARGPAR_HIDDEN
 211 const char *argpar_item_non_opt_arg(const struct argpar_item * const item)
 212 {
 213         ARGPAR_ASSERT(item);
 214         ARGPAR_ASSERT(item->type == ARGPAR_ITEM_TYPE_NON_OPT);
 215         return ((const struct argpar_item_non_opt *) item)->arg;
 216 }
 217
 218 ARGPAR_HIDDEN
 219 unsigned int argpar_item_non_opt_orig_index(
 220                 const struct argpar_item * const item)
 221 {
 222         ARGPAR_ASSERT(item);
 223         ARGPAR_ASSERT(item->type == ARGPAR_ITEM_TYPE_NON_OPT);
 224         return ((const struct argpar_item_non_opt *) item)->orig_index;
 225 }
 226
 227 ARGPAR_HIDDEN
 228 unsigned int argpar_item_non_opt_non_opt_index(
 229                 const struct argpar_item * const item)
 230 {
 231         ARGPAR_ASSERT(item);
 232         ARGPAR_ASSERT(item->type == ARGPAR_ITEM_TYPE_NON_OPT);
 233         return ((const struct argpar_item_non_opt *) item)->non_opt_index;
 234 }
 235
 236 ARGPAR_HIDDEN
 237 void argpar_item_destroy(const struct argpar_item * const item)
 238 {
 239         if (!item) {
 240                 goto end;
 241         }
 242
 243         if (item->type == ARGPAR_ITEM_TYPE_OPT) {
 244                 struct argpar_item_opt * const opt_item =
 245                         (struct argpar_item_opt *) item;
 246
 247                 free(opt_item->arg);
 248         }
 249
 250         free((void *) item);
 251
 252 end:
 253         return;
 254 }
 255
 256 static
 257 bool push_item(struct argpar_item_array * const array,
 258                 const struct argpar_item * const item)
 259 {
 260         bool success;
 261
 262         ARGPAR_ASSERT(array);
 263         ARGPAR_ASSERT(item);
 264
 265         if (array->n_items == array->n_alloc) {
 266                 const unsigned int new_n_alloc = array->n_alloc * 2;
 267                 const struct argpar_item ** const new_items =
 268                         ARGPAR_REALLOC(array->items, const struct argpar_item *,
 269                                 new_n_alloc);
 270                 if (!new_items) {
 271                         success = false;
 272                         goto end;
 273                 }
 274
 275                 array->n_alloc = new_n_alloc;
 276                 array->items = new_items;
 277         }
 278
 279         array->items[array->n_items] = item;
 280         array->n_items++;
 281         success = true;
 282
 283 end:
 284         return success;
 285 }
 286
 287 static
 288 void destroy_item_array(struct argpar_item_array * const array)
 289 {
 290         if (array) {
 291                 unsigned int i;
 292
 293                 for (i = 0; i < array->n_items; i++) {
 294                         argpar_item_destroy(array->items[i]);
 295                 }
 296
 297                 free(array->items);
 298                 free(array);
 299         }
 300 }
 301
 302 static
 303 struct argpar_item_array *create_item_array(void)
 304 {
 305         struct argpar_item_array *ret;
 306         const int initial_size = 10;
 307
 308         ret = ARGPAR_ZALLOC(struct argpar_item_array);
 309         if (!ret) {
 310                 goto end;
 311         }
 312
 313         ret->items = ARGPAR_CALLOC(const struct argpar_item *, initial_size);
 314         if (!ret->items) {
 315                 goto error;
 316         }
 317
 318         ret->n_alloc = initial_size;
 319         goto end;
 320
 321 error:
 322         destroy_item_array(ret);
 323         ret = NULL;
 324
 325 end:
 326         return ret;
 327 }
 328
 329 static
 330 struct argpar_item_opt *create_opt_item(
 331                 const struct argpar_opt_descr * const descr,
 332                 const char * const arg)
 333 {
 334         struct argpar_item_opt *opt_item =
 335                 ARGPAR_ZALLOC(struct argpar_item_opt);
 336
 337         if (!opt_item) {
 338                 goto end;
 339         }
 340
 341         opt_item->base.type = ARGPAR_ITEM_TYPE_OPT;
 342         opt_item->descr = descr;
 343
 344         if (arg) {
 345                 opt_item->arg = strdup(arg);
 346                 if (!opt_item->arg) {
 347                         goto error;
 348                 }
 349         }
 350
 351         goto end;
 352
 353 error:
 354         argpar_item_destroy(&opt_item->base);
 355         opt_item = NULL;
 356
 357 end:
 358         return opt_item;
 359 }
 360
 361 static
 362 struct argpar_item_non_opt *create_non_opt_item(const char * const arg,
 363                 const unsigned int orig_index,
 364                 const unsigned int non_opt_index)
 365 {
 366         struct argpar_item_non_opt * const non_opt_item =
 367                 ARGPAR_ZALLOC(struct argpar_item_non_opt);
 368
 369         if (!non_opt_item) {
 370                 goto end;
 371         }
 372
 373         non_opt_item->base.type = ARGPAR_ITEM_TYPE_NON_OPT;
 374         non_opt_item->arg = arg;
 375         non_opt_item->orig_index = orig_index;
 376         non_opt_item->non_opt_index = non_opt_index;
 377
 378 end:
 379         return non_opt_item;
 380 }
 381
 382 static
 383 const struct argpar_opt_descr *find_descr(
 384                 const struct argpar_opt_descr * const descrs,
 385                 const char short_name, const char * const long_name)
 386 {
 387         const struct argpar_opt_descr *descr;
 388
 389         for (descr = descrs; descr->short_name || descr->long_name; descr++) {
 390                 if (short_name && descr->short_name &&
 391                                 short_name == descr->short_name) {
 392                         goto end;
 393                 }
 394
 395                 if (long_name && descr->long_name &&
 396                                 strcmp(long_name, descr->long_name) == 0) {
 397                         goto end;
 398                 }
 399         }
 400
 401 end:
 402         return !descr->short_name && !descr->long_name ? NULL : descr;
 403 }
 404
 405 enum parse_orig_arg_opt_ret {
 406         PARSE_ORIG_ARG_OPT_RET_OK,
 407         PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT = -1,
 408         PARSE_ORIG_ARG_OPT_RET_ERROR_MISSING_OPT_ARG = -2,
 409         PARSE_ORIG_ARG_OPT_RET_ERROR_UNEXPECTED_OPT_ARG = -4,
 410         PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY = -5,
 411 };
 412
 413 static
 414 enum parse_orig_arg_opt_ret parse_short_opts(const char * const short_opts,
 415                 const char * const next_orig_arg,
 416                 const struct argpar_opt_descr * const descrs,
 417                 struct argpar_iter * const iter,
 418                 char ** const error, struct argpar_item ** const item)
 419 {
 420         enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK;
 421         bool used_next_orig_arg = false;
 422         const char *opt_arg = NULL;
 423         const struct argpar_opt_descr *descr;
 424         struct argpar_item_opt *opt_item;
 425
 426         ARGPAR_ASSERT(strlen(short_opts) != 0);
 427
 428         if (!iter->short_opt_ch) {
 429                 iter->short_opt_ch = short_opts;
 430         }
 431
 432         /* Find corresponding option descriptor */
 433         descr = find_descr(descrs, *iter->short_opt_ch, NULL);
 434         if (!descr) {
 435                 try_append_string_printf(error, "Unknown option `-%c`",
 436                         *iter->short_opt_ch);
 437                 ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT;
 438                 goto error;
 439         }
 440
 441         if (descr->with_arg) {
 442                 if (iter->short_opt_ch[1]) {
 443                         /* `-oarg` form */
 444                         opt_arg = &iter->short_opt_ch[1];
 445                 } else {
 446                         /* `-o arg` form */
 447                         opt_arg = next_orig_arg;
 448                         used_next_orig_arg = true;
 449                 }
 450
 451                 /*
 452                  * We accept `-o ''` (empty option argument), but not
 453                  * `-o` alone if an option argument is expected.
 454                  */
 455                 if (!opt_arg || (iter->short_opt_ch[1] &&
 456                                 strlen(opt_arg) == 0)) {
 457                         try_append_string_printf(error,
 458                                 "Missing required argument for option `-%c`",
 459                                 *iter->short_opt_ch);
 460                         used_next_orig_arg = false;
 461                         ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MISSING_OPT_ARG;
 462                         goto error;
 463                 }
 464         }
 465
 466         /* Create and append option argument */
 467         opt_item = create_opt_item(descr, opt_arg);
 468         if (!opt_item) {
 469                 ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY;
 470                 goto error;
 471         }
 472
 473         *item = &opt_item->base;
 474         iter->short_opt_ch++;
 475
 476         if (descr->with_arg || !*iter->short_opt_ch) {
 477                 /* Option has an argument: no more options */
 478                 iter->short_opt_ch = NULL;
 479
 480                 if (used_next_orig_arg) {
 481                         iter->i += 2;
 482                 } else {
 483                         iter->i++;
 484                 }
 485         }
 486
 487         goto end;
 488
 489 error:
 490         ARGPAR_ASSERT(ret != PARSE_ORIG_ARG_OPT_RET_OK);
 491
 492 end:
 493         return ret;
 494 }
 495
 496 static
 497 enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg,
 498                 const char * const next_orig_arg,
 499                 const struct argpar_opt_descr * const descrs,
 500                 struct argpar_iter * const iter,
 501                 char ** const error, struct argpar_item ** const item)
 502 {
 503         enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK;
 504         const struct argpar_opt_descr *descr;
 505         struct argpar_item_opt *opt_item;
 506         bool used_next_orig_arg = false;
 507
 508         /* Option's argument, if any */
 509         const char *opt_arg = NULL;
 510
 511         /* Position of first `=`, if any */
 512         const char *eq_pos;
 513
 514         /* Option name */
 515         const char *long_opt_name = long_opt_arg;
 516
 517         ARGPAR_ASSERT(strlen(long_opt_arg) != 0);
 518
 519         /* Find the first `=` in original argument */
 520         eq_pos = strchr(long_opt_arg, '=');
 521         if (eq_pos) {
 522                 const size_t long_opt_name_size = eq_pos - long_opt_arg;
 523
 524                 /* Isolate the option name */
 525                 while (long_opt_name_size > iter->tmp_buf.size - 1) {
 526                         iter->tmp_buf.size *= 2;
 527                         iter->tmp_buf.data = ARGPAR_REALLOC(iter->tmp_buf.data,
 528                                 char, iter->tmp_buf.size);
 529                         if (!iter->tmp_buf.data) {
 530                                 ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY;
 531                                 goto error;
 532                         }
 533                 }
 534
 535                 memcpy(iter->tmp_buf.data, long_opt_arg, long_opt_name_size);
 536                 iter->tmp_buf.data[long_opt_name_size] = '\0';
 537                 long_opt_name = iter->tmp_buf.data;
 538         }
 539
 540         /* Find corresponding option descriptor */
 541         descr = find_descr(descrs, '\0', long_opt_name);
 542         if (!descr) {
 543                 try_append_string_printf(error, "Unknown option `--%s`",
 544                         long_opt_name);
 545                 ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT;
 546                 goto error;
 547         }
 548
 549         /* Find option's argument if any */
 550         if (descr->with_arg) {
 551                 if (eq_pos) {
 552                         /* `--long-opt=arg` style */
 553                         opt_arg = eq_pos + 1;
 554                 } else {
 555                         /* `--long-opt arg` style */
 556                         if (!next_orig_arg) {
 557                                 try_append_string_printf(error,
 558                                         "Missing required argument for option `--%s`",
 559                                         long_opt_name);
 560                                 ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MISSING_OPT_ARG;
 561                                 goto error;
 562                         }
 563
 564                         opt_arg = next_orig_arg;
 565                         used_next_orig_arg = true;
 566                 }
 567         } else if (eq_pos) {
 568                 /*
 569                  * Unexpected `--opt=arg` style for a long option which
 570                  * doesn't accept an argument.
 571                  */
 572                 try_append_string_printf(error,
 573                         "Unexpected argument for option `--%s`", long_opt_name);
 574                 ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNEXPECTED_OPT_ARG;
 575                 goto error;
 576         }
 577
 578         /* Create and append option argument */
 579         opt_item = create_opt_item(descr, opt_arg);
 580         if (!opt_item) {
 581                 goto error;
 582         }
 583
 584         if (used_next_orig_arg) {
 585                 iter->i += 2;
 586         } else {
 587                 iter->i++;
 588         }
 589
 590         *item = &opt_item->base;
 591         goto end;
 592
 593 error:
 594         ARGPAR_ASSERT(ret != PARSE_ORIG_ARG_OPT_RET_OK);
 595
 596 end:
 597         return ret;
 598 }
 599
 600 static
 601 enum parse_orig_arg_opt_ret parse_orig_arg_opt(const char * const orig_arg,
 602                 const char * const next_orig_arg,
 603                 const struct argpar_opt_descr * const descrs,
 604                 struct argpar_iter * const iter, char ** const error,
 605                 struct argpar_item ** const item)
 606 {
 607         enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK;
 608
 609         ARGPAR_ASSERT(orig_arg[0] == '-');
 610
 611         if (orig_arg[1] == '-') {
 612                 /* Long option */
 613                 ret = parse_long_opt(&orig_arg[2],
 614                         next_orig_arg, descrs, iter, error, item);
 615         } else {
 616                 /* Short option */
 617                 ret = parse_short_opts(&orig_arg[1],
 618                         next_orig_arg, descrs, iter, error, item);
 619         }
 620
 621         return ret;
 622 }
 623
 624 static
 625 bool try_prepend_while_parsing_arg_to_error(char ** const error,
 626                 const unsigned int i, const char * const arg)
 627 {
 628         char *new_error;
 629         bool success;
 630
 631         if (!error) {
 632                 success = true;
 633                 goto end;
 634         }
 635
 636         ARGPAR_ASSERT(*error);
 637         new_error = argpar_asprintf("While parsing argument #%u (`%s`): %s",
 638                 i + 1, arg, *error);
 639         if (!new_error) {
 640                 success = false;
 641                 goto end;
 642         }
 643
 644         free(*error);
 645         *error = new_error;
 646         success = true;
 647
 648 end:
 649         return success;
 650 }
 651
 652 ARGPAR_HIDDEN
 653 struct argpar_iter *argpar_iter_create(const unsigned int argc,
 654                 const char * const * const argv,
 655                 const struct argpar_opt_descr * const descrs)
 656 {
 657         struct argpar_iter *iter = ARGPAR_ZALLOC(struct argpar_iter);
 658
 659         if (!iter) {
 660                 goto end;
 661         }
 662
 663         iter->argc = argc;
 664         iter->argv = argv;
 665         iter->descrs = descrs;
 666         iter->tmp_buf.size = 128;
 667         iter->tmp_buf.data = ARGPAR_CALLOC(char, iter->tmp_buf.size);
 668         if (!iter->tmp_buf.data) {
 669                 argpar_iter_destroy(iter);
 670                 iter = NULL;
 671                 goto end;
 672         }
 673
 674 end:
 675         return iter;
 676 }
 677
 678 ARGPAR_HIDDEN
 679 void argpar_iter_destroy(struct argpar_iter * const iter)
 680 {
 681         if (iter) {
 682                 free(iter->tmp_buf.data);
 683                 free(iter);
 684         }
 685 }
 686
 687 ARGPAR_HIDDEN
 688 enum argpar_iter_next_status argpar_iter_next(
 689                 struct argpar_iter * const iter,
 690                 const struct argpar_item ** const item, char ** const error)
 691 {
 692         enum argpar_iter_next_status status;
 693         enum parse_orig_arg_opt_ret parse_orig_arg_opt_ret;
 694         const char *orig_arg;
 695         const char *next_orig_arg;
 696
 697         ARGPAR_ASSERT(iter->i <= iter->argc);
 698
 699         if (error) {
 700                 *error = NULL;
 701         }
 702
 703         if (iter->i == iter->argc) {
 704                 status = ARGPAR_ITER_NEXT_STATUS_END;
 705                 goto end;
 706         }
 707
 708         orig_arg = iter->argv[iter->i];
 709         next_orig_arg =
 710                 iter->i < (iter->argc - 1) ? iter->argv[iter->i + 1] : NULL;
 711
 712         if (strcmp(orig_arg, "-") == 0 || strcmp(orig_arg, "--") == 0 ||
 713                         orig_arg[0] != '-') {
 714                 /* Non-option argument */
 715                 const struct argpar_item_non_opt * const non_opt_item =
 716                         create_non_opt_item(orig_arg, iter->i,
 717                                 iter->non_opt_index);
 718
 719                 if (!non_opt_item) {
 720                         status = ARGPAR_ITER_NEXT_STATUS_ERROR_MEMORY;
 721                         goto end;
 722                 }
 723
 724                 iter->non_opt_index++;
 725                 iter->i++;
 726                 *item = &non_opt_item->base;
 727                 status = ARGPAR_ITER_NEXT_STATUS_OK;
 728                 goto end;
 729         }
 730
 731         /* Option argument */
 732         parse_orig_arg_opt_ret = parse_orig_arg_opt(orig_arg,
 733                 next_orig_arg, iter->descrs, iter, error,
 734                 (struct argpar_item **) item);
 735         switch (parse_orig_arg_opt_ret) {
 736         case PARSE_ORIG_ARG_OPT_RET_OK:
 737                 status = ARGPAR_ITER_NEXT_STATUS_OK;
 738                 break;
 739         case PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT:
 740         case PARSE_ORIG_ARG_OPT_RET_ERROR_MISSING_OPT_ARG:
 741         case PARSE_ORIG_ARG_OPT_RET_ERROR_UNEXPECTED_OPT_ARG:
 742                 try_prepend_while_parsing_arg_to_error(error, iter->i,
 743                         orig_arg);
 744
 745                 switch (parse_orig_arg_opt_ret) {
 746                 case PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT:
 747                         status = ARGPAR_ITER_NEXT_STATUS_ERROR_UNKNOWN_OPT;
 748                         break;
 749                 case PARSE_ORIG_ARG_OPT_RET_ERROR_MISSING_OPT_ARG:
 750                         status = ARGPAR_ITER_NEXT_STATUS_ERROR_MISSING_OPT_ARG;
 751                         break;
 752                 case PARSE_ORIG_ARG_OPT_RET_ERROR_UNEXPECTED_OPT_ARG:
 753                         status = ARGPAR_ITER_NEXT_STATUS_ERROR_UNEXPECTED_OPT_ARG;
 754                         break;
 755                 default:
 756                         abort();
 757                 }
 758
 759                 break;
 760         case PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY:
 761                 status = ARGPAR_ITER_NEXT_STATUS_ERROR_MEMORY;
 762                 break;
 763         default:
 764                 abort();
 765         }
 766
 767 end:
 768         return status;
 769 }
 770
 771 ARGPAR_HIDDEN
 772 unsigned int argpar_iter_ingested_orig_args(
 773                 const struct argpar_iter * const iter)
 774 {
 775         return iter->i;
 776 }
 777
 778 ARGPAR_HIDDEN
 779 struct argpar_parse_ret argpar_parse(const unsigned int argc,
 780                 const char * const * const argv,
 781                 const struct argpar_opt_descr * const descrs,
 782                 const bool fail_on_unknown_opt)
 783 {
 784         struct argpar_parse_ret parse_ret = { 0 };
 785         const struct argpar_item *item = NULL;
 786         struct argpar_iter *iter = NULL;
 787
 788         parse_ret.items = create_item_array();
 789         if (!parse_ret.items) {
 790                 parse_ret.error = strdup("Failed to create items array.");
 791                 ARGPAR_ASSERT(parse_ret.error);
 792                 goto error;
 793         }
 794
 795         iter = argpar_iter_create(argc, argv, descrs);
 796         if (!iter) {
 797                 parse_ret.error = strdup("Failed to create argpar iter.");
 798                 ARGPAR_ASSERT(parse_ret.error);
 799                 goto error;
 800         }
 801
 802         while (true) {
 803                 const enum argpar_iter_next_status status =
 804                         argpar_iter_next(iter, &item, &parse_ret.error);
 805
 806                 switch (status) {
 807                 case ARGPAR_ITER_NEXT_STATUS_ERROR_MISSING_OPT_ARG:
 808                 case ARGPAR_ITER_NEXT_STATUS_ERROR_UNEXPECTED_OPT_ARG:
 809                 case ARGPAR_ITER_NEXT_STATUS_ERROR_MEMORY:
 810                         goto error;
 811                 case ARGPAR_ITER_NEXT_STATUS_ERROR_UNKNOWN_OPT:
 812                         if (fail_on_unknown_opt) {
 813                                 parse_ret.ingested_orig_args =
 814                                         argpar_iter_ingested_orig_args(iter);
 815                                 goto error;
 816                         }
 817
 818                         free(parse_ret.error);
 819                         parse_ret.error = NULL;
 820                         goto success;
 821                 case ARGPAR_ITER_NEXT_STATUS_END:
 822                         goto success;
 823                 default:
 824                         ARGPAR_ASSERT(status == ARGPAR_ITER_NEXT_STATUS_OK);
 825                         break;
 826                 }
 827
 828                 if (!push_item(parse_ret.items, item)) {
 829                         goto error;
 830                 }
 831
 832                 item = NULL;
 833         }
 834
 835 success:
 836         ARGPAR_ASSERT(!parse_ret.error);
 837         parse_ret.ingested_orig_args = argpar_iter_ingested_orig_args(iter);
 838         goto end;
 839
 840 error:
 841         ARGPAR_ASSERT(parse_ret.error);
 842
 843         /* That's how we indicate that an error occurred */
 844         destroy_item_array(parse_ret.items);
 845         parse_ret.items = NULL;
 846
 847 end:
 848         argpar_iter_destroy(iter);
 849         argpar_item_destroy(item);
 850         return parse_ret;
 851 }
 852
 853 ARGPAR_HIDDEN
 854 void argpar_parse_ret_fini(struct argpar_parse_ret * const ret)
 855 {
 856         ARGPAR_ASSERT(ret);
 857         destroy_item_array(ret->items);
 858         ret->items = NULL;
 859         free(ret->error);
 860         ret->error = NULL;
 861 }