ba577976a789f71d667e4f1b35be322de91bd6e6
[argpar.git] / 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 }
This page took 0.073873 seconds and 3 git commands to generate.