polly/lib/External/isl/isl_arg.c

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