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