?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
isl_ast_build_set_loop_bounds: extract out update of pending and generated
[isl.git] / isl_arg.c
bloba5211574a5038bfdd60cac9dfd367566402c6d50
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 if (decl->offset != (size_t) -1)
815 *(unsigned *)(((char *)opt) + decl->offset) = u;
816 if (decl->u.choice.set)
817 decl->u.choice.set(opt, u);
818
819 return 1;
820 }
821
822 if (!has_argument)
823 choice = arg[1];
824
825 for (i = 0; decl->u.choice.choice[i].name; ++i) {
826 unsigned u;
827
828 if (strcmp(choice, decl->u.choice.choice[i].name))
829 continue;
830
831 u = decl->u.choice.choice[i].value;
832 if (decl->offset != (size_t) -1)
833 *(unsigned *)(((char *)opt) + decl->offset) = u;
834 if (decl->u.choice.set)
835 decl->u.choice.set(opt, u);
836
837 return has_argument ? 1 : 2;
838 }
839
840 return 0;
841 }
842
843 static int set_flag(struct isl_arg *decl, unsigned *val, const char *flag,
844 size_t len)
845 {
846 int i;
847
848 for (i = 0; decl->u.flags.flags[i].name; ++i) {
849 if (strncmp(flag, decl->u.flags.flags[i].name, len))
850 continue;
851
852 *val &= ~decl->u.flags.flags[i].mask;
853 *val |= decl->u.flags.flags[i].value;
854
855 return 1;
856 }
857
858 return 0;
859 }
860
861 static int parse_flags_option(struct isl_arg *decl, char **arg,
862 struct isl_prefixes *prefixes, void *opt)
863 {
864 int has_argument;
865 const char *flags;
866 const char *comma;
867 unsigned val;
868
869 flags = skip_name(decl, arg[0], prefixes, 0, &has_argument);
870 if (!flags)
871 return 0;
872
873 if (!has_argument && !arg[1])
874 return 0;
875
876 if (!has_argument)
877 flags = arg[1];
878
879 val = 0;
880
881 while ((comma = strchr(flags, ',')) != NULL) {
882 if (!set_flag(decl, &val, flags, comma - flags))
883 return 0;
884 flags = comma + 1;
885 }
886 if (!set_flag(decl, &val, flags, strlen(flags)))
887 return 0;
888
889 *(unsigned *)(((char *)opt) + decl->offset) = val;
890
891 return has_argument ? 1 : 2;
892 }
893
894 static int parse_bool_option(struct isl_arg *decl, char **arg,
895 struct isl_prefixes *prefixes, void *opt)
896 {
897 const char *name;
898 unsigned *p = (unsigned *)(((char *)opt) + decl->offset);
899 int next_prefix;
900
901 if (skip_name(decl, arg[0], prefixes, 0, NULL)) {
902 if ((decl->flags & ISL_ARG_BOOL_ARG) && arg[1]) {
903 char *endptr;
904 int val = strtol(arg[1], &endptr, 0);
905 if (*endptr == '\0' && (val == 0 || val == 1)) {
906 if (decl->offset != (size_t) -1)
907 *p = val;
908 if (decl->u.b.set)
909 decl->u.b.set(opt, val);
910 return 2;
911 }
912 }
913 if (decl->offset != (size_t) -1)
914 *p = 1;
915 if (decl->u.b.set)
916 decl->u.b.set(opt, 1);
917
918 return 1;
919 }
920
921 if (!decl->long_name)
922 return 0;
923
924 name = skip_dash_dash(decl, arg[0]);
925 if (!name)
926 return 0;
927
928 next_prefix = 0;
929 name = skip_prefixes(name, prefixes, &next_prefix);
930
931 if (strncmp(name, "no-", 3))
932 return 0;
933 name += 3;
934
935 name = skip_prefixes(name, prefixes, &next_prefix);
936
937 if (match_long_name(decl, name, name + strlen(name))) {
938 if (decl->offset != (size_t) -1)
939 *p = 0;
940 if (decl->u.b.set)
941 decl->u.b.set(opt, 0);
942
943 return 1;
944 }
945
946 return 0;
947 }
948
949 static int parse_str_option(struct isl_arg *decl, char **arg,
950 struct isl_prefixes *prefixes, void *opt)
951 {
952 int has_argument;
953 const char *s;
954 char **p = (char **)(((char *)opt) + decl->offset);
955
956 s = skip_name(decl, arg[0], prefixes, 0, &has_argument);
957 if (!s)
958 return 0;
959
960 if (has_argument) {
961 free(*p);
962 *p = strdup(s);
963 return 1;
964 }
965
966 if (arg[1]) {
967 free(*p);
968 *p = strdup(arg[1]);
969 return 2;
970 }
971
972 return 0;
973 }
974
975 static int isl_arg_str_list_append(struct isl_arg *decl, void *opt,
976 const char *s)
977 {
978 int *n = (int *)(((char *) opt) + decl->u.str_list.offset_n);
979 char **list = *(char ***)(((char *) opt) + decl->offset);
980
981 list = realloc(list, (*n + 1) * sizeof(char *));
982 if (!list)
983 return -1;
984 *(char ***)(((char *) opt) + decl->offset) = list;
985 list[*n] = strdup(s);
986 (*n)++;
987 return 0;
988 }
989
990 static int parse_str_list_option(struct isl_arg *decl, char **arg,
991 struct isl_prefixes *prefixes, void *opt)
992 {
993 int has_argument;
994 const char *s;
995
996 s = skip_name(decl, arg[0], prefixes, 0, &has_argument);
997 if (!s)
998 return 0;
999
1000 if (has_argument) {
1001 isl_arg_str_list_append(decl, opt, s);
1002 return 1;
1003 }
1004
1005 if (arg[1]) {
1006 isl_arg_str_list_append(decl, opt, arg[1]);
1007 return 2;
1008 }
1009
1010 return 0;
1011 }
1012
1013 static int parse_int_option(struct isl_arg *decl, char **arg,
1014 struct isl_prefixes *prefixes, void *opt)
1015 {
1016 int has_argument;
1017 const char *val;
1018 char *endptr;
1019 int *p = (int *)(((char *)opt) + decl->offset);
1020
1021 val = skip_name(decl, arg[0], prefixes, 0, &has_argument);
1022 if (!val)
1023 return 0;
1024
1025 if (has_argument) {
1026 *p = atoi(val);
1027 return 1;
1028 }
1029
1030 if (arg[1]) {
1031 int i = strtol(arg[1], &endptr, 0);
1032 if (*endptr == '\0') {
1033 *p = i;
1034 return 2;
1035 }
1036 }
1037
1038 return 0;
1039 }
1040
1041 static int parse_long_option(struct isl_arg *decl, char **arg,
1042 struct isl_prefixes *prefixes, void *opt)
1043 {
1044 int has_argument;
1045 const char *val;
1046 char *endptr;
1047 long *p = (long *)(((char *)opt) + decl->offset);
1048
1049 val = skip_name(decl, arg[0], prefixes, 0, &has_argument);
1050 if (!val)
1051 return 0;
1052
1053 if (has_argument) {
1054 long l = strtol(val, NULL, 0);
1055 *p = l;
1056 if (decl->u.l.set)
1057 decl->u.l.set(opt, l);
1058 return 1;
1059 }
1060
1061 if (arg[1]) {
1062 long l = strtol(arg[1], &endptr, 0);
1063 if (*endptr == '\0') {
1064 *p = l;
1065 if (decl->u.l.set)
1066 decl->u.l.set(opt, l);
1067 return 2;
1068 }
1069 }
1070
1071 if (decl->u.l.default_value != decl->u.l.default_selected) {
1072 *p = decl->u.l.default_selected;
1073 if (decl->u.l.set)
1074 decl->u.l.set(opt, decl->u.l.default_selected);
1075 return 1;
1076 }
1077
1078 return 0;
1079 }
1080
1081 static int parse_ulong_option(struct isl_arg *decl, char **arg,
1082 struct isl_prefixes *prefixes, void *opt)
1083 {
1084 int has_argument;
1085 const char *val;
1086 char *endptr;
1087 unsigned long *p = (unsigned long *)(((char *)opt) + decl->offset);
1088
1089 val = skip_name(decl, arg[0], prefixes, 0, &has_argument);
1090 if (!val)
1091 return 0;
1092
1093 if (has_argument) {
1094 *p = strtoul(val, NULL, 0);
1095 return 1;
1096 }
1097
1098 if (arg[1]) {
1099 unsigned long ul = strtoul(arg[1], &endptr, 0);
1100 if (*endptr == '\0') {
1101 *p = ul;
1102 return 2;
1103 }
1104 }
1105
1106 return 0;
1107 }
1108
1109 static int parse_option(struct isl_arg *decl, char **arg,
1110 struct isl_prefixes *prefixes, void *opt);
1111
1112 static int parse_child_option(struct isl_arg *decl, char **arg,
1113 struct isl_prefixes *prefixes, void *opt)
1114 {
1115 void *child;
1116 int first, parsed;
1117
1118 if (decl->offset == (size_t) -1)
1119 child = opt;
1120 else
1121 child = *(void **)(((char *)opt) + decl->offset);
1122
1123 first = add_prefix(prefixes, decl->long_name);
1124 parsed = parse_option(decl->u.child.child->args, arg, prefixes, child);
1125 drop_prefix(prefixes, first);
1126
1127 return parsed;
1128 }
1129
1130 static int parse_option(struct isl_arg *decl, char **arg,
1131 struct isl_prefixes *prefixes, void *opt)
1132 {
1133 int i;
1134
1135 for (i = 0; decl[i].type != isl_arg_end; ++i) {
1136 int parsed = 0;
1137 switch (decl[i].type) {
1138 case isl_arg_choice:
1139 parsed = parse_choice_option(&decl[i], arg,
1140 prefixes, opt);
1141 break;
1142 case isl_arg_flags:
1143 parsed = parse_flags_option(&decl[i], arg,
1144 prefixes, opt);
1145 break;
1146 case isl_arg_int:
1147 parsed = parse_int_option(&decl[i], arg, prefixes, opt);
1148 break;
1149 case isl_arg_long:
1150 parsed = parse_long_option(&decl[i], arg,
1151 prefixes, opt);
1152 break;
1153 case isl_arg_ulong:
1154 parsed = parse_ulong_option(&decl[i], arg,
1155 prefixes, opt);
1156 break;
1157 case isl_arg_bool:
1158 parsed = parse_bool_option(&decl[i], arg,
1159 prefixes, opt);
1160 break;
1161 case isl_arg_str:
1162 parsed = parse_str_option(&decl[i], arg, prefixes, opt);
1163 break;
1164 case isl_arg_str_list:
1165 parsed = parse_str_list_option(&decl[i], arg, prefixes,
1166 opt);
1167 break;
1168 case isl_arg_child:
1169 parsed = parse_child_option(&decl[i], arg,
1170 prefixes, opt);
1171 break;
1172 case isl_arg_alias:
1173 case isl_arg_arg:
1174 case isl_arg_footer:
1175 case isl_arg_user:
1176 case isl_arg_version:
1177 case isl_arg_end:
1178 break;
1179 }
1180 if (parsed)
1181 return parsed;
1182 }
1183
1184 return 0;
1185 }
1186
1187 static void print_version(struct isl_arg *decl)
1188 {
1189 int i;
1190
1191 for (i = 0; decl[i].type != isl_arg_end; ++i) {
1192 switch (decl[i].type) {
1193 case isl_arg_version:
1194 decl[i].u.version.print_version();
1195 break;
1196 case isl_arg_child:
1197 print_version(decl[i].u.child.child->args);
1198 break;
1199 default:
1200 break;
1201 }
1202 }
1203 }
1204
1205 static void print_version_and_exit(struct isl_arg *decl)
1206 {
1207 print_version(decl);
1208
1209 exit(0);
1210 }
1211
1212 static int drop_argument(int argc, char **argv, int drop, int n)
1213 {
1214 for (; drop + n < argc; ++drop)
1215 argv[drop] = argv[drop + n];
1216
1217 return argc - n;
1218 }
1219
1220 static int n_arg(struct isl_arg *arg)
1221 {
1222 int i;
1223 int n_arg = 0;
1224
1225 for (i = 0; arg[i].type != isl_arg_end; ++i)
1226 if (arg[i].type == isl_arg_arg)
1227 n_arg++;
1228
1229 return n_arg;
1230 }
1231
1232 static int next_arg(struct isl_arg *arg, int a)
1233 {
1234 for (++a; arg[a].type != isl_arg_end; ++a)
1235 if (arg[a].type == isl_arg_arg)
1236 return a;
1237
1238 return -1;
1239 }
1240
1241 /* Unless ISL_ARG_SKIP_HELP is set, check if "arg" is
1242 * equal to "--help" and if so call print_help_and_exit.
1243 */
1244 static void check_help(struct isl_args *args, char *arg, char *prog, void *opt,
1245 unsigned flags)
1246 {
1247 if (ISL_FL_ISSET(flags, ISL_ARG_SKIP_HELP))
1248 return;
1249
1250 if (strcmp(arg, "--help") == 0)
1251 print_help_and_exit(args->args, prog, opt);
1252 }
1253
1254 int isl_args_parse(struct isl_args *args, int argc, char **argv, void *opt,
1255 unsigned flags)
1256 {
1257 int a = -1;
1258 int skip = 0;
1259 int i;
1260 int n;
1261 struct isl_prefixes prefixes = { 0 };
1262
1263 n = n_arg(args->args);
1264
1265 for (i = 1; i < argc; ++i) {
1266 if ((strcmp(argv[i], "--version") == 0 ||
1267 strcmp(argv[i], "-V") == 0) && any_version(args->args))
1268 print_version_and_exit(args->args);
1269 }
1270
1271 while (argc > 1 + skip) {
1272 int parsed;
1273 if (argv[1 + skip][0] != '-') {
1274 a = next_arg(args->args, a);
1275 if (a >= 0) {
1276 char **p;
1277 p = (char **)(((char *)opt)+args->args[a].offset);
1278 free(*p);
1279 *p = strdup(argv[1 + skip]);
1280 argc = drop_argument(argc, argv, 1 + skip, 1);
1281 --n;
1282 } else if (ISL_FL_ISSET(flags, ISL_ARG_ALL)) {
1283 fprintf(stderr, "%s: extra argument: %s\n",
1284 prog_name(argv[0]), argv[1 + skip]);
1285 exit(-1);
1286 } else
1287 ++skip;
1288 continue;
1289 }
1290 check_help(args, argv[1 + skip], argv[0], opt, flags);
1291 parsed = parse_option(args->args, &argv[1 + skip],
1292 &prefixes, opt);
1293 if (parsed)
1294 argc = drop_argument(argc, argv, 1 + skip, parsed);
1295 else if (ISL_FL_ISSET(flags, ISL_ARG_ALL)) {
1296 fprintf(stderr, "%s: unrecognized option: %s\n",
1297 prog_name(argv[0]), argv[1 + skip]);
1298 exit(-1);
1299 } else
1300 ++skip;
1301 }
1302
1303 if (n > 0) {
1304 fprintf(stderr, "%s: expecting %d more argument(s)\n",
1305 prog_name(argv[0]), n);
1306 exit(-1);
1307 }
1308
1309 return argc;
1310 }
Integer set library