?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make pass-by-reference explicit by using pointers
[isl.git] / isl_arg.c
blob70d1b3458ab9721d360a509d2bab18afa804b550
1 /*
2 * Copyright 2008-2009 Katholieke Universiteit Leuven
3 *
4 * Use of this software is governed by the MIT license
5 *
6 * Written by Sven Verdoolaege, K.U.Leuven, Departement
7 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
8 */
9
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <string.h>
13
14 #include <isl/arg.h>
15 #include <isl/ctx.h>
16
17 static struct isl_arg help_arg[] = {
18 ISL_ARG_PHANTOM_BOOL('h', "help", NULL, "print this help, then exit")
19 };
20
21 static void set_default_choice(struct isl_arg *arg, void *opt)
22 {
23 if (arg->offset == (size_t) -1)
24 return;
25 *(unsigned *)(((char *)opt) + arg->offset) = arg->u.choice.default_value;
26 }
27
28 static void set_default_flags(struct isl_arg *arg, void *opt)
29 {
30 *(unsigned *)(((char *)opt) + arg->offset) = arg->u.flags.default_value;
31 }
32
33 static void set_default_bool(struct isl_arg *arg, void *opt)
34 {
35 if (arg->offset == (size_t) -1)
36 return;
37 *(unsigned *)(((char *)opt) + arg->offset) = arg->u.b.default_value;
38 }
39
40 static void set_default_child(struct isl_arg *arg, void *opt)
41 {
42 void *child;
43
44 if (arg->offset == (size_t) -1)
45 child = opt;
46 else {
47 child = calloc(1, arg->u.child.child->options_size);
48 *(void **)(((char *)opt) + arg->offset) = child;
49 }
50
51 if (child)
52 isl_args_set_defaults(arg->u.child.child, child);
53 }
54
55 static void set_default_user(struct isl_arg *arg, void *opt)
56 {
57 arg->u.user.init(((char *)opt) + arg->offset);
58 }
59
60 static void set_default_int(struct isl_arg *arg, void *opt)
61 {
62 *(int *)(((char *)opt) + arg->offset) = arg->u.i.default_value;
63 }
64
65 static void set_default_long(struct isl_arg *arg, void *opt)
66 {
67 *(long *)(((char *)opt) + arg->offset) = arg->u.l.default_value;
68 }
69
70 static void set_default_ulong(struct isl_arg *arg, void *opt)
71 {
72 *(unsigned long *)(((char *)opt) + arg->offset) = arg->u.ul.default_value;
73 }
74
75 static void set_default_str(struct isl_arg *arg, void *opt)
76 {
77 const char *str = NULL;
78 if (arg->u.str.default_value)
79 str = strdup(arg->u.str.default_value);
80 *(const char **)(((char *)opt) + arg->offset) = str;
81 }
82
83 static void set_default_str_list(struct isl_arg *arg, void *opt)
84 {
85 *(const char ***)(((char *) opt) + arg->offset) = NULL;
86 *(int *)(((char *) opt) + arg->u.str_list.offset_n) = 0;
87 }
88
89 void isl_args_set_defaults(struct isl_args *args, void *opt)
90 {
91 int i;
92
93 for (i = 0; args->args[i].type != isl_arg_end; ++i) {
94 switch (args->args[i].type) {
95 case isl_arg_choice:
96 set_default_choice(&args->args[i], opt);
97 break;
98 case isl_arg_flags:
99 set_default_flags(&args->args[i], opt);
100 break;
101 case isl_arg_bool:
102 set_default_bool(&args->args[i], opt);
103 break;
104 case isl_arg_child:
105 set_default_child(&args->args[i], opt);
106 break;
107 case isl_arg_user:
108 set_default_user(&args->args[i], opt);
109 break;
110 case isl_arg_int:
111 set_default_int(&args->args[i], opt);
112 break;
113 case isl_arg_long:
114 set_default_long(&args->args[i], opt);
115 break;
116 case isl_arg_ulong:
117 set_default_ulong(&args->args[i], opt);
118 break;
119 case isl_arg_arg:
120 case isl_arg_str:
121 set_default_str(&args->args[i], opt);
122 break;
123 case isl_arg_str_list:
124 set_default_str_list(&args->args[i], opt);
125 break;
126 case isl_arg_alias:
127 case isl_arg_footer:
128 case isl_arg_version:
129 case isl_arg_end:
130 break;
131 }
132 }
133 }
134
135 static void free_args(struct isl_arg *arg, void *opt);
136
137 static void free_child(struct isl_arg *arg, void *opt)
138 {
139 if (arg->offset == (size_t) -1)
140 free_args(arg->u.child.child->args, opt);
141 else
142 isl_args_free(arg->u.child.child,
143 *(void **)(((char *)opt) + arg->offset));
144 }
145
146 static void free_str_list(struct isl_arg *arg, void *opt)
147 {
148 int i;
149 int n = *(int *)(((char *) opt) + arg->u.str_list.offset_n);
150 char **list = *(char ***)(((char *) opt) + arg->offset);
151
152 for (i = 0; i < n; ++i)
153 free(list[i]);
154 free(list);
155 }
156
157 static void free_user(struct isl_arg *arg, void *opt)
158 {
159 if (arg->u.user.clear)
160 arg->u.user.clear(((char *)opt) + arg->offset);
161 }
162
163 static void free_args(struct isl_arg *arg, void *opt)
164 {
165 int i;
166
167 for (i = 0; arg[i].type != isl_arg_end; ++i) {
168 switch (arg[i].type) {
169 case isl_arg_child:
170 free_child(&arg[i], opt);
171 break;
172 case isl_arg_arg:
173 case isl_arg_str:
174 free(*(char **)(((char *)opt) + arg[i].offset));
175 break;
176 case isl_arg_str_list:
177 free_str_list(&arg[i], opt);
178 break;
179 case isl_arg_user:
180 free_user(&arg[i], opt);
181 break;
182 case isl_arg_alias:
183 case isl_arg_bool:
184 case isl_arg_choice:
185 case isl_arg_flags:
186 case isl_arg_int:
187 case isl_arg_long:
188 case isl_arg_ulong:
189 case isl_arg_version:
190 case isl_arg_footer:
191 case isl_arg_end:
192 break;
193 }
194 }
195 }
196
197 void isl_args_free(struct isl_args *args, void *opt)
198 {
199 if (!opt)
200 return;
201
202 free_args(args->args, opt);
203
204 free(opt);
205 }
206
207 /* Data structure for collecting the prefixes of ancestor nodes.
208 *
209 * n is the number of prefixes.
210 * prefix[i] for i < n is a prefix of an ancestor.
211 * len[i] for i < n is the length of prefix[i].
212 */
213 struct isl_prefixes {
214 int n;
215 const char *prefix[10];
216 size_t len[10];
217 };
218
219 /* Add "prefix" to the list of prefixes and return the updated
220 * number of prefixes.
221 */
222 static int add_prefix(struct isl_prefixes *prefixes, const char *prefix)
223 {
224 int n = prefixes->n;
225
226 if (!prefix)
227 return n;
228
229 if (prefixes->n >= 10) {
230 fprintf(stderr, "too many prefixes\n");
231 exit(EXIT_FAILURE);
232 }
233 prefixes->len[prefixes->n] = strlen(prefix);
234 prefixes->prefix[prefixes->n] = prefix;
235 prefixes->n++;
236
237 return n;
238 }
239
240 /* Drop all prefixes starting at "first".
241 */
242 static void drop_prefix(struct isl_prefixes *prefixes, int first)
243 {
244 prefixes->n = first;
245 }
246
247 /* Print the prefixes in "prefixes".
248 */
249 static int print_prefixes(struct isl_prefixes *prefixes)
250 {
251 int i;
252 int len = 0;
253
254 if (!prefixes)
255 return 0;
256
257 for (i = 0; i < prefixes->n; ++i) {
258 printf("%s-", prefixes->prefix[i]);
259 len += strlen(prefixes->prefix[i]) + 1;
260 }
261
262 return len;
263 }
264
265 /* Check if "name" starts with one or more of the prefixes in "prefixes",
266 * starting at *first. If so, advance the pointer beyond the prefixes
267 * and return the updated pointer. Additionally, update *first to
268 * the index after the last prefix found.
269 */
270 static const char *skip_prefixes(const char *name,
271 struct isl_prefixes *prefixes, int *first)
272 {
273 int i;
274
275 for (i = first ? *first : 0; i < prefixes->n; ++i) {
276 size_t len = prefixes->len[i];
277 const char *prefix = prefixes->prefix[i];
278 if (strncmp(name, prefix, len) == 0 && name[len] == '-') {
279 name += len + 1;
280 if (first)
281 *first = i + 1;
282 }
283 }
284
285 return name;
286 }
287
288 static int print_arg_help(struct isl_arg *decl, struct isl_prefixes *prefixes,
289 int no)
290 {
291 int len = 0;
292
293 if (!decl->long_name) {
294 printf(" -%c", decl->short_name);
295 return 4;
296 }
297
298 if (decl->short_name) {
299 printf(" -%c, --", decl->short_name);
300 len += 8;
301 } else if (decl->flags & ISL_ARG_SINGLE_DASH) {
302 printf(" -");
303 len += 3;
304 } else {
305 printf(" --");
306 len += 8;
307 }
308
309 if (no) {
310 printf("no-");
311 len += 3;
312 }
313 len += print_prefixes(prefixes);
314 printf("%s", decl->long_name);
315 len += strlen(decl->long_name);
316
317 while ((++decl)->type == isl_arg_alias) {
318 printf(", --");
319 len += 4;
320 if (no) {
321 printf("no-");
322 len += 3;
323 }
324 printf("%s", decl->long_name);
325 len += strlen(decl->long_name);
326 }
327
328 return len;
329 }
330
331 const void *isl_memrchr(const void *s, int c, size_t n)
332 {
333 const char *p = s;
334 while (n-- > 0)
335 if (p[n] == c)
336 return p + n;
337 return NULL;
338 }
339
340 static int wrap_msg(const char *s, int indent, int pos)
341 {
342 int len;
343 int wrap_len = 75 - indent;
344
345 if (pos + 1 >= indent)
346 printf("\n%*s", indent, "");
347 else
348 printf("%*s", indent - pos, "");
349
350 len = strlen(s);
351 while (len > wrap_len) {
352 const char *space = isl_memrchr(s, ' ', wrap_len);
353 int l;
354
355 if (!space)
356 space = strchr(s + wrap_len, ' ');
357 if (!space)
358 break;
359 l = space - s;
360 printf("%.*s", l, s);
361 s = space + 1;
362 len -= l + 1;
363 printf("\n%*s", indent, "");
364 }
365
366 printf("%s", s);
367 return len;
368 }
369
370 static int print_help_msg(struct isl_arg *decl, int pos)
371 {
372 if (!decl->help_msg)
373 return pos;
374
375 return wrap_msg(decl->help_msg, 30, pos);
376 }
377
378 static void print_default(struct isl_arg *decl, const char *def, int pos)
379 {
380 const char *default_prefix = "[default: ";
381 const char *default_suffix = "]";
382 int len;
383
384 len = strlen(default_prefix) + strlen(def) + strlen(default_suffix);
385
386 if (!decl->help_msg) {
387 if (pos >= 29)
388 printf("\n%30s", "");
389 else
390 printf("%*s", 30 - pos, "");
391 } else {
392 if (pos + len >= 48)
393 printf("\n%30s", "");
394 else
395 printf(" ");
396 }
397 printf("%s%s%s", default_prefix, def, default_suffix);
398 }
399
400 static void print_default_choice(struct isl_arg *decl, void *opt, int pos)
401 {
402 int i;
403 const char *s = "none";
404 unsigned *p;
405
406 p = (unsigned *)(((char *) opt) + decl->offset);
407 for (i = 0; decl->u.choice.choice[i].name; ++i)
408 if (decl->u.choice.choice[i].value == *p) {
409 s = decl->u.choice.choice[i].name;
410 break;
411 }
412
413 print_default(decl, s, pos);
414 }
415
416 static void print_choice_help(struct isl_arg *decl,
417 struct isl_prefixes *prefixes, void *opt)
418 {
419 int i;
420 int pos;
421
422 pos = print_arg_help(decl, prefixes, 0);
423 printf("=");
424 pos++;
425
426 for (i = 0; decl->u.choice.choice[i].name; ++i) {
427 if (i) {
428 printf("|");
429 pos++;
430 }
431 printf("%s", decl->u.choice.choice[i].name);
432 pos += strlen(decl->u.choice.choice[i].name);
433 }
434
435 pos = print_help_msg(decl, pos);
436 print_default_choice(decl, opt, pos);
437
438 printf("\n");
439 }
440
441 static void print_default_flags(struct isl_arg *decl, void *opt, int pos)
442 {
443 int i, first;
444 const char *default_prefix = "[default: ";
445 const char *default_suffix = "]";
446 int len = strlen(default_prefix) + strlen(default_suffix);
447 unsigned *p;
448
449 p = (unsigned *)(((char *) opt) + decl->offset);
450 for (i = 0; decl->u.flags.flags[i].name; ++i)
451 if ((*p & decl->u.flags.flags[i].mask) ==
452 decl->u.flags.flags[i].value)
453 len += strlen(decl->u.flags.flags[i].name);
454
455 if (!decl->help_msg) {
456 if (pos >= 29)
457 printf("\n%30s", "");
458 else
459 printf("%*s", 30 - pos, "");
460 } else {
461 if (pos + len >= 48)
462 printf("\n%30s", "");
463 else
464 printf(" ");
465 }
466 printf("%s", default_prefix);
467
468 for (first = 1, i = 0; decl->u.flags.flags[i].name; ++i)
469 if ((*p & decl->u.flags.flags[i].mask) ==
470 decl->u.flags.flags[i].value) {
471 if (!first)
472 printf(",");
473 printf("%s", decl->u.flags.flags[i].name);
474 first = 0;
475 }
476
477 printf("%s", default_suffix);
478 }
479
480 static void print_flags_help(struct isl_arg *decl,
481 struct isl_prefixes *prefixes, void *opt)
482 {
483 int i, j;
484 int pos;
485
486 pos = print_arg_help(decl, prefixes, 0);
487 printf("=");
488 pos++;
489
490 for (i = 0; decl->u.flags.flags[i].name; ++i) {
491 if (i) {
492 printf(",");
493 pos++;
494 }
495 for (j = i;
496 decl->u.flags.flags[j].mask == decl->u.flags.flags[i].mask;
497 ++j) {
498 if (j != i) {
499 printf("|");
500 pos++;
501 }
502 printf("%s", decl->u.flags.flags[j].name);
503 pos += strlen(decl->u.flags.flags[j].name);
504 }
505 i = j - 1;
506 }
507
508 pos = print_help_msg(decl, pos);
509 print_default_flags(decl, opt, pos);
510
511 printf("\n");
512 }
513
514 static void print_bool_help(struct isl_arg *decl,
515 struct isl_prefixes *prefixes, void *opt)
516 {
517 int pos;
518 unsigned *p = opt ? (unsigned *)(((char *) opt) + decl->offset) : NULL;
519 int no = p ? *p == 1 : 0;
520 pos = print_arg_help(decl, prefixes, no);
521 pos = print_help_msg(decl, pos);
522 if (decl->offset != (size_t) -1)
523 print_default(decl, no ? "yes" : "no", pos);
524 printf("\n");
525 }
526
527 static int print_argument_name(struct isl_arg *decl, const char *name, int pos)
528 {
529 printf("%c<%s>", decl->long_name ? '=' : ' ', name);
530 return pos + 3 + strlen(name);
531 }
532
533 static void print_int_help(struct isl_arg *decl,
534 struct isl_prefixes *prefixes, void *opt)
535 {
536 int pos;
537 char val[20];
538 int *p = (int *)(((char *) opt) + decl->offset);
539 pos = print_arg_help(decl, prefixes, 0);
540 pos = print_argument_name(decl, decl->argument_name, pos);
541 pos = print_help_msg(decl, pos);
542 snprintf(val, sizeof(val), "%d", *p);
543 print_default(decl, val, pos);
544 printf("\n");
545 }
546
547 static void print_long_help(struct isl_arg *decl,
548 struct isl_prefixes *prefixes, void *opt)
549 {
550 int pos;
551 long *p = (long *)(((char *) opt) + decl->offset);
552 pos = print_arg_help(decl, prefixes, 0);
553 if (*p != decl->u.l.default_selected) {
554 printf("[");
555 pos++;
556 }
557 printf("=long");
558 pos += 5;
559 if (*p != decl->u.l.default_selected) {
560 printf("]");
561 pos++;
562 }
563 print_help_msg(decl, pos);
564 printf("\n");
565 }
566
567 static void print_ulong_help(struct isl_arg *decl,
568 struct isl_prefixes *prefixes)
569 {
570 int pos;
571 pos = print_arg_help(decl, prefixes, 0);
572 printf("=ulong");
573 pos += 6;
574 print_help_msg(decl, pos);
575 printf("\n");
576 }
577
578 static void print_str_help(struct isl_arg *decl,
579 struct isl_prefixes *prefixes, void *opt)
580 {
581 int pos;
582 const char *a = decl->argument_name ? decl->argument_name : "string";
583 const char **p = (const char **)(((char *) opt) + decl->offset);
584 pos = print_arg_help(decl, prefixes, 0);
585 pos = print_argument_name(decl, a, pos);
586 pos = print_help_msg(decl, pos);
587 if (*p)
588 print_default(decl, *p, pos);
589 printf("\n");
590 }
591
592 static void print_str_list_help(struct isl_arg *decl,
593 struct isl_prefixes *prefixes)
594 {
595 int pos;
596 const char *a = decl->argument_name ? decl->argument_name : "string";
597 pos = print_arg_help(decl, prefixes, 0);
598 pos = print_argument_name(decl, a, pos);
599 pos = print_help_msg(decl, pos);
600 printf("\n");
601 }
602
603 static void print_help(struct isl_arg *arg,
604 struct isl_prefixes *prefixes, void *opt)
605 {
606 int i;
607 int any = 0;
608
609 for (i = 0; arg[i].type != isl_arg_end; ++i) {
610 if (arg[i].flags & ISL_ARG_HIDDEN)
611 continue;
612 switch (arg[i].type) {
613 case isl_arg_flags:
614 print_flags_help(&arg[i], prefixes, opt);
615 any = 1;
616 break;
617 case isl_arg_choice:
618 print_choice_help(&arg[i], prefixes, opt);
619 any = 1;
620 break;
621 case isl_arg_bool:
622 print_bool_help(&arg[i], prefixes, opt);
623 any = 1;
624 break;
625 case isl_arg_int:
626 print_int_help(&arg[i], prefixes, opt);
627 any = 1;
628 break;
629 case isl_arg_long:
630 print_long_help(&arg[i], prefixes, opt);
631 any = 1;
632 break;
633 case isl_arg_ulong:
634 print_ulong_help(&arg[i], prefixes);
635 any = 1;
636 break;
637 case isl_arg_str:
638 print_str_help(&arg[i], prefixes, opt);
639 any = 1;
640 break;
641 case isl_arg_str_list:
642 print_str_list_help(&arg[i], prefixes);
643 any = 1;
644 break;
645 case isl_arg_alias:
646 case isl_arg_version:
647 case isl_arg_arg:
648 case isl_arg_footer:
649 case isl_arg_child:
650 case isl_arg_user:
651 case isl_arg_end:
652 break;
653 }
654 }
655
656 for (i = 0; arg[i].type != isl_arg_end; ++i) {
657 void *child;
658 int first;
659
660 if (arg[i].type != isl_arg_child)
661 continue;
662 if (arg[i].flags & ISL_ARG_HIDDEN)
663 continue;
664
665 if (any)
666 printf("\n");
667 if (arg[i].help_msg)
668 printf(" %s\n", arg[i].help_msg);
669 if (arg[i].offset == (size_t) -1)
670 child = opt;
671 else
672 child = *(void **)(((char *) opt) + arg[i].offset);
673 first = add_prefix(prefixes, arg[i].long_name);
674 print_help(arg[i].u.child.child->args, prefixes, child);
675 drop_prefix(prefixes, first);
676 any = 1;
677 }
678 }
679
680 static const char *prog_name(const char *prog)
681 {
682 const char *slash;
683
684 slash = strrchr(prog, '/');
685 if (slash)
686 prog = slash + 1;
687 if (strncmp(prog, "lt-", 3) == 0)
688 prog += 3;
689
690 return prog;
691 }
692
693 static int any_version(struct isl_arg *decl)
694 {
695 int i;
696
697 for (i = 0; decl[i].type != isl_arg_end; ++i) {
698 switch (decl[i].type) {
699 case isl_arg_version:
700 return 1;
701 case isl_arg_child:
702 if (any_version(decl[i].u.child.child->args))
703 return 1;
704 break;
705 default:
706 break;
707 }
708 }
709
710 return 0;
711 }
712
713 static void print_help_and_exit(struct isl_arg *arg, const char *prog,
714 void *opt)
715 {
716 int i;
717 struct isl_prefixes prefixes = { 0 };
718
719 printf("Usage: %s [OPTION...]", prog_name(prog));
720
721 for (i = 0; arg[i].type != isl_arg_end; ++i)
722 if (arg[i].type == isl_arg_arg)
723 printf(" %s", arg[i].argument_name);
724
725 printf("\n\n");
726
727 print_help(arg, &prefixes, opt);
728 printf("\n");
729 if (any_version(arg))
730 printf(" -V, --version\n");
731 print_bool_help(help_arg, NULL, NULL);
732
733 for (i = 0; arg[i].type != isl_arg_end; ++i) {
734 if (arg[i].type != isl_arg_footer)
735 continue;
736 wrap_msg(arg[i].help_msg, 0, 0);
737 printf("\n");
738 }
739
740 exit(0);
741 }
742
743 static int match_long_name(struct isl_arg *decl,
744 const char *start, const char *end)
745 {
746 do {
747 if (end - start == strlen(decl->long_name) &&
748 !strncmp(start, decl->long_name, end - start))
749 return 1;
750 } while ((++decl)->type == isl_arg_alias);
751
752 return 0;
753 }
754
755 static const char *skip_dash_dash(struct isl_arg *decl, const char *arg)
756 {
757 if (!strncmp(arg, "--", 2))
758 return arg + 2;
759 if ((decl->flags & ISL_ARG_SINGLE_DASH) && arg[0] == '-')
760 return arg + 1;
761 return NULL;
762 }
763
764 static const char *skip_name(struct isl_arg *decl, const char *arg,
765 struct isl_prefixes *prefixes, int need_argument, int *has_argument)
766 {
767 const char *equal;
768 const char *name;
769 const char *end;
770
771 if (arg[0] == '-' && arg[1] && arg[1] == decl->short_name) {
772 if (need_argument && !arg[2])
773 return NULL;
774 if (has_argument)
775 *has_argument = arg[2] != '\0';
776 return arg + 2;
777 }
778 if (!decl->long_name)
779 return NULL;
780
781 name = skip_dash_dash(decl, arg);
782 if (!name)
783 return NULL;
784
785 equal = strchr(name, '=');
786 if (need_argument && !equal)
787 return NULL;
788
789 if (has_argument)
790 *has_argument = !!equal;
791 end = equal ? equal : name + strlen(name);
792
793 name = skip_prefixes(name, prefixes, NULL);
794
795 if (!match_long_name(decl, name, end))
796 return NULL;
797
798 return equal ? equal + 1 : end;
799 }
800
801 static int parse_choice_option(struct isl_arg *decl, char **arg,
802 struct isl_prefixes *prefixes, void *opt)
803 {
804 int i;
805 int has_argument;
806 const char *choice;
807
808 choice = skip_name(decl, arg[0], prefixes, 0, &has_argument);
809 if (!choice)
810 return 0;
811
812 if (!has_argument && (!arg[1] || arg[1][0] == '-')) {
813 unsigned u = decl->u.choice.default_selected;
814 *(unsigned *)(((char *)opt) + decl->offset) = u;
815 if (decl->u.choice.set)
816 decl->u.choice.set(opt, u);
817
818 return 1;
819 }
820
821 if (!has_argument)
822 choice = arg[1];
823
824 for (i = 0; decl->u.choice.choice[i].name; ++i) {
825 unsigned u;
826
827 if (strcmp(choice, decl->u.choice.choice[i].name))
828 continue;
829
830 u = decl->u.choice.choice[i].value;
831 *(unsigned *)(((char *)opt) + decl->offset) = u;
832 if (decl->u.choice.set)
833 decl->u.choice.set(opt, u);
834
835 return has_argument ? 1 : 2;
836 }
837
838 return 0;
839 }
840
841 static int set_flag(struct isl_arg *decl, unsigned *val, const char *flag,
842 size_t len)
843 {
844 int i;
845
846 for (i = 0; decl->u.flags.flags[i].name; ++i) {
847 if (strncmp(flag, decl->u.flags.flags[i].name, len))
848 continue;
849
850 *val &= ~decl->u.flags.flags[i].mask;
851 *val |= decl->u.flags.flags[i].value;
852
853 return 1;
854 }
855
856 return 0;
857 }
858
859 static int parse_flags_option(struct isl_arg *decl, char **arg,
860 struct isl_prefixes *prefixes, void *opt)
861 {
862 int has_argument;
863 const char *flags;
864 const char *comma;
865 unsigned val;
866
867 flags = skip_name(decl, arg[0], prefixes, 0, &has_argument);
868 if (!flags)
869 return 0;
870
871 if (!has_argument && !arg[1])
872 return 0;
873
874 if (!has_argument)
875 flags = arg[1];
876
877 val = 0;
878
879 while ((comma = strchr(flags, ',')) != NULL) {
880 if (!set_flag(decl, &val, flags, comma - flags))
881 return 0;
882 flags = comma + 1;
883 }
884 if (!set_flag(decl, &val, flags, strlen(flags)))
885 return 0;
886
887 *(unsigned *)(((char *)opt) + decl->offset) = val;
888
889 return has_argument ? 1 : 2;
890 }
891
892 static int parse_bool_option(struct isl_arg *decl, char **arg,
893 struct isl_prefixes *prefixes, void *opt)
894 {
895 const char *name;
896 unsigned *p = (unsigned *)(((char *)opt) + decl->offset);
897 int next_prefix;
898
899 if (skip_name(decl, arg[0], prefixes, 0, NULL)) {
900 if ((decl->flags & ISL_ARG_BOOL_ARG) && arg[1]) {
901 char *endptr;
902 int val = strtol(arg[1], &endptr, 0);
903 if (*endptr == '\0' && (val == 0 || val == 1)) {
904 if (decl->offset != (size_t) -1)
905 *p = val;
906 if (decl->u.b.set)
907 decl->u.b.set(opt, val);
908 return 2;
909 }
910 }
911 if (decl->offset != (size_t) -1)
912 *p = 1;
913 if (decl->u.b.set)
914 decl->u.b.set(opt, 1);
915
916 return 1;
917 }
918
919 if (!decl->long_name)
920 return 0;
921
922 name = skip_dash_dash(decl, arg[0]);
923 if (!name)
924 return 0;
925
926 next_prefix = 0;
927 name = skip_prefixes(name, prefixes, &next_prefix);
928
929 if (strncmp(name, "no-", 3))
930 return 0;
931 name += 3;
932
933 name = skip_prefixes(name, prefixes, &next_prefix);
934
935 if (match_long_name(decl, name, name + strlen(name))) {
936 if (decl->offset != (size_t) -1)
937 *p = 0;
938 if (decl->u.b.set)
939 decl->u.b.set(opt, 0);
940
941 return 1;
942 }
943
944 return 0;
945 }
946
947 static int parse_str_option(struct isl_arg *decl, char **arg,
948 struct isl_prefixes *prefixes, void *opt)
949 {
950 int has_argument;
951 const char *s;
952 char **p = (char **)(((char *)opt) + decl->offset);
953
954 s = skip_name(decl, arg[0], prefixes, 0, &has_argument);
955 if (!s)
956 return 0;
957
958 if (has_argument) {
959 free(*p);
960 *p = strdup(s);
961 return 1;
962 }
963
964 if (arg[1]) {
965 free(*p);
966 *p = strdup(arg[1]);
967 return 2;
968 }
969
970 return 0;
971 }
972
973 static int isl_arg_str_list_append(struct isl_arg *decl, void *opt,
974 const char *s)
975 {
976 int *n = (int *)(((char *) opt) + decl->u.str_list.offset_n);
977 char **list = *(char ***)(((char *) opt) + decl->offset);
978
979 list = realloc(list, (*n + 1) * sizeof(char *));
980 if (!list)
981 return -1;
982 *(char ***)(((char *) opt) + decl->offset) = list;
983 list[*n] = strdup(s);
984 (*n)++;
985 return 0;
986 }
987
988 static int parse_str_list_option(struct isl_arg *decl, char **arg,
989 struct isl_prefixes *prefixes, void *opt)
990 {
991 int has_argument;
992 const char *s;
993
994 s = skip_name(decl, arg[0], prefixes, 0, &has_argument);
995 if (!s)
996 return 0;
997
998 if (has_argument) {
999 isl_arg_str_list_append(decl, opt, s);
1000 return 1;
1001 }
1002
1003 if (arg[1]) {
1004 isl_arg_str_list_append(decl, opt, arg[1]);
1005 return 2;
1006 }
1007
1008 return 0;
1009 }
1010
1011 static int parse_int_option(struct isl_arg *decl, char **arg,
1012 struct isl_prefixes *prefixes, void *opt)
1013 {
1014 int has_argument;
1015 const char *val;
1016 char *endptr;
1017 int *p = (int *)(((char *)opt) + decl->offset);
1018
1019 val = skip_name(decl, arg[0], prefixes, 0, &has_argument);
1020 if (!val)
1021 return 0;
1022
1023 if (has_argument) {
1024 *p = atoi(val);
1025 return 1;
1026 }
1027
1028 if (arg[1]) {
1029 int i = strtol(arg[1], &endptr, 0);
1030 if (*endptr == '\0') {
1031 *p = i;
1032 return 2;
1033 }
1034 }
1035
1036 return 0;
1037 }
1038
1039 static int parse_long_option(struct isl_arg *decl, char **arg,
1040 struct isl_prefixes *prefixes, void *opt)
1041 {
1042 int has_argument;
1043 const char *val;
1044 char *endptr;
1045 long *p = (long *)(((char *)opt) + decl->offset);
1046
1047 val = skip_name(decl, arg[0], prefixes, 0, &has_argument);
1048 if (!val)
1049 return 0;
1050
1051 if (has_argument) {
1052 long l = strtol(val, NULL, 0);
1053 *p = l;
1054 if (decl->u.l.set)
1055 decl->u.l.set(opt, l);
1056 return 1;
1057 }
1058
1059 if (arg[1]) {
1060 long l = strtol(arg[1], &endptr, 0);
1061 if (*endptr == '\0') {
1062 *p = l;
1063 if (decl->u.l.set)
1064 decl->u.l.set(opt, l);
1065 return 2;
1066 }
1067 }
1068
1069 if (decl->u.l.default_value != decl->u.l.default_selected) {
1070 *p = decl->u.l.default_selected;
1071 if (decl->u.l.set)
1072 decl->u.l.set(opt, decl->u.l.default_selected);
1073 return 1;
1074 }
1075
1076 return 0;
1077 }
1078
1079 static int parse_ulong_option(struct isl_arg *decl, char **arg,
1080 struct isl_prefixes *prefixes, void *opt)
1081 {
1082 int has_argument;
1083 const char *val;
1084 char *endptr;
1085 unsigned long *p = (unsigned long *)(((char *)opt) + decl->offset);
1086
1087 val = skip_name(decl, arg[0], prefixes, 0, &has_argument);
1088 if (!val)
1089 return 0;
1090
1091 if (has_argument) {
1092 *p = strtoul(val, NULL, 0);
1093 return 1;
1094 }
1095
1096 if (arg[1]) {
1097 unsigned long ul = strtoul(arg[1], &endptr, 0);
1098 if (*endptr == '\0') {
1099 *p = ul;
1100 return 2;
1101 }
1102 }
1103
1104 return 0;
1105 }
1106
1107 static int parse_option(struct isl_arg *decl, char **arg,
1108 struct isl_prefixes *prefixes, void *opt);
1109
1110 static int parse_child_option(struct isl_arg *decl, char **arg,
1111 struct isl_prefixes *prefixes, void *opt)
1112 {
1113 void *child;
1114 int first, parsed;
1115
1116 if (decl->offset == (size_t) -1)
1117 child = opt;
1118 else
1119 child = *(void **)(((char *)opt) + decl->offset);
1120
1121 first = add_prefix(prefixes, decl->long_name);
1122 parsed = parse_option(decl->u.child.child->args, arg, prefixes, child);
1123 drop_prefix(prefixes, first);
1124
1125 return parsed;
1126 }
1127
1128 static int parse_option(struct isl_arg *decl, char **arg,
1129 struct isl_prefixes *prefixes, void *opt)
1130 {
1131 int i;
1132
1133 for (i = 0; decl[i].type != isl_arg_end; ++i) {
1134 int parsed = 0;
1135 switch (decl[i].type) {
1136 case isl_arg_choice:
1137 parsed = parse_choice_option(&decl[i], arg,
1138 prefixes, opt);
1139 break;
1140 case isl_arg_flags:
1141 parsed = parse_flags_option(&decl[i], arg,
1142 prefixes, opt);
1143 break;
1144 case isl_arg_int:
1145 parsed = parse_int_option(&decl[i], arg, prefixes, opt);
1146 break;
1147 case isl_arg_long:
1148 parsed = parse_long_option(&decl[i], arg,
1149 prefixes, opt);
1150 break;
1151 case isl_arg_ulong:
1152 parsed = parse_ulong_option(&decl[i], arg,
1153 prefixes, opt);
1154 break;
1155 case isl_arg_bool:
1156 parsed = parse_bool_option(&decl[i], arg,
1157 prefixes, opt);
1158 break;
1159 case isl_arg_str:
1160 parsed = parse_str_option(&decl[i], arg, prefixes, opt);
1161 break;
1162 case isl_arg_str_list:
1163 parsed = parse_str_list_option(&decl[i], arg, prefixes,
1164 opt);
1165 break;
1166 case isl_arg_child:
1167 parsed = parse_child_option(&decl[i], arg,
1168 prefixes, opt);
1169 break;
1170 case isl_arg_alias:
1171 case isl_arg_arg:
1172 case isl_arg_footer:
1173 case isl_arg_user:
1174 case isl_arg_version:
1175 case isl_arg_end:
1176 break;
1177 }
1178 if (parsed)
1179 return parsed;
1180 }
1181
1182 return 0;
1183 }
1184
1185 static void print_version(struct isl_arg *decl)
1186 {
1187 int i;
1188
1189 for (i = 0; decl[i].type != isl_arg_end; ++i) {
1190 switch (decl[i].type) {
1191 case isl_arg_version:
1192 decl[i].u.version.print_version();
1193 break;
1194 case isl_arg_child:
1195 print_version(decl[i].u.child.child->args);
1196 break;
1197 default:
1198 break;
1199 }
1200 }
1201 }
1202
1203 static void print_version_and_exit(struct isl_arg *decl)
1204 {
1205 print_version(decl);
1206
1207 exit(0);
1208 }
1209
1210 static int drop_argument(int argc, char **argv, int drop, int n)
1211 {
1212 for (; drop + n < argc; ++drop)
1213 argv[drop] = argv[drop + n];
1214
1215 return argc - n;
1216 }
1217
1218 static int n_arg(struct isl_arg *arg)
1219 {
1220 int i;
1221 int n_arg = 0;
1222
1223 for (i = 0; arg[i].type != isl_arg_end; ++i)
1224 if (arg[i].type == isl_arg_arg)
1225 n_arg++;
1226
1227 return n_arg;
1228 }
1229
1230 static int next_arg(struct isl_arg *arg, int a)
1231 {
1232 for (++a; arg[a].type != isl_arg_end; ++a)
1233 if (arg[a].type == isl_arg_arg)
1234 return a;
1235
1236 return -1;
1237 }
1238
1239 /* Unless ISL_ARG_SKIP_HELP is set, check if "arg" is
1240 * equal to "--help" and if so call print_help_and_exit.
1241 */
1242 static void check_help(struct isl_args *args, char *arg, char *prog, void *opt,
1243 unsigned flags)
1244 {
1245 if (ISL_FL_ISSET(flags, ISL_ARG_SKIP_HELP))
1246 return;
1247
1248 if (strcmp(arg, "--help") == 0)
1249 print_help_and_exit(args->args, prog, opt);
1250 }
1251
1252 int isl_args_parse(struct isl_args *args, int argc, char **argv, void *opt,
1253 unsigned flags)
1254 {
1255 int a = -1;
1256 int skip = 0;
1257 int i;
1258 int n;
1259 struct isl_prefixes prefixes = { 0 };
1260
1261 n = n_arg(args->args);
1262
1263 for (i = 1; i < argc; ++i) {
1264 if ((strcmp(argv[i], "--version") == 0 ||
1265 strcmp(argv[i], "-V") == 0) && any_version(args->args))
1266 print_version_and_exit(args->args);
1267 }
1268
1269 while (argc > 1 + skip) {
1270 int parsed;
1271 if (argv[1 + skip][0] != '-') {
1272 a = next_arg(args->args, a);
1273 if (a >= 0) {
1274 char **p;
1275 p = (char **)(((char *)opt)+args->args[a].offset);
1276 free(*p);
1277 *p = strdup(argv[1 + skip]);
1278 argc = drop_argument(argc, argv, 1 + skip, 1);
1279 --n;
1280 } else if (ISL_FL_ISSET(flags, ISL_ARG_ALL)) {
1281 fprintf(stderr, "%s: extra argument: %s\n",
1282 prog_name(argv[0]), argv[1 + skip]);
1283 exit(-1);
1284 } else
1285 ++skip;
1286 continue;
1287 }
1288 check_help(args, argv[1 + skip], argv[0], opt, flags);
1289 parsed = parse_option(args->args, &argv[1 + skip],
1290 &prefixes, opt);
1291 if (parsed)
1292 argc = drop_argument(argc, argv, 1 + skip, parsed);
1293 else if (ISL_FL_ISSET(flags, ISL_ARG_ALL)) {
1294 fprintf(stderr, "%s: unrecognized option: %s\n",
1295 prog_name(argv[0]), argv[1 + skip]);
1296 exit(-1);
1297 } else
1298 ++skip;
1299 }
1300
1301 if (n > 0) {
1302 fprintf(stderr, "%s: expecting %d more argument(s)\n",
1303 prog_name(argv[0]), n);
1304 exit(-1);
1305 }
1306
1307 return argc;
1308 }
Integer set library