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