utils/wvargs.cc

   1 /* -*- Mode: C++ -*-
   2  *   Copyright (C) 2004-2005 Net Integration Technologies, Inc.
   3  *
   4  * WvStreams interface for command-line argument processing
   5  */
   6
   7 #include "wvargs.h"
   8 #include "wvscatterhash.h"
   9
  10 // Some screwy defines that show up in _WIN32 and cause problems
  11 #undef error_t
  12 #undef __error_t_defined
  13 #undef argc
  14 #undef argv
  15 #undef __argc
  16 #undef __argv
  17
  18 #include <argp.h>
  19
  20
  21 class WvArgsOption
  22 {
  23 public:
  24
  25     int short_option;
  26     WvString long_option;
  27     WvString desc;
  28
  29     WvArgsOption(int _short_option,
  30                  WvStringParm _long_option,
  31                  WvStringParm _desc)
  32         : short_option(_short_option), long_option(_long_option), desc(_desc)
  33     {
  34     }
  35
  36     virtual ~WvArgsOption()
  37     {
  38     }
  39
  40     virtual WvString process(WvStringParm arg)
  41     {
  42         return WvString::null;
  43     }
  44
  45     virtual void add_to_argp(WvArgsData &data);
  46 };
  47
  48
  49 DeclareWvList(WvArgsOption);
  50 DeclareWvScatterDict(WvArgsOption, int, short_option);
  51
  52 class WvArgsData
  53 {
  54 public:
  55     WvArgsData();
  56     ~WvArgsData();
  57
  58     argp_option *argp() const;
  59     void *self() const;
  60
  61     void add(WvArgsOption *option);
  62     void remove(char short_option, WvStringParm long_option);
  63     void zap();
  64
  65     void add_required_arg();
  66     void subtract_required_arg();
  67     const WvStringList &args() const;
  68
  69     static error_t parser(int key, char *arg, argp_state *state);
  70
  71     unsigned int flags;
  72
  73 protected:
  74     friend class WvArgsOption;
  75     friend class WvArgsArgOption;
  76     friend class WvArgs;
  77
  78     void argp_build();
  79     bool argp_add(const char *name, int key, const char *arg, int flags,
  80                   const char *doc, int group);
  81 private:
  82     void argp_init(size_t size = 0);
  83
  84     bool argp_add(const argp_option &option);
  85     bool argp_double();
  86
  87     argp_option *argp_;
  88     size_t argp_index;          // Last element in the options array
  89     size_t argp_size;           // Size of the options array
  90
  91     // I create two data-structures, only one of them actually owning
  92     // the objects, of course.  The List is for ordered construction
  93     // of argp_.  The Dict is for constant-time lookups when
  94     // process()ing options.
  95     WvArgsOptionList options_list; // An ordered list of WvArgsOptions
  96     WvArgsOptionDict options_dict; // A constant-time lookup of them
  97
  98     WvStringList args_;         // Arguments after all options have been parsed
  99     size_t required_args;       // Number of these mandatory arguments.
 100     size_t maximum_args;        // Number of maximum arguments.
 101
 102     int last_no_key;            // Last key for options with no short_option
 103 };
 104
 105
 106 void WvArgsOption::add_to_argp(WvArgsData &data)
 107 {
 108     data.argp_add(long_option, short_option, 0, 0, desc, 0);
 109 }
 110
 111
 112 class WvArgsNoArgOption : public WvArgsOption
 113 {
 114
 115 public:
 116
 117     WvArgsNoArgOption(int _short_option,
 118                       WvStringParm _long_option,
 119                       WvStringParm _desc)
 120         : WvArgsOption(_short_option, _long_option, _desc)
 121     {
 122     }
 123 };
 124
 125
 126 class WvArgsSetBoolOption : public WvArgsNoArgOption
 127 {
 128
 129 private:
 130
 131     bool &flag;
 132
 133 public:
 134
 135     WvArgsSetBoolOption(int _short_option,
 136                         WvStringParm _long_option,
 137                         WvStringParm _desc,
 138                         bool &_flag)
 139         : WvArgsNoArgOption(_short_option, _long_option, _desc),
 140           flag(_flag)
 141     {
 142     }
 143
 144     virtual WvString process(WvStringParm arg)
 145     {
 146         flag = true;
 147         return WvString::null;
 148     }
 149 };
 150
 151
 152 class WvArgsResetBoolOption : public WvArgsNoArgOption
 153 {
 154
 155 private:
 156
 157     bool &flag;
 158
 159 public:
 160
 161     WvArgsResetBoolOption(int _short_option,
 162                           WvStringParm _long_option,
 163                           WvStringParm _desc,
 164                           bool &_flag)
 165         : WvArgsNoArgOption(_short_option, _long_option, _desc),
 166           flag(_flag)
 167     {
 168     }
 169
 170     virtual WvString process(WvStringParm arg)
 171     {
 172         flag = false;
 173         return WvString::null;
 174     }
 175 };
 176
 177
 178 class WvArgsFlipBoolOption : public WvArgsNoArgOption
 179 {
 180
 181 private:
 182
 183     bool &flag;
 184
 185 public:
 186
 187     WvArgsFlipBoolOption(int _short_option,
 188                          WvStringParm _long_option,
 189                          WvStringParm _desc,
 190                          bool &_flag)
 191         : WvArgsNoArgOption(_short_option, _long_option, _desc),
 192           flag(_flag)
 193     {
 194     }
 195
 196     virtual WvString process(WvStringParm arg)
 197     {
 198         flag = !flag;
 199         return WvString::null;
 200     }
 201 };
 202
 203
 204 class WvArgsIncIntOption : public WvArgsNoArgOption
 205 {
 206 private:
 207     int &val;
 208
 209 public:
 210     WvArgsIncIntOption(int _short_option,
 211                        WvStringParm _long_option,
 212                        WvStringParm _desc,
 213                        int &_val)
 214         : WvArgsNoArgOption(_short_option, _long_option, _desc),
 215           val(_val)
 216     {
 217     }
 218
 219     virtual WvString process(WvStringParm arg)
 220     {
 221         val++;
 222         return WvString::null;
 223     }
 224 };
 225
 226
 227 class WvArgsNoArgCallbackOption : public WvArgsNoArgOption
 228 {
 229
 230 private:
 231
 232     WvArgs::NoArgCallback cb;
 233     void *ud;
 234
 235 public:
 236
 237     WvArgsNoArgCallbackOption(int _short_option,
 238                               WvStringParm _long_option,
 239                               WvStringParm _desc,
 240                               WvArgs::NoArgCallback _cb,
 241                               void *_ud)
 242         : WvArgsNoArgOption(_short_option, _long_option, _desc),
 243           cb(_cb), ud(_ud)
 244     {
 245     }
 246
 247     virtual WvString process(WvStringParm arg)
 248     {
 249         if (cb(ud))
 250             return WvString::null;
 251         else
 252             return WvString("invalid option `%s'", arg);
 253     }
 254 };
 255
 256
 257 class WvArgsArgOption : public WvArgsOption
 258 {
 259 private:
 260
 261     WvString arg_desc;
 262
 263 public:
 264
 265     WvArgsArgOption(int _short_option,
 266                     WvStringParm _long_option,
 267                     WvStringParm _desc,
 268                     WvStringParm _arg_desc)
 269         : WvArgsOption(_short_option, _long_option, _desc),
 270           arg_desc(_arg_desc)
 271     {
 272     }
 273
 274     virtual void add_to_argp(WvArgsData &data)
 275     {
 276         data.argp_add(long_option, short_option, arg_desc, 0, desc, 0);
 277     }
 278 };
 279
 280
 281 class WvArgsIntOption : public WvArgsArgOption
 282 {
 283 private:
 284
 285     int &val;
 286
 287 public:
 288
 289     WvArgsIntOption(int _short_option,
 290                     WvStringParm _long_option,
 291                     WvStringParm _desc,
 292                     WvStringParm _arg_desc,
 293                     int &_val)
 294         : WvArgsArgOption(_short_option, _long_option, _desc, _arg_desc),
 295           val(_val)
 296     {
 297     }
 298
 299     virtual WvString process(WvStringParm arg)
 300     {
 301         char *tailptr = NULL;
 302         errno = 0;
 303         long int tmp = strtol(arg, &tailptr, 10);
 304         if (errno == ERANGE || tmp > INT_MAX || tmp < INT_MIN )
 305         {
 306             // Out of range
 307             return WvString("`%s': invalid number.", arg);
 308         }
 309         else if (*tailptr)
 310         {
 311             // Invalid number
 312             return WvString("`%s': invalid number.", arg);
 313         }
 314         else
 315         {
 316             val = tmp;
 317             return WvString::null;
 318         }
 319     }
 320 };
 321
 322
 323 class WvArgsLongOption : public WvArgsArgOption
 324 {
 325 private:
 326
 327     long &val;
 328
 329 public:
 330
 331     WvArgsLongOption(int _short_option,
 332                      WvStringParm _long_option,
 333                      WvStringParm _desc,
 334                      WvStringParm _arg_desc,
 335                      long &_val)
 336         : WvArgsArgOption(_short_option, _long_option, _desc, _arg_desc),
 337           val(_val)
 338     {
 339     }
 340
 341     virtual WvString process(WvStringParm arg)
 342     {
 343         char *tailptr = NULL;
 344         errno = 0;
 345         long int tmp = strtol(arg, &tailptr, 10);
 346         if (errno == ERANGE)
 347         {
 348             // Out of range
 349             return WvString("`%s': invalid number.", arg);
 350         }
 351         else if (*tailptr)
 352         {
 353             // Invalid number
 354             return WvString("`%s': invalid number.", arg);
 355         }
 356         else
 357         {
 358             val = tmp;
 359             return WvString::null;
 360         }
 361     }
 362 };
 363
 364
 365 class WvArgsFloatOption : public WvArgsArgOption
 366 {
 367 private:
 368
 369     float &val;
 370
 371 public:
 372
 373     WvArgsFloatOption(int _short_option,
 374                       WvStringParm _long_option,
 375                       WvStringParm _desc,
 376                       WvStringParm _arg_desc,
 377                       float &_val)
 378         : WvArgsArgOption(_short_option, _long_option, _desc, _arg_desc),
 379           val(_val)
 380     {
 381     }
 382
 383     virtual WvString process(WvStringParm arg)
 384     {
 385         char *tailptr = NULL;
 386         errno = 0;
 387         float tmp = strtof(arg, &tailptr);
 388         if (errno == ERANGE)
 389         {
 390             // Out of range
 391             return WvString("`%s': invalid number.", arg);
 392         }
 393         else if (*tailptr)
 394         {
 395             // Invalid number
 396             return WvString("`%s': invalid number.", arg);
 397         }
 398         else
 399         {
 400             val = tmp;
 401             return WvString::null;
 402         }
 403     }
 404 };
 405
 406
 407 class WvArgsDoubleOption : public WvArgsArgOption
 408 {
 409 private:
 410
 411     double &val;
 412
 413 public:
 414
 415     WvArgsDoubleOption(int _short_option,
 416                        WvStringParm _long_option,
 417                        WvStringParm _desc,
 418                        WvStringParm _arg_desc,
 419                        double &_val)
 420         : WvArgsArgOption(_short_option, _long_option, _desc, _arg_desc),
 421           val(_val)
 422     {
 423     }
 424
 425     virtual WvString process(WvStringParm arg)
 426     {
 427         char *tailptr = NULL;
 428         errno = 0;
 429         double tmp = strtod(arg, &tailptr);
 430         if (errno == ERANGE)
 431         {
 432             // Out of range
 433             return WvString("`%s': invalid number.", arg);
 434         }
 435         else if (*tailptr)
 436         {
 437             // Invalid number
 438             return WvString("`%s': invalid number.", arg);
 439         }
 440         else
 441         {
 442             val = tmp;
 443             return WvString::null;
 444         }
 445     }
 446 };
 447
 448
 449 class WvArgsStringOption : public WvArgsArgOption
 450 {
 451 private:
 452
 453     WvString &val;
 454
 455 public:
 456
 457     WvArgsStringOption(int _short_option,
 458                        WvStringParm _long_option,
 459                        WvStringParm _desc,
 460                        WvStringParm _arg_desc,
 461                        WvString &_val)
 462         : WvArgsArgOption(_short_option, _long_option, _desc, _arg_desc),
 463           val(_val)
 464     {
 465     }
 466
 467     virtual WvString process(WvStringParm arg)
 468     {
 469         val = arg;
 470         return WvString::null;
 471     }
 472 };
 473
 474
 475 class WvArgsStringListAppendOption : public WvArgsArgOption
 476 {
 477 private:
 478
 479     WvStringList &val;
 480
 481 public:
 482
 483     WvArgsStringListAppendOption(int _short_option,
 484                                  WvStringParm _long_option,
 485                                  WvStringParm _desc,
 486                                  WvStringParm _arg_desc,
 487                                  WvStringList &_val)
 488         : WvArgsArgOption(_short_option, _long_option, _desc, _arg_desc),
 489           val(_val)
 490     {
 491     }
 492
 493     virtual WvString process(WvStringParm arg)
 494     {
 495         val.append(arg);
 496         return WvString::null;
 497     }
 498 };
 499
 500
 501 class WvArgsArgCallbackOption : public WvArgsArgOption
 502 {
 503 private:
 504
 505     WvArgs::ArgCallback cb;
 506     void *ud;
 507
 508 public:
 509
 510     WvArgsArgCallbackOption(int _short_option,
 511                             WvStringParm _long_option,
 512                             WvStringParm _desc,
 513                             WvStringParm _arg_desc,
 514                             WvArgs::ArgCallback _cb,
 515                             void *_ud)
 516         : WvArgsArgOption(_short_option, _long_option, _desc, _arg_desc),
 517           cb(_cb), ud(_ud)
 518     {
 519     }
 520
 521     virtual WvString process(WvStringParm arg)
 522     {
 523         if (cb(arg, ud))
 524             return WvString::null;
 525         else
 526             return WvString("invalid option: `%s'", arg);
 527     }
 528 };
 529
 530
 531 WvArgsData::WvArgsData()
 532     : flags(0), argp_(NULL), argp_index(0), argp_size(0),
 533       required_args(0), maximum_args(0), last_no_key(-1)
 534 {
 535 }
 536
 537
 538 WvArgsData::~WvArgsData()
 539 {
 540     if (argp_)
 541         free(argp_);
 542 }
 543
 544
 545 argp_option *WvArgsData::argp() const
 546 {
 547     return argp_;
 548 }
 549
 550
 551 void *WvArgsData::self() const
 552 {
 553     return (void *)this;
 554 }
 555
 556
 557 void WvArgsData::add(WvArgsOption *option)
 558 {
 559     if (!option)
 560         return;
 561
 562     if (!option->short_option)
 563         option->short_option = last_no_key--;
 564
 565     options_list.append(option, true);
 566     options_dict.add(option, false);
 567 }
 568
 569
 570 // This method removes both short_option and long_option from the
 571 // options_* structures.  Completely.
 572 void WvArgsData::remove(char short_option, WvStringParm long_option)
 573 {
 574     // First, look through options_list, and remove them from
 575     // options_dict once we find them.
 576     WvArgsOptionList::Iter i(options_list);
 577     for (i.rewind(); i.next(); )
 578     {
 579         bool matches_short = false;
 580         bool matches_long = false;
 581
 582         if (short_option != '\0' && i->short_option == short_option)
 583             matches_short = true;
 584         if (!long_option.isnull() && i->long_option == long_option)
 585             matches_long = true;
 586
 587         if (matches_short && matches_long
 588             || matches_short && i->long_option.isnull()
 589             || matches_long && i->short_option == '\0')
 590         {
 591             // Delete this item from the data-structures
 592             options_dict.remove(i.ptr());
 593             i.xunlink();
 594             if (argp_)
 595             {
 596                 free(argp_);
 597                 argp_ = NULL;
 598             }
 599         }
 600         else if (matches_short)
 601         {
 602             // Update the short description and change how it's filed
 603             // in the dictionary.
 604             i->short_option = '\0';
 605             options_dict.remove(i.ptr());
 606             options_dict.add(i.ptr(), false);
 607         }
 608         else if (matches_long)
 609         {
 610             // Update the long description only
 611             i->long_option = WvString::null;
 612         }
 613     }
 614 }
 615
 616
 617 void WvArgsData::zap()
 618 {
 619     options_dict.zap();
 620     options_list.zap();
 621
 622     if (argp_)
 623     {
 624         free(argp_);
 625         argp_ = NULL;
 626     }
 627 }
 628
 629
 630 void WvArgsData::argp_init(size_t size)
 631 {
 632     argp_size = size;
 633     if (argp_size < 1)
 634         argp_size = 1;
 635
 636     // I'm sorry to use malloc(), but this argp is a C library
 637     argp_ = (argp_option *)malloc(argp_size * sizeof(argp_option));
 638     // Terminate the empty array
 639     memset(argp_, 0, sizeof(argp_option));
 640 }
 641
 642
 643 void WvArgsData::argp_build()
 644 {
 645     if (!argp_)
 646         argp_init(options_list.count() + 2);
 647
 648     WvArgsOptionList::Iter i(options_list);
 649     for (i.rewind(); i.next(); )
 650         i->add_to_argp(*this);
 651 }
 652
 653
 654 bool WvArgsData::argp_add(const argp_option &option)
 655 {
 656     if (argp_index >= (argp_size - 1))
 657     {
 658         if (!argp_double())
 659             return false;
 660     }
 661
 662     // Make a copy of the option that we're building.
 663     memcpy(argp_ + argp_index, &option, sizeof(argp_option));
 664     // Terminate the array.
 665     ++argp_index;
 666     memset(argp_ + argp_index, 0, sizeof(argp_option));
 667     return true;
 668 }
 669
 670
 671 bool WvArgsData::argp_add(const char *name, int key, const char *arg,
 672                           int flags, const char *doc, int group)
 673 {
 674     if (argp_index >= (argp_size - 1))
 675     {
 676         if (!argp_double())
 677             return false;
 678     }
 679
 680     // Set the elements.
 681     argp_option *option = argp_ + argp_index;
 682     option->name = name;
 683     option->key = key;
 684     option->arg = arg;
 685     option->flags = flags;
 686     option->doc = doc;
 687     option->group = group;
 688     // Terminate the array.
 689     ++argp_index;
 690     memset(argp_ + argp_index, 0, sizeof(argp_option));
 691     return true;
 692 }
 693
 694
 695 bool WvArgsData::argp_double()
 696 {
 697     // We won't be able to fit the next entry into the array
 698     void *tmp = realloc(argp_, 2 * argp_size * sizeof(argp_option));
 699     if (!tmp)
 700         return false;
 701
 702     argp_ = (argp_option *)tmp;
 703     argp_size *= 2;
 704     return true;
 705 }
 706
 707
 708 void WvArgsData::add_required_arg()
 709 {
 710     ++required_args;
 711 }
 712
 713
 714 void WvArgsData::subtract_required_arg()
 715 {
 716     --required_args;
 717 }
 718
 719
 720 const WvStringList &WvArgsData::args() const
 721 {
 722     return args_;
 723 }
 724
 725
 726 error_t WvArgsData::parser(int key, char *arg, struct argp_state *state)
 727 {
 728     WvArgsData *data = (WvArgsData *)state->input;
 729
 730     switch (key)
 731     {
 732     case ARGP_KEY_ARG:
 733         if (state->arg_num >= data->maximum_args)
 734         {
 735             // Too many arguments
 736             argp_usage(state);
 737         }
 738         data->args_.append(arg);
 739         break;
 740
 741     case ARGP_KEY_NO_ARGS:
 742     case ARGP_KEY_END:
 743         if (state->arg_num < data->required_args)
 744         {
 745             // Too few arguments
 746             argp_usage(state);
 747         }
 748         break;
 749
 750     default:
 751         WvArgsOption *option = data->options_dict[key];
 752         if (option)
 753         {
 754             WvString error = option->process(arg);
 755             if (!error.isnull())
 756             {
 757                 argp_failure(state, argp_err_exit_status, 0,
 758                              "%s", error.cstr());
 759                 return EINVAL;
 760             }
 761         }
 762         else
 763             return ARGP_ERR_UNKNOWN;
 764     }
 765
 766     return 0;
 767 }
 768
 769
 770 WvArgs::WvArgs()
 771     : data(new WvArgsData())
 772 {
 773 }
 774
 775
 776 WvArgs::~WvArgs()
 777 {
 778     if (data)
 779         delete data;
 780 }
 781
 782
 783 bool WvArgs::process(int argc, char **argv, WvStringList *remaining_args)
 784 {
 785     if (!data->argp())
 786         data->argp_build();
 787
 788     // Setup --help headers and footers
 789     WvString prog_doc;
 790     if (header && footer)
 791         prog_doc = WvString("%s\v%s", header, footer);
 792     else if (header)
 793         prog_doc = WvString("%s", header);
 794     else if (footer)
 795         prog_doc = WvString(" \v%s", footer);
 796
 797     // Setup the constant version number and e-mail address
 798     argp_program_version = version;
 799     argp_program_bug_address = email;
 800
 801     struct argp argp = { data->argp(), &WvArgsData::parser, args_doc, prog_doc,
 802                          0, 0, 0 };
 803
 804     bool error = argp_parse(&argp, argc, argv, data->flags, 0, data->self());
 805
 806     if (remaining_args)
 807     {
 808         remaining_args->zap();
 809         WvStringList::Iter i(data->args());
 810         for (i.rewind(); i.next(); )
 811             remaining_args->add(new WvString(*i), true);
 812     }
 813
 814     return !error;
 815 }
 816
 817
 818 void WvArgs::set_version(WvStringParm version)
 819 {
 820     this->version = version;
 821 }
 822
 823
 824 void WvArgs::set_email(WvStringParm email)
 825 {
 826     this->email = email;
 827 }
 828
 829
 830 void WvArgs::set_help_header(WvStringParm header)
 831 {
 832     this->header = header;
 833 }
 834
 835
 836 void WvArgs::set_help_footer(WvStringParm footer)
 837 {
 838     this->footer = footer;
 839 }
 840
 841
 842 void WvArgs::print_usage(int argc, char **argv)
 843 {
 844     struct argp argp = { data->argp(), 0, 0, 0, 0, 0, 0 };
 845     argp_help(&argp, stdout, ARGP_HELP_STD_USAGE, argv[0]);
 846 }
 847
 848
 849 void WvArgs::print_help(int argc, char **argv)
 850 {
 851     struct argp argp = { data->argp(), 0, 0, 0, 0, 0, 0 };
 852     argp_help(&argp, stdout, ARGP_HELP_STD_HELP, argv[0]);
 853 }
 854
 855 void WvArgs::add_set_bool_option(char short_option, WvStringParm long_option,
 856                                  WvStringParm desc, bool &val)
 857 {
 858     data->remove(short_option, long_option);
 859     data->add(new WvArgsSetBoolOption(short_option, long_option, desc, val));
 860 }
 861
 862
 863 void WvArgs::add_reset_bool_option(char short_option, WvStringParm long_option,
 864                                    WvStringParm desc, bool &val)
 865 {
 866     data->remove(short_option, long_option);
 867     data->add(new WvArgsResetBoolOption(short_option, long_option, desc, val));
 868 }
 869
 870
 871 void WvArgs::add_flip_bool_option(char short_option, WvStringParm long_option,
 872                                   WvStringParm desc, bool &val)
 873 {
 874     data->remove(short_option, long_option);
 875     data->add(new WvArgsFlipBoolOption(short_option, long_option, desc, val));
 876 }
 877
 878
 879 void WvArgs::add_option(char short_option, WvStringParm long_option,
 880                         WvStringParm desc, NoArgCallback cb, void *ud)
 881 {
 882     data->remove(short_option, long_option);
 883     data->add(new WvArgsNoArgCallbackOption(short_option, long_option, desc,
 884                                             cb, ud));
 885 }
 886
 887 void WvArgs::add_option(char short_option, WvStringParm long_option,
 888                         WvStringParm desc, WvStringParm arg_desc, int &val)
 889 {
 890     data->remove(short_option, long_option);
 891     data->add(new WvArgsIntOption(short_option, long_option, desc, arg_desc,
 892                                   val));
 893 }
 894
 895 void WvArgs::add_option(char short_option, WvStringParm long_option,
 896                         WvStringParm desc, WvStringParm arg_desc, long &val)
 897 {
 898     data->remove(short_option, long_option);
 899     data->add(new WvArgsLongOption(short_option, long_option, desc, arg_desc,
 900                                    val));
 901 }
 902
 903 void WvArgs::add_option(char short_option, WvStringParm long_option,
 904                         WvStringParm desc, WvStringParm arg_desc, float &val)
 905 {
 906     data->remove(short_option, long_option);
 907     data->add(new WvArgsFloatOption(short_option, long_option, desc, arg_desc,
 908                                     val));
 909 }
 910
 911 void WvArgs::add_option(char short_option, WvStringParm long_option,
 912                         WvStringParm desc, WvStringParm arg_desc, double &val)
 913 {
 914     data->remove(short_option, long_option);
 915     data->add(new WvArgsDoubleOption(short_option, long_option, desc,
 916                                      arg_desc, val));
 917 }
 918
 919 void WvArgs::add_option(char short_option, WvStringParm long_option,
 920                         WvStringParm desc, WvStringParm arg_desc,
 921                         WvString &val)
 922 {
 923     data->remove(short_option, long_option);
 924     data->add(new WvArgsStringOption(short_option, long_option, desc,
 925                                      arg_desc, val));
 926 }
 927
 928 void WvArgs::add_option(char short_option, WvStringParm long_option,
 929                         WvStringParm desc, WvStringParm arg_desc,
 930                         WvStringList &val)
 931 {
 932     data->remove(short_option, long_option);
 933     data->add(new WvArgsStringListAppendOption(short_option, long_option,
 934                                                desc, arg_desc, val));
 935 }
 936
 937 void WvArgs::add_option(char short_option, WvStringParm long_option,
 938                         WvStringParm desc, WvStringParm arg_desc,
 939                         ArgCallback cb, void *ud)
 940 {
 941     data->remove(short_option, long_option);
 942     data->add(new WvArgsArgCallbackOption(short_option, long_option, desc,
 943                                           arg_desc, cb, ud));
 944 }
 945
 946
 947 void WvArgs::remove_option(char short_option)
 948 {
 949     data->remove(short_option, WvString::null);
 950 }
 951
 952
 953 void WvArgs::remove_option(WvStringParm long_option)
 954 {
 955     data->remove(0, long_option);
 956 }
 957
 958
 959 void WvArgs::remove_all_options()
 960 {
 961     data->zap();
 962 }
 963
 964
 965 void WvArgs::add_required_arg(WvStringParm desc, bool multiple)
 966 {
 967     data->add_required_arg();
 968     if (!!args_doc)
 969         args_doc.append(" ");
 970     args_doc.append(desc);
 971     if (multiple)
 972     {
 973         args_doc.append("...");
 974         data->maximum_args = LONG_MAX;
 975     }
 976     else if (data->maximum_args < LONG_MAX)
 977         ++(data->maximum_args);
 978 }
 979
 980
 981 void WvArgs::add_optional_arg(WvStringParm desc, bool multiple)
 982 {
 983     // an optional arg is a required arg without the requirement :-)
 984     add_required_arg(WvString("[%s]", desc), multiple);
 985     data->subtract_required_arg();
 986 }
 987
 988
 989 bool WvArgs::get_flag(const flags_t flag) const
 990 {
 991     switch (flag)
 992     {
 993     case NO_EXIT_ON_ERRORS:
 994         return data->flags & ARGP_NO_EXIT;
 995     default:
 996         return false;
 997     }
 998 }
 999
1000
1001 void WvArgs::set_flag(const flags_t flag, const bool value)
1002 {
1003     printf("set_flag(%d, %d)\n", flag, value);
1004     unsigned int mask;
1005     switch (flag)
1006     {
1007     case NO_EXIT_ON_ERRORS:
1008         mask = ARGP_NO_EXIT;
1009         break;
1010     default:
1011         return;
1012     }
1013
1014     if (value)
1015         data->flags |= mask;
1016     else
1017         data->flags &= ~mask;
1018
1019     printf("set_flag(%d, %d) = %d\n", flag, value, data->flags);
1020 }