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(struct isl_arg *decl, const char *def, int pos)
 211 {
 212         int i;
 213         const char *default_prefix = "[default: ";
 214         const char *default_suffix = "]";
 215         int len;
 216
 217         len = strlen(default_prefix) + strlen(def) + strlen(default_suffix);
 218
 219         if (!decl->help_msg) {
 220                 if (pos >= 29)
 221                         printf("\n%30s", "");
 222                 else
 223                         printf("%*s", 30 - pos, "");
 224                 pos = 0;
 225         } else {
 226                 if (pos + len >= 48)
 227                         printf("\n%30s", "");
 228                 else
 229                         printf(" ");
 230         }
 231         printf("%s%s%s", default_prefix, def, default_suffix);
 232 }
 233
 234 static void print_default_choice(struct isl_arg *decl, int pos)
 235 {
 236         int i;
 237         const char *s = "none";
 238
 239         for (i = 0; decl->u.choice.choice[i].name; ++i)
 240                 if (decl->u.choice.choice[i].value == decl->u.choice.default_value) {
 241                         s = decl->u.choice.choice[i].name;
 242                         break;
 243                 }
 244
 245         print_default(decl, s, pos);
 246 }
 247
 248 static void print_choice_help(struct isl_arg *decl, const char *prefix)
 249 {
 250         int i;
 251         int pos;
 252
 253         pos = print_arg_help(decl, prefix, 0);
 254         printf("=");
 255         pos++;
 256
 257         for (i = 0; decl->u.choice.choice[i].name; ++i) {
 258                 if (i) {
 259                         printf("|");
 260                         pos++;
 261                 }
 262                 printf("%s", decl->u.choice.choice[i].name);
 263                 pos += strlen(decl->u.choice.choice[i].name);
 264         }
 265
 266         pos = print_help_msg(decl, pos);
 267         print_default_choice(decl, pos);
 268
 269         printf("\n");
 270 }
 271
 272 static void print_default_flags(struct isl_arg *decl, int pos)
 273 {
 274         int i, first;
 275         const char *default_prefix = "[default: ";
 276         const char *default_suffix = "]";
 277         int len = strlen(default_prefix) + strlen(default_suffix);
 278
 279         for (i = 0; decl->u.flags.flags[i].name; ++i)
 280                 if ((decl->u.flags.default_value & decl->u.flags.flags[i].mask) ==
 281                      decl->u.flags.flags[i].value)
 282                         len += strlen(decl->u.flags.flags[i].name);
 283
 284         if (!decl->help_msg) {
 285                 if (pos >= 29)
 286                         printf("\n%30s", "");
 287                 else
 288                         printf("%*s", 30 - pos, "");
 289                 pos = 0;
 290         } else {
 291                 if (pos + len >= 48)
 292                         printf("\n%30s", "");
 293                 else
 294                         printf(" ");
 295         }
 296         printf("%s", default_prefix);
 297
 298         for (first = 1, i = 0; decl->u.flags.flags[i].name; ++i)
 299                 if ((decl->u.flags.default_value & decl->u.flags.flags[i].mask) ==
 300                      decl->u.flags.flags[i].value) {
 301                         if (!first)
 302                                 printf(",");
 303                         printf("%s", decl->u.flags.flags[i].name);
 304                         first = 0;
 305                 }
 306
 307         printf("%s", default_suffix);
 308 }
 309
 310 static void print_flags_help(struct isl_arg *decl, const char *prefix)
 311 {
 312         int i, j;
 313         int pos;
 314
 315         pos = print_arg_help(decl, prefix, 0);
 316         printf("=");
 317         pos++;
 318
 319         for (i = 0; decl->u.flags.flags[i].name; ++i) {
 320                 if (i) {
 321                         printf(",");
 322                         pos++;
 323                 }
 324                 for (j = i;
 325                      decl->u.flags.flags[j].mask == decl->u.flags.flags[i].mask;
 326                      ++j) {
 327                         if (j != i) {
 328                                 printf("|");
 329                                 pos++;
 330                         }
 331                         printf("%s", decl->u.flags.flags[j].name);
 332                         pos += strlen(decl->u.flags.flags[j].name);
 333                 }
 334                 i = j - 1;
 335         }
 336
 337         pos = print_help_msg(decl, pos);
 338         print_default_flags(decl, pos);
 339
 340         printf("\n");
 341 }
 342
 343 static void print_bool_help(struct isl_arg *decl, const char *prefix)
 344 {
 345         int pos;
 346         int no = decl->u.b.default_value == 1;
 347         pos = print_arg_help(decl, prefix, no);
 348         pos = print_help_msg(decl, pos);
 349         print_default(decl, no ? "yes" : "no", pos);
 350         printf("\n");
 351 }
 352
 353 static int print_argument_name(struct isl_arg *decl, const char *name, int pos)
 354 {
 355         printf("%c<%s>", decl->long_name ? '=' : ' ', name);
 356         return pos + 3 + strlen(name);
 357 }
 358
 359 static void print_long_help(struct isl_arg *decl, const char *prefix)
 360 {
 361         int pos;
 362         pos = print_arg_help(decl, prefix, 0);
 363         if (decl->u.l.default_value != decl->u.l.default_selected) {
 364                 printf("[");
 365                 pos++;
 366         }
 367         printf("=long");
 368         pos += 5;
 369         if (decl->u.l.default_value != decl->u.l.default_selected) {
 370                 printf("]");
 371                 pos++;
 372         }
 373         print_help_msg(decl, pos);
 374         printf("\n");
 375 }
 376
 377 static void print_ulong_help(struct isl_arg *decl, const char *prefix)
 378 {
 379         int pos;
 380         pos = print_arg_help(decl, prefix, 0);
 381         printf("=ulong");
 382         pos += 6;
 383         print_help_msg(decl, pos);
 384         printf("\n");
 385 }
 386
 387 static void print_str_help(struct isl_arg *decl, const char *prefix)
 388 {
 389         int pos;
 390         const char *a = decl->argument_name ? decl->argument_name : "string";
 391         pos = print_arg_help(decl, prefix, 0);
 392         pos = print_argument_name(decl, a, pos);
 393         pos = print_help_msg(decl, pos);
 394         if (decl->u.str.default_value)
 395                 print_default(decl, decl->u.str.default_value, pos);
 396         printf("\n");
 397 }
 398
 399 static void print_help(struct isl_arg *arg, const char *prefix)
 400 {
 401         int i;
 402
 403         for (i = 0; arg[i].type != isl_arg_end; ++i) {
 404                 switch (arg[i].type) {
 405                 case isl_arg_flags:
 406                         print_flags_help(&arg[i], prefix);
 407                         break;
 408                 case isl_arg_choice:
 409                         print_choice_help(&arg[i], prefix);
 410                         break;
 411                 case isl_arg_bool:
 412                         print_bool_help(&arg[i], prefix);
 413                         break;
 414                 case isl_arg_long:
 415                         print_long_help(&arg[i], prefix);
 416                         break;
 417                 case isl_arg_ulong:
 418                         print_ulong_help(&arg[i], prefix);
 419                         break;
 420                 case isl_arg_str:
 421                         print_str_help(&arg[i], prefix);
 422                         break;
 423                 case isl_arg_version:
 424                 case isl_arg_arg:
 425                 case isl_arg_child:
 426                 case isl_arg_user:
 427                 case isl_arg_end:
 428                         break;
 429                 }
 430         }
 431
 432         for (i = 0; arg[i].type != isl_arg_end; ++i) {
 433                 if (arg[i].type != isl_arg_child)
 434                         continue;
 435
 436                 printf("\n");
 437                 if (arg[i].help_msg)
 438                         printf(" %s\n", arg[i].help_msg);
 439                 print_help(arg[i].u.child.child, arg[i].long_name);
 440         }
 441 }
 442
 443 static const char *prog_name(const char *prog)
 444 {
 445         const char *slash;
 446
 447         slash = strrchr(prog, '/');
 448         if (slash)
 449                 prog = slash + 1;
 450         if (strncmp(prog, "lt-", 3) == 0)
 451                 prog += 3;
 452
 453         return prog;
 454 }
 455
 456 static int any_version(struct isl_arg *decl)
 457 {
 458         int i;
 459
 460         for (i = 0; decl[i].type != isl_arg_end; ++i) {
 461                 switch (decl[i].type) {
 462                 case isl_arg_version:
 463                         return 1;
 464                 case isl_arg_child:
 465                         if (any_version(decl[i].u.child.child))
 466                                 return 1;
 467                         break;
 468                 default:
 469                         break;
 470                 }
 471         }
 472
 473         return 0;
 474 }
 475
 476 static void print_help_and_exit(struct isl_arg *arg, const char *prog)
 477 {
 478         int i;
 479
 480         printf("Usage: %s [OPTION...]", prog_name(prog));
 481
 482         for (i = 0; arg[i].type != isl_arg_end; ++i)
 483                 if (arg[i].type == isl_arg_arg)
 484                         printf(" %s", arg[i].argument_name);
 485
 486         printf("\n\n");
 487
 488         print_help(arg, NULL);
 489         if (any_version(arg)) {
 490                 printf("\n");
 491                 printf("  -V, --version\n");
 492         }
 493
 494         exit(0);
 495 }
 496
 497 static const char *skip_name(struct isl_arg *decl, const char *arg,
 498         const char *prefix, int need_argument, int *has_argument)
 499 {
 500         const char *equal;
 501         const char *name;
 502         const char *end;
 503
 504         if (arg[0] == '-' && arg[1] && arg[1] == decl->short_name) {
 505                 if (need_argument && !arg[2])
 506                         return NULL;
 507                 if (has_argument)
 508                         *has_argument = arg[2] != '\0';
 509                 return arg + 2;
 510         }
 511         if (!decl->long_name)
 512                 return NULL;
 513
 514         if (strncmp(arg, "--", 2))
 515                 return NULL;
 516
 517         name = arg + 2;
 518         equal = strchr(name, '=');
 519         if (need_argument && !equal)
 520                 return NULL;
 521
 522         if (has_argument)
 523                 *has_argument = !!equal;
 524         end = equal ? equal : name + strlen(name);
 525
 526         if (prefix) {
 527                 size_t prefix_len = strlen(prefix);
 528                 if (strncmp(name, prefix, prefix_len) == 0 &&
 529                     name[prefix_len] == '-')
 530                         name += prefix_len + 1;
 531         }
 532
 533         if (end - name != strlen(decl->long_name) ||
 534             strncmp(name, decl->long_name, end - name))
 535                 return NULL;
 536
 537         return equal ? equal + 1 : end;
 538 }
 539
 540 static int parse_choice_option(struct isl_arg *decl, char **arg,
 541         const char *prefix, void *opt)
 542 {
 543         int i;
 544         int has_argument;
 545         const char *choice;
 546
 547         choice = skip_name(decl, arg[0], prefix, 0, &has_argument);
 548         if (!choice)
 549                 return 0;
 550
 551         if (!has_argument && (!arg[1] || arg[1][0] == '-')) {
 552                 unsigned u = decl->u.choice.default_selected;
 553                 if (decl->u.choice.set)
 554                         decl->u.choice.set(opt, u);
 555                 else
 556                         *(unsigned *)(((char *)opt) + decl->offset) = u;
 557
 558                 return 1;
 559         }
 560
 561         if (!has_argument)
 562                 choice = arg[1];
 563
 564         for (i = 0; decl->u.choice.choice[i].name; ++i) {
 565                 unsigned u;
 566
 567                 if (strcmp(choice, decl->u.choice.choice[i].name))
 568                         continue;
 569
 570                 u = decl->u.choice.choice[i].value;
 571                 if (decl->u.choice.set)
 572                         decl->u.choice.set(opt, u);
 573                 else
 574                         *(unsigned *)(((char *)opt) + decl->offset) = u;
 575
 576                 return has_argument ? 1 : 2;
 577         }
 578
 579         return 0;
 580 }
 581
 582 static int set_flag(struct isl_arg *decl, unsigned *val, const char *flag,
 583         size_t len)
 584 {
 585         int i;
 586
 587         for (i = 0; decl->u.flags.flags[i].name; ++i) {
 588                 if (strncmp(flag, decl->u.flags.flags[i].name, len))
 589                         continue;
 590
 591                 *val &= ~decl->u.flags.flags[i].mask;
 592                 *val |= decl->u.flags.flags[i].value;
 593
 594                 return 1;
 595         }
 596
 597         return 0;
 598 }
 599
 600 static int parse_flags_option(struct isl_arg *decl, char **arg,
 601         const char *prefix, void *opt)
 602 {
 603         int has_argument;
 604         const char *flags;
 605         const char *comma;
 606         unsigned val;
 607
 608         flags = skip_name(decl, arg[0], prefix, 0, &has_argument);
 609         if (!flags)
 610                 return 0;
 611
 612         if (!has_argument && !arg[1])
 613                 return 0;
 614
 615         if (!has_argument)
 616                 flags = arg[1];
 617
 618         val = *(unsigned *)(((char *)opt) + decl->offset);
 619
 620         while ((comma = strchr(flags, ',')) != NULL) {
 621                 if (!set_flag(decl, &val, flags, comma - flags))
 622                         return 0;
 623                 flags = comma + 1;
 624         }
 625         if (!set_flag(decl, &val, flags, strlen(flags)))
 626                 return 0;
 627
 628         *(unsigned *)(((char *)opt) + decl->offset) = val;
 629
 630         return has_argument ? 1 : 2;
 631 }
 632
 633 static int parse_bool_option(struct isl_arg *decl, const char *arg,
 634         const char *prefix, void *opt)
 635 {
 636         if (skip_name(decl, arg, prefix, 0, NULL)) {
 637                 *(unsigned *)(((char *)opt) + decl->offset) = 1;
 638
 639                 return 1;
 640         }
 641
 642         if (!decl->long_name)
 643                 return 0;
 644
 645         if (strncmp(arg, "--", 2))
 646                 return 0;
 647         arg += 2;
 648
 649         if (prefix) {
 650                 size_t prefix_len = strlen(prefix);
 651                 if (strncmp(arg, prefix, prefix_len) == 0 &&
 652                     arg[prefix_len] == '-') {
 653                         arg += prefix_len + 1;
 654                         prefix = NULL;
 655                 }
 656         }
 657
 658         if (strncmp(arg, "no-", 3))
 659                 return 0;
 660         arg += 3;
 661
 662         if (prefix) {
 663                 size_t prefix_len = strlen(prefix);
 664                 if (strncmp(arg, prefix, prefix_len) == 0 &&
 665                     arg[prefix_len] == '-')
 666                         arg += prefix_len + 1;
 667         }
 668
 669         if (!strcmp(arg, decl->long_name)) {
 670                 *(unsigned *)(((char *)opt) + decl->offset) = 0;
 671
 672                 return 1;
 673         }
 674
 675         return 0;
 676 }
 677
 678 static int parse_str_option(struct isl_arg *decl, char **arg,
 679         const char *prefix, void *opt)
 680 {
 681         int has_argument;
 682         const char *s;
 683         char **p = (char **)(((char *)opt) + decl->offset);
 684
 685         s = skip_name(decl, arg[0], prefix, 0, &has_argument);
 686         if (!s)
 687                 return 0;
 688
 689         if (has_argument) {
 690                 *p = strdup(s);
 691                 return 1;
 692         }
 693
 694         if (arg[1]) {
 695                 *p = strdup(arg[1]);
 696                 return 2;
 697         }
 698
 699         return 0;
 700 }
 701
 702 static int parse_long_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         long *p = (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                 long l = strtol(val, NULL, 0);
 716                 if (decl->u.l.set)
 717                         decl->u.l.set(opt, l);
 718                 else
 719                         *p = l;
 720                 return 1;
 721         }
 722
 723         if (arg[1]) {
 724                 long l = strtol(arg[1], &endptr, 0);
 725                 if (*endptr == '\0') {
 726                         if (decl->u.l.set)
 727                                 decl->u.l.set(opt, l);
 728                         else
 729                                 *p = l;
 730                         return 2;
 731                 }
 732         }
 733
 734         if (decl->u.l.default_value != decl->u.l.default_selected) {
 735                 if (decl->u.l.set)
 736                         decl->u.l.set(opt, decl->u.l.default_selected);
 737                 else
 738                         *p = decl->u.l.default_selected;
 739                 return 1;
 740         }
 741
 742         return 0;
 743 }
 744
 745 static int parse_ulong_option(struct isl_arg *decl, char **arg,
 746         const char *prefix, void *opt)
 747 {
 748         int has_argument;
 749         const char *val;
 750         char *endptr;
 751         unsigned long *p = (unsigned long *)(((char *)opt) + decl->offset);
 752
 753         val = skip_name(decl, arg[0], prefix, 0, &has_argument);
 754         if (!val)
 755                 return 0;
 756
 757         if (has_argument) {
 758                 *p = strtoul(val, NULL, 0);
 759                 return 1;
 760         }
 761
 762         if (arg[1]) {
 763                 unsigned long ul = strtoul(arg[1], &endptr, 0);
 764                 if (*endptr == '\0') {
 765                         *p = ul;
 766                         return 2;
 767                 }
 768         }
 769
 770         return 0;
 771 }
 772
 773 static int parse_option(struct isl_arg *decl, char **arg,
 774         const char *prefix, void *opt);
 775
 776 static int parse_child_option(struct isl_arg *decl, char **arg, void *opt)
 777 {
 778         return parse_option(decl->u.child.child, arg, decl->long_name,
 779                                 *(void **)(((char *)opt) + decl->offset));
 780 }
 781
 782 static int parse_option(struct isl_arg *decl, char **arg,
 783         const char *prefix, void *opt)
 784 {
 785         int i;
 786
 787         for (i = 0; decl[i].type != isl_arg_end; ++i) {
 788                 int parsed = 0;
 789                 switch (decl[i].type) {
 790                 case isl_arg_choice:
 791                         parsed = parse_choice_option(&decl[i], arg, prefix, opt);
 792                         break;
 793                 case isl_arg_flags:
 794                         parsed = parse_flags_option(&decl[i], arg, prefix, opt);
 795                         break;
 796                 case isl_arg_long:
 797                         parsed = parse_long_option(&decl[i], arg, prefix, opt);
 798                         break;
 799                 case isl_arg_ulong:
 800                         parsed = parse_ulong_option(&decl[i], arg, prefix, opt);
 801                         break;
 802                 case isl_arg_bool:
 803                         parsed = parse_bool_option(&decl[i], *arg, prefix, opt);
 804                         break;
 805                 case isl_arg_str:
 806                         parsed = parse_str_option(&decl[i], arg, prefix, opt);
 807                         break;
 808                 case isl_arg_child:
 809                         parsed = parse_child_option(&decl[i], arg, opt);
 810                         break;
 811                 case isl_arg_arg:
 812                 case isl_arg_user:
 813                 case isl_arg_version:
 814                 case isl_arg_end:
 815                         break;
 816                 }
 817                 if (parsed)
 818                         return parsed;
 819         }
 820
 821         return 0;
 822 }
 823
 824 static void print_version(struct isl_arg *decl)
 825 {
 826         int i;
 827
 828         for (i = 0; decl[i].type != isl_arg_end; ++i) {
 829                 switch (decl[i].type) {
 830                 case isl_arg_version:
 831                         decl[i].u.version.print_version();
 832                         break;
 833                 case isl_arg_child:
 834                         print_version(decl[i].u.child.child);
 835                         break;
 836                 default:
 837                         break;
 838                 }
 839         }
 840 }
 841
 842 static void print_version_and_exit(struct isl_arg *decl)
 843 {
 844         print_version(decl);
 845
 846         exit(0);
 847 }
 848
 849 static int drop_argument(int argc, char **argv, int drop, int n)
 850 {
 851         for (; drop < argc; ++drop)
 852                 argv[drop] = argv[drop + n];
 853
 854         return argc - n;
 855 }
 856
 857 static int n_arg(struct isl_arg *arg)
 858 {
 859         int i;
 860         int n_arg = 0;
 861
 862         for (i = 0; arg[i].type != isl_arg_end; ++i)
 863                 if (arg[i].type == isl_arg_arg)
 864                         n_arg++;
 865
 866         return n_arg;
 867 }
 868
 869 static int next_arg(struct isl_arg *arg, int a)
 870 {
 871         for (++a; arg[a].type != isl_arg_end; ++a)
 872                 if (arg[a].type == isl_arg_arg)
 873                         return a;
 874
 875         return -1;
 876 }
 877
 878 int isl_arg_parse(struct isl_arg *arg, int argc, char **argv, void *opt,
 879         unsigned flags)
 880 {
 881         int a = -1;
 882         int skip = 0;
 883         int i;
 884         int n;
 885
 886         n = n_arg(arg);
 887
 888         for (i = 1; i < argc; ++i) {
 889                 if (strcmp(argv[i], "--help") == 0)
 890                         print_help_and_exit(arg, argv[0]);
 891         }
 892
 893         for (i = 1; i < argc; ++i) {
 894                 if ((strcmp(argv[i], "--version") == 0 ||
 895                      strcmp(argv[i], "-V") == 0) && any_version(arg))
 896                         print_version_and_exit(arg);
 897         }
 898
 899         while (argc > 1 + skip) {
 900                 int parsed;
 901                 if (argv[1 + skip][0] != '-') {
 902                         a = next_arg(arg, a);
 903                         if (a >= 0) {
 904                                 const char **p;
 905                                 p = (const char **)(((char *)opt)+arg[a].offset);
 906                                 *p = strdup(argv[1 + skip]);
 907                                 argc = drop_argument(argc, argv, 1 + skip, 1);
 908                                 --n;
 909                         } else if (ISL_FL_ISSET(flags, ISL_ARG_ALL)) {
 910                                 fprintf(stderr, "%s: extra argument: %s\n",
 911                                             prog_name(argv[0]), argv[1 + skip]);
 912                                 exit(-1);
 913                         } else
 914                                 ++skip;
 915                         continue;
 916                 }
 917                 parsed = parse_option(arg, &argv[1 + skip], NULL, opt);
 918                 if (parsed)
 919                         argc = drop_argument(argc, argv, 1 + skip, parsed);
 920                 else if (ISL_FL_ISSET(flags, ISL_ARG_ALL)) {
 921                         fprintf(stderr, "%s: unrecognized option: %s\n",
 922                                         prog_name(argv[0]), argv[1 + skip]);
 923                         exit(-1);
 924                 } else
 925                         ++skip;
 926         }
 927
 928         if (n > 0) {
 929                 fprintf(stderr, "%s: expecting %d more argument(s)\n",
 930                                 prog_name(argv[0]), n);
 931                 exit(-1);
 932         }
 933
 934         return argc;
 935 }