version-gen.sh: Make it work in conflicted state.
[lopsub.git] / lopsub.c
1 /*
2  * Copyright (C) 2016 Andre Noll <maan@tuebingen.mpg.de>
3  *
4  * Licensed under the LGPL v3, see http://www.gnu.org/licenses/lgpl-3.0.html
5  */
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include <stdbool.h>
10 #include <assert.h>
11 #include <stdarg.h>
12 #include <inttypes.h>
13 #include <errno.h>
14 #include <limits.h>
15
16 #include "lopsub-internal.h"
17 #include "lopsub.h"
18
19 /* For detecting version mismatches, see lopsub-internal.h. */
20 const unsigned LLS_ABI_VERSION_VAR = 0;
21
22 #define FOR_EACH_OPTION(_i, _opts) \
23         for (_i = 0; (_opts) && (_opts)[(_i)].name; (_i)++)
24
25 #define FOR_EACH_OPTION_IN_COMMAND(_opt, _cmd) \
26         for ( \
27                 (_opt) = (_cmd)->options; \
28                 (_opt) && (_opt) < (_cmd)->options + (_cmd)->num_options; \
29                 (opt)++ \
30         )
31
32 /* The result of parsing one option and its arguments. */
33 struct lls_arg {
34         int idx; /* index into either argv[] or the lls_option array. */
35         const char *arg; /* NULL if option has no argument. */
36 };
37
38 /*
39  * This structure, and the exchange_args(), decode_option() and parse_option()
40  * functions below are inspired by the glibc implementation of getopt.c,
41  * Copyright (C) 1987-2015 Free Software Foundation, Inc.
42  */
43 struct lls_data {
44         const struct lls_option *opts;
45         int argc;
46         char *const *argv;
47
48         int optind; /* index into argv[] which we are parsing. */
49         const char *next_char;
50         /*
51          * These describe the part of argv[] that contains non-options that
52          * have been skipped. first_nonopt is the index in argv[] of the first
53          * of them, last_nonopt is the index after the last of them. Initially
54          * both indices are zero.
55          */
56         int first_nonopt;
57         int last_nonopt;
58 };
59
60 const struct lls_command *lls_cmd(unsigned cmd_num,
61                 const struct lls_suite *suite)
62 {
63         if (cmd_num > suite->num_subcommands)
64                 return NULL;
65         return suite->commands + cmd_num;
66 }
67
68 const char *lls_command_name(const struct lls_command *cmd)
69 {
70         return cmd->name;
71 }
72
73 const void *lls_user_data(const struct lls_command *cmd)
74 {
75         return cmd->user_data;
76 }
77
78 const struct lls_option *lls_opt(unsigned opt_num,
79                 const struct lls_command *cmd)
80 {
81         return cmd->options + opt_num;
82 }
83
84 const struct lls_opt_result *lls_opt_result(unsigned opt_num,
85                 const struct lls_parse_result *lpr)
86 {
87         return lpr->opt_result + opt_num;
88 }
89
90 unsigned lls_opt_given(const struct lls_opt_result *r)
91 {
92         return r->given;
93 }
94
95 const char *lls_enum_string_val(unsigned idx, const struct lls_option *opt)
96 {
97         return opt->values[idx].string_val;
98 }
99
100 const char *lls_string_val(unsigned idx, const struct lls_opt_result *r)
101 {
102         return r->value[idx].string_val;
103 }
104
105 int32_t lls_int32_val(unsigned idx, const struct lls_opt_result *r)
106 {
107         return r->value[idx].int32_val;
108 }
109
110 uint32_t lls_uint32_val(unsigned idx, const struct lls_opt_result *r)
111 {
112         return r->value[idx].uint32_val;
113 }
114
115 int64_t lls_int64_val(unsigned idx, const struct lls_opt_result *r)
116 {
117         return r->value[idx].int64_val;
118 }
119
120 uint64_t lls_uint64_val(unsigned idx, const struct lls_opt_result *r)
121 {
122         return r->value[idx].uint64_val;
123 }
124
125 unsigned lls_num_inputs(const struct lls_parse_result *lpr)
126 {
127         return lpr->num_inputs;
128 }
129
130 const char *lls_purpose(const struct lls_command *cmd)
131 {
132         return cmd->purpose;
133 }
134
135 const char *lls_input(unsigned input_num, const struct lls_parse_result *lpr)
136 {
137         return lpr->inputs[input_num];
138 }
139
140 const char *lls_strerror(int lss_errno)
141 {
142         #define LLS_ERROR(_n, _s) _s,
143         static const char * const error_string[] = {LLS_ERRORS NULL};
144         #undef LLS_ERROR
145         return error_string[lss_errno];
146 }
147
148 static int xrealloc(void *p, size_t size)
149 {
150         void **pp = p, *newp = realloc(*pp, size);
151
152         if (!newp)
153                 return -E_LLS_NOMEM;
154         *pp = newp;
155         return 0;
156 }
157
158 /* Print a formated message to a dynamically allocated string. */
159 __attribute__ ((format (printf, 2, 0)))
160 static int xvasprintf(char **result, const char *fmt, va_list ap)
161 {
162         int ret;
163         size_t size = 150;
164         va_list aq;
165
166         if (!result)
167                 return 0;
168         if (*result)
169                 free(*result);
170         *result = malloc(size + 1);
171         if (!*result)
172                 return -E_LLS_NOMEM;
173         va_copy(aq, ap);
174         ret = vsnprintf(*result, size, fmt, aq);
175         va_end(aq);
176         assert(ret >= 0);
177         if (ret < size) /* OK */
178                 return ret;
179         size = ret + 1;
180         ret = xrealloc(result, size);
181         if (ret < 0) {
182                 free(*result);
183                 *result = NULL;
184                 return ret;
185         }
186         va_copy(aq, ap);
187         ret = vsnprintf(*result, size, fmt, aq);
188         va_end(aq);
189         assert(ret >= 0 && ret < size);
190         return ret;
191 }
192
193 /* Print to a dynamically allocated string, variable number of arguments. */
194 __attribute__ ((format (printf, 2, 3)))
195 static int xasprintf(char **result, const char *fmt, ...)
196 {
197         va_list ap;
198         unsigned ret;
199
200         va_start(ap, fmt);
201         ret = xvasprintf(result, fmt, ap);
202         va_end(ap);
203         return ret;
204 }
205
206 static inline unsigned num_vals_in_parse_result(const struct lls_command *cmd,
207         int opt_num, const struct lls_parse_result *lpr)
208 {
209         const struct lls_option *opt = cmd->options + opt_num;
210         struct lls_opt_result *lor = lpr->opt_result + opt_num;
211
212         if (opt->arg_info == LLS_NO_ARGUMENT)
213                 return 0;
214         if (lor->given == 0)
215                 return 1; /* for the default value */
216         if (!(opt->flags & LLS_MULTIPLE))
217                 return 1;
218         return lor->given;
219 }
220
221 union atoi_result {
222         int32_t int32;
223         uint32_t uint32;
224         int64_t int64;
225         uint64_t uint64;
226 };
227
228 enum atoi_mode {ATOI_INT32, ATOI_UINT32, ATOI_INT64, ATOI_UINT64};
229
230 /*
231  * Convert a string to a 32 or 64 bit signed or unsigned integer value.
232  *
233  * For conversions to unsigned integers, negative values are considered valid
234  * input and are silently converted.
235  */
236 static int lls_atoi(const char *str, enum atoi_mode mode, union atoi_result *value)
237 {
238         char *endptr;
239         union atoi_result result;
240
241         memset(value, 0, sizeof(*value));
242         errno = 0; /* To distinguish success/failure after call */
243         /*
244          * We pass zero as the base to strtoll(3) and strtoull(3) to let the
245          * function recognize an optional base prefix like "0x".
246          */
247         if (mode == ATOI_UINT64) {
248                 unsigned long long tmp = strtoull(str, &endptr, 0);
249                 if (errno == ERANGE && tmp == ULLONG_MAX)
250                         return -E_LLS_OVERFLOW;
251                 result.uint64 = tmp;
252         } else { /* parse as signed 64 bit and check range */
253                 long long tmp = strtoll(str, &endptr, 0);
254                 if (errno == ERANGE && (tmp == LLONG_MAX || tmp == LLONG_MIN))
255                         return -E_LLS_OVERFLOW;
256                 switch (mode) {
257                 case ATOI_INT64: /* no additional range check necessary */
258                         result.int64 = tmp;
259                         break;
260                 case ATOI_INT32:
261                         if (tmp < INT_MIN || tmp > INT_MAX)
262                                 return -E_LLS_OVERFLOW;
263                         result.int32 = tmp;
264                         break;
265                 case ATOI_UINT32:
266                         if (tmp > UINT_MAX)
267                                 return -E_LLS_OVERFLOW;
268                         result.uint32 = tmp;
269                         break;
270                 default:
271                         assert(0);
272                 }
273         }
274         /*
275          * If there were no digits at all, strtol() and friends store the
276          * original value of str in *endptr.
277          */
278         if (endptr == str)
279                 return -E_LLS_NO_DIGITS;
280         /*
281          * The implementation may also set errno (and return 0) in case no
282          * conversion was performed.
283          */
284         if (errno != 0)
285                 return -E_LLS_NO_DIGITS;
286         if (*endptr != '\0') /* Further characters after number */
287                 return -E_LLS_TRAILING_GARBAGE;
288         *value = result;
289         return 1;
290 }
291
292 static int atoi32(const char *str, int32_t *result)
293 {
294         union atoi_result ar;
295         int ret = lls_atoi(str, ATOI_INT32, &ar);
296         *result = ar.int32;
297         return ret;
298 }
299
300 static int atou32(const char *str, uint32_t *result)
301 {
302         union atoi_result ar;
303         int ret = lls_atoi(str, ATOI_UINT32, &ar);
304         *result = ar.uint32;
305         return ret;
306 }
307
308 static int atoi64(const char *str, int64_t *result)
309 {
310         union atoi_result ar;
311         int ret = lls_atoi(str, ATOI_INT64, &ar);
312         *result = ar.int64;
313         return ret;
314 }
315
316 static int atou64(const char *str, uint64_t *result)
317 {
318         union atoi_result ar;
319         int ret = lls_atoi(str, ATOI_UINT64, &ar);
320         *result = ar.uint64;
321         return ret;
322 }
323
324 static void free_opt_result(int opt_num, struct lls_parse_result *lpr,
325                 const struct lls_command *cmd)
326 {
327         const struct lls_option *opt = cmd->options + opt_num;
328
329         if (opt->arg_type == LLS_STRING && !opt->values) {
330                 unsigned num_vals = num_vals_in_parse_result(cmd, opt_num, lpr);
331                 int j;
332                 for (j = 0; j < num_vals; j++)
333                         if (lpr->opt_result[opt_num].value)
334                                 free(lpr->opt_result[opt_num].value[j].string_val);
335         }
336         if (opt->arg_info != LLS_NO_ARGUMENT)
337                 free(lpr->opt_result[opt_num].value);
338 }
339
340 void lls_free_parse_result(struct lls_parse_result *lpr,
341                 const struct lls_command *cmd)
342 {
343         int i;
344
345         if (!lpr)
346                 return;
347         if (lpr->inputs)
348                 for (i = 0; i < lpr->num_inputs; i++)
349                         free(lpr->inputs[i]);
350         free(lpr->inputs);
351         if (lpr->opt_result)
352                 FOR_EACH_OPTION(i, cmd->options)
353                         free_opt_result(i, lpr, cmd);
354         free(lpr->opt_result);
355         free(lpr);
356 }
357
358 static struct lls_data *init_lls_data(const struct lls_option *opts,
359                 int argc, char *const *argv)
360 {
361         struct lls_data *d = malloc(sizeof(*d));
362
363         if (!d)
364                 return NULL;
365         d->optind = 0;
366         /* start with an empty non-option list */
367         d->first_nonopt = d->last_nonopt = d->optind;
368         d->opts = opts;
369         d->argc = argc;
370         d->argv = argv;
371         d->next_char = NULL;
372         return d;
373 }
374
375 /*
376  * Exchange two adjacent subsets of argv[].
377  *
378  * One subset is given by indices {first_nonopt, ..., last_nonopt - 1}. It
379  * contains all the non-options that have been skipped so far. The other subset
380  * corresponds to indices {last_nonopt, ... optind - 1} which contains all the
381  * options processed since those non-options were skipped.
382  *
383  * Before the function returns, ->first_nonopt and ->last_nonopt are updated to
384  * describe the new set of non-options in argv[].
385  */
386 static void exchange_args(struct lls_data *d)
387 {
388         int bottom = d->first_nonopt;
389         int middle = d->last_nonopt;
390         int top = d->optind;
391         char **argv = (char **)d->argv;
392
393         /*
394          * Exchange the shorter segment with the far end of the longer segment.
395          * That puts the shorter segment into the right place. It leaves the
396          * longer segment in the right place overall, but it consists of two
397          * parts that need to be swapped next.
398         */
399         while (top > middle && middle > bottom) {
400                 if (top - middle > middle - bottom) {
401                         /* Bottom segment is the short one.  */
402                         int i, len = middle - bottom;
403
404                         /* Swap it with the top part of the top segment. */
405                         for (i = 0; i < len; i++) {
406                                 char *tmp = argv[bottom + i];
407                                 argv[bottom + i] = argv[top - (middle - bottom) + i];
408                                 argv[top - (middle - bottom) + i] = tmp;
409                         }
410                         /* Exclude the moved bottom segment from further swapping. */
411                         top -= len;
412                 } else {
413                         /* Top segment is the short one.  */
414                         int i, len = top - middle;
415                         /* Swap it with the bottom part of the bottom segment. */
416                         for (i = 0; i < len; i++) {
417                                 char *tmp = argv[bottom + i];
418                                 argv[bottom + i] = argv[middle + i];
419                                 argv[middle + i] = tmp;
420                         }
421                         /* Exclude the moved top segment from further swapping. */
422                         bottom += len;
423                 }
424         }
425         /* Update records for the slots the non-options now occupy. */
426         d->first_nonopt += d->optind - d->last_nonopt;
427         d->last_nonopt = d->optind;
428 }
429
430 /* whether arg points to an option argument */
431 static inline bool is_option(const char *arg)
432 {
433         return arg[0] == '-' && arg[1] != '\0';
434 }
435
436 static void check_errctx(char **errctx, int ret)
437 {
438         if (!errctx)
439                 return;
440         if (ret >= 0)
441                 assert(!*errctx); /* memory leak/uninitialized pointer */
442         else if (ret != -E_LLS_NOMEM)
443                 assert(*errctx); /* we must provide an error message */
444 }
445
446 /*
447  * Decode the current option. On success, set result->idx to the index in the
448  * ->options array which was decoded successfully. On failure, result->idx is
449  * the index in argv[] which could not be parsed.
450  */
451 static int decode_option(struct lls_data *d, struct lls_arg *result,
452                 char **errctx)
453 {
454         const char *word = d->argv[d->optind], *cur, *end;
455         size_t len;
456         int i;
457         const struct lls_option *match = NULL;
458         bool ambig = false, shortopt;
459
460         assert(word[0] != '\0');
461         shortopt = word[1] != '-';
462         result->idx = d->optind;
463         result->arg = word;
464
465         if (d->next_char)
466                 cur = d->next_char;
467         else
468                 cur = word + 1 + !shortopt; /* skip dash(es) */
469         for (end = cur; *end && *end != '='; end++)
470                 ; /* nothing */
471         len = end - cur;
472
473         /* test all options for exact or abbreviated matches */
474         FOR_EACH_OPTION(i, d->opts) {
475                 const struct lls_option *opt = d->opts + i;
476                 if (opt->flags & LLS_IGNORED)
477                         continue;
478                 if (shortopt) {
479                         if (*cur != opt->short_opt)
480                                 continue;
481                         match = opt;
482                         d->next_char = cur + 1;
483                         if (d->next_char[0] == '\0' || d->next_char[0] == '=')
484                                 d->next_char = NULL;
485                         break;
486                 }
487                 if (strncmp(opt->name, cur, len) != 0)
488                         continue;
489                 if (strlen(opt->name) == len) { /* exact match */
490                         match = opt;
491                         break;
492                 }
493                 if (match) { /* second non-exact match */
494                         ambig = true;
495                         break;
496                 }
497                 /* first non-exact match */
498                 match = opt;
499         }
500         if (!match) { /* option not found */
501                 xasprintf(errctx, "error token: %s", cur);
502                 return -E_LLS_BAD_OPTION;
503         }
504         if (ambig) {
505                 xasprintf(errctx, "%s", word);
506                 return -E_LLS_AMBIG_OPTION;
507         }
508         if (d->next_char) {
509                 if (match->arg_info == LLS_REQUIRED_ARGUMENT) {
510                         xasprintf(errctx, "--%s", match->name);
511                         return -E_LLS_NO_ARG_GIVEN;
512                 }
513                 result->arg = NULL;
514                 goto success;
515         }
516         d->optind++;
517         if (*end == '=') {
518                 if (match->arg_info == LLS_NO_ARGUMENT) {
519                         xasprintf(errctx, "--%s", match->name);
520                         return -E_LLS_ARG_GIVEN;
521                 }
522                 result->arg = end + 1;
523         } else if (match->arg_info == LLS_REQUIRED_ARGUMENT) {
524                 if (d->optind >= d->argc) {
525                         xasprintf(errctx, "--%s", match->name);
526                         return -E_LLS_NO_ARG_GIVEN;
527                 }
528                 result->arg = d->argv[d->optind++];
529         } else
530                 result->arg = NULL;
531 success:
532         result->idx = match - d->opts;
533         return 1;
534 }
535
536 /*
537  * Parse one option, including its argument (if any).
538  *
539  * We permute the contents of ARGV as we scan, so that eventually all the
540  * non-options are at the end. This allows options to be given in any order.
541  *
542  * Returns zero on end-of-argv, negative on errors, one if an option was parsed
543  * successfully. The structure pointed to by result is initialized as follows:
544  *
545  * end-of-args case: ->idx is the index of first non-option in argv[], ->arg is
546  * argv[result->idx].
547  *
548  * error case: ->idx is the index of the first problematic option in argv. ->arg is
549  * argv[result->idx] as in the end-of-args case.
550  *
551  * success case: ->idx is the index into the option array which corresponds to
552  * the option that was parsed successfully, ->arg its argument, or NULL if no
553  * argument was given.
554  *
555  * After this function returned non-positive, it must not be called again.
556  */
557 static int parse_option(struct lls_data *d, struct lls_arg *result, char **errctx)
558 {
559         assert(d->last_nonopt <= d->optind);
560         assert(d->first_nonopt <= d->optind);
561
562         if (d->next_char)
563                 return decode_option(d, result, errctx);
564         /*
565          * If we have just processed some options following some non-options,
566          * exchange them so that the options come first.
567          */
568         if (d->first_nonopt != d->last_nonopt && d->last_nonopt != d->optind)
569                 exchange_args(d);
570         else if (d->last_nonopt != d->optind)
571                 d->first_nonopt = d->optind;
572         /*
573          * Skip any additional non-options and extend the range of non-options
574          * previously skipped.
575          */
576         while (d->optind < d->argc && !is_option(d->argv[d->optind]))
577                 d->optind++;
578         d->last_nonopt = d->optind;
579         /*
580          * The special argument `--' forces an end of option-scanning. We skip
581          * it like a null option, then exchange it with previous non-options as
582          * if it were an option. Then we skip everything else like a non-option.
583          */
584         if (d->optind != d->argc && !strcmp(d->argv[d->optind], "--")) {
585                 d->optind++;
586                 if (d->first_nonopt != d->last_nonopt && d->last_nonopt != d->optind)
587                         exchange_args(d);
588                 else if (d->first_nonopt == d->last_nonopt)
589                         d->first_nonopt = d->optind;
590                 d->last_nonopt = d->argc;
591                 d->optind = d->argc;
592         }
593         /*
594          * If we have done all the argv elements, stop the scan and back over
595          * any non-options that we skipped and permuted.
596          */
597         if (d->optind == d->argc) {
598                 /*
599                  * Set the index to point at the non-options that we
600                  * previously skipped.
601                  */
602                 result->idx = d->first_nonopt;
603                 result->arg = d->argv[result->idx];
604                 return 0;
605         }
606         assert(is_option(d->argv[d->optind]));
607         return decode_option(d, result, errctx);
608 }
609
610 static int check_enum_arg(const char *arg, const struct lls_option *opt,
611                 char **errctx)
612 {
613         int i;
614         char *val;
615
616         for (i = 0; (val = opt->values[i].string_val); i++)
617                 if (!strcmp(arg, val))
618                         return i;
619         xasprintf(errctx, "arg: %s, option: %s", arg, opt->name);
620         return -E_LLS_ENUM;
621 }
622
623 /*
624  * Increase the "given" count and store argument if the option takes one.
625  * Allocates or reallocates the ->value array of struct lls_opt_result in lpr.
626  */
627 static int lls_parse_arg(struct lls_arg *la, const struct lls_option *opts,
628                 struct lls_parse_result *lpr, char **errctx)
629 {
630         const struct lls_option *opt = opts + la->idx;
631         struct lls_opt_result *lor = lpr->opt_result + la->idx;
632         bool multiple;
633         int idx, ret;
634
635         if (!la->arg)
636                 goto success;
637         if (opt->arg_info == LLS_NO_ARGUMENT) {
638                 xasprintf(errctx, "arg: %s, option: %s", la->arg, opt->name);
639                 return -E_LLS_ARG_GIVEN;
640         }
641         multiple = opt->flags & LLS_MULTIPLE;
642         idx = multiple? lor->given : 0;
643         if (lor->given == 0 || multiple) {
644                 ret = xrealloc(&lor->value,
645                         (lor->given + 1) * sizeof(*lor->value));
646                 if (ret < 0) {
647                         xasprintf(errctx, "option value array for --%s",
648                                 opt->name);
649                         return ret;
650                 }
651         }
652         switch (opt->arg_type) {
653         case LLS_STRING:
654                 if (lor->given > 0 && !multiple)
655                         free(lor->value[idx].string_val);
656                 if (opt->values) {
657                         ret = check_enum_arg(la->arg, opt, errctx);
658                         if (ret < 0)
659                                 return ret;
660                         lor->value[idx].uint32_val = ret;
661                 } else {
662                         lor->value[idx].string_val = strdup(la->arg);
663                         if (!lor->value[idx].string_val) {
664                                 xasprintf(errctx, "string value for %s",
665                                         opt->name);
666                                 return -E_LLS_NOMEM;
667                         }
668                 }
669                 break;
670         case LLS_INT32:
671                 ret = atoi32(la->arg, &lor->value[idx].int32_val);
672                 if (ret < 0)
673                         goto atoi_error;
674                 break;
675         case LLS_UINT32:
676                 ret = atou32(la->arg, &lor->value[idx].uint32_val);
677                 if (ret < 0)
678                         goto atoi_error;
679                 break;
680         case LLS_INT64:
681                 ret = atoi64(la->arg, &lor->value[idx].int64_val);
682                 if (ret < 0)
683                         goto atoi_error;
684                 break;
685         case LLS_UINT64:
686                 ret = atou64(la->arg, &lor->value[idx].uint64_val);
687                 if (ret < 0)
688                         goto atoi_error;
689                 break;
690         default:
691                 assert(false);
692         }
693 success:
694         lor->given++;
695         return 1;
696 atoi_error:
697         assert(ret < 0);
698         xasprintf(errctx, "conversion error for argument \"%s\" to option --%s",
699                 la->arg, opt->name);
700         return ret;
701 }
702
703 static int copy_val(union lls_val *dst, const union lls_val *src,
704                 const struct lls_option *opt, char **errctx)
705 {
706         if (opt->arg_type != LLS_STRING || opt->values) {
707                 *dst = *src;
708                 return 0;
709         }
710         if (!src->string_val) {
711                 dst->string_val = NULL;
712                 return 0;
713         }
714         dst->string_val = strdup(src->string_val);
715         if (!dst->string_val) {
716                 xasprintf(errctx, "copy value for --%s", opt->name);
717                 return -E_LLS_NOMEM;
718         }
719         return 1;
720 }
721
722 int lls_check_arg_count(const struct lls_parse_result *lpr,
723                 int min_argc, int max_argc, char **errctx)
724 {
725         if (errctx)
726                 *errctx = NULL;
727         if (lpr->num_inputs < min_argc) {
728                 xasprintf(errctx, "at least %u non-option args required, "
729                         "%u given", min_argc, lpr->num_inputs);
730                 return -E_LLS_BAD_ARG_COUNT;
731         }
732         if (lpr->num_inputs > max_argc) {
733                 if (max_argc == 0)
734                         xasprintf(errctx, "no non-option args allowed, "
735                                 "%u given", lpr->num_inputs);
736                 else
737                         xasprintf(errctx, "at most %u non-option args allowed, "
738                                 "%u given", max_argc, lpr->num_inputs);
739                 return -E_LLS_BAD_ARG_COUNT;
740         }
741         return 1;
742 }
743
744 /*
745  * Unlike getopt(3) this implementation can not resume the scan where it left
746  * off.
747  */
748 int lls_parse(int argc, char **argv, const struct lls_command *cmd,
749                 struct lls_parse_result **lprp, char **errctx)
750 {
751         const struct lls_option *opts = cmd->options;
752         struct lls_data *d = NULL;
753         int i, ret;
754         struct lls_arg la;
755         struct lls_parse_result *lpr;
756
757         if (errctx)
758                 *errctx = NULL;
759         lpr = calloc(1, sizeof(*lpr));
760         if (!lpr) {
761                 xasprintf(errctx, "log parse result");
762                 ret = -E_LLS_NOMEM;
763                 goto out;
764         }
765         d = init_lls_data(opts, argc, argv);
766         if (!d) {
767                 xasprintf(errctx, "init_lls_data()");
768                 ret = -E_LLS_NOMEM;
769                 goto out;
770         }
771         if (cmd->num_options == 0) {
772                 la.idx = 0;
773                 lpr->opt_result = NULL;
774         } else {
775                 lpr->opt_result = calloc(cmd->num_options,
776                         sizeof(*lpr->opt_result));
777                 if (!lpr->opt_result) {
778                         xasprintf(errctx, "option result array for %s",
779                                 cmd->name);
780                         ret = -E_LLS_NOMEM;
781                         goto out;
782                 }
783                 for (;;) {
784                         ret = parse_option(d, &la, errctx);
785                         if (ret < 0)
786                                 goto out;
787                         if (ret == 0)
788                                 break;
789                         ret = lls_parse_arg(&la, opts, lpr, errctx);
790                         if (ret < 0)
791                                 goto out;
792                 }
793         }
794         lpr->num_inputs = argc - la.idx - 1;
795         if (!cmd->non_opts_name) {
796                 ret = lls_check_arg_count(lpr, 0, 0, errctx);
797                 if (ret < 0) {
798                         /* needed for lls_free_parse_result() */
799                         lpr->inputs = NULL;
800                         goto out;
801                 }
802         }
803         /* We always make a copy of the elements of argv[] */
804         lpr->inputs = malloc((lpr->num_inputs + 1) * sizeof(char *));
805         if (!lpr->inputs) {
806                 xasprintf(errctx, "inputs array for %s", cmd->name);
807                 ret = -E_LLS_NOMEM;
808                 goto out;
809         }
810         for (i = 0; i < lpr->num_inputs; i++) {
811                 char *arg = argv[i + la.idx + 1];
812                 lpr->inputs[i] = strdup(arg);
813                 if (lpr->inputs[i])
814                         continue;
815                 xasprintf(errctx, "option #%d (%s) of %s", i, arg, cmd->name);
816                 ret = -E_LLS_NOMEM;
817                 goto out;
818         }
819         lpr->inputs[lpr->num_inputs] = NULL;
820         /* initialize default values */
821         FOR_EACH_OPTION(i, opts) {
822                 const struct lls_option *opt = opts + i;
823                 struct lls_opt_result *lor = lpr->opt_result + i;
824                 bool required = opt->flags & LLS_REQUIRED;
825                 bool has_arg = opt->arg_info != LLS_NO_ARGUMENT;
826
827                 if (lor->given == 0 && required) {
828                         xasprintf(errctx, "--%s", opt->name);
829                         ret = -E_LLS_OPT_MANDATORY;
830                         goto out;
831                 }
832                 if (lor->value)
833                         continue;
834                 if (!has_arg)
835                         continue;
836                 /*
837                  * allocate space for the default value, even if there is no
838                  * default given in the .suite file
839                  */
840                 lor->value = malloc(sizeof(*lor->value));
841                 if (!lor->value) {
842                         xasprintf(errctx, "value array for --%s", opt->name);
843                         ret = -E_LLS_NOMEM;
844                         goto out;
845                 }
846                 ret = copy_val(lor->value, &opt->default_val, opt, errctx);
847                 if (ret < 0)
848                         goto out;
849         }
850         ret = 1;
851 out:
852         free(d);
853         check_errctx(errctx, ret);
854         if (ret < 0) {
855                 lls_free_parse_result(lpr, cmd);
856                 *lprp = NULL;
857         } else
858                 *lprp = lpr;
859         return ret;
860 }
861
862 #define MAX_OPTION_LEN 30
863 #define HELP_INDENT 6
864 static const char space[MAX_OPTION_LEN + 1] = "                              ";
865
866 static int short_option_help(const struct lls_option *opt, char **result)
867 {
868         int ret = 0;
869         char *opt_names = NULL;
870         bool overlong, has_short = opt->short_opt;
871         const char *typestr;
872
873         *result = NULL;
874         if (opt->flags & LLS_IGNORED)
875                 return xasprintf(result, "%s", opt->summary);
876         if (opt->arg_info == LLS_NO_ARGUMENT)
877                 typestr = "";
878         else
879                 typestr = opt->typestr? opt->typestr : "val";
880
881         ret = xasprintf(&opt_names,
882                 "%s%c%s"
883                 " --%s"
884                 "%s%s%s%s%s"
885                 ,
886                 has_short? "  -" : "   ",
887                 has_short? opt->short_opt : ' ',
888                 has_short? "," : " ",
889                 opt->name,
890                 opt->arg_info == LLS_OPTIONAL_ARGUMENT? "[" : "",
891                 opt->arg_info == LLS_NO_ARGUMENT? "" : "=<",
892                 typestr,
893                 opt->arg_info == LLS_NO_ARGUMENT? "" : ">",
894                 opt->arg_info == LLS_OPTIONAL_ARGUMENT? "]" : ""
895         );
896         if (ret < 0)
897                 return ret;
898         overlong = ret >= MAX_OPTION_LEN;
899         ret = xasprintf(result,
900                 "%s"
901                 "%s"
902                 "%s"
903                 "%s"
904                 ,
905                 opt_names,
906                 overlong? "\n" : "",
907                 overlong? space : space + ret,
908                 opt->summary? opt->summary : ""
909         );
910         free(opt_names);
911         return ret;
912 }
913
914 static int format_default_val(const struct lls_option *opt, char **result)
915 {
916         const union lls_val *val = &opt->default_val;
917
918         *result = NULL;
919         if (opt->arg_info == LLS_NO_ARGUMENT)
920                 return 0;
921         if (!(opt->flags & LLS_HAS_DEFAULT))
922                 return 0;
923         switch (opt->arg_type) {
924         case LLS_STRING:
925                 if (opt->values)
926                         return 0;
927                 return xasprintf(result, "(string, default: %s)",
928                         val->string_val? val->string_val : "[NULL]");
929         case LLS_INT32:
930                 return xasprintf(result, "(int32, default: %" PRId32 ")",
931                         val->int32_val);
932         case LLS_UINT32:
933                 return xasprintf(result, "(uint32, default: %" PRIu32 ")",
934                         val->uint32_val);
935         case LLS_INT64:
936                 return xasprintf(result, "(int64, default: %" PRId64 ")",
937                         val->int64_val);
938         case LLS_UINT64:
939                 return xasprintf(result, "(uint64, default: %" PRIu64 ")",
940                         val->uint64_val);
941         default:
942                 assert(0);
943         }
944         return 1;
945 }
946
947 static int format_values(const struct lls_option *opt, char **result)
948 {
949         int i;
950         uint32_t dflt_idx;
951         const char *val, *pfx = "values: ";
952         size_t len, line_len;
953         const int indent_len = 6, max_len = 75, pfx_len = 8;
954         char *p;
955
956         *result = NULL;
957         if (!opt->values)
958                 return 0;
959         assert(opt->arg_type == LLS_STRING);
960         dflt_idx = opt->default_val.uint32_val;
961         line_len = indent_len + pfx_len;
962         len = line_len;
963         for (i = 0; (val = opt->values[i].string_val); i++) {
964                 size_t val_len = strlen(val);
965                 /* comma and space, and [] around default val */
966                 int extra_len = 2 * (i != 0) + 2 * (i == dflt_idx);
967                 bool cr = line_len + val_len + extra_len > max_len;
968                 if (cr) {
969                         line_len = indent_len + pfx_len;
970                         len += 1 + indent_len + pfx_len; /* +1 for \n */
971                 }
972                 len += val_len + extra_len;
973                 line_len += val_len + extra_len;
974         }
975         *result = malloc(len + 1); /* +1 for terminating zero byte */
976         if (!*result)
977                 return -E_LLS_NOMEM;
978         p = *result + sprintf(*result, "%.*s%s", indent_len, space, pfx);
979         line_len = p - *result;
980         for (i = 0; (val = opt->values[i].string_val); i++) {
981                 size_t val_len = strlen(val);
982                 int extra_len = 2 * (i != 0) + 2 * (i == dflt_idx);
983                 bool cr = line_len + val_len + extra_len > max_len;
984                 p += sprintf(p,
985                         "%s"
986                         "%s"
987                         "%.*s"
988                         "%s%s%s",
989                         i == 0? "" : ", ",
990                         cr? "\n" : "",
991                         cr? pfx_len + indent_len : 0, cr? space : "",
992                         i == dflt_idx? "[" : "", val, i == dflt_idx? "]" : ""
993                 );
994                 if (cr)
995                         line_len = indent_len + pfx_len;
996                 line_len += val_len + extra_len;
997         }
998         return 1;
999 }
1000
1001 static char *create_help_buf(const struct lls_command *cmd, bool long_help)
1002 {
1003         char *header, *option_help, *result;
1004         const struct lls_option *opt;
1005         int ret;
1006         const char *desc = (long_help && cmd->description)?
1007                 cmd->description : "";
1008         const char *closing = (long_help && cmd->closing)? cmd->closing : NULL;
1009
1010         result = NULL;
1011         header = NULL;
1012         ret = xasprintf(&header,
1013                 "%s - %s\n\n"
1014                 "Usage: %s %s\n"
1015                 "%s%s"
1016         ,
1017                 cmd->name, cmd->purpose,
1018                 cmd->name, cmd->synopsis,
1019                 desc,
1020                 cmd->options? "\n" : ""
1021         );
1022         if (ret < 0)
1023                 return NULL;
1024         if (!cmd->options)
1025                 return header;
1026         option_help = NULL;
1027         FOR_EACH_OPTION_IN_COMMAND(opt, cmd) {
1028                 char *tmp, *soh, *loh = NULL, *dflt, *values;
1029                 int indent = (opt->flags & LLS_IGNORED)? 0 : HELP_INDENT;
1030
1031                 ret = short_option_help(opt, &soh);
1032                 if (ret < 0)
1033                         goto out;
1034                 if (long_help && opt->help) {
1035                         const char *p, *q;
1036                         for (p = opt->help; (q = strchr(p, '\n')); p = q + 1) {
1037                                 tmp = NULL;
1038                                 ret = xasprintf(&tmp, "%s%.*s%.*s",
1039                                         loh? loh : "\n", indent, space,
1040                                         (int)(q - p + 1), p);
1041                                 free(loh);
1042                                 if (ret < 0) {
1043                                         free(soh);
1044                                         goto out;
1045                                 }
1046                                 loh = tmp;
1047                         }
1048                 }
1049                 ret = format_default_val(opt, &dflt);
1050                 if (ret < 0) {
1051                         free(soh);
1052                         free(loh);
1053                         goto out;
1054                 }
1055                 if (long_help) {
1056                         ret = format_values(opt, &values);
1057                         if (ret < 0) {
1058                                 free(dflt);
1059                                 free(soh);
1060                                 free(loh);
1061                                 goto out;
1062                         }
1063                 } else
1064                         values = NULL;
1065                 tmp = NULL;
1066                 ret = xasprintf(&tmp,
1067                         "%s"
1068                         "%s"
1069                         "%s%s%s"
1070                         "%s%s"
1071                         "%s\n",
1072                         option_help? option_help : "",
1073                         soh ? soh : "",
1074                         dflt? "\n" : "", dflt? space : "", dflt? dflt : "",
1075                         values? "\n" : "", values? values : "",
1076                         loh? loh : ""
1077                 );
1078                 free(values);
1079                 free(dflt);
1080                 free(soh);
1081                 free(loh);
1082                 if (ret < 0)
1083                         goto out;
1084                 free(option_help);
1085                 option_help = tmp;
1086         }
1087         ret = xasprintf(&result, "%s%s%s%s", header, option_help,
1088                 closing? "\n" : "", closing? closing : "");
1089 out:
1090         free(header);
1091         free(option_help);
1092         return ret < 0? NULL : result;
1093 }
1094
1095 char *lls_long_help(const struct lls_command *cmd)
1096 {
1097         return create_help_buf(cmd, true /* include help */);
1098 }
1099
1100 char *lls_short_help(const struct lls_command *cmd)
1101 {
1102         return create_help_buf(cmd, false /* only options */);
1103 }
1104
1105 static int partial_match(const char *arg, const char *name)
1106 {
1107         size_t arglen = strlen(arg);
1108
1109         if (strncmp(arg, name, arglen) != 0)
1110                 return 1; /* no match */
1111         if (name[arglen] == '\0')
1112                 return 0; /* exact match */
1113         return -1; /* partial match */
1114 }
1115
1116 int lls_lookup_subcmd(const char *string, const struct lls_suite *suite,
1117                 char **errctx)
1118 {
1119         int i, ret;
1120
1121         if (errctx)
1122                 *errctx = NULL;
1123         if (!string) {
1124                 xasprintf(errctx, "nothing to look up");
1125                 return -E_LLS_BAD_SUBCMD;
1126         }
1127         ret = 0; /* no match so far */
1128         for (i = 1; i <= suite->num_subcommands; i++) {
1129                 switch (partial_match(string, suite->commands[i].name)) {
1130                 case 1: /* no match */
1131                         continue;
1132                 case 0: /* exact match */
1133                         return i;
1134                 case -1: /* partial match */
1135                         if (ret > 0) {
1136                                 ret = -E_LLS_AMBIG_SUBCMD;
1137                                 goto fail;
1138                         }
1139                         ret = i;
1140                 }
1141         }
1142         if (ret > 0) /* unique partial match */
1143                 return ret;
1144         ret = -E_LLS_BAD_SUBCMD;
1145 fail:
1146         xasprintf(errctx, "%s", string);
1147         return ret;
1148 }
1149
1150 static size_t get_opt_result_pointer(const struct lls_option *opt, int val_num,
1151                 struct lls_opt_result *lor, void **result)
1152 {
1153         union lls_val *val = lor->value + val_num;
1154
1155         switch (opt->arg_type) {
1156         case LLS_INT32:
1157                 *result = &val->int32_val;
1158                 return 4;
1159         case LLS_UINT32:
1160                 *result = &val->uint32_val;
1161                 return 4;
1162         case LLS_INT64:
1163                 *result = &val->int64_val;
1164                 return 8;
1165         case LLS_UINT64:
1166                 *result = &val->uint64_val;
1167                 return 8;
1168         default:
1169                 assert(0);
1170         }
1171 }
1172
1173 /* never fails, returns number of bytes needed/written */
1174 static size_t serialize_parse_result(const struct lls_parse_result *lpr,
1175         const struct lls_command *cmd, char *result)
1176 {
1177         int i, j;
1178         size_t nbytes;
1179
1180         /* num_inputs */
1181         if (result)
1182                 memcpy(result, &lpr->num_inputs, 4);
1183         nbytes = 4;
1184
1185         /* inputs */
1186         for (i = 0; i < lpr->num_inputs; i++) {
1187                 if (result)
1188                         strcpy(result + nbytes, lpr->inputs[i]);
1189                 nbytes += strlen(lpr->inputs[i]) + 1;
1190         }
1191         /* options */
1192         FOR_EACH_OPTION(i, cmd->options) {
1193                 const struct lls_option *opt = cmd->options + i;
1194                 struct lls_opt_result *lor = lpr->opt_result + i;
1195                 unsigned num_vals;
1196
1197                 if (result)
1198                         memcpy(result + nbytes, &lor->given, 4);
1199                 nbytes += 4;
1200                 if (opt->arg_info == LLS_NO_ARGUMENT)
1201                         continue;
1202                 num_vals = num_vals_in_parse_result(cmd, i, lpr);
1203                 if (opt->arg_type == LLS_STRING && !opt->values) {
1204                         for (j = 0; j < num_vals; j++) {
1205                                 if (result)
1206                                         strcpy(result + nbytes,
1207                                                 lor->value[j].string_val);
1208                                 nbytes += strlen(lor->value[j].string_val) + 1;
1209                         }
1210                 } else {
1211                         for (j = 0; j < num_vals; j++) {
1212                                 size_t bytes;
1213                                 void *p;
1214                                 bytes = get_opt_result_pointer(opt, j, lor, &p);
1215                                 if (result)
1216                                         memcpy(result + nbytes, p, bytes);
1217                                 nbytes += bytes;
1218                         }
1219                 }
1220         }
1221         return nbytes;
1222 }
1223
1224 int lls_serialize_parse_result(const struct lls_parse_result *lpr,
1225         const struct lls_command *cmd, char **result, size_t *nbytes)
1226 {
1227         size_t sz;
1228         int ret;
1229
1230         if (!result || !*result) { /* need to compute needed space */
1231                 sz = serialize_parse_result(lpr, cmd, NULL);
1232                 if (!result) { /* just report needed space */
1233                         ret = 0;
1234                         goto out;
1235                 }
1236                 *result = malloc(sz);
1237                 if (!*result) {
1238                         sz = 0;
1239                         ret = -E_LLS_NOMEM;
1240                         goto out;
1241                 }
1242         }
1243         /* serialize it */
1244         sz = serialize_parse_result(lpr, cmd, *result);
1245         ret = 1;
1246 out:
1247         if (nbytes)
1248                 *nbytes = sz;
1249         return ret;
1250 }
1251
1252 int lls_deserialize_parse_result(const char *buf, const struct lls_command *cmd,
1253                 struct lls_parse_result **lprp)
1254 {
1255         int i, j;
1256         const char *p = buf;
1257         struct lls_parse_result *lpr;
1258
1259         *lprp = NULL;
1260         lpr = malloc(sizeof(*lpr));
1261         if (!lpr)
1262                 return -E_LLS_NOMEM;
1263         memcpy(&lpr->num_inputs, p, 4);
1264         p += 4;
1265         if (lpr->num_inputs > 0) {
1266                 lpr->inputs = malloc(lpr->num_inputs * sizeof(char *));
1267                 if (!lpr->inputs)
1268                         goto free_lpr;
1269         } else
1270                 lpr->inputs = NULL;
1271         for (i = 0; i < lpr->num_inputs; i++) {
1272                 lpr->inputs[i] = strdup(p);
1273                 if (!lpr->inputs[i])
1274                         goto free_inputs;
1275                 p += strlen(p) + 1;
1276         }
1277         lpr->opt_result = malloc(cmd->num_options * sizeof(*lpr->opt_result));
1278         if (!lpr->opt_result)
1279                 goto free_inputs;
1280         FOR_EACH_OPTION(i, cmd->options) {
1281                 const struct lls_option *opt = cmd->options + i;
1282                 struct lls_opt_result *lor = lpr->opt_result + i;
1283                 uint32_t num_vals;
1284
1285                 memcpy(&lor->given, p, 4);
1286                 p += 4;
1287                 if (opt->arg_info == LLS_NO_ARGUMENT)
1288                         continue;
1289                 num_vals = num_vals_in_parse_result(cmd, i, lpr);
1290                 lor->value = malloc(num_vals * sizeof(*lor->value));
1291                 if (!lor->value)
1292                         goto free_options;
1293                 if (opt->arg_type == LLS_STRING && !opt->values) {
1294                         for (j = 0; j < num_vals; j++) {
1295                                 lor->value[j].string_val = strdup(p);
1296                                 if (!lor->value[j].string_val) {
1297                                         for (; j >= 0; j--)
1298                                                 free(lor->value[j].string_val);
1299                                         free(lor->value);
1300                                         goto free_options;
1301                                 }
1302                                 p += strlen(lor->value[j].string_val) + 1;
1303                         }
1304                 } else {
1305                         for (j = 0; j < num_vals; j++) {
1306                                 size_t bytes;
1307                                 void *q;
1308                                 bytes = get_opt_result_pointer(opt, j, lor, &q);
1309                                 memcpy(q, p, bytes);
1310                                 p += bytes;
1311                         }
1312                 }
1313         }
1314         *lprp = lpr;
1315         return 1;
1316 free_options:
1317         for (i--; i >= 0; i--) {
1318                 const struct lls_option *opt = cmd->options + i;
1319                 struct lls_opt_result *lor = lpr->opt_result + i;
1320                 unsigned num_vals = (opt->flags & LLS_MULTIPLE)? lor->given : 1;
1321                 for (j = 0; j < num_vals; j++)
1322                         if (opt->arg_type == LLS_STRING && !opt->values)
1323                                 free(lor->value[j].string_val);
1324                 free(lor->value);
1325         }
1326         free(lpr->opt_result);
1327 free_inputs:
1328         for (; i >= 0; i--)
1329                 free(lpr->inputs[i]);
1330         free(lpr->inputs);
1331 free_lpr:
1332         free(lpr);
1333         return -E_LLS_NOMEM;
1334 }
1335
1336 static int merge_option(int opt_num, const struct lls_parse_result *primary,
1337                 const struct lls_parse_result *secondary,
1338                 const struct lls_command *cmd, struct lls_parse_result *result,
1339                 char **errctx)
1340 {
1341         int l, m, ret;
1342         const struct lls_option *opt = cmd->options + opt_num;
1343         struct lls_opt_result *lor1, *lor2, *lor;
1344
1345         lor1 = primary->opt_result + opt_num;
1346         lor2 = secondary->opt_result + opt_num;
1347         lor = result->opt_result + opt_num;
1348         lor->given = lor1->given + lor2->given;
1349         if (opt->arg_info == LLS_NO_ARGUMENT)
1350                 return 0;
1351         if (lor->given > 0 && (opt->flags & LLS_MULTIPLE)) {
1352                 lor->value = malloc(lor->given * sizeof(*lor->value));
1353                 if (!lor->value) {
1354                         xasprintf(errctx, "value array for option %s", opt->name);
1355                         goto fail;
1356                 }
1357                 for (l = 0; l < lor1->given; l++) {
1358                         ret = copy_val(lor->value + l, lor1->value + l,
1359                                 opt, errctx);
1360                         if (ret < 0)
1361                                 goto free_primary_options;
1362                 }
1363                 for (m = 0; m < lor2->given; m++) {
1364                         ret = copy_val(lor->value + l + m, lor2->value + m,
1365                                 opt, errctx);
1366                         if (ret < 0)
1367                                 goto free_secondary_options;
1368                 }
1369                 return 1;
1370         }
1371         lor->value = malloc(sizeof(*lor->value)); /* one value only */
1372         if (!lor->value) {
1373                 xasprintf(errctx, "(single) value for option %s", opt->name);
1374                 goto fail;
1375         }
1376         if (lor1->given) {
1377                 ret = copy_val(lor->value, lor1->value, opt, errctx);
1378                 if (ret < 0)
1379                         goto free_value;
1380         } else if (lor2->given) {
1381                 ret = copy_val(lor->value, lor2->value, opt, errctx);
1382                 if (ret < 0)
1383                         goto free_value;
1384         } else {
1385                 ret = copy_val(lor->value, &opt->default_val, opt, errctx);
1386                 if (ret < 0)
1387                         goto free_value;
1388         }
1389         return 1;
1390 free_secondary_options:
1391         if (opt->arg_type == LLS_STRING && !opt->values)
1392                 for (m--; m >= 0; m--)
1393                         free(lor->value[l + m].string_val);
1394 free_primary_options:
1395         if (opt->arg_type == LLS_STRING && !opt->values)
1396                 for (l--; l >= 0; l--)
1397                         free(lor->value[l].string_val);
1398 free_value:
1399         free(lor->value);
1400 fail:
1401         return -E_LLS_NOMEM;
1402 }
1403
1404 int lls_merge(const struct lls_parse_result *primary,
1405                 const struct lls_parse_result *secondary,
1406                 const struct lls_command *cmd, struct lls_parse_result **lprp,
1407                 char **errctx)
1408 {
1409         int i, j, k, ret;
1410         unsigned num = primary->num_inputs + secondary->num_inputs;
1411         struct lls_parse_result *result;
1412
1413         if (errctx)
1414                 *errctx = NULL;
1415         result = malloc(sizeof(*result));
1416         if (!result) {
1417                 ret = -E_LLS_NOMEM;
1418                 xasprintf(errctx, "parse result");
1419                 goto fail;
1420         }
1421         result->inputs = malloc((num + 1) * sizeof(char *));
1422         if (!result->inputs) {
1423                 ret = -E_LLS_NOMEM;
1424                 xasprintf(errctx, "inputs array of size %u", num);
1425                 goto free_parse_result;
1426         }
1427         for (i = 0; i < primary->num_inputs; i++) {
1428                 result->inputs[i] = strdup(primary->inputs[i]);
1429                 if (!result->inputs[i]) {
1430                         ret = -E_LLS_NOMEM;
1431                         xasprintf(errctx, "primary input #%d", i);
1432                         goto free_primary_inputs;
1433                 }
1434         }
1435         for (j = 0; j < secondary->num_inputs; j++) {
1436                 result->inputs[i + j] = strdup(secondary->inputs[j]);
1437                 if (!result->inputs[i + j]) {
1438                         ret = -E_LLS_NOMEM;
1439                         xasprintf(errctx, "secondary input #%d", i);
1440                         goto free_secondary_inputs;
1441                 }
1442         }
1443         result->inputs[i + j] = NULL;
1444         result->opt_result = malloc(cmd->num_options
1445                 * sizeof(*result->opt_result));
1446         if (!result->opt_result)
1447                 goto free_secondary_inputs;
1448         FOR_EACH_OPTION(k, cmd->options) {
1449                 ret = merge_option(k, primary, secondary, cmd, result, errctx);
1450                 if (ret < 0)
1451                         goto free_opt_results;
1452         }
1453         result->num_inputs = num;
1454         *lprp = result;
1455         ret = 1;
1456         goto out;
1457 free_opt_results:
1458         for (k--; k >= 0; k--)
1459                 free_opt_result(k, result, cmd);
1460 free_secondary_inputs:
1461         for (j--; j >= 0; j--)
1462                 free(result->inputs[i + j]);
1463 free_primary_inputs:
1464         for (i--; i >= 0; i--)
1465                 free(result->inputs[i]);
1466         free(result->inputs);
1467 free_parse_result:
1468         free(result);
1469 fail:
1470         assert(ret < 0);
1471         *lprp = NULL;
1472 out:
1473         check_errctx(errctx, ret);
1474         return ret;
1475 }
1476
1477 static bool is_default_val(const union lls_val *val,
1478                 const struct lls_option *opt)
1479 {
1480         bool has_default = opt->flags & LLS_HAS_DEFAULT;
1481         bool has_arg = opt->arg_info != LLS_NO_ARGUMENT;
1482         const union lls_val *dflt;
1483
1484         if (!has_arg)
1485                 return false;
1486         if (!has_default)
1487                 return false;
1488         dflt = &opt->default_val;
1489         switch (opt->arg_type) {
1490         case LLS_INT32:
1491                 return val->int32_val == dflt->int32_val;
1492         case LLS_UINT32:
1493                 return val->uint32_val == dflt->uint32_val;
1494         case LLS_INT64:
1495                 return val->int64_val == dflt->int64_val;
1496         case LLS_UINT64:
1497                 return val->uint64_val == dflt->uint64_val;
1498         case LLS_STRING:
1499                 {
1500                 const char *s1, *s2;
1501
1502                 if (opt->values)
1503                         return val->uint32_val == dflt->uint32_val;
1504                 s1 = val->string_val;
1505                 s2 = dflt->string_val;
1506                 if (!s1 && !s2)
1507                         return true;
1508                 if (!s1 || !s2)
1509                         return false;
1510                 return !strcmp(s1, s2);
1511                 }
1512         default:
1513                 assert(0);
1514         }
1515 }
1516
1517 static char *append_opt_val(const union lls_val *val,
1518                 const struct lls_option *opt, char *result)
1519 {
1520         char *line = NULL, *tmp = NULL;
1521
1522         switch (opt->arg_type) {
1523         case LLS_INT32:
1524                 xasprintf(&line, "%" PRId32, val->int32_val);
1525                 break;
1526         case LLS_UINT32:
1527                 xasprintf(&line, "%" PRIu32, val->uint32_val);
1528                 break;
1529         case LLS_INT64:
1530                 xasprintf(&line, "%" PRId64, val->int64_val);
1531                 break;
1532         case LLS_UINT64:
1533                 xasprintf(&line, "%" PRIu64, val->uint64_val);
1534                 break;
1535         case LLS_STRING:
1536                 {
1537                 const char *s, *p;
1538                 char *q;
1539
1540                 if (opt->values)
1541                         s = lls_enum_string_val(val->uint32_val, opt);
1542                 else {
1543                         s = val->string_val;
1544                         if (!s)
1545                                 return result;
1546                 }
1547                 line = malloc(2 * strlen(s) + 3);
1548                 if (!line) {
1549                         free(result);
1550                         return NULL;
1551                 }
1552                 line[0] = '"';
1553                 for (p = s, q = line + 1; *p; p++, q++) {
1554                         if (*p == '\\' || *p == '\n' || *p == '\t' || *p == '"') {
1555                                 *q = '\\';
1556                                 q++;
1557                         }
1558                         *q = *p;
1559                 }
1560                 q[0] = '"';
1561                 q[1] = '\0';
1562                 break;
1563                 }
1564         default:
1565                 assert(0);
1566         }
1567         xasprintf(&tmp, "%s%s=%s\n", result? result : "", opt->name, line);
1568         free(line);
1569         free(result);
1570         return tmp;
1571 }
1572
1573 char *lls_dump_parse_result(const struct lls_parse_result *lpr,
1574                 const struct lls_command *cmd, bool non_default_only)
1575 {
1576         int i;
1577         char *result = NULL;
1578
1579         FOR_EACH_OPTION(i, cmd->options) {
1580                 const struct lls_option *opt = cmd->options + i;
1581                 struct lls_opt_result *lor = lpr->opt_result + i;
1582                 bool given = lor->given;
1583                 int j, n;
1584
1585                 if (!given && non_default_only)
1586                         continue;
1587                 if (opt->arg_info == LLS_NO_ARGUMENT) {
1588                         char *tmp = NULL;
1589                         if (!given)
1590                                 continue;
1591                         xasprintf(&tmp, "%s%s\n", result? result : "",
1592                                 opt->name);
1593                         free(result);
1594                         result = tmp;
1595                         continue;
1596                 }
1597                 n = num_vals_in_parse_result(cmd, i, lpr);
1598                 for (j = 0; j < n; j++) {
1599                         union lls_val *val = lor->value + j;
1600                         if (non_default_only && is_default_val(val, opt))
1601                                 continue;
1602                         result = append_opt_val(val, opt, result);
1603                 }
1604         }
1605         if (!result) { /* empty dump */
1606                 result = malloc(1);
1607                 if (result)
1608                         result[0] = '\0';
1609         }
1610         return result;
1611 }