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{
24public:
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
50DeclareWvList(WvArgsOption);
51DeclareWvScatterDict(WvArgsOption, int, short_option);
52
54{
55public:
56 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
74protected:
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);
82private:
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
107void WvArgsOption::add_to_argp(WvArgsData &data)
108{
109 data.argp_add(long_option, short_option, 0, 0, desc, 0);
110}
111
112
114{
115
116public:
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
130private:
131
132 bool &flag;
133
134public:
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
156private:
157
158 bool &flag;
159
160public:
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
182private:
183
184 bool &flag;
185
186public:
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{
207private:
208 int &val;
209
210public:
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
231private:
232
234 void *ud;
235
236public:
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{
260private:
261
262 WvString arg_desc;
263
264public:
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{
284private:
285
286 int &val;
287
288public:
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{
326private:
327
328 long &val;
329
330public:
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{
368private:
369
370 float &val;
371
372public:
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{
410private:
411
412 double &val;
413
414public:
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{
452private:
453
454 WvString &val;
455
456public:
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{
478private:
479
480 WvStringList &val;
481
482public:
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{
504private:
505
507 void *ud;
508
509public:
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
532WvArgsData::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
539WvArgsData::~WvArgsData()
540{
541 if (argp_)
542 free(argp_);
543}
544
545
546argp_option *WvArgsData::argp() const
547{
548 return argp_;
549}
550
551
552void *WvArgsData::self() const
553{
554 return (void *)this;
555}
556
557
558void 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.
573void 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
618void 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
631void 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
644void 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
655bool 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
672bool 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
696bool 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
709void WvArgsData::add_required_arg()
710{
711 ++required_args;
712}
713
714
715void WvArgsData::subtract_required_arg()
716{
717 --required_args;
718}
719
720
721const WvStringList &WvArgsData::args() const
722{
723 return args_;
724}
725
726
727error_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
771WvArgs::WvArgs()
772 : data(new WvArgsData())
773{
774}
775
776
777WvArgs::~WvArgs()
778{
779 if (data)
780 delete data;
781}
782
783
784bool 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
820{
821 this->version = version;
822}
823
824
826{
827 this->email = email;
828}
829
830
832{
833 this->header = header;
834}
835
836
838{
839 this->footer = footer;
840}
841
842
843void 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
850void 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
856void 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
864void 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
872void 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
880void 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
888void 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
896void 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
904void 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
912void 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
920void 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
929void 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
938void 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
948void WvArgs::remove_option(char short_option)
949{
950 data->remove(short_option, WvString::null);
951}
952
953
955{
956 data->remove(0, long_option);
957}
958
959
961{
962 data->zap();
963}
964
965
966void 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
982void 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
990bool 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
1002void 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 - Sane command-line argument processing for WvStreams.
Definition wvargs.h:62
void remove_option(char short_option)
Remove an option by specifying its short form.
Definition wvargs.cc:948
void remove_all_options()
Remove all options.
Definition wvargs.cc:960
bool get_flag(const flags_t flag) const
Get and set flags.
Definition wvargs.cc:990
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
void add_optional_arg(WvStringParm desc, bool multiple=false)
Add an optional argument to the list of parameters.
Definition wvargs.cc:982
flags_t
These flags control the behaviour of WvArgs.
Definition wvargs.h:339
void set_help_header(WvStringParm header)
Set the introductory help message, printed at the beginning of –help.
Definition wvargs.cc:831
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
void print_usage(int argc, char **argv)
Output the short usage message based on the provided options.
Definition wvargs.cc:843
void set_help_footer(WvStringParm footer)
Set the descriptive help message, printed at the end of –help.
Definition wvargs.cc:837
wv::function< bool(void *)> NoArgCallback
The callback type used for switches that do not take a parameter.
Definition wvargs.h:69
void set_version(WvStringParm version)
Set the –version string.
Definition wvargs.cc:819
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
void add_required_arg(WvStringParm desc, bool multiple=false)
Add a required argument to the list of parameters.
Definition wvargs.cc:966
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
void set_email(WvStringParm email)
Set the e-mail address for bug reports.
Definition wvargs.cc:825
void print_help(int argc, char **argv)
Output the long usage message based on the provided options.
Definition wvargs.cc:850
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
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
A WvFastString acts exactly like a WvString, but can take (const char *) strings without needing to a...
Definition wvstring.h:94
bool isnull() const
returns true if this string is null
Definition wvstring.h:290
const char * cstr() const
return a (const char *) for this string.
Definition wvstring.h:267
This is a WvList of WvStrings, and is a really handy way to parse strings.
WvString is an implementation of a simple and efficient printable-string class.
Definition wvstring.h:330
Definition argp.h:213