src/common/argpar/argpar.c

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright 2019 Philippe Proulx <pproulx@efficios.com>
   5  */
   6
   7 #include <assert.h>
   8 #include <stdarg.h>
   9 #include <stdbool.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13
  14 #include "argpar.h"
  15
  16 #define argpar_realloc(_ptr, _type, _nmemb) ((_type *) realloc(_ptr, (_nmemb) * sizeof(_type)))
  17 #define argpar_calloc(_type, _nmemb) ((_type *) calloc((_nmemb), sizeof(_type)))
  18 #define argpar_zalloc(_type) argpar_calloc(_type, 1)
  19
  20 #define ARGPAR_ASSERT(_cond) assert(_cond)
  21
  22 #ifdef __MINGW_PRINTF_FORMAT
  23 # define ARGPAR_PRINTF_FORMAT __MINGW_PRINTF_FORMAT
  24 #else
  25 # define ARGPAR_PRINTF_FORMAT printf
  26 #endif
  27
  28 /*
  29  * Structure holding the argpar state between successive argpar_state_parse_next
  30  * calls.
  31  *
  32  * Created with `argpar_state_create` and destroyed with `argpar_state_destroy`.
  33  */
  34 struct argpar_state {
  35         /*
  36          * Data provided by the user in argpar_state_create, does not change
  37          * afterwards.
  38          */
  39         unsigned int argc;
  40         const char * const *argv;
  41         const struct argpar_opt_descr *descrs;
  42
  43         /*
  44          * Index of the argument to process in the next argpar_state_parse_next
  45          * call.
  46          */
  47         unsigned int i;
  48
  49         /* Counter of non-option arguments. */
  50         int non_opt_index;
  51
  52         /*
  53          * Short option state: if set, we are in the middle of a short option
  54          * group, so we should resume there at the next argpar_state_parse_next
  55          * call.
  56          */
  57         const char *short_opt_ch;
  58 };
  59
  60 static __attribute__((format(ARGPAR_PRINTF_FORMAT, 1, 0)))
  61 char *argpar_vasprintf(const char *fmt, va_list args)
  62 {
  63         int len1, len2;
  64         char *str;
  65         va_list args2;
  66
  67         va_copy(args2, args);
  68
  69         len1 = vsnprintf(NULL, 0, fmt, args);
  70         if (len1 < 0) {
  71                 str = NULL;
  72                 goto end;
  73         }
  74
  75         str = malloc(len1 + 1);
  76         if (!str) {
  77                 goto end;
  78         }
  79
  80         len2 = vsnprintf(str, len1 + 1, fmt, args2);
  81
  82         ARGPAR_ASSERT(len1 == len2);
  83
  84 end:
  85         va_end(args2);
  86         return str;
  87 }
  88
  89
  90 static __attribute__((format(ARGPAR_PRINTF_FORMAT, 1, 2)))
  91 char *argpar_asprintf(const char *fmt, ...)
  92 {
  93         va_list args;
  94         char *str;
  95
  96         va_start(args, fmt);
  97         str = argpar_vasprintf(fmt, args);
  98         va_end(args);
  99
 100         return str;
 101 }
 102
 103 static  __attribute__((format(ARGPAR_PRINTF_FORMAT, 2, 3)))
 104 bool argpar_string_append_printf(char **str, const char *fmt, ...)
 105 {
 106         char *new_str = NULL;
 107         char *addendum;
 108         bool success;
 109         va_list args;
 110
 111         ARGPAR_ASSERT(str);
 112
 113         va_start(args, fmt);
 114         addendum = argpar_vasprintf(fmt, args);
 115         va_end(args);
 116
 117         if (!addendum) {
 118                 success = false;
 119                 goto end;
 120         }
 121
 122         new_str = argpar_asprintf("%s%s", *str ? *str : "", addendum);
 123         if (!new_str) {
 124                 success = false;
 125                 goto end;
 126         }
 127
 128         free(*str);
 129         *str = new_str;
 130
 131         success = true;
 132
 133 end:
 134         free(addendum);
 135
 136         return success;
 137 }
 138
 139 ARGPAR_HIDDEN
 140 void argpar_item_destroy(struct argpar_item *item)
 141 {
 142         if (!item) {
 143                 goto end;
 144         }
 145
 146         if (item->type == ARGPAR_ITEM_TYPE_OPT) {
 147                 struct argpar_item_opt * const opt_item = (void *) item;
 148
 149                 free((void *) opt_item->arg);
 150         }
 151
 152         free(item);
 153
 154 end:
 155         return;
 156 }
 157
 158 static
 159 bool push_item(struct argpar_item_array * const array,
 160                 struct argpar_item * const item)
 161 {
 162         bool success;
 163
 164         ARGPAR_ASSERT(array);
 165         ARGPAR_ASSERT(item);
 166
 167         if (array->n_items == array->n_alloc) {
 168                 unsigned int new_n_alloc = array->n_alloc * 2;
 169                 struct argpar_item **new_items;
 170
 171                 new_items = argpar_realloc(array->items,
 172                         struct argpar_item *, new_n_alloc);
 173                 if (!new_items) {
 174                         success = false;
 175                         goto end;
 176                 }
 177
 178                 array->n_alloc = new_n_alloc;
 179                 array->items = new_items;
 180         }
 181
 182         array->items[array->n_items] = item;
 183         array->n_items++;
 184
 185         success = true;
 186
 187 end:
 188         return success;
 189 }
 190
 191 static
 192 void destroy_item_array(struct argpar_item_array * const array)
 193 {
 194         if (array) {
 195                 unsigned int i;
 196
 197                 for (i = 0; i < array->n_items; i++) {
 198                         argpar_item_destroy(array->items[i]);
 199                 }
 200
 201                 free(array->items);
 202                 free(array);
 203         }
 204 }
 205
 206 static
 207 struct argpar_item_array *new_item_array(void)
 208 {
 209         struct argpar_item_array *ret;
 210         const int initial_size = 10;
 211
 212         ret = argpar_zalloc(struct argpar_item_array);
 213         if (!ret) {
 214                 goto end;
 215         }
 216
 217         ret->items = argpar_calloc(struct argpar_item *, initial_size);
 218         if (!ret->items) {
 219                 goto error;
 220         }
 221
 222         ret->n_alloc = initial_size;
 223
 224         goto end;
 225
 226 error:
 227         destroy_item_array(ret);
 228         ret = NULL;
 229
 230 end:
 231         return ret;
 232 }
 233
 234 static
 235 struct argpar_item_opt *create_opt_item(
 236                 const struct argpar_opt_descr * const descr,
 237                 const char * const arg)
 238 {
 239         struct argpar_item_opt *opt_item =
 240                 argpar_zalloc(struct argpar_item_opt);
 241
 242         if (!opt_item) {
 243                 goto end;
 244         }
 245
 246         opt_item->base.type = ARGPAR_ITEM_TYPE_OPT;
 247         opt_item->descr = descr;
 248
 249         if (arg) {
 250                 opt_item->arg = strdup(arg);
 251                 if (!opt_item->arg) {
 252                         goto error;
 253                 }
 254         }
 255
 256         goto end;
 257
 258 error:
 259         argpar_item_destroy(&opt_item->base);
 260         opt_item = NULL;
 261
 262 end:
 263         return opt_item;
 264 }
 265
 266 static
 267 struct argpar_item_non_opt *create_non_opt_item(const char * const arg,
 268                 const unsigned int orig_index,
 269                 const unsigned int non_opt_index)
 270 {
 271         struct argpar_item_non_opt * const non_opt_item =
 272                 argpar_zalloc(struct argpar_item_non_opt);
 273
 274         if (!non_opt_item) {
 275                 goto end;
 276         }
 277
 278         non_opt_item->base.type = ARGPAR_ITEM_TYPE_NON_OPT;
 279         non_opt_item->arg = arg;
 280         non_opt_item->orig_index = orig_index;
 281         non_opt_item->non_opt_index = non_opt_index;
 282
 283 end:
 284         return non_opt_item;
 285 }
 286
 287 static
 288 const struct argpar_opt_descr *find_descr(
 289                 const struct argpar_opt_descr * const descrs,
 290                 const char short_name, const char * const long_name)
 291 {
 292         const struct argpar_opt_descr *descr;
 293
 294         for (descr = descrs; descr->short_name || descr->long_name; descr++) {
 295                 if (short_name && descr->short_name &&
 296                                 short_name == descr->short_name) {
 297                         goto end;
 298                 }
 299
 300                 if (long_name && descr->long_name &&
 301                                 strcmp(long_name, descr->long_name) == 0) {
 302                         goto end;
 303                 }
 304         }
 305
 306 end:
 307         return !descr->short_name && !descr->long_name ? NULL : descr;
 308 }
 309
 310 enum parse_orig_arg_opt_ret {
 311         PARSE_ORIG_ARG_OPT_RET_OK,
 312         PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT = -2,
 313         PARSE_ORIG_ARG_OPT_RET_ERROR = -1,
 314 };
 315
 316 static
 317 enum parse_orig_arg_opt_ret parse_short_opts(const char * const short_opts,
 318                 const char * const next_orig_arg,
 319                 const struct argpar_opt_descr * const descrs,
 320                 struct argpar_state *state,
 321                 char **error,
 322                 struct argpar_item **item)
 323 {
 324         enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK;
 325         bool used_next_orig_arg = false;
 326
 327         if (strlen(short_opts) == 0) {
 328                 argpar_string_append_printf(error, "Invalid argument");
 329                 goto error;
 330         }
 331
 332         if (!state->short_opt_ch) {
 333                 state->short_opt_ch = short_opts;
 334         }
 335
 336         const char *opt_arg = NULL;
 337         const struct argpar_opt_descr *descr;
 338         struct argpar_item_opt *opt_item;
 339
 340         /* Find corresponding option descriptor */
 341         descr = find_descr(descrs, *state->short_opt_ch, NULL);
 342         if (!descr) {
 343                 ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT;
 344                 argpar_string_append_printf(error,
 345                         "Unknown option `-%c`", *state->short_opt_ch);
 346                 goto error;
 347         }
 348
 349         if (descr->with_arg) {
 350                 if (state->short_opt_ch[1]) {
 351                         /* `-oarg` form */
 352                         opt_arg = &state->short_opt_ch[1];
 353                 } else {
 354                         /* `-o arg` form */
 355                         opt_arg = next_orig_arg;
 356                         used_next_orig_arg = true;
 357                 }
 358
 359                 /*
 360                         * We accept `-o ''` (empty option's argument),
 361                         * but not `-o` alone if an option's argument is
 362                         * expected.
 363                         */
 364                 if (!opt_arg || (state->short_opt_ch[1] && strlen(opt_arg) == 0)) {
 365                         argpar_string_append_printf(error,
 366                                 "Missing required argument for option `-%c`",
 367                                 *state->short_opt_ch);
 368                         used_next_orig_arg = false;
 369                         goto error;
 370                 }
 371         }
 372
 373         /* Create and append option argument */
 374         opt_item = create_opt_item(descr, opt_arg);
 375         if (!opt_item) {
 376                 goto error;
 377         }
 378
 379         *item = &opt_item->base;
 380
 381         state->short_opt_ch++;
 382
 383         if (descr->with_arg || !*state->short_opt_ch) {
 384                 /* Option has an argument: no more options */
 385                 state->short_opt_ch = NULL;
 386
 387                 if (used_next_orig_arg) {
 388                         state->i += 2;
 389                 } else {
 390                         state->i += 1;
 391                 }
 392         }
 393
 394         goto end;
 395
 396 error:
 397         if (ret == PARSE_ORIG_ARG_OPT_RET_OK) {
 398                 ret = PARSE_ORIG_ARG_OPT_RET_ERROR;
 399         }
 400
 401 end:
 402         return ret;
 403 }
 404
 405 static
 406 enum parse_orig_arg_opt_ret parse_long_opt(const char * const long_opt_arg,
 407                 const char * const next_orig_arg,
 408                 const struct argpar_opt_descr * const descrs,
 409                 struct argpar_state *state,
 410                 char **error,
 411                 struct argpar_item **item)
 412 {
 413         const size_t max_len = 127;
 414         enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK;
 415         const struct argpar_opt_descr *descr;
 416         struct argpar_item_opt *opt_item;
 417         bool used_next_orig_arg = false;
 418
 419         /* Option's argument, if any */
 420         const char *opt_arg = NULL;
 421
 422         /* Position of first `=`, if any */
 423         const char *eq_pos;
 424
 425         /* Buffer holding option name when `long_opt_arg` contains `=` */
 426         char buf[max_len + 1];
 427
 428         /* Option name */
 429         const char *long_opt_name = long_opt_arg;
 430
 431         if (strlen(long_opt_arg) == 0) {
 432                 argpar_string_append_printf(error,
 433                         "Invalid argument");
 434                 goto error;
 435         }
 436
 437         /* Find the first `=` in original argument */
 438         eq_pos = strchr(long_opt_arg, '=');
 439         if (eq_pos) {
 440                 const size_t long_opt_name_size = eq_pos - long_opt_arg;
 441
 442                 /* Isolate the option name */
 443                 if (long_opt_name_size > max_len) {
 444                         argpar_string_append_printf(error,
 445                                 "Invalid argument `--%s`", long_opt_arg);
 446                         goto error;
 447                 }
 448
 449                 memcpy(buf, long_opt_arg, long_opt_name_size);
 450                 buf[long_opt_name_size] = '\0';
 451                 long_opt_name = buf;
 452         }
 453
 454         /* Find corresponding option descriptor */
 455         descr = find_descr(descrs, '\0', long_opt_name);
 456         if (!descr) {
 457                 argpar_string_append_printf(error,
 458                         "Unknown option `--%s`", long_opt_name);
 459                 ret = PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT;
 460                 goto error;
 461         }
 462
 463         /* Find option's argument if any */
 464         if (descr->with_arg) {
 465                 if (eq_pos) {
 466                         /* `--long-opt=arg` style */
 467                         opt_arg = eq_pos + 1;
 468                 } else {
 469                         /* `--long-opt arg` style */
 470                         if (!next_orig_arg) {
 471                                 argpar_string_append_printf(error,
 472                                         "Missing required argument for option `--%s`",
 473                                         long_opt_name);
 474                                 goto error;
 475                         }
 476
 477                         opt_arg = next_orig_arg;
 478                         used_next_orig_arg = true;
 479                 }
 480         }
 481
 482         /* Create and append option argument */
 483         opt_item = create_opt_item(descr, opt_arg);
 484         if (!opt_item) {
 485                 goto error;
 486         }
 487
 488         if (used_next_orig_arg) {
 489                 state->i += 2;
 490         } else {
 491                 state->i += 1;
 492         }
 493
 494         *item = &opt_item->base;
 495         goto end;
 496
 497 error:
 498         if (ret == PARSE_ORIG_ARG_OPT_RET_OK) {
 499                 ret = PARSE_ORIG_ARG_OPT_RET_ERROR;
 500         }
 501
 502 end:
 503         return ret;
 504 }
 505
 506 static
 507 enum parse_orig_arg_opt_ret parse_orig_arg_opt(const char * const orig_arg,
 508                 const char * const next_orig_arg,
 509                 const struct argpar_opt_descr * const descrs,
 510                 struct argpar_state *state,
 511                 char **error,
 512                 struct argpar_item **item)
 513 {
 514         enum parse_orig_arg_opt_ret ret = PARSE_ORIG_ARG_OPT_RET_OK;
 515
 516         ARGPAR_ASSERT(orig_arg[0] == '-');
 517
 518         if (orig_arg[1] == '-') {
 519                 /* Long option */
 520                 ret = parse_long_opt(&orig_arg[2],
 521                         next_orig_arg, descrs, state, error, item);
 522         } else {
 523                 /* Short option */
 524                 ret = parse_short_opts(&orig_arg[1],
 525                         next_orig_arg, descrs, state, error, item);
 526         }
 527
 528         return ret;
 529 }
 530
 531 static
 532 bool prepend_while_parsing_arg_to_error(char **error,
 533                 const unsigned int i, const char * const arg)
 534 {
 535         char *new_error;
 536         bool success;
 537
 538         ARGPAR_ASSERT(error);
 539         ARGPAR_ASSERT(*error);
 540
 541         new_error = argpar_asprintf("While parsing argument #%u (`%s`): %s",
 542                 i + 1, arg, *error);
 543         if (!new_error) {
 544                 success = false;
 545                 goto end;
 546         }
 547
 548         free(*error);
 549         *error = new_error;
 550         success = true;
 551
 552 end:
 553         return success;
 554 }
 555
 556 ARGPAR_HIDDEN
 557 struct argpar_state *argpar_state_create(
 558                 unsigned int argc,
 559                 const char * const *argv,
 560                 const struct argpar_opt_descr * const descrs)
 561 {
 562         struct argpar_state *state;
 563
 564         state = argpar_zalloc(struct argpar_state);
 565         if (!state) {
 566                 goto end;
 567         }
 568
 569         state->argc = argc;
 570         state->argv = argv;
 571         state->descrs = descrs;
 572
 573 end:
 574         return state;
 575 }
 576
 577 ARGPAR_HIDDEN
 578 void argpar_state_destroy(struct argpar_state *state)
 579 {
 580         free(state);
 581 }
 582
 583 ARGPAR_HIDDEN
 584 enum argpar_state_parse_next_status argpar_state_parse_next(
 585                 struct argpar_state *state,
 586                 struct argpar_item **item,
 587                 char **error)
 588 {
 589         enum argpar_state_parse_next_status status;
 590
 591         ARGPAR_ASSERT(state->i <= state->argc);
 592
 593         *error = NULL;
 594
 595         if (state->i == state->argc) {
 596                 status = ARGPAR_STATE_PARSE_NEXT_STATUS_END;
 597                 goto end;
 598         }
 599
 600         enum parse_orig_arg_opt_ret parse_orig_arg_opt_ret;
 601         const char * const orig_arg = state->argv[state->i];
 602         const char * const next_orig_arg =
 603                 state->i < (state->argc - 1) ? state->argv[state->i + 1] : NULL;
 604
 605         if (orig_arg[0] != '-') {
 606                 /* Non-option argument */
 607                 struct argpar_item_non_opt *non_opt_item =
 608                         create_non_opt_item(orig_arg, state->i, state->non_opt_index);
 609
 610                 if (!non_opt_item) {
 611                         status = ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR;
 612                         goto end;
 613                 }
 614
 615                 state->non_opt_index++;
 616                 state->i++;
 617
 618                 *item = &non_opt_item->base;
 619                 status = ARGPAR_STATE_PARSE_NEXT_STATUS_OK;
 620                 goto end;
 621         }
 622
 623         /* Option argument */
 624         parse_orig_arg_opt_ret = parse_orig_arg_opt(orig_arg,
 625                 next_orig_arg, state->descrs, state, error, item);
 626         switch (parse_orig_arg_opt_ret) {
 627         case PARSE_ORIG_ARG_OPT_RET_OK:
 628                 status = ARGPAR_STATE_PARSE_NEXT_STATUS_OK;
 629                 break;
 630         case PARSE_ORIG_ARG_OPT_RET_ERROR_UNKNOWN_OPT:
 631                 status = ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT;
 632                 break;;
 633         case PARSE_ORIG_ARG_OPT_RET_ERROR:
 634                 prepend_while_parsing_arg_to_error(
 635                         error, state->i, orig_arg);
 636                 status = ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR;
 637                 break;
 638         default:
 639                 abort();
 640         }
 641
 642 end:
 643         return status;
 644 }
 645
 646 ARGPAR_HIDDEN
 647 int argpar_state_get_ingested_orig_args(struct argpar_state *state)
 648 {
 649         return state->i;
 650 }
 651
 652 ARGPAR_HIDDEN
 653 struct argpar_parse_ret argpar_parse(unsigned int argc,
 654                 const char * const *argv,
 655                 const struct argpar_opt_descr * const descrs,
 656                 bool fail_on_unknown_opt)
 657 {
 658         struct argpar_parse_ret parse_ret = { 0 };
 659         struct argpar_item *item = NULL;
 660         struct argpar_state *state = NULL;
 661
 662         parse_ret.items = new_item_array();
 663         if (!parse_ret.items) {
 664                 parse_ret.error = strdup("Failed to create items array.");
 665                 ARGPAR_ASSERT(parse_ret.error);
 666                 goto error;
 667         }
 668
 669         state = argpar_state_create(argc, argv, descrs);
 670         if (!state) {
 671                 parse_ret.error = strdup("Failed to create argpar state.");
 672                 ARGPAR_ASSERT(parse_ret.error);
 673                 goto error;
 674         }
 675
 676         while (true) {
 677                 enum argpar_state_parse_next_status status;
 678
 679                 status = argpar_state_parse_next(state, &item, &parse_ret.error);
 680                 if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR) {
 681                         goto error;
 682                 } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_END) {
 683                         break;
 684                 } else if (status == ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) {
 685                         if (fail_on_unknown_opt) {
 686                                 parse_ret.ingested_orig_args =
 687                                         argpar_state_get_ingested_orig_args(state);
 688                                 prepend_while_parsing_arg_to_error(
 689                                         &parse_ret.error, parse_ret.ingested_orig_args,
 690                                         argv[parse_ret.ingested_orig_args]);
 691                                 status = ARGPAR_STATE_PARSE_NEXT_STATUS_ERROR;
 692                                 goto error;
 693                         }
 694
 695                         free(parse_ret.error);
 696                         parse_ret.error = NULL;
 697                         break;
 698                 }
 699
 700                 ARGPAR_ASSERT(status == ARGPAR_STATE_PARSE_NEXT_STATUS_OK);
 701
 702                 if (!push_item(parse_ret.items, item)) {
 703                         goto error;
 704                 }
 705                 item = NULL;
 706         }
 707
 708         ARGPAR_ASSERT(!parse_ret.error);
 709         parse_ret.ingested_orig_args =
 710                 argpar_state_get_ingested_orig_args(state);
 711         goto end;
 712
 713 error:
 714         ARGPAR_ASSERT(parse_ret.error);
 715
 716         /* That's how we indicate that an error occurred */
 717         destroy_item_array(parse_ret.items);
 718         parse_ret.items = NULL;
 719
 720 end:
 721         argpar_state_destroy(state);
 722         argpar_item_destroy(item);
 723         return parse_ret;
 724 }
 725
 726 ARGPAR_HIDDEN
 727 void argpar_parse_ret_fini(struct argpar_parse_ret *ret)
 728 {
 729         ARGPAR_ASSERT(ret);
 730
 731         destroy_item_array(ret->items);
 732         ret->items = NULL;
 733
 734         free(ret->error);
 735         ret->error = NULL;
 736 }