SoW-2020-0002: Trace Hit Counters: trigger error reporting integration
[lttng-tools.git] / src / common / argpar / argpar.c
1 /*
2 * Copyright 2019 Philippe Proulx <pproulx@efficios.com>
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20 * SOFTWARE.
21 */
22
23 #include <assert.h>
24 #include <stdarg.h>
25 #include <stdbool.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29
30 #include "argpar.h"
31
32 #define argpar_realloc(_ptr, _type, _nmemb) ((_type *) realloc(_ptr, (_nmemb) * sizeof(_type)))
33 #define argpar_calloc(_type, _nmemb) ((_type *) calloc((_nmemb), sizeof(_type)))
34 #define argpar_zalloc(_type) argpar_calloc(_type, 1)
35
36 #define ARGPAR_ASSERT(_cond) assert(_cond)
37
38 /*
39 * Structure holding the argpar state between successive argpar_state_parse_next
40 * calls.
41 *
42 * Created with `argpar_state_create` and destroyed with `argpar_state_destroy`.
43 */
44 struct argpar_state {
45 /*
46 * Data provided by the user in argpar_state_create, does not change
47 * afterwards.
48 */
49 unsigned int argc;
50 const char * const *argv;
51 const struct argpar_opt_descr *descrs;
52
53 /*
54 * Index of the argument to process in the next argpar_state_parse_next
55 * call.
56 */
57 unsigned int i;
58
59 /* Counter of non-option arguments. */
60 int non_opt_index;
61
62 /*
63 * Short option state: if set, we are in the middle of a short option
64 * group, so we should resume there at the next argpar_state_parse_next
65 * call.
66 */
67 const char *short_opt_ch;
68 };
69
70 static
71 char *argpar_vasprintf(const char *fmt, va_list args)
72 {
73 int len1, len2;
74 char *str;
75 va_list args2;
76
77 va_copy(args2, args);
78
79 len1 = vsnprintf(NULL, 0, fmt, args);
80 if (len1 < 0) {
81 str = NULL;
82 goto end;
83 }
84
85 str = malloc(len1 + 1);
86 if (!str) {
87 goto end;
88 }
89
90 len2 = vsnprintf(str, len1 + 1, fmt, args2);
91
92 ARGPAR_ASSERT(len1 == len2);
93
94 end:
95 va_end(args2);
96 return str;
97 }
98
99
100 static
101 char *argpar_asprintf(const char *fmt, ...)
102 {
103 va_list args;
104 char *str;
105
106 va_start(args, fmt);
107 str = argpar_vasprintf(fmt, args);
108 va_end(args);
109
110 return str;
111 }
112
113 static
114 bool argpar_string_append_printf(char **str, const char *fmt, ...)
115 {
116 char *new_str = NULL;
117 char *addendum;
118 bool success;
119 va_list args;
120
121 ARGPAR_ASSERT(str);
122
123 va_start(args, fmt);
124 addendum = argpar_vasprintf(fmt, args);
125 va_end(args);
126
127 if (!addendum) {
128 success = false;
129 goto end;
130 }
131
132 new_str = argpar_asprintf("%s%s", *str ? *str : "", addendum);
133 if (!new_str) {
134 success = false;
135 goto end;
136 }
137
138 free(*str);
139 *str = new_str;
140
141 success = true;
142
143 end:
144 free(addendum);
145
146 return success;
147 }
148
149 ARGPAR_HIDDEN
150 void argpar_item_destroy(struct argpar_item *item)
151 {
152 if (!item) {
153 goto end;
154 }
155
156 if (item->type == ARGPAR_ITEM_TYPE_OPT) {
157 struct argpar_item_opt * const opt_item = (void *) item;
158
159 free((void *) opt_item->arg);
160 }
161
162 free(item);
163
164 end:
165 return;
166 }
167
168 static
169 bool push_item(struct argpar_item_array * const array,
170 struct argpar_item * const item)
171 {
172 bool success;
173
174 ARGPAR_ASSERT(array);
175 ARGPAR_ASSERT(item);
176
177 if (array->n_items == array->n_alloc) {
178 unsigned int new_n_alloc = array->n_alloc * 2;
179 struct argpar_item **new_items;
180
181 new_items = argpar_realloc(array->items,
182 struct argpar_item *, new_n_alloc);
183 if (!new_items) {
184 success = false;
185 goto end;
186 }
187
188 array->n_alloc = new_n_alloc;
189 array->items = new_items;
190 }
191
192 array->items[array->n_items] = item;
193 array->n_items++;
194
195 success = true;
196
197 end:
198 return success;
199 }
200
201 static
202 void destroy_item_array(struct argpar_item_array * const array)
203 {
204 if (array) {
205 unsigned int i;
206
207 for (i = 0; i < array->n_items; i++) {
208 argpar_item_destroy(array->items[i]);
209 }
210
211 free(array->items);
212 free(array);
213 }
214 }
215
216 static
217 struct argpar_item_array *new_item_array(void)
218 {
219 struct argpar_item_array *ret;
220 const int initial_size = 10;
221
222 ret = argpar_zalloc(struct argpar_item_array);
223 if (!ret) {
224 goto end;
225 }
226
227 ret->items = argpar_calloc(struct argpar_item *, initial_size);
228 if (!ret->items) {
229 goto error;
230 }
231
232 ret->n_alloc = initial_size;
233
234 goto end;
235
236 error:
237 destroy_item_array(ret);
238 ret = NULL;
239
240 end:
241 return ret;
242 }
243
244 static
245 struct argpar_item_opt *create_opt_item(
246 const struct argpar_opt_descr * const descr,
247 const char * const arg)
248 {
249 struct argpar_item_opt *opt_item =
250 argpar_zalloc(struct argpar_item_opt);
251
252 if (!opt_item) {
253 goto end;
254 }
255
256 opt_item->base.type = ARGPAR_ITEM_TYPE_OPT;
257 opt_item->descr = descr;
258
259 if (arg) {
260 opt_item->arg = strdup(arg);
261 if (!opt_item->arg) {
262 goto error;
263 }
264 }
265
266 goto end;
267
268 error:
269 argpar_item_destroy(&opt_item->base);
270 opt_item = NULL;
271
272 end:
273 return opt_item;
274 }
275
276 static
277 struct argpar_item_non_opt *create_non_opt_item(const char * const arg,
278 const unsigned int orig_index,
279 const unsigned int non_opt_index)
280 {
281 struct argpar_item_non_opt * const non_opt_item =
282 argpar_zalloc(struct argpar_item_non_opt);
283
284 if (!non_opt_item) {
285 goto end;
286 }
287
288 non_opt_item->base.type = ARGPAR_ITEM_TYPE_NON_OPT;
289 non_opt_item->arg = arg;
290 non_opt_item->orig_index = orig_index;
291 non_opt_item->non_opt_index = non_opt_index;
292
293 end:
294 return non_opt_item;
295 }
296
297 static
298 const struct argpar_opt_descr *find_descr(
299 const struct argpar_opt_descr * const descrs,
300 const char short_name, const char * const long_name)
301 {
302 const struct argpar_opt_descr *descr;
303
304 for (descr = descrs; descr->short_name || descr->long_name; descr++) {
305 if (short_name && descr->short_name &&
306 short_name == descr->short_name) {
307 goto end;
308 }
309
310 if (long_name && descr->long_name &&
311 strcmp(long_name, descr->long_name) == 0) {
312 goto end;
313 }
314 }
315
316 end:
317 return !descr->short_name && !descr->long_name ? NULL : descr;
318 }
319
320 enum parse_orig_arg_opt_ret {
321 PARSE_ORIG_ARG_OPT_RET_OK,
322 PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT = -2,
323 PARSE_ORIG_ARG_OPT_RET_ERROR = -1,
324 };
325
326 static
327 enum parse_orig_arg_opt_ret parse_short_opts(const char * const short_opts,
328 const char * const next_orig_arg,
329 const struct argpar_opt_descr * const descrs,
330 struct argpar_state *state,
331 char **error,
332 struct argpar_item **item)
333 {
334 enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK;
335 bool used_next_orig_arg = false;
336
337 if (strlen(short_opts) == 0) {
338 argpar_string_append_printf(error, "Invalid argument");
339 goto error;
340 }
341
342 if (!state->short_opt_ch) {
343 state->short_opt_ch = short_opts;
344 }
345
346 const char *opt_arg = NULL;
347 const struct argpar_opt_descr *descr;
348 struct argpar_item_opt *opt_item;
349
350 /* Find corresponding option descriptor */
351 descr = find_descr(descrs, *state->short_opt_ch, NULL);
352 if (!descr) {
353 ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT;
354 argpar_string_append_printf(error,
355 "Unknown option `-%c`", *state->short_opt_ch);
356 goto error;
357 }
358
359 if (descr->with_arg) {
360 if (state->short_opt_ch[1]) {
361 /* `-oarg` form */
362 opt_arg = &state->short_opt_ch[1];
363 } else {
364 /* `-o arg` form */
365 opt_arg = next_orig_arg;
366 used_next_orig_arg = true;
367 }
368
369 /*
370 * We accept `-o ''` (empty option's argument),
371 * but not `-o` alone if an option's argument is
372 * expected.
373 */
374 if (!opt_arg || (state->short_opt_ch[1] && strlen(opt_arg) == 0)) {
375 argpar_string_append_printf(error,
376 "Missing required argument for option `-%c`",
377 *state->short_opt_ch);
378 used_next_orig_arg = false;
379 goto error;
380 }
381 }
382
383 /* Create and append option argument */
384 opt_item = create_opt_item(descr, opt_arg);
385 if (!opt_item) {
386 goto error;
387 }
388
389 *item = &opt_item->base;
390
391 state->short_opt_ch++;
392
393 if (descr->with_arg || !*state->short_opt_ch) {
394 /* Option has an argument: no more options */
395 state->short_opt_ch = NULL;
396
397 if (used_next_orig_arg) {
398 state->i += 2;
399 } else {
400 state->i += 1;
401 }
402 }
403
404 goto end;
405
406 error:
407 if (ret == PARSE_ORIG_ARG_OPT_RET_OK) {
408 ret = PARSE_ORIG_ARG_OPT_RET_ERROR;
409 }
410
411 end:
412 return ret;
413 }
414
415 static
416 enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg,
417 const char * const next_orig_arg,
418 const struct argpar_opt_descr * const descrs,
419 struct argpar_state *state,
420 char **error,
421 struct argpar_item **item)
422 {
423 const size_t max_len = 127;
424 enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK;
425 const struct argpar_opt_descr *descr;
426 struct argpar_item_opt *opt_item;
427 bool used_next_orig_arg = false;
428
429 /* Option's argument, if any */
430 const char *opt_arg = NULL;
431
432 /* Position of first `=`, if any */
433 const char *eq_pos;
434
435 /* Buffer holding option name when `long_opt_arg` contains `=` */
436 char buf[max_len + 1];
437
438 /* Option name */
439 const char *long_opt_name = long_opt_arg;
440
441 if (strlen(long_opt_arg) == 0) {
442 argpar_string_append_printf(error,
443 "Invalid argument");
444 goto error;
445 }
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 */
453 if (long_opt_name_size > max_len) {
454 argpar_string_append_printf(error,
455 "Invalid argument `--%s`", long_opt_arg);
456 goto error;
457 }
458
459 memcpy(buf, long_opt_arg, long_opt_name_size);
460 buf[long_opt_name_size] = '\0';
461 long_opt_name = buf;
462 }
463
464 /* Find corresponding option descriptor */
465 descr = find_descr(descrs, '\0', long_opt_name);
466 if (!descr) {
467 argpar_string_append_printf(error,
468 "Unknown option `--%s`", long_opt_name);
469 ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT;
470 goto error;
471 }
472
473 /* Find option's argument if any */
474 if (descr->with_arg) {
475 if (eq_pos) {
476 /* `--long-opt=arg` style */
477 opt_arg = eq_pos + 1;
478 } else {
479 /* `--long-opt arg` style */
480 if (!next_orig_arg) {
481 argpar_string_append_printf(error,
482 "Missing required argument for option `--%s`",
483 long_opt_name);
484 goto error;
485 }
486
487 opt_arg = next_orig_arg;
488 used_next_orig_arg = true;
489 }
490 }
491
492 /* Create and append option argument */
493 opt_item = create_opt_item(descr, opt_arg);
494 if (!opt_item) {
495 goto error;
496 }
497
498 if (used_next_orig_arg) {
499 state->i += 2;
500 } else {
501 state->i += 1;
502 }
503
504 *item = &opt_item->base;
505 goto end;
506
507 error:
508 if (ret == PARSE_ORIG_ARG_OPT_RET_OK) {
509 ret = PARSE_ORIG_ARG_OPT_RET_ERROR;
510 }
511
512 end:
513 return ret;
514 }
515
516 static
517 enum parse_orig_arg_opt_ret parse_orig_arg_opt(const char * const orig_arg,
518 const char * const next_orig_arg,
519 const struct argpar_opt_descr * const descrs,
520 struct argpar_state *state,
521 char **error,
522 struct argpar_item **item)
523 {
524 enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK;
525
526 ARGPAR_ASSERT(orig_arg[0] == '-');
527
528 if (orig_arg[1] == '-') {
529 /* Long option */
530 ret = parse_long_opt(&orig_arg[2],
531 next_orig_arg, descrs, state, error, item);
532 } else {
533 /* Short option */
534 ret = parse_short_opts(&orig_arg[1],
535 next_orig_arg, descrs, state, error, item);
536 }
537
538 return ret;
539 }
540
541 static
542 bool prepend_while_parsing_arg_to_error(char **error,
543 const unsigned int i, const char * const arg)
544 {
545 char *new_error;
546 bool success;
547
548 ARGPAR_ASSERT(error);
549 ARGPAR_ASSERT(*error);
550
551 new_error = argpar_asprintf("While parsing argument #%u (`%s`): %s",
552 i + 1, arg, *error);
553 if (!new_error) {
554 success = false;
555 goto end;
556 }
557
558 free(*error);
559 *error = new_error;
560 success = true;
561
562 end:
563 return success;
564 }
565
566 ARGPAR_HIDDEN
567 struct argpar_state *argpar_state_create(
568 unsigned int argc,
569 const char * const *argv,
570 const struct argpar_opt_descr * const descrs)
571 {
572 struct argpar_state *state;
573
574 state = argpar_zalloc(struct argpar_state);
575 if (!state) {
576 goto end;
577 }
578
579 state->argc = argc;
580 state->argv = argv;
581 state->descrs = descrs;
582
583 end:
584 return state;
585 }
586
587 ARGPAR_HIDDEN
588 void argpar_state_destroy(struct argpar_state *state)
589 {
590 free(state);
591 }
592
593 ARGPAR_HIDDEN
594 enum argpar_state_parse_next_status argpar_state_parse_next(
595 struct argpar_state *state,
596 struct argpar_item **item,
597 char **error)
598 {
599 enum argpar_state_parse_next_status status;
600
601 ARGPAR_ASSERT(state->i <= state->argc);
602
603 *error = NULL;
604
605 if (state->i == state->argc) {
606 status = ARGPAR_STATE_PARSE_NEXT_STATUS_END;
607 goto end;
608 }
609
610 enum parse_orig_arg_opt_ret parse_orig_arg_opt_ret;
611 const char * const orig_arg = state->argv[state->i];
612 const char * const next_orig_arg =
613 state->i < (state->argc - 1) ? state->argv[state->i + 1] : NULL;
614
615 if (orig_arg[0] != '-') {
616 /* Non-option argument */
617 struct argpar_item_non_opt *non_opt_item =
618 create_non_opt_item(orig_arg, state->i, state->non_opt_index);
619
620 if (!non_opt_item) {
621 status = ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR;
622 goto end;
623 }
624
625 state->non_opt_index++;
626 state->i++;
627
628 *item = &non_opt_item->base;
629 status = ARGPAR_STATE_PARSE_NEXT_STATUS_OK;
630 goto end;
631 }
632
633 /* Option argument */
634 parse_orig_arg_opt_ret = parse_orig_arg_opt(orig_arg,
635 next_orig_arg, state->descrs, state, error, item);
636 switch (parse_orig_arg_opt_ret) {
637 case PARSE_ORIG_ARG_OPT_RET_OK:
638 status = ARGPAR_STATE_PARSE_NEXT_STATUS_OK;
639 break;
640 case PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT:
641 status = ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT;
642 break;;
643 case PARSE_ORIG_ARG_OPT_RET_ERROR:
644 prepend_while_parsing_arg_to_error(
645 error, state->i, orig_arg);
646 status = ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR;
647 break;
648 default:
649 abort();
650 }
651
652 end:
653 return status;
654 }
655
656 ARGPAR_HIDDEN
657 int argpar_state_get_ingested_orig_args(struct argpar_state *state)
658 {
659 return state->i;
660 }
661
662 ARGPAR_HIDDEN
663 struct argpar_parse_ret argpar_parse(unsigned int argc,
664 const char * const *argv,
665 const struct argpar_opt_descr * const descrs,
666 bool fail_on_unknown_opt)
667 {
668 struct argpar_parse_ret parse_ret = { 0 };
669 struct argpar_item *item = NULL;
670 struct argpar_state *state = NULL;
671
672 parse_ret.items = new_item_array();
673 if (!parse_ret.items) {
674 parse_ret.error = strdup("Failed to create items array.");
675 ARGPAR_ASSERT(parse_ret.error);
676 goto error;
677 }
678
679 state = argpar_state_create(argc, argv, descrs);
680 if (!state) {
681 parse_ret.error = strdup("Failed to create argpar state.");
682 ARGPAR_ASSERT(parse_ret.error);
683 goto error;
684 }
685
686 while (true) {
687 enum argpar_state_parse_next_status status;
688
689 status = argpar_state_parse_next(state, &item, &parse_ret.error);
690 if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR) {
691 goto error;
692 } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_END) {
693 break;
694 } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) {
695 if (fail_on_unknown_opt) {
696 parse_ret.ingested_orig_args =
697 argpar_state_get_ingested_orig_args(state);
698 prepend_while_parsing_arg_to_error(
699 &parse_ret.error, parse_ret.ingested_orig_args,
700 argv[parse_ret.ingested_orig_args]);
701 status = ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR;
702 goto error;
703 }
704
705 free(parse_ret.error);
706 parse_ret.error = NULL;
707 break;
708 }
709
710 ARGPAR_ASSERT(status == ARGPAR_STATE_PARSE_NEXT_STATUS_OK);
711
712 if (!push_item(parse_ret.items, item)) {
713 goto error;
714 }
715 item = NULL;
716 }
717
718 ARGPAR_ASSERT(!parse_ret.error);
719 parse_ret.ingested_orig_args =
720 argpar_state_get_ingested_orig_args(state);
721 goto end;
722
723 error:
724 ARGPAR_ASSERT(parse_ret.error);
725
726 /* That's how we indicate that an error occured */
727 destroy_item_array(parse_ret.items);
728 parse_ret.items = NULL;
729
730 end:
731 argpar_state_destroy(state);
732 argpar_item_destroy(item);
733 return parse_ret;
734 }
735
736 ARGPAR_HIDDEN
737 void argpar_parse_ret_fini(struct argpar_parse_ret *ret)
738 {
739 ARGPAR_ASSERT(ret);
740
741 destroy_item_array(ret->items);
742 ret->items = NULL;
743
744 free(ret->error);
745 ret->error = NULL;
746 }
This page took 0.072909 seconds and 5 git commands to generate.