isl_arg.c

   1 /*
   2  * Copyright 2008-2009 Katholieke Universiteit Leuven
   3  *
   4  * Use of this software is governed by the GNU LGPLv2.1 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 void set_default_choice(struct isl_arg *arg, void *opt)
  18 {
  19         *(unsigned *)(((char *)opt) + arg->offset) = arg->u.choice.default_value;
  20 }
  21
  22 static void set_default_flags(struct isl_arg *arg, void *opt)
  23 {
  24         *(unsigned *)(((char *)opt) + arg->offset) = arg->u.flags.default_value;
  25 }
  26
  27 static void set_default_bool(struct isl_arg *arg, void *opt)
  28 {
  29         *(unsigned *)(((char *)opt) + arg->offset) = arg->u.b.default_value;
  30 }
  31
  32 static void set_default_child(struct isl_arg *arg, void *opt)
  33 {
  34         void *child = calloc(1, arg->u.child.size);
  35
  36         if (child)
  37                 isl_arg_set_defaults(arg->u.child.child, child);
  38
  39         *(void **)(((char *)opt) + arg->offset) = child;
  40 }
  41
  42 static void set_default_user(struct isl_arg *arg, void *opt)
  43 {
  44         arg->u.user.init(((char *)opt) + arg->offset);
  45 }
  46
  47 static void set_default_long(struct isl_arg *arg, void *opt)
  48 {
  49         *(long *)(((char *)opt) + arg->offset) = arg->u.l.default_value;
  50 }
  51
  52 static void set_default_ulong(struct isl_arg *arg, void *opt)
  53 {
  54         *(unsigned long *)(((char *)opt) + arg->offset) = arg->u.ul.default_value;
  55 }
  56
  57 static void set_default_str(struct isl_arg *arg, void *opt)
  58 {
  59         const char *str = NULL;
  60         if (arg->u.str.default_value)
  61                 str = strdup(arg->u.str.default_value);
  62         *(const char **)(((char *)opt) + arg->offset) = str;
  63 }
  64
  65 void isl_arg_set_defaults(struct isl_arg *arg, void *opt)
  66 {
  67         int i;
  68
  69         for (i = 0; arg[i].type != isl_arg_end; ++i) {
  70                 switch (arg[i].type) {
  71                 case isl_arg_choice:
  72                         set_default_choice(&arg[i], opt);
  73                         break;
  74                 case isl_arg_flags:
  75                         set_default_flags(&arg[i], opt);
  76                         break;
  77                 case isl_arg_bool:
  78                         set_default_bool(&arg[i], opt);
  79                         break;
  80                 case isl_arg_child:
  81                         set_default_child(&arg[i], opt);
  82                         break;
  83                 case isl_arg_user:
  84                         set_default_user(&arg[i], opt);
  85                         break;
  86                 case isl_arg_long:
  87                         set_default_long(&arg[i], opt);
  88                         break;
  89                 case isl_arg_ulong:
  90                         set_default_ulong(&arg[i], opt);
  91                         break;
  92                 case isl_arg_arg:
  93                 case isl_arg_str:
  94                         set_default_str(&arg[i], opt);
  95                         break;
  96                 case isl_arg_version:
  97                 case isl_arg_end:
  98                         break;
  99                 }
 100         }
 101 }
 102
 103 void isl_arg_free(struct isl_arg *arg, void *opt)
 104 {
 105         int i;
 106
 107         if (!opt)
 108                 return;
 109
 110         for (i = 0; arg[i].type != isl_arg_end; ++i) {
 111                 switch (arg[i].type) {
 112                 case isl_arg_child:
 113                         isl_arg_free(arg[i].u.child.child,
 114                                 *(void **)(((char *)opt) + arg[i].offset));
 115                         break;
 116                 case isl_arg_arg:
 117                 case isl_arg_str:
 118                         free(*(char **)(((char *)opt) + arg[i].offset));
 119                         break;
 120                 case isl_arg_user:
 121                         if (arg[i].u.user.clear)
 122                                 arg[i].u.user.clear(((char *)opt) + arg[i].offset);
 123                         break;
 124                 case isl_arg_bool:
 125                 case isl_arg_choice:
 126                 case isl_arg_flags:
 127                 case isl_arg_long:
 128                 case isl_arg_ulong:
 129                 case isl_arg_version:
 130                 case isl_arg_end:
 131                         break;
 132                 }
 133         }
 134
 135         free(opt);
 136 }
 137
 138 static int print_arg_help(struct isl_arg *decl, const char *prefix, int no)
 139 {
 140         int len = 0;
 141
 142         if (!decl->long_name) {
 143                 printf("  -%c", decl->short_name);
 144                 return 4;
 145         }
 146
 147         if (decl->short_name)
 148                 printf("  -%c, --", decl->short_name);
 149         else
 150                 printf("      --");
 151         len += 8;
 152
 153         if (prefix) {
 154                 printf("%s-", prefix);
 155                 len += strlen(prefix) + 1;
 156         }
 157         if (no) {
 158                 printf("no-");
 159                 len += 3;
 160         }
 161         printf("%s", decl->long_name);
 162         len += strlen(decl->long_name);
 163
 164         return len;
 165 }
 166
 167 const void *isl_memrchr(const void *s, int c, size_t n)
 168 {
 169         const char *p = s;
 170         while (n-- > 0)
 171                 if (p[n] == c)
 172                         return p + n;
 173         return NULL;
 174 }
 175
 176 static int print_help_msg(struct isl_arg *decl, int pos)
 177 {
 178         int len;
 179         const char *s;
 180
 181         if (!decl->help_msg)
 182                 return pos;
 183
 184         if (pos >= 29)
 185                 printf("\n%30s", "");
 186         else
 187                 printf("%*s", 30 - pos, "");
 188
 189         s = decl->help_msg;
 190         len = strlen(s);
 191         while (len > 45) {
 192                 const char *space = isl_memrchr(s, ' ', 45);
 193                 int l;
 194
 195                 if (!space)
 196                         space = strchr(s + 45, ' ');
 197                 if (!space)
 198                         break;
 199                 l = space - s;
 200                 printf("%.*s", l, s);
 201                 s = space + 1;
 202                 len -= l + 1;
 203                 printf("\n%30s", "");
 204         }
 205
 206         printf("%s", s);
 207         return len;
 208 }
 209
 210 static void print_default_choice(struct isl_arg *decl, int pos)
 211 {
 212         int i;
 213         const char *default_prefix = "[default: ";
 214         const char *default_suffix = "]";
 215         const char *s = "none";
 216         int len;
 217
 218         for (i = 0; decl->u.choice.choice[i].name; ++i)
 219                 if (decl->u.choice.choice[i].value == decl->u.choice.default_value) {
 220                         s = decl->u.choice.choice[i].name;
 221                         break;
 222                 }
 223         len = strlen(default_prefix) + strlen(s) + strlen(default_suffix);
 224
 225         if (!decl->help_msg) {
 226                 if (pos >= 29)
 227                         printf("\n%30s", "");
 228                 else
 229                         printf("%*s", 30 - pos, "");
 230                 pos = 0;
 231         } else {
 232                 if (pos + len >= 48)
 233                         printf("\n%30s", "");
 234                 else
 235                         printf(" ");
 236         }
 237         printf("%s%s%s", default_prefix, s, default_suffix);
 238 }
 239
 240 static void print_choice_help(struct isl_arg *decl, const char *prefix)
 241 {
 242         int i;
 243         int pos;
 244
 245         pos = print_arg_help(decl, prefix, 0);
 246         printf("=");
 247         pos++;
 248
 249         for (i = 0; decl->u.choice.choice[i].name; ++i) {
 250                 if (i) {
 251                         printf("|");
 252                         pos++;
 253                 }
 254                 printf("%s", decl->u.choice.choice[i].name);
 255                 pos += strlen(decl->u.choice.choice[i].name);
 256         }
 257
 258         pos = print_help_msg(decl, pos);
 259         print_default_choice(decl, pos);
 260
 261         printf("\n");
 262 }
 263
 264 static void print_default_flags(struct isl_arg *decl, int pos)
 265 {
 266         int i, first;
 267         const char *default_prefix = "[default: ";
 268         const char *default_suffix = "]";
 269         int len = strlen(default_prefix) + strlen(default_suffix);
 270
 271         for (i = 0; decl->u.flags.flags[i].name; ++i)
 272                 if ((decl->u.flags.default_value & decl->u.flags.flags[i].mask) ==
 273                      decl->u.flags.flags[i].value)
 274                         len += strlen(decl->u.flags.flags[i].name);
 275
 276         if (!decl->help_msg) {
 277                 if (pos >= 29)
 278                         printf("\n%30s", "");
 279                 else
 280                         printf("%*s", 30 - pos, "");
 281                 pos = 0;
 282         } else {
 283                 if (pos + len >= 48)
 284                         printf("\n%30s", "");
 285                 else
 286                         printf(" ");
 287         }
 288         printf("%s", default_prefix);
 289
 290         for (first = 1, i = 0; decl->u.flags.flags[i].name; ++i)
 291                 if ((decl->u.flags.default_value & decl->u.flags.flags[i].mask) ==
 292                      decl->u.flags.flags[i].value) {
 293                         if (!first)
 294                                 printf(",");
 295                         printf("%s", decl->u.flags.flags[i].name);
 296                         first = 0;
 297                 }
 298
 299         printf("%s", default_suffix);
 300 }
 301
 302 static void print_flags_help(struct isl_arg *decl, const char *prefix)
 303 {
 304         int i, j;
 305         int pos;
 306
 307         pos = print_arg_help(decl, prefix, 0);
 308         printf("=");
 309         pos++;
 310
 311         for (i = 0; decl->u.flags.flags[i].name; ++i) {
 312                 if (i) {
 313                         printf(",");
 314                         pos++;
 315                 }
 316                 for (j = i;
 317                      decl->u.flags.flags[j].mask == decl->u.flags.flags[i].mask;
 318                      ++j) {
 319                         if (j != i) {
 320                                 printf("|");
 321                                 pos++;
 322                         }
 323                         printf("%s", decl->u.flags.flags[j].name);
 324                         pos += strlen(decl->u.flags.flags[j].name);
 325                 }
 326                 i = j - 1;
 327         }
 328
 329         pos = print_help_msg(decl, pos);
 330         print_default_flags(decl, pos);
 331
 332         printf("\n");
 333 }
 334
 335 static void print_bool_help(struct isl_arg *decl, const char *prefix)
 336 {
 337         int pos;
 338         int no = decl->u.b.default_value == 1;
 339         pos = print_arg_help(decl, prefix, no);
 340         print_help_msg(decl, pos);
 341         printf("\n");
 342 }
 343
 344 static void print_long_help(struct isl_arg *decl, const char *prefix)
 345 {
 346         int pos;
 347         pos = print_arg_help(decl, prefix, 0);
 348         if (decl->u.l.default_value != decl->u.l.default_selected) {
 349                 printf("[");
 350                 pos++;
 351         }
 352         printf("=long");
 353         pos += 5;
 354         if (decl->u.l.default_value != decl->u.l.default_selected) {
 355                 printf("]");
 356                 pos++;
 357         }
 358         print_help_msg(decl, pos);
 359         printf("\n");
 360 }
 361
 362 static void print_ulong_help(struct isl_arg *decl, const char *prefix)
 363 {
 364         int pos;
 365         pos = print_arg_help(decl, prefix, 0);
 366         printf("=ulong");
 367         pos += 6;
 368         print_help_msg(decl, pos);
 369         printf("\n");
 370 }
 371
 372 static void print_str_help(struct isl_arg *decl, const char *prefix)
 373 {
 374         int pos;
 375         const char *a = decl->argument_name ? decl->argument_name : "string";
 376         pos = print_arg_help(decl, prefix, 0);
 377         printf("=%s", a);
 378         pos += 1 + strlen(a);
 379         print_help_msg(decl, pos);
 380         printf("\n");
 381 }
 382
 383 static void print_help(struct isl_arg *arg, const char *prefix)
 384 {
 385         int i;
 386
 387         for (i = 0; arg[i].type != isl_arg_end; ++i) {
 388                 switch (arg[i].type) {
 389                 case isl_arg_flags:
 390                         print_flags_help(&arg[i], prefix);
 391                         break;
 392                 case isl_arg_choice:
 393                         print_choice_help(&arg[i], prefix);
 394                         break;
 395                 case isl_arg_bool:
 396                         print_bool_help(&arg[i], prefix);
 397                         break;
 398                 case isl_arg_long:
 399                         print_long_help(&arg[i], prefix);
 400                         break;
 401                 case isl_arg_ulong:
 402                         print_ulong_help(&arg[i], prefix);
 403                         break;
 404                 case isl_arg_str:
 405                         print_str_help(&arg[i], prefix);
 406                         break;
 407                 case isl_arg_version:
 408                         printf("  -V, --version\n");
 409                         break;
 410                 case isl_arg_arg:
 411                 case isl_arg_child:
 412                 case isl_arg_user:
 413                 case isl_arg_end:
 414                         break;
 415                 }
 416         }
 417
 418         for (i = 0; arg[i].type != isl_arg_end; ++i) {
 419                 if (arg[i].type != isl_arg_child)
 420                         continue;
 421
 422                 printf("\n");
 423                 if (arg[i].help_msg)
 424                         printf(" %s\n", arg[i].help_msg);
 425                 print_help(arg[i].u.child.child, arg[i].long_name);
 426         }
 427 }
 428
 429 static const char *prog_name(const char *prog)
 430 {
 431         const char *slash;
 432
 433         slash = strrchr(prog, '/');
 434         if (slash)
 435                 prog = slash + 1;
 436         if (strncmp(prog, "lt-", 3) == 0)
 437                 prog += 3;
 438
 439         return prog;
 440 }
 441
 442 static void print_help_and_exit(struct isl_arg *arg, const char *prog)
 443 {
 444         int i;
 445
 446         printf("Usage: %s [OPTION...]", prog_name(prog));
 447
 448         for (i = 0; arg[i].type != isl_arg_end; ++i)
 449                 if (arg[i].type == isl_arg_arg)
 450                         printf(" %s", arg[i].argument_name);
 451
 452         printf("\n\n");
 453
 454         print_help(arg, NULL);
 455
 456         exit(0);
 457 }
 458
 459 static const char *skip_name(struct isl_arg *decl, const char *arg,
 460         const char *prefix, int need_argument, int *has_argument)
 461 {
 462         const char *equal;
 463         const char *name;
 464         const char *end;
 465
 466         if (arg[0] == '-' && arg[1] && arg[1] == decl->short_name) {
 467                 if (need_argument && !arg[2])
 468                         return NULL;
 469                 if (has_argument)
 470                         *has_argument = arg[2] != '\0';
 471                 return arg + 2;
 472         }
 473
 474         if (strncmp(arg, "--", 2))
 475                 return NULL;
 476
 477         name = arg + 2;
 478         equal = strchr(name, '=');
 479         if (need_argument && !equal)
 480                 return NULL;
 481
 482         if (has_argument)
 483                 *has_argument = !!equal;
 484         end = equal ? equal : name + strlen(name);
 485
 486         if (prefix) {
 487                 size_t prefix_len = strlen(prefix);
 488                 if (strncmp(name, prefix, prefix_len) == 0 &&
 489                     name[prefix_len] == '-')
 490                         name += prefix_len + 1;
 491         }
 492
 493         if (end - name != strlen(decl->long_name) ||
 494             strncmp(name, decl->long_name, end - name))
 495                 return NULL;
 496
 497         return equal ? equal + 1 : end;
 498 }
 499
 500 static int parse_choice_option(struct isl_arg *decl, char **arg,
 501         const char *prefix, void *opt)
 502 {
 503         int i;
 504         int has_argument;
 505         const char *choice;
 506
 507         choice = skip_name(decl, arg[0], prefix, 0, &has_argument);
 508         if (!choice)
 509                 return 0;
 510
 511         if (!has_argument && (!arg[1] || arg[1][0] == '-')) {
 512                 unsigned u = decl->u.choice.default_selected;
 513                 if (decl->u.choice.set)
 514                         decl->u.choice.set(opt, u);
 515                 else
 516                         *(unsigned *)(((char *)opt) + decl->offset) = u;
 517
 518                 return 1;
 519         }
 520
 521         if (!has_argument)
 522                 choice = arg[1];
 523
 524         for (i = 0; decl->u.choice.choice[i].name; ++i) {
 525                 unsigned u;
 526
 527                 if (strcmp(choice, decl->u.choice.choice[i].name))
 528                         continue;
 529
 530                 u = decl->u.choice.choice[i].value;
 531                 if (decl->u.choice.set)
 532                         decl->u.choice.set(opt, u);
 533                 else
 534                         *(unsigned *)(((char *)opt) + decl->offset) = u;
 535
 536                 return has_argument ? 1 : 2;
 537         }
 538
 539         return 0;
 540 }
 541
 542 static int set_flag(struct isl_arg *decl, unsigned *val, const char *flag,
 543         size_t len)
 544 {
 545         int i;
 546
 547         for (i = 0; decl->u.flags.flags[i].name; ++i) {
 548                 if (strncmp(flag, decl->u.flags.flags[i].name, len))
 549                         continue;
 550
 551                 *val &= ~decl->u.flags.flags[i].mask;
 552                 *val |= decl->u.flags.flags[i].value;
 553
 554                 return 1;
 555         }
 556
 557         return 0;
 558 }
 559
 560 static int parse_flags_option(struct isl_arg *decl, char **arg,
 561         const char *prefix, void *opt)
 562 {
 563         int has_argument;
 564         const char *flags;
 565         const char *comma;
 566         unsigned val;
 567
 568         flags = skip_name(decl, arg[0], prefix, 0, &has_argument);
 569         if (!flags)
 570                 return 0;
 571
 572         if (!has_argument && !arg[1])
 573                 return 0;
 574
 575         if (!has_argument)
 576                 flags = arg[1];
 577
 578         val = *(unsigned *)(((char *)opt) + decl->offset);
 579
 580         while ((comma = strchr(flags, ',')) != NULL) {
 581                 if (!set_flag(decl, &val, flags, comma - flags))
 582                         return 0;
 583                 flags = comma + 1;
 584         }
 585         if (!set_flag(decl, &val, flags, strlen(flags)))
 586                 return 0;
 587
 588         *(unsigned *)(((char *)opt) + decl->offset) = val;
 589
 590         return has_argument ? 1 : 2;
 591 }
 592
 593 static int parse_bool_option(struct isl_arg *decl, const char *arg,
 594         const char *prefix, void *opt)
 595 {
 596         if (skip_name(decl, arg, prefix, 0, NULL)) {
 597                 *(unsigned *)(((char *)opt) + decl->offset) = 1;
 598
 599                 return 1;
 600         }
 601
 602         if (strncmp(arg, "--", 2))
 603                 return 0;
 604         arg += 2;
 605
 606         if (prefix) {
 607                 size_t prefix_len = strlen(prefix);
 608                 if (strncmp(arg, prefix, prefix_len) == 0 &&
 609                     arg[prefix_len] == '-') {
 610                         arg += prefix_len + 1;
 611                         prefix = NULL;
 612                 }
 613         }
 614
 615         if (strncmp(arg, "no-", 3))
 616                 return 0;
 617         arg += 3;
 618
 619         if (prefix) {
 620                 size_t prefix_len = strlen(prefix);
 621                 if (strncmp(arg, prefix, prefix_len) == 0 &&
 622                     arg[prefix_len] == '-')
 623                         arg += prefix_len + 1;
 624         }
 625
 626         if (!strcmp(arg, decl->long_name)) {
 627                 *(unsigned *)(((char *)opt) + decl->offset) = 0;
 628
 629                 return 1;
 630         }
 631
 632         return 0;
 633 }
 634
 635 static int parse_str_option(struct isl_arg *decl, char **arg,
 636         const char *prefix, void *opt)
 637 {
 638         int has_argument;
 639         const char *s;
 640         char **p = (char **)(((char *)opt) + decl->offset);
 641
 642         s = skip_name(decl, arg[0], prefix, 0, &has_argument);
 643         if (!s)
 644                 return 0;
 645
 646         if (has_argument) {
 647                 *p = strdup(s);
 648                 return 1;
 649         }
 650
 651         if (arg[1]) {
 652                 *p = strdup(arg[1]);
 653                 return 2;
 654         }
 655
 656         return 0;
 657 }
 658
 659 static int parse_long_option(struct isl_arg *decl, char **arg,
 660         const char *prefix, void *opt)
 661 {
 662         int has_argument;
 663         const char *val;
 664         char *endptr;
 665         long *p = (long *)(((char *)opt) + decl->offset);
 666
 667         val = skip_name(decl, arg[0], prefix, 0, &has_argument);
 668         if (!val)
 669                 return 0;
 670
 671         if (has_argument) {
 672                 long l = strtol(val, NULL, 0);
 673                 if (decl->u.l.set)
 674                         decl->u.l.set(opt, l);
 675                 else
 676                         *p = l;
 677                 return 1;
 678         }
 679
 680         if (arg[1]) {
 681                 long l = strtol(arg[1], &endptr, 0);
 682                 if (*endptr == '\0') {
 683                         if (decl->u.l.set)
 684                                 decl->u.l.set(opt, l);
 685                         else
 686                                 *p = l;
 687                         return 2;
 688                 }
 689         }
 690
 691         if (decl->u.l.default_value != decl->u.l.default_selected) {
 692                 if (decl->u.l.set)
 693                         decl->u.l.set(opt, decl->u.l.default_selected);
 694                 else
 695                         *p = decl->u.l.default_selected;
 696                 return 1;
 697         }
 698
 699         return 0;
 700 }
 701
 702 static int parse_ulong_option(struct isl_arg *decl, char **arg,
 703         const char *prefix, void *opt)
 704 {
 705         int has_argument;
 706         const char *val;
 707         char *endptr;
 708         unsigned long *p = (unsigned long *)(((char *)opt) + decl->offset);
 709
 710         val = skip_name(decl, arg[0], prefix, 0, &has_argument);
 711         if (!val)
 712                 return 0;
 713
 714         if (has_argument) {
 715                 *p = strtoul(val, NULL, 0);
 716                 return 1;
 717         }
 718
 719         if (arg[1]) {
 720                 unsigned long ul = strtoul(arg[1], &endptr, 0);
 721                 if (*endptr == '\0') {
 722                         *p = ul;
 723                         return 2;
 724                 }
 725         }
 726
 727         return 0;
 728 }
 729
 730 static int parse_option(struct isl_arg *decl, char **arg,
 731         const char *prefix, void *opt);
 732
 733 static int parse_child_option(struct isl_arg *decl, char **arg, void *opt)
 734 {
 735         return parse_option(decl->u.child.child, arg, decl->long_name,
 736                                 *(void **)(((char *)opt) + decl->offset));
 737 }
 738
 739 static int parse_option(struct isl_arg *decl, char **arg,
 740         const char *prefix, void *opt)
 741 {
 742         int i;
 743
 744         for (i = 0; decl[i].type != isl_arg_end; ++i) {
 745                 int parsed = 0;
 746                 switch (decl[i].type) {
 747                 case isl_arg_choice:
 748                         parsed = parse_choice_option(&decl[i], arg, prefix, opt);
 749                         break;
 750                 case isl_arg_flags:
 751                         parsed = parse_flags_option(&decl[i], arg, prefix, opt);
 752                         break;
 753                 case isl_arg_long:
 754                         parsed = parse_long_option(&decl[i], arg, prefix, opt);
 755                         break;
 756                 case isl_arg_ulong:
 757                         parsed = parse_ulong_option(&decl[i], arg, prefix, opt);
 758                         break;
 759                 case isl_arg_bool:
 760                         parsed = parse_bool_option(&decl[i], *arg, prefix, opt);
 761                         break;
 762                 case isl_arg_str:
 763                         parsed = parse_str_option(&decl[i], arg, prefix, opt);
 764                         break;
 765                 case isl_arg_child:
 766                         parsed = parse_child_option(&decl[i], arg, opt);
 767                         break;
 768                 case isl_arg_arg:
 769                 case isl_arg_user:
 770                 case isl_arg_version:
 771                 case isl_arg_end:
 772                         break;
 773                 }
 774                 if (parsed)
 775                         return parsed;
 776         }
 777
 778         return 0;
 779 }
 780
 781 static int any_version(struct isl_arg *decl)
 782 {
 783         int i;
 784
 785         for (i = 0; decl[i].type != isl_arg_end; ++i) {
 786                 switch (decl[i].type) {
 787                 case isl_arg_version:
 788                         return 1;
 789                 case isl_arg_child:
 790                         if (any_version(decl[i].u.child.child))
 791                                 return 1;
 792                         break;
 793                 default:
 794                         break;
 795                 }
 796         }
 797
 798         return 0;
 799 }
 800
 801 static void print_version(struct isl_arg *decl)
 802 {
 803         int i;
 804
 805         for (i = 0; decl[i].type != isl_arg_end; ++i) {
 806                 switch (decl[i].type) {
 807                 case isl_arg_version:
 808                         decl[i].u.version.print_version();
 809                         break;
 810                 case isl_arg_child:
 811                         print_version(decl[i].u.child.child);
 812                         break;
 813                 default:
 814                         break;
 815                 }
 816         }
 817 }
 818
 819 static void print_version_and_exit(struct isl_arg *decl)
 820 {
 821         print_version(decl);
 822
 823         exit(0);
 824 }
 825
 826 static int drop_argument(int argc, char **argv, int drop, int n)
 827 {
 828         for (; drop < argc; ++drop)
 829                 argv[drop] = argv[drop + n];
 830
 831         return argc - n;
 832 }
 833
 834 static int n_arg(struct isl_arg *arg)
 835 {
 836         int i;
 837         int n_arg = 0;
 838
 839         for (i = 0; arg[i].type != isl_arg_end; ++i)
 840                 if (arg[i].type == isl_arg_arg)
 841                         n_arg++;
 842
 843         return n_arg;
 844 }
 845
 846 int isl_arg_parse(struct isl_arg *arg, int argc, char **argv, void *opt,
 847         unsigned flags)
 848 {
 849         int skip = 0;
 850         int i;
 851         int n;
 852
 853         n = n_arg(arg);
 854
 855         for (i = 1; i < argc; ++i) {
 856                 if (strcmp(argv[i], "--help") == 0)
 857                         print_help_and_exit(arg, argv[0]);
 858         }
 859
 860         for (i = 1; i < argc; ++i) {
 861                 if ((strcmp(argv[i], "--version") == 0 ||
 862                      strcmp(argv[i], "-V") == 0) && any_version(arg))
 863                         print_version_and_exit(arg);
 864         }
 865
 866         while (argc > 1 + skip) {
 867                 int parsed;
 868                 if (argv[1 + skip][0] != '-')
 869                         break;
 870                 parsed = parse_option(arg, &argv[1 + skip], NULL, opt);
 871                 if (parsed)
 872                         argc = drop_argument(argc, argv, 1 + skip, parsed);
 873                 else if (ISL_FL_ISSET(flags, ISL_ARG_ALL)) {
 874                         fprintf(stderr, "%s: unrecognized option: %s\n",
 875                                         prog_name(argv[0]), argv[1 + skip]);
 876                         exit(-1);
 877                 } else
 878                         ++skip;
 879         }
 880
 881         if (ISL_FL_ISSET(flags, ISL_ARG_ALL) ? argc != 1 + n
 882                                              : argc < 1 + skip + n) {
 883                 fprintf(stderr, "%s: expecting %d arguments\n",
 884                                 prog_name(argv[0]), n);
 885                 exit(-1);
 886         }
 887
 888         for (i = 0; arg[i].type != isl_arg_end; ++i) {
 889                 const char *str;
 890                 if (arg[i].type != isl_arg_arg)
 891                         continue;
 892                 str = strdup(argv[1 + skip]);
 893                 *(const char **)(((char *)opt) + arg[i].offset) = str;
 894                 argc = drop_argument(argc, argv, 1 + skip, 1);
 895         }
 896
 897         return argc;
 898 }