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