configure.ac: set the version of the project to 0.1.0
[argpar.git] / argpar / argpar.c
CommitLineData
903a5b8a 1/*
03e1579f 2 * SPDX-License-Identifier: MIT
903a5b8a 3 *
fc07e526
SM
4 * Copyright (c) 2019-2021 Philippe Proulx <pproulx@efficios.com>
5 * Copyright (c) 2020-2021 Simon Marchi <simon.marchi@efficios.com>
903a5b8a
SM
6 */
7
7ac57709
SM
8#include <assert.h>
9#include <stdarg.h>
903a5b8a 10#include <stdbool.h>
7ac57709 11#include <stdio.h>
903a5b8a
SM
12#include <stdlib.h>
13#include <string.h>
903a5b8a
SM
14
15#include "argpar.h"
16
fb12ac67
PP
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)
7ac57709
SM
24
25#define ARGPAR_ASSERT(_cond) assert(_cond)
26
1ae22b5e
SM
27#ifdef __MINGW_PRINTF_FORMAT
28# define ARGPAR_PRINTF_FORMAT __MINGW_PRINTF_FORMAT
29#else
30# define ARGPAR_PRINTF_FORMAT printf
31#endif
32
fc07e526
SM
33/*
34 * An argpar iterator.
35 *
2af370d0
PP
36 * Such a structure contains the state of an iterator between calls to
37 * argpar_iter_next().
fc07e526
SM
38 */
39struct 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
2af370d0 50 * argpar_iter_next() call.
fc07e526
SM
51 */
52 unsigned int i;
53
54 /* Counter of non-option arguments */
55 int non_opt_index;
56
57 /*
d7a82d7f
PP
58 * Current character within the current short option group: if
59 * it's not `NULL`, the parser is within a short option group,
60 * therefore it must resume there in the next argpar_iter_next()
61 * call.
fc07e526 62 */
d7a82d7f 63 const char *short_opt_group_ch;
d1f7bbdb
PP
64
65 /* Temporary character buffer which only grows */
66 struct {
67 size_t size;
68 char *data;
69 } tmp_buf;
fc07e526
SM
70};
71
d4539a90
PP
72/* Base parsing item */
73struct argpar_item {
74 enum argpar_item_type type;
75};
76
77/* Option parsing item */
78struct 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 */
89struct 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
1ae22b5e 108static __attribute__((format(ARGPAR_PRINTF_FORMAT, 1, 0)))
fb12ac67 109char *argpar_vasprintf(const char * const fmt, va_list args)
7ac57709
SM
110{
111 int len1, len2;
112 char *str;
113 va_list args2;
114
115 va_copy(args2, args);
7ac57709
SM
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);
7ac57709
SM
128 ARGPAR_ASSERT(len1 == len2);
129
130end:
92ecd98e 131 va_end(args2);
7ac57709
SM
132 return str;
133}
134
135
1ae22b5e 136static __attribute__((format(ARGPAR_PRINTF_FORMAT, 1, 2)))
fb12ac67 137char *argpar_asprintf(const char * const fmt, ...)
7ac57709
SM
138{
139 va_list args;
140 char *str;
f46b5106 141
7ac57709
SM
142 va_start(args, fmt);
143 str = argpar_vasprintf(fmt, args);
144 va_end(args);
7ac57709
SM
145 return str;
146}
147
1ae22b5e 148static __attribute__((format(ARGPAR_PRINTF_FORMAT, 2, 3)))
37bb2b1f 149bool try_append_string_printf(char ** const str, const char *fmt, ...)
7ac57709
SM
150{
151 char *new_str = NULL;
37bb2b1f 152 char *addendum = NULL;
7ac57709
SM
153 bool success;
154 va_list args;
155
37bb2b1f
PP
156 if (!str) {
157 success = true;
158 goto end;
159 }
160
7ac57709 161 ARGPAR_ASSERT(str);
7ac57709
SM
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 }
f46b5106 176
7ac57709
SM
177 free(*str);
178 *str = new_str;
7ac57709
SM
179 success = true;
180
181end:
182 free(addendum);
7ac57709
SM
183 return success;
184}
185
d4539a90
PP
186ARGPAR_HIDDEN
187enum argpar_item_type argpar_item_type(const struct argpar_item * const item)
188{
189 ARGPAR_ASSERT(item);
190 return item->type;
191}
192
193ARGPAR_HIDDEN
194const 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
202ARGPAR_HIDDEN
203const 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
210ARGPAR_HIDDEN
211const 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
218ARGPAR_HIDDEN
219unsigned 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
227ARGPAR_HIDDEN
228unsigned 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
fc07e526
SM
236ARGPAR_HIDDEN
237void argpar_item_destroy(const struct argpar_item * const item)
903a5b8a
SM
238{
239 if (!item) {
240 goto end;
241 }
242
1c9a6bde 243 if (item->type == ARGPAR_ITEM_TYPE_OPT) {
fc07e526
SM
244 struct argpar_item_opt * const opt_item =
245 (struct argpar_item_opt *) item;
903a5b8a 246
d4539a90 247 free(opt_item->arg);
903a5b8a
SM
248 }
249
fc07e526 250 free((void *) item);
903a5b8a
SM
251
252end:
253 return;
254}
255
256static
1c9a6bde
SM
257struct argpar_item_opt *create_opt_item(
258 const struct argpar_opt_descr * const descr,
903a5b8a
SM
259 const char * const arg)
260{
1c9a6bde 261 struct argpar_item_opt *opt_item =
fb12ac67 262 ARGPAR_ZALLOC(struct argpar_item_opt);
903a5b8a
SM
263
264 if (!opt_item) {
265 goto end;
266 }
267
1c9a6bde 268 opt_item->base.type = ARGPAR_ITEM_TYPE_OPT;
903a5b8a
SM
269 opt_item->descr = descr;
270
271 if (arg) {
7ac57709 272 opt_item->arg = strdup(arg);
903a5b8a
SM
273 if (!opt_item->arg) {
274 goto error;
275 }
276 }
277
278 goto end;
279
280error:
fc07e526 281 argpar_item_destroy(&opt_item->base);
903a5b8a
SM
282 opt_item = NULL;
283
284end:
285 return opt_item;
286}
287
288static
1c9a6bde 289struct argpar_item_non_opt *create_non_opt_item(const char * const arg,
903a5b8a
SM
290 const unsigned int orig_index,
291 const unsigned int non_opt_index)
292{
1c9a6bde 293 struct argpar_item_non_opt * const non_opt_item =
fb12ac67 294 ARGPAR_ZALLOC(struct argpar_item_non_opt);
903a5b8a
SM
295
296 if (!non_opt_item) {
297 goto end;
298 }
299
1c9a6bde 300 non_opt_item->base.type = ARGPAR_ITEM_TYPE_NON_OPT;
903a5b8a
SM
301 non_opt_item->arg = arg;
302 non_opt_item->orig_index = orig_index;
303 non_opt_item->non_opt_index = non_opt_index;
304
305end:
306 return non_opt_item;
307}
308
309static
1c9a6bde
SM
310const struct argpar_opt_descr *find_descr(
311 const struct argpar_opt_descr * const descrs,
903a5b8a
SM
312 const char short_name, const char * const long_name)
313{
1c9a6bde 314 const struct argpar_opt_descr *descr;
903a5b8a
SM
315
316 for (descr = descrs; descr->short_name || descr->long_name; descr++) {
317 if (short_name && descr->short_name &&
318 short_name == descr->short_name) {
319 goto end;
320 }
321
322 if (long_name && descr->long_name &&
323 strcmp(long_name, descr->long_name) == 0) {
324 goto end;
325 }
326 }
327
328end:
329 return !descr->short_name && !descr->long_name ? NULL : descr;
330}
331
332enum parse_orig_arg_opt_ret {
333 PARSE_ORIG_ARG_OPT_RET_OK,
871eba32
PP
334 PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT = -1,
335 PARSE_ORIG_ARG_OPT_RET_ERROR_MISSING_OPT_ARG = -2,
871eba32
PP
336 PARSE_ORIG_ARG_OPT_RET_ERROR_UNEXPECTED_OPT_ARG = -4,
337 PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY = -5,
903a5b8a
SM
338};
339
340static
d7a82d7f
PP
341enum parse_orig_arg_opt_ret parse_short_opt_group(
342 const char * const short_opt_group,
903a5b8a 343 const char * const next_orig_arg,
1c9a6bde 344 const struct argpar_opt_descr * const descrs,
fc07e526
SM
345 struct argpar_iter * const iter,
346 char ** const error, struct argpar_item ** const item)
903a5b8a
SM
347{
348 enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK;
fc07e526
SM
349 bool used_next_orig_arg = false;
350 const char *opt_arg = NULL;
351 const struct argpar_opt_descr *descr;
352 struct argpar_item_opt *opt_item;
903a5b8a 353
d7a82d7f 354 ARGPAR_ASSERT(strlen(short_opt_group) != 0);
903a5b8a 355
d7a82d7f
PP
356 if (!iter->short_opt_group_ch) {
357 iter->short_opt_group_ch = short_opt_group;
fc07e526 358 }
903a5b8a 359
fc07e526 360 /* Find corresponding option descriptor */
d7a82d7f 361 descr = find_descr(descrs, *iter->short_opt_group_ch, NULL);
fc07e526 362 if (!descr) {
37bb2b1f 363 try_append_string_printf(error, "Unknown option `-%c`",
d7a82d7f 364 *iter->short_opt_group_ch);
871eba32 365 ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT;
fc07e526
SM
366 goto error;
367 }
903a5b8a 368
fc07e526 369 if (descr->with_arg) {
d7a82d7f 370 if (iter->short_opt_group_ch[1]) {
fc07e526 371 /* `-oarg` form */
d7a82d7f 372 opt_arg = &iter->short_opt_group_ch[1];
fc07e526
SM
373 } else {
374 /* `-o arg` form */
375 opt_arg = next_orig_arg;
376 used_next_orig_arg = true;
903a5b8a
SM
377 }
378
fc07e526
SM
379 /*
380 * We accept `-o ''` (empty option argument), but not
381 * `-o` alone if an option argument is expected.
382 */
d7a82d7f 383 if (!opt_arg || (iter->short_opt_group_ch[1] &&
fb12ac67 384 strlen(opt_arg) == 0)) {
37bb2b1f 385 try_append_string_printf(error,
fc07e526 386 "Missing required argument for option `-%c`",
d7a82d7f 387 *iter->short_opt_group_ch);
fc07e526 388 used_next_orig_arg = false;
871eba32 389 ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MISSING_OPT_ARG;
903a5b8a
SM
390 goto error;
391 }
fc07e526 392 }
903a5b8a 393
fc07e526
SM
394 /* Create and append option argument */
395 opt_item = create_opt_item(descr, opt_arg);
396 if (!opt_item) {
871eba32 397 ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY;
fc07e526
SM
398 goto error;
399 }
903a5b8a 400
fc07e526 401 *item = &opt_item->base;
d7a82d7f 402 iter->short_opt_group_ch++;
903a5b8a 403
d7a82d7f 404 if (descr->with_arg || !*iter->short_opt_group_ch) {
fc07e526 405 /* Option has an argument: no more options */
d7a82d7f 406 iter->short_opt_group_ch = NULL;
fc07e526
SM
407
408 if (used_next_orig_arg) {
409 iter->i += 2;
410 } else {
411 iter->i++;
412 }
903a5b8a
SM
413 }
414
415 goto end;
416
417error:
871eba32 418 ARGPAR_ASSERT(ret != PARSE_ORIG_ARG_OPT_RET_OK);
903a5b8a
SM
419
420end:
421 return ret;
422}
423
424static
425enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg,
426 const char * const next_orig_arg,
1c9a6bde 427 const struct argpar_opt_descr * const descrs,
fc07e526
SM
428 struct argpar_iter * const iter,
429 char ** const error, struct argpar_item ** const item)
903a5b8a 430{
903a5b8a 431 enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK;
1c9a6bde
SM
432 const struct argpar_opt_descr *descr;
433 struct argpar_item_opt *opt_item;
fc07e526 434 bool used_next_orig_arg = false;
903a5b8a
SM
435
436 /* Option's argument, if any */
437 const char *opt_arg = NULL;
438
439 /* Position of first `=`, if any */
440 const char *eq_pos;
441
903a5b8a
SM
442 /* Option name */
443 const char *long_opt_name = long_opt_arg;
444
dd757a65 445 ARGPAR_ASSERT(strlen(long_opt_arg) != 0);
903a5b8a
SM
446
447 /* Find the first `=` in original argument */
448 eq_pos = strchr(long_opt_arg, '=');
449 if (eq_pos) {
450 const size_t long_opt_name_size = eq_pos - long_opt_arg;
451
452 /* Isolate the option name */
d1f7bbdb
PP
453 while (long_opt_name_size > iter->tmp_buf.size - 1) {
454 iter->tmp_buf.size *= 2;
455 iter->tmp_buf.data = ARGPAR_REALLOC(iter->tmp_buf.data,
456 char, iter->tmp_buf.size);
457 if (!iter->tmp_buf.data) {
458 ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY;
459 goto error;
460 }
903a5b8a
SM
461 }
462
d1f7bbdb
PP
463 memcpy(iter->tmp_buf.data, long_opt_arg, long_opt_name_size);
464 iter->tmp_buf.data[long_opt_name_size] = '\0';
465 long_opt_name = iter->tmp_buf.data;
903a5b8a
SM
466 }
467
468 /* Find corresponding option descriptor */
469 descr = find_descr(descrs, '\0', long_opt_name);
470 if (!descr) {
37bb2b1f 471 try_append_string_printf(error, "Unknown option `--%s`",
fb12ac67 472 long_opt_name);
903a5b8a
SM
473 ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT;
474 goto error;
475 }
476
477 /* Find option's argument if any */
478 if (descr->with_arg) {
479 if (eq_pos) {
480 /* `--long-opt=arg` style */
481 opt_arg = eq_pos + 1;
482 } else {
483 /* `--long-opt arg` style */
484 if (!next_orig_arg) {
37bb2b1f 485 try_append_string_printf(error,
903a5b8a
SM
486 "Missing required argument for option `--%s`",
487 long_opt_name);
871eba32 488 ret = PARSE_ORIG_ARG_OPT_RET_ERROR_MISSING_OPT_ARG;
903a5b8a
SM
489 goto error;
490 }
491
492 opt_arg = next_orig_arg;
fc07e526 493 used_next_orig_arg = true;
903a5b8a 494 }
430fe886
SM
495 } else if (eq_pos) {
496 /*
497 * Unexpected `--opt=arg` style for a long option which
498 * doesn't accept an argument.
499 */
37bb2b1f 500 try_append_string_printf(error,
fc07e526 501 "Unexpected argument for option `--%s`", long_opt_name);
871eba32 502 ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNEXPECTED_OPT_ARG;
430fe886 503 goto error;
903a5b8a
SM
504 }
505
506 /* Create and append option argument */
507 opt_item = create_opt_item(descr, opt_arg);
508 if (!opt_item) {
509 goto error;
510 }
511
fc07e526
SM
512 if (used_next_orig_arg) {
513 iter->i += 2;
514 } else {
515 iter->i++;
7ac57709
SM
516 }
517
fc07e526 518 *item = &opt_item->base;
903a5b8a
SM
519 goto end;
520
521error:
871eba32 522 ARGPAR_ASSERT(ret != PARSE_ORIG_ARG_OPT_RET_OK);
903a5b8a
SM
523
524end:
525 return ret;
526}
527
528static
529enum parse_orig_arg_opt_ret parse_orig_arg_opt(const char * const orig_arg,
530 const char * const next_orig_arg,
1c9a6bde 531 const struct argpar_opt_descr * const descrs,
fb12ac67 532 struct argpar_iter * const iter, char ** const error,
fc07e526 533 struct argpar_item ** const item)
903a5b8a
SM
534{
535 enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK;
536
7ac57709 537 ARGPAR_ASSERT(orig_arg[0] == '-');
903a5b8a
SM
538
539 if (orig_arg[1] == '-') {
540 /* Long option */
541 ret = parse_long_opt(&orig_arg[2],
fc07e526 542 next_orig_arg, descrs, iter, error, item);
903a5b8a
SM
543 } else {
544 /* Short option */
d7a82d7f 545 ret = parse_short_opt_group(&orig_arg[1],
fc07e526 546 next_orig_arg, descrs, iter, error, item);
903a5b8a
SM
547 }
548
549 return ret;
550}
551
552static
37bb2b1f 553bool try_prepend_while_parsing_arg_to_error(char ** const error,
903a5b8a
SM
554 const unsigned int i, const char * const arg)
555{
7ac57709
SM
556 char *new_error;
557 bool success;
903a5b8a 558
37bb2b1f
PP
559 if (!error) {
560 success = true;
561 goto end;
562 }
563
7ac57709 564 ARGPAR_ASSERT(*error);
7ac57709
SM
565 new_error = argpar_asprintf("While parsing argument #%u (`%s`): %s",
566 i + 1, arg, *error);
567 if (!new_error) {
568 success = false;
903a5b8a
SM
569 goto end;
570 }
571
7ac57709
SM
572 free(*error);
573 *error = new_error;
574 success = true;
903a5b8a
SM
575
576end:
7ac57709 577 return success;
903a5b8a
SM
578}
579
7ac57709 580ARGPAR_HIDDEN
fc07e526
SM
581struct argpar_iter *argpar_iter_create(const unsigned int argc,
582 const char * const * const argv,
583 const struct argpar_opt_descr * const descrs)
903a5b8a 584{
d1f7bbdb 585 struct argpar_iter *iter = ARGPAR_ZALLOC(struct argpar_iter);
903a5b8a 586
fc07e526
SM
587 if (!iter) {
588 goto end;
903a5b8a
SM
589 }
590
fc07e526
SM
591 iter->argc = argc;
592 iter->argv = argv;
593 iter->descrs = descrs;
d1f7bbdb
PP
594 iter->tmp_buf.size = 128;
595 iter->tmp_buf.data = ARGPAR_CALLOC(char, iter->tmp_buf.size);
596 if (!iter->tmp_buf.data) {
597 argpar_iter_destroy(iter);
598 iter = NULL;
599 goto end;
600 }
903a5b8a 601
fc07e526
SM
602end:
603 return iter;
604}
903a5b8a 605
fc07e526
SM
606ARGPAR_HIDDEN
607void argpar_iter_destroy(struct argpar_iter * const iter)
608{
d1f7bbdb
PP
609 if (iter) {
610 free(iter->tmp_buf.data);
611 free(iter);
612 }
fc07e526 613}
903a5b8a 614
fc07e526 615ARGPAR_HIDDEN
2af370d0 616enum argpar_iter_next_status argpar_iter_next(
fc07e526 617 struct argpar_iter * const iter,
fb12ac67 618 const struct argpar_item ** const item, char ** const error)
fc07e526 619{
2af370d0 620 enum argpar_iter_next_status status;
fc07e526
SM
621 enum parse_orig_arg_opt_ret parse_orig_arg_opt_ret;
622 const char *orig_arg;
623 const char *next_orig_arg;
7ac57709 624
fc07e526 625 ARGPAR_ASSERT(iter->i <= iter->argc);
37bb2b1f
PP
626
627 if (error) {
628 *error = NULL;
629 }
fc07e526
SM
630
631 if (iter->i == iter->argc) {
2af370d0 632 status = ARGPAR_ITER_NEXT_STATUS_END;
fc07e526
SM
633 goto end;
634 }
7ac57709 635
fc07e526
SM
636 orig_arg = iter->argv[iter->i];
637 next_orig_arg =
638 iter->i < (iter->argc - 1) ? iter->argv[iter->i + 1] : NULL;
639
dd757a65
PP
640 if (strcmp(orig_arg, "-") == 0 || strcmp(orig_arg, "--") == 0 ||
641 orig_arg[0] != '-') {
fc07e526 642 /* Non-option argument */
dd757a65 643 const struct argpar_item_non_opt * const non_opt_item =
fc07e526
SM
644 create_non_opt_item(orig_arg, iter->i,
645 iter->non_opt_index);
646
647 if (!non_opt_item) {
2af370d0 648 status = ARGPAR_ITER_NEXT_STATUS_ERROR_MEMORY;
fc07e526 649 goto end;
903a5b8a
SM
650 }
651
fc07e526
SM
652 iter->non_opt_index++;
653 iter->i++;
654 *item = &non_opt_item->base;
2af370d0 655 status = ARGPAR_ITER_NEXT_STATUS_OK;
fc07e526
SM
656 goto end;
657 }
903a5b8a 658
fc07e526
SM
659 /* Option argument */
660 parse_orig_arg_opt_ret = parse_orig_arg_opt(orig_arg,
661 next_orig_arg, iter->descrs, iter, error,
662 (struct argpar_item **) item);
663 switch (parse_orig_arg_opt_ret) {
664 case PARSE_ORIG_ARG_OPT_RET_OK:
2af370d0 665 status = ARGPAR_ITER_NEXT_STATUS_OK;
fc07e526
SM
666 break;
667 case PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT:
871eba32 668 case PARSE_ORIG_ARG_OPT_RET_ERROR_MISSING_OPT_ARG:
871eba32 669 case PARSE_ORIG_ARG_OPT_RET_ERROR_UNEXPECTED_OPT_ARG:
37bb2b1f
PP
670 try_prepend_while_parsing_arg_to_error(error, iter->i,
671 orig_arg);
d4d05805
PP
672
673 switch (parse_orig_arg_opt_ret) {
674 case PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT:
2af370d0 675 status = ARGPAR_ITER_NEXT_STATUS_ERROR_UNKNOWN_OPT;
d4d05805
PP
676 break;
677 case PARSE_ORIG_ARG_OPT_RET_ERROR_MISSING_OPT_ARG:
2af370d0 678 status = ARGPAR_ITER_NEXT_STATUS_ERROR_MISSING_OPT_ARG;
d4d05805 679 break;
d4d05805 680 case PARSE_ORIG_ARG_OPT_RET_ERROR_UNEXPECTED_OPT_ARG:
2af370d0 681 status = ARGPAR_ITER_NEXT_STATUS_ERROR_UNEXPECTED_OPT_ARG;
d4d05805
PP
682 break;
683 default:
684 abort();
685 }
686
687 break;
688 case PARSE_ORIG_ARG_OPT_RET_ERROR_MEMORY:
2af370d0 689 status = ARGPAR_ITER_NEXT_STATUS_ERROR_MEMORY;
fc07e526
SM
690 break;
691 default:
692 abort();
693 }
694
695end:
696 return status;
697}
698
699ARGPAR_HIDDEN
f3ab5ca1 700unsigned int argpar_iter_ingested_orig_args(
fc07e526
SM
701 const struct argpar_iter * const iter)
702{
703 return iter->i;
704}
This page took 0.08905 seconds and 4 git commands to generate.