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