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