├── .gitignore
├── .travis.yml
├── LICENSE
├── Makefile
├── OptionParser.cpp
├── OptionParser.h
├── README.md
├── t
    └── testprog
├── test.sh
└── testprog.cpp


/.gitignore:
--------------------------------------------------------------------------------
1 | *.o
2 | /testprog
3 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: cpp
2 | compiler:
3 | - clang
4 | - gcc
5 | env:
6 | - CPP11=0
7 | - CPP11=1
8 | script: make test WARN=1
9 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2010 Johannes Weißl
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | ifeq ($(WARN),1)
 2 | ifeq ($(CXX),g++)
 3 | WARN_FLAGS = -O3 -g -Wall -Wextra -Wabi -Wctor-dtor-privacy -Wnon-virtual-dtor -Wreorder -Wstrict-null-sentinel -Woverloaded-virtual -Wshadow -Wcast-align -Wpointer-arith -Wwrite-strings -Wundef -Wredundant-decls -Werror # -Weffc++
 4 | else ifeq ($(CXX),clang++)
 5 | WARN_FLAGS = -O3 -g -Werror
 6 | else ifeq ($(CXX),icpc)
 7 | WARN_FLAGS = -O3 -ipo -g -Wall -wd981 -wd383 -wd2259 -Werror # -Weffc++
 8 | endif
 9 | endif
10 | 
11 | ifeq ($(CPP11),1)
12 | STD_FLAGS = -std=c++0x
13 | endif
14 | 
15 | BIN = testprog
16 | OBJECTS = OptionParser.o testprog.o
17 | 
18 | $(BIN): $(OBJECTS)
19 | 	$(CXX) -o $@ $(OBJECTS) $(WARN_FLAGS) $(STD_FLAGS) $(LINKFLAGS)
20 | 
21 | %.o: %.cpp OptionParser.h
22 | 	$(CXX) $(WARN_FLAGS) $(STD_FLAGS) $(CXXFLAGS) -c $< -o $@
23 | 
24 | .PHONY: clean test
25 | 
26 | test: testprog
27 | 	./test.sh
28 | 
29 | clean:
30 | 	rm -f *.o $(BIN)
31 | 


--------------------------------------------------------------------------------
/OptionParser.cpp:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Copyright (C) 2010 Johannes Weißl <jargon@molb.org>
  3 |  * License: MIT License
  4 |  * URL: https://github.com/weisslj/cpp-optparse
  5 |  */
  6 | 
  7 | #include "OptionParser.h"
  8 | 
  9 | #include <cstdlib>
 10 | #include <algorithm>
 11 | #include <complex>
 12 | #include <ciso646>
 13 | 
 14 | #if defined(ENABLE_NLS) && ENABLE_NLS
 15 | # include <libintl.h>
 16 | # define _(s) gettext(s)
 17 | #else
 18 | # define _(s) ((const char *) (s))
 19 | #endif
 20 | 
 21 | using namespace std;
 22 | 
 23 | namespace optparse {
 24 | 
 25 | ////////// auxiliary (string) functions { //////////
 26 | class str_wrap {
 27 | public:
 28 |   str_wrap(const string& l, const string& r) : lwrap(l), rwrap(r) {}
 29 |   str_wrap(const string& w) : lwrap(w), rwrap(w) {}
 30 |   string operator() (const string& s) { return lwrap + s + rwrap; }
 31 |   const string lwrap, rwrap;
 32 | };
 33 | template<typename InputIterator, typename UnaryOperator>
 34 | static string str_join_trans(const string& sep, InputIterator begin, InputIterator end, UnaryOperator op) {
 35 |   string buf;
 36 |   for (InputIterator it = begin; it != end; ++it) {
 37 |     if (it != begin)
 38 |       buf += sep;
 39 |     buf += op(*it);
 40 |   }
 41 |   return buf;
 42 | }
 43 | template<class InputIterator>
 44 | static string str_join(const string& sep, InputIterator begin, InputIterator end) {
 45 |   return str_join_trans(sep, begin, end, str_wrap(""));
 46 | }
 47 | static string& str_replace(string& s, const string& patt, const string& repl) {
 48 |   size_t pos = 0, n = patt.length();
 49 |   while (true) {
 50 |     pos = s.find(patt, pos);
 51 |     if (pos == string::npos)
 52 |       break;
 53 |     s.replace(pos, n, repl);
 54 |     pos += repl.size();
 55 |   }
 56 |   return s;
 57 | }
 58 | static string str_replace(const string& s, const string& patt, const string& repl) {
 59 |   string tmp = s;
 60 |   str_replace(tmp, patt, repl);
 61 |   return tmp;
 62 | }
 63 | static string str_format(const string& str, size_t pre, size_t len, bool running_text = true, bool indent_first = true) {
 64 |   string s = str;
 65 |   stringstream ss;
 66 |   string p;
 67 |   len -= 2; // Python seems to not use full length
 68 |   if (running_text)
 69 |     replace(s.begin(), s.end(), '\n', ' ');
 70 |   if (indent_first)
 71 |     p = string(pre, ' ');
 72 | 
 73 |   size_t pos = 0, linestart = 0;
 74 |   size_t line = 0;
 75 |   while (true) {
 76 |     bool wrap = false;
 77 | 
 78 |     size_t new_pos = s.find_first_of(" \n\t", pos);
 79 |     if (new_pos == string::npos)
 80 |       break;
 81 |     if (s[new_pos] == '\n') {
 82 |       pos = new_pos + 1;
 83 |       wrap = true;
 84 |     }
 85 |     if (line == 1)
 86 |       p = string(pre, ' ');
 87 |     if (wrap || new_pos + pre > linestart + len) {
 88 |       ss << p << s.substr(linestart, pos - linestart - 1) << endl;
 89 |       linestart = pos;
 90 |       line++;
 91 |     }
 92 |     pos = new_pos + 1;
 93 |   }
 94 |   ss << p << s.substr(linestart) << endl;
 95 |   return ss.str();
 96 | }
 97 | static string str_inc(const string& s) {
 98 |   stringstream ss;
 99 |   string v = (s != "") ? s : "0";
100 |   long i;
101 |   istringstream(v) >> i;
102 |   ss << i+1;
103 |   return ss.str();
104 | }
105 | static unsigned int cols() {
106 |   unsigned int n = 80;
107 | #ifndef _WIN32
108 |   const char *s = getenv("COLUMNS");
109 |   if (s)
110 |     istringstream(s) >> n;
111 | #endif
112 |   return n;
113 | }
114 | static string basename(const string& s) {
115 |   string b = s;
116 |   size_t i = b.find_last_not_of('/');
117 |   if (i == string::npos) {
118 |     if (b[0] == '/')
119 |       b.erase(1);
120 |     return b;
121 |   }
122 |   b.erase(i+1, b.length()-i-1);
123 |   i = b.find_last_of("/");
124 |   if (i != string::npos)
125 |     b.erase(0, i+1);
126 |   return b;
127 | }
128 | ////////// } auxiliary (string) functions //////////
129 | 
130 | 
131 | ////////// class OptionContainer { //////////
132 | Option& OptionContainer::add_option(const string& opt) {
133 |   const string tmp[1] = { opt };
134 |   return add_option(vector<string>(&tmp[0], &tmp[1]));
135 | }
136 | Option& OptionContainer::add_option(const string& opt1, const string& opt2) {
137 |   const string tmp[2] = { opt1, opt2 };
138 |   return add_option(vector<string>(&tmp[0], &tmp[2]));
139 | }
140 | Option& OptionContainer::add_option(const string& opt1, const string& opt2, const string& opt3) {
141 |   const string tmp[3] = { opt1, opt2, opt3 };
142 |   return add_option(vector<string>(&tmp[0], &tmp[3]));
143 | }
144 | Option& OptionContainer::add_option(const vector<string>& v) {
145 |   _opts.resize(_opts.size()+1, Option(get_parser()));
146 |   Option& option = _opts.back();
147 |   string dest_fallback;
148 |   for (vector<string>::const_iterator it = v.begin(); it != v.end(); ++it) {
149 |     if (it->substr(0,2) == "--") {
150 |       const string s = it->substr(2);
151 |       if (option.dest() == "")
152 |         option.dest(str_replace(s, "-", "_"));
153 |       option._long_opts.insert(s);
154 |       _optmap_l[s] = &option;
155 |     } else {
156 |       const string s = it->substr(1,1);
157 |       if (dest_fallback == "")
158 |         dest_fallback = s;
159 |       option._short_opts.insert(s);
160 |       _optmap_s[s] = &option;
161 |     }
162 |   }
163 |   if (option.dest() == "")
164 |     option.dest(dest_fallback);
165 |   return option;
166 | }
167 | string OptionContainer::format_option_help(unsigned int indent /* = 2 */) const {
168 |   stringstream ss;
169 | 
170 |   if (_opts.empty())
171 |     return ss.str();
172 | 
173 |   for (list<Option>::const_iterator it = _opts.begin(); it != _opts.end(); ++it) {
174 |     if (it->help() != SUPPRESS_HELP)
175 |       ss << it->format_help(indent);
176 |   }
177 | 
178 |   return ss.str();
179 | }
180 | ////////// } class OptionContainer //////////
181 | 
182 | ////////// class OptionParser { //////////
183 | OptionParser::OptionParser() :
184 |   OptionContainer(),
185 |   _usage(_("%prog [options]")),
186 |   _add_help_option(true),
187 |   _add_version_option(true),
188 |   _interspersed_args(true) {}
189 | 
190 | OptionParser& OptionParser::add_option_group(const OptionGroup& group) {
191 |   for (list<Option>::const_iterator oit = group._opts.begin(); oit != group._opts.end(); ++oit) {
192 |     const Option& option = *oit;
193 |     for (set<string>::const_iterator it = option._short_opts.begin(); it != option._short_opts.end(); ++it)
194 |       _optmap_s[*it] = &option;
195 |     for (set<string>::const_iterator it = option._long_opts.begin(); it != option._long_opts.end(); ++it)
196 |       _optmap_l[*it] = &option;
197 |   }
198 |   _groups.push_back(&group);
199 |   return *this;
200 | }
201 | 
202 | const Option& OptionParser::lookup_short_opt(const string& opt) const {
203 |   optMap::const_iterator it = _optmap_s.find(opt);
204 |   if (it == _optmap_s.end())
205 |     error(_("no such option") + string(": -") + opt);
206 |   return *it->second;
207 | }
208 | 
209 | void OptionParser::handle_short_opt(const string& opt, const string& arg) {
210 | 
211 |   _remaining.pop_front();
212 |   string value;
213 | 
214 |   const Option& option = lookup_short_opt(opt);
215 |   if (option._nargs == 1) {
216 |     value = arg.substr(2);
217 |     if (value == "") {
218 |       if (_remaining.empty())
219 |         error("-" + opt + " " + _("option requires an argument"));
220 |       value = _remaining.front();
221 |       _remaining.pop_front();
222 |     }
223 |   } else {
224 |     if (arg.length() > 2)
225 |       _remaining.push_front(string("-") + arg.substr(2));
226 |   }
227 | 
228 |   process_opt(option, string("-") + opt, value);
229 | }
230 | 
231 | const Option& OptionParser::lookup_long_opt(const string& opt) const {
232 | 
233 |   list<string> matching;
234 |   for (optMap::const_iterator it = _optmap_l.begin(); it != _optmap_l.end(); ++it) {
235 |     if (it->first.compare(0, opt.length(), opt) == 0) {
236 |       matching.push_back(it->first);
237 |       if (it->first.length() == opt.length())
238 |         break;
239 |     }
240 |   }
241 |   if (matching.size() > 1) {
242 |     string x = str_join_trans(", ", matching.begin(), matching.end(), str_wrap("--", ""));
243 |     error(_("ambiguous option") + string(": --") + opt + " (" + x + "?)");
244 |   }
245 |   if (matching.size() == 0)
246 |     error(_("no such option") + string(": --") + opt);
247 | 
248 |   return *_optmap_l.find(matching.front())->second;
249 | }
250 | 
251 | void OptionParser::handle_long_opt(const string& optstr) {
252 | 
253 |   _remaining.pop_front();
254 |   string opt, value;
255 | 
256 |   size_t delim = optstr.find("=");
257 |   if (delim != string::npos) {
258 |     opt = optstr.substr(0, delim);
259 |     value = optstr.substr(delim+1);
260 |   } else
261 |     opt = optstr;
262 | 
263 |   const Option& option = lookup_long_opt(opt);
264 |   if (option._nargs == 1 and delim == string::npos) {
265 |     if (not _remaining.empty()) {
266 |       value = _remaining.front();
267 |       _remaining.pop_front();
268 |     }
269 |   }
270 | 
271 |   if (option._nargs == 1 and value == "")
272 |     error("--" + opt + " " + _("option requires an argument"));
273 | 
274 |   process_opt(option, string("--") + opt, value);
275 | }
276 | 
277 | Values& OptionParser::parse_args(const int argc, char const* const* const argv) {
278 |   if (prog() == "")
279 |     prog(basename(argv[0]));
280 |   return parse_args(&argv[1], &argv[argc]);
281 | }
282 | Values& OptionParser::parse_args(const vector<string>& v) {
283 | 
284 |   _remaining.assign(v.begin(), v.end());
285 | 
286 |   if (add_help_option()) {
287 |     add_option("-h", "--help") .action("help") .help(_("show this help message and exit"));
288 |     _opts.splice(_opts.begin(), _opts, --(_opts.end()));
289 |   }
290 |   if (add_version_option() and version() != "") {
291 |     add_option("--version") .action("version") .help(_("show program's version number and exit"));
292 |     _opts.splice(_opts.begin(), _opts, --(_opts.end()));
293 |   }
294 | 
295 |   while (not _remaining.empty()) {
296 |     const string arg = _remaining.front();
297 | 
298 |     if (arg == "--") {
299 |       _remaining.pop_front();
300 |       break;
301 |     }
302 | 
303 |     if (arg.substr(0,2) == "--") {
304 |       handle_long_opt(arg.substr(2));
305 |     } else if (arg.substr(0,1) == "-" and arg.length() > 1) {
306 |       handle_short_opt(arg.substr(1,1), arg);
307 |     } else {
308 |       _remaining.pop_front();
309 |       _leftover.push_back(arg);
310 |       if (not interspersed_args())
311 |         break;
312 |     }
313 |   }
314 |   while (not _remaining.empty()) {
315 |     const string arg = _remaining.front();
316 |     _remaining.pop_front();
317 |     _leftover.push_back(arg);
318 |   }
319 | 
320 |   for (list<Option>::const_iterator it = _opts.begin(); it != _opts.end(); ++it) {
321 |     if (it->get_default() != "" and not _values.is_set(it->dest()))
322 |       _values[it->dest()] = it->get_default();
323 |   }
324 | 
325 |   for (list<OptionGroup const*>::iterator group_it = _groups.begin(); group_it != _groups.end(); ++group_it) {
326 |     for (list<Option>::const_iterator it = (*group_it)->_opts.begin(); it != (*group_it)->_opts.end(); ++it) {
327 |       if (it->get_default() != "" and not _values.is_set(it->dest()))
328 |         _values[it->dest()] = it->get_default();
329 |     }
330 |   }
331 | 
332 |   return _values;
333 | }
334 | 
335 | void OptionParser::process_opt(const Option& o, const string& opt, const string& value) {
336 |   if (o.action() == "store") {
337 |     string err = o.check_type(opt, value);
338 |     if (err != "")
339 |       error(err);
340 |     _values[o.dest()] = value;
341 |     _values.is_set_by_user(o.dest(), true);
342 |   }
343 |   else if (o.action() == "store_const") {
344 |     _values[o.dest()] = o.get_const();
345 |     _values.is_set_by_user(o.dest(), true);
346 |   }
347 |   else if (o.action() == "store_true") {
348 |     _values[o.dest()] = "1";
349 |     _values.is_set_by_user(o.dest(), true);
350 |   }
351 |   else if (o.action() == "store_false") {
352 |     _values[o.dest()] = "0";
353 |     _values.is_set_by_user(o.dest(), true);
354 |   }
355 |   else if (o.action() == "append") {
356 |     string err = o.check_type(opt, value);
357 |     if (err != "")
358 |       error(err);
359 |     _values[o.dest()] = value;
360 |     _values.all(o.dest()).push_back(value);
361 |     _values.is_set_by_user(o.dest(), true);
362 |   }
363 |   else if (o.action() == "append_const") {
364 |     _values[o.dest()] = o.get_const();
365 |     _values.all(o.dest()).push_back(o.get_const());
366 |     _values.is_set_by_user(o.dest(), true);
367 |   }
368 |   else if (o.action() == "count") {
369 |     _values[o.dest()] = str_inc(_values[o.dest()]);
370 |     _values.is_set_by_user(o.dest(), true);
371 |   }
372 |   else if (o.action() == "help") {
373 |     print_help();
374 |     std::exit(0);
375 |   }
376 |   else if (o.action() == "version") {
377 |     print_version();
378 |     std::exit(0);
379 |   }
380 |   else if (o.action() == "callback" && o.callback()) {
381 |     string err = o.check_type(opt, value);
382 |     if (err != "")
383 |       error(err);
384 |     (*o.callback())(o, opt, value, *this);
385 |   }
386 | }
387 | 
388 | string OptionParser::format_help() const {
389 |   stringstream ss;
390 | 
391 |   if (usage() != SUPPRESS_USAGE)
392 |     ss << get_usage() << endl;
393 | 
394 |   if (description() != "")
395 |     ss << str_format(description(), 0, cols()) << endl;
396 | 
397 |   ss << _("Options") << ":" << endl;
398 |   ss << format_option_help();
399 | 
400 |   for (list<OptionGroup const*>::const_iterator it = _groups.begin(); it != _groups.end(); ++it) {
401 |     const OptionGroup& group = **it;
402 |     ss << endl << "  " << group.title() << ":" << endl;
403 |     if (group.description() != "") {
404 |       unsigned int malus = 4; // Python seems to not use full length
405 |       ss << str_format(group.description(), 4, cols() - malus) << endl;
406 |     }
407 |     ss << group.format_option_help(4);
408 |   }
409 | 
410 |   if (epilog() != "")
411 |     ss << endl << str_format(epilog(), 0, cols());
412 | 
413 |   return ss.str();
414 | }
415 | void OptionParser::print_help() const {
416 |   cout << format_help();
417 | }
418 | 
419 | void OptionParser::set_usage(const string& u) {
420 |   string lower = u;
421 |   transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
422 |   if (lower.compare(0, 7, "usage: ") == 0)
423 |     _usage = u.substr(7);
424 |   else
425 |     _usage = u;
426 | }
427 | string OptionParser::format_usage(const string& u) const {
428 |   stringstream ss;
429 |   ss << _("Usage") << ": " << u << endl;
430 |   return ss.str();
431 | }
432 | string OptionParser::get_usage() const {
433 |   if (usage() == SUPPRESS_USAGE)
434 |     return string("");
435 |   return format_usage(str_replace(usage(), "%prog", prog()));
436 | }
437 | void OptionParser::print_usage(ostream& out) const {
438 |   string u = get_usage();
439 |   if (u != "")
440 |     out << u << endl;
441 | }
442 | void OptionParser::print_usage() const {
443 |   print_usage(cout);
444 | }
445 | 
446 | string OptionParser::get_version() const {
447 |   return str_replace(_version, "%prog", prog());
448 | }
449 | void OptionParser::print_version(ostream& out) const {
450 |   out << get_version() << endl;
451 | }
452 | void OptionParser::print_version() const {
453 |   print_version(cout);
454 | }
455 | 
456 | void OptionParser::exit() const {
457 |   std::exit(2);
458 | }
459 | void OptionParser::error(const string& msg) const {
460 |   print_usage(cerr);
461 |   cerr << prog() << ": " << _("error") << ": " << msg << endl;
462 |   exit();
463 | }
464 | ////////// } class OptionParser //////////
465 | 
466 | ////////// class Values { //////////
467 | const string& Values::operator[] (const string& d) const {
468 |   strMap::const_iterator it = _map.find(d);
469 |   static const string empty = "";
470 |   return (it != _map.end()) ? it->second : empty;
471 | }
472 | void Values::is_set_by_user(const string& d, bool yes) {
473 |   if (yes)
474 |     _userSet.insert(d);
475 |   else
476 |     _userSet.erase(d);
477 | }
478 | ////////// } class Values //////////
479 | 
480 | ////////// class Option { //////////
481 | string Option::check_type(const string& opt, const string& val) const {
482 |   istringstream ss(val);
483 |   stringstream err;
484 | 
485 |   if (type() == "int" || type() == "long") {
486 |     long t;
487 |     if (not (ss >> t))
488 |       err << _("option") << " " << opt << ": " << _("invalid integer value") << ": '" << val << "'";
489 |   }
490 |   else if (type() == "float" || type() == "double") {
491 |     double t;
492 |     if (not (ss >> t))
493 |       err << _("option") << " " << opt << ": " << _("invalid floating-point value") << ": '" << val << "'";
494 |   }
495 |   else if (type() == "choice") {
496 |     if (find(choices().begin(), choices().end(), val) == choices().end()) {
497 |       list<string> tmp = choices();
498 |       transform(tmp.begin(), tmp.end(), tmp.begin(), str_wrap("'"));
499 |       err << _("option") << " " << opt << ": " << _("invalid choice") << ": '" << val << "'"
500 |         << " (" << _("choose from") << " " << str_join(", ", tmp.begin(), tmp.end()) << ")";
501 |     }
502 |   }
503 |   else if (type() == "complex") {
504 |     complex<double> t;
505 |     if (not (ss >> t))
506 |       err << _("option") << " " << opt << ": " << _("invalid complex value") << ": '" << val << "'";
507 |   }
508 | 
509 |   return err.str();
510 | }
511 | 
512 | string Option::format_option_help(unsigned int indent /* = 2 */) const {
513 | 
514 |   string mvar_short, mvar_long;
515 |   if (nargs() == 1) {
516 |     string mvar = metavar();
517 |     if (mvar == "") {
518 |       mvar = dest();
519 |       transform(mvar.begin(), mvar.end(), mvar.begin(), ::toupper);
520 |      }
521 |     mvar_short = " " + mvar;
522 |     mvar_long = "=" + mvar;
523 |   }
524 | 
525 |   stringstream ss;
526 |   ss << string(indent, ' ');
527 | 
528 |   if (not _short_opts.empty()) {
529 |     ss << str_join_trans(", ", _short_opts.begin(), _short_opts.end(), str_wrap("-", mvar_short));
530 |     if (not _long_opts.empty())
531 |       ss << ", ";
532 |   }
533 |   if (not _long_opts.empty())
534 |     ss << str_join_trans(", ", _long_opts.begin(), _long_opts.end(), str_wrap("--", mvar_long));
535 | 
536 |   return ss.str();
537 | }
538 | 
539 | string Option::format_help(unsigned int indent /* = 2 */) const {
540 |   stringstream ss;
541 |   string h = format_option_help(indent);
542 |   unsigned int width = cols();
543 |   unsigned int opt_width = min(width*3/10, 36u);
544 |   bool indent_first = false;
545 |   ss << h;
546 |   // if the option list is too long, start a new paragraph
547 |   if (h.length() >= (opt_width-1)) {
548 |     ss << endl;
549 |     indent_first = true;
550 |   } else {
551 |     ss << string(opt_width - h.length(), ' ');
552 |     if (help() == "")
553 |       ss << endl;
554 |   }
555 |   if (help() != "") {
556 |     string help_str = (get_default() != "") ? str_replace(help(), "%default", get_default()) : help();
557 |     if (type() == "choice") {
558 |         help_str = str_replace(help_str, "%choices", str_join("|", _choices.begin(), _choices.end()));
559 |     }
560 |     ss << str_format(help_str, opt_width, width, false, indent_first);
561 |   }
562 |   return ss.str();
563 | }
564 | 
565 | Option& Option::action(const string& a) {
566 |   _action = a;
567 |   if (a == "store_const" || a == "store_true" || a == "store_false" ||
568 |       a == "append_const" || a == "count" || a == "help" || a == "version") {
569 |     nargs(0);
570 |   } else if (a == "callback") {
571 |     nargs(0);
572 |     type("");
573 |   }
574 |   return *this;
575 | }
576 | 
577 | 
578 | Option& Option::type(const std::string& t) {
579 |   _type = t;
580 |   nargs((t == "") ? 0 : 1);
581 |   return *this;
582 | }
583 | 
584 | const std::string& Option::get_default() const {
585 |   strMap::const_iterator it = _parser._defaults.find(dest());
586 |   if (it != _parser._defaults.end())
587 |     return it->second;
588 |   else
589 |     return _default;
590 | }
591 | ////////// } class Option //////////
592 | 
593 | }
594 | 


--------------------------------------------------------------------------------
/OptionParser.h:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Copyright (C) 2010 Johannes Weißl <jargon@molb.org>
  3 |  * License: MIT License
  4 |  * URL: https://github.com/weisslj/cpp-optparse
  5 |  */
  6 | 
  7 | #ifndef OPTIONPARSER_H_
  8 | #define OPTIONPARSER_H_
  9 | 
 10 | #include <string>
 11 | #include <vector>
 12 | #include <list>
 13 | #include <map>
 14 | #include <set>
 15 | #include <iostream>
 16 | #include <sstream>
 17 | 
 18 | namespace optparse {
 19 | 
 20 | class OptionParser;
 21 | class OptionGroup;
 22 | class Option;
 23 | class Values;
 24 | class Value;
 25 | class Callback;
 26 | 
 27 | typedef std::map<std::string,std::string> strMap;
 28 | typedef std::map<std::string,std::list<std::string> > lstMap;
 29 | typedef std::map<std::string,Option const*> optMap;
 30 | 
 31 | const char* const SUPPRESS_HELP = "SUPPRESS" "HELP";
 32 | const char* const SUPPRESS_USAGE = "SUPPRESS" "USAGE";
 33 | 
 34 | //! Class for automatic conversion from string -> anytype
 35 | class Value {
 36 |   public:
 37 |     Value() : str(), valid(false) {}
 38 |     Value(const std::string& v) : str(v), valid(true) {}
 39 |     operator const char*() { return str.c_str(); }
 40 |     operator bool() { bool t; return (valid && (std::istringstream(str) >> t)) ? t : false; }
 41 |     operator short() { short t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
 42 |     operator unsigned short() { unsigned short t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
 43 |     operator int() { int t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
 44 |     operator unsigned int() { unsigned int t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
 45 |     operator long() { long t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
 46 |     operator unsigned long() { unsigned long t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
 47 |     operator float() { float t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
 48 |     operator double() { double t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
 49 |     operator long double() { long double t; return (valid && (std::istringstream(str) >> t)) ? t : 0; }
 50 |  private:
 51 |     const std::string str;
 52 |     bool valid;
 53 | };
 54 | 
 55 | class Values {
 56 |   public:
 57 |     Values() : _map() {}
 58 |     const std::string& operator[] (const std::string& d) const;
 59 |     std::string& operator[] (const std::string& d) { return _map[d]; }
 60 |     bool is_set(const std::string& d) const { return _map.find(d) != _map.end(); }
 61 |     bool is_set_by_user(const std::string& d) const { return _userSet.find(d) != _userSet.end(); }
 62 |     void is_set_by_user(const std::string& d, bool yes);
 63 |     Value get(const std::string& d) const { return (is_set(d)) ? Value((*this)[d]) : Value(); }
 64 | 
 65 |     typedef std::list<std::string>::iterator iterator;
 66 |     typedef std::list<std::string>::const_iterator const_iterator;
 67 |     std::list<std::string>& all(const std::string& d) { return _appendMap[d]; }
 68 |     const std::list<std::string>& all(const std::string& d) const { return _appendMap.find(d)->second; }
 69 | 
 70 |   private:
 71 |     strMap _map;
 72 |     lstMap _appendMap;
 73 |     std::set<std::string> _userSet;
 74 | };
 75 | 
 76 | class OptionContainer {
 77 |   public:
 78 |     OptionContainer(const std::string& d = "") : _description(d) {}
 79 |     virtual ~OptionContainer() {}
 80 | 
 81 |     virtual OptionContainer& description(const std::string& d) { _description = d; return *this; }
 82 |     virtual const std::string& description() const { return _description; }
 83 | 
 84 |     Option& add_option(const std::string& opt);
 85 |     Option& add_option(const std::string& opt1, const std::string& opt2);
 86 |     Option& add_option(const std::string& opt1, const std::string& opt2, const std::string& opt3);
 87 |     Option& add_option(const std::vector<std::string>& opt);
 88 | 
 89 |     std::string format_option_help(unsigned int indent = 2) const;
 90 | 
 91 |   protected:
 92 |     std::string _description;
 93 | 
 94 |     std::list<Option> _opts;
 95 |     optMap _optmap_s;
 96 |     optMap _optmap_l;
 97 | 
 98 |   private:
 99 |     virtual const OptionParser& get_parser() = 0;
100 | };
101 | 
102 | class OptionParser : public OptionContainer {
103 |   public:
104 |     OptionParser();
105 |     virtual ~OptionParser() {}
106 | 
107 |     OptionParser& usage(const std::string& u) { set_usage(u); return *this; }
108 |     OptionParser& version(const std::string& v) { _version = v; return *this; }
109 |     OptionParser& description(const std::string& d) { _description = d; return *this; }
110 |     OptionParser& add_help_option(bool h) { _add_help_option = h; return *this; }
111 |     OptionParser& add_version_option(bool v) { _add_version_option = v; return *this; }
112 |     OptionParser& prog(const std::string& p) { _prog = p; return *this; }
113 |     OptionParser& epilog(const std::string& e) { _epilog = e; return *this; }
114 |     OptionParser& set_defaults(const std::string& dest, const std::string& val) {
115 |       _defaults[dest] = val; return *this;
116 |     }
117 |     template<typename T>
118 |     OptionParser& set_defaults(const std::string& dest, T t) { std::ostringstream ss; ss << t; _defaults[dest] = ss.str(); return *this; }
119 |     OptionParser& enable_interspersed_args() { _interspersed_args = true; return *this; }
120 |     OptionParser& disable_interspersed_args() { _interspersed_args = false; return *this; }
121 |     OptionParser& add_option_group(const OptionGroup& group);
122 | 
123 |     const std::string& usage() const { return _usage; }
124 |     const std::string& version() const { return _version; }
125 |     const std::string& description() const { return _description; }
126 |     bool add_help_option() const { return _add_help_option; }
127 |     bool add_version_option() const { return _add_version_option; }
128 |     const std::string& prog() const { return _prog; }
129 |     const std::string& epilog() const { return _epilog; }
130 |     bool interspersed_args() const { return _interspersed_args; }
131 | 
132 |     Values& parse_args(int argc, char const* const* argv);
133 |     Values& parse_args(const std::vector<std::string>& args);
134 |     template<typename InputIterator>
135 |     Values& parse_args(InputIterator begin, InputIterator end) {
136 |       return parse_args(std::vector<std::string>(begin, end));
137 |     }
138 | 
139 |     const std::list<std::string>& args() const { return _leftover; }
140 |     std::vector<std::string> args() {
141 |       return std::vector<std::string>(_leftover.begin(), _leftover.end());
142 |     }
143 | 
144 |     std::string format_help() const;
145 |     void print_help() const;
146 | 
147 |     void set_usage(const std::string& u);
148 |     std::string get_usage() const;
149 |     void print_usage(std::ostream& out) const;
150 |     void print_usage() const;
151 | 
152 |     std::string get_version() const;
153 |     void print_version(std::ostream& out) const;
154 |     void print_version() const;
155 | 
156 |     void error(const std::string& msg) const;
157 |     void exit() const;
158 | 
159 |   private:
160 |     const OptionParser& get_parser() { return *this; }
161 |     const Option& lookup_short_opt(const std::string& opt) const;
162 |     const Option& lookup_long_opt(const std::string& opt) const;
163 | 
164 |     void handle_short_opt(const std::string& opt, const std::string& arg);
165 |     void handle_long_opt(const std::string& optstr);
166 | 
167 |     void process_opt(const Option& option, const std::string& opt, const std::string& value);
168 | 
169 |     std::string format_usage(const std::string& u) const;
170 | 
171 |     std::string _usage;
172 |     std::string _version;
173 |     bool _add_help_option;
174 |     bool _add_version_option;
175 |     std::string _prog;
176 |     std::string _epilog;
177 |     bool _interspersed_args;
178 | 
179 |     Values _values;
180 | 
181 |     strMap _defaults;
182 |     std::list<OptionGroup const*> _groups;
183 | 
184 |     std::list<std::string> _remaining;
185 |     std::list<std::string> _leftover;
186 | 
187 |     friend class Option;
188 | };
189 | 
190 | class OptionGroup : public OptionContainer {
191 |   public:
192 |     OptionGroup(const OptionParser& p, const std::string& t, const std::string& d = "") :
193 |       OptionContainer(d), _parser(p), _title(t) {}
194 |     virtual ~OptionGroup() {}
195 | 
196 |     OptionGroup& title(const std::string& t) { _title = t; return *this; }
197 |     const std::string& title() const { return _title; }
198 | 
199 |   private:
200 |     const OptionParser& get_parser() { return _parser; }
201 | 
202 |     const OptionParser& _parser;
203 |     std::string _title;
204 | 
205 |   friend class OptionParser;
206 | };
207 | 
208 | class Option {
209 |   public:
210 |     Option(const OptionParser& p) :
211 |       _parser(p), _action("store"), _type("string"), _nargs(1), _callback(0) {}
212 |     virtual ~Option() {}
213 | 
214 |     Option& action(const std::string& a);
215 |     Option& type(const std::string& t);
216 |     Option& dest(const std::string& d) { _dest = d; return *this; }
217 |     Option& set_default(const std::string& d) { _default = d; return *this; }
218 |     template<typename T>
219 |     Option& set_default(T t) { std::ostringstream ss; ss << t; _default = ss.str(); return *this; }
220 |     Option& nargs(size_t n) { _nargs = n; return *this; }
221 |     Option& set_const(const std::string& c) { _const = c; return *this; }
222 |     template<typename InputIterator>
223 |     Option& choices(InputIterator begin, InputIterator end) {
224 |       _choices.assign(begin, end); type("choice"); return *this;
225 |     }
226 | #if __cplusplus >= 201103L
227 |     Option& choices(std::initializer_list<std::string> ilist) {
228 |       _choices.assign(ilist); type("choice"); return *this;
229 |     }
230 | #endif
231 |     Option& help(const std::string& h) { _help = h; return *this; }
232 |     Option& metavar(const std::string& m) { _metavar = m; return *this; }
233 |     Option& callback(Callback& c) { _callback = &c; return *this; }
234 | 
235 |     const std::string& action() const { return _action; }
236 |     const std::string& type() const { return _type; }
237 |     const std::string& dest() const { return _dest; }
238 |     const std::string& get_default() const;
239 |     size_t nargs() const { return _nargs; }
240 |     const std::string& get_const() const { return _const; }
241 |     const std::list<std::string>& choices() const { return _choices; }
242 |     const std::string& help() const { return _help; }
243 |     const std::string& metavar() const { return _metavar; }
244 |     Callback* callback() const { return _callback; }
245 | 
246 |   private:
247 |     std::string check_type(const std::string& opt, const std::string& val) const;
248 |     std::string format_option_help(unsigned int indent = 2) const;
249 |     std::string format_help(unsigned int indent = 2) const;
250 | 
251 |     const OptionParser& _parser;
252 | 
253 |     std::set<std::string> _short_opts;
254 |     std::set<std::string> _long_opts;
255 | 
256 |     std::string _action;
257 |     std::string _type;
258 |     std::string _dest;
259 |     std::string _default;
260 |     size_t _nargs;
261 |     std::string _const;
262 |     std::list<std::string> _choices;
263 |     std::string _help;
264 |     std::string _metavar;
265 |     Callback* _callback;
266 | 
267 |     friend class OptionContainer;
268 |     friend class OptionParser;
269 | };
270 | 
271 | class Callback {
272 | public:
273 |   virtual void operator() (const Option& option, const std::string& opt, const std::string& val, const OptionParser& parser) = 0;
274 |   virtual ~Callback() {}
275 | };
276 | 
277 | }
278 | 
279 | #endif
280 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # cpp-optparse
 2 | 
 3 | This is yet another option parser for C++. It is modelled after the excellent
 4 | Python optparse API. Although incomplete, anyone familiar to
 5 | [optparse](http://docs.python.org/library/optparse.html) should feel at home.
 6 | 
 7 | - Copyright (c) 2010 Johannes Weißl
 8 | - License: MIT License
 9 | 
10 | ## Design decisions
11 | 
12 | - Elegant and easy usage more important than speed / flexibility
13 | - Small size more important than feature completeness, e.g.:
14 |   * No unicode
15 |   * No checking for user programming errors
16 |   * No conflict handlers
17 |   * No adding of new actions
18 | 
19 | ## FAQ
20 | 
21 | - Why not use getopt/getopt_long?
22 |   * Not C++ / not completely POSIX
23 |   * Too cumbersome to use, would need lot of additional code
24 | - Why not use Boost.Program_options?
25 |   * Boost not installed on all target platforms (esp. cluster, HPC, ...)
26 |   * Too big to include just for option handling for many projects:
27 |     322 *.h (44750 lines) + 7 *.cpp (2078 lines)
28 | - Why not use tclap/Opag/Options/CmdLine/Anyoption/Argument_helper/...?
29 |   * Similarity to Python desired for faster learning curve
30 | 
31 | ## Future work
32 | 
33 | - Support nargs > 1?
34 | 
35 | ## Example
36 | 
37 | ```cpp
38 | using optparse::OptionParser;
39 | 
40 | OptionParser parser = OptionParser() .description("just an example");
41 | 
42 | parser.add_option("-f", "--file") .dest("filename")
43 |                   .help("write report to FILE") .metavar("FILE");
44 | parser.add_option("-q", "--quiet")
45 |                   .action("store_false") .dest("verbose") .set_default("1")
46 |                   .help("don't print status messages to stdout");
47 | 
48 | optparse::Values options = parser.parse_args(argc, argv);
49 | vector<string> args = parser.args();
50 | 
51 | if (options.get("verbose"))
52 |     cout << options["filename"] << endl;
53 | ```
54 | 


--------------------------------------------------------------------------------
/t/testprog:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | # -*- mode: python; coding: utf-8; indent-tabs-mode: nil -*-
  3 | # vim: set filetype=python fileencoding=utf-8 expandtab sw=4 sts=4:
  4 | 
  5 | import sys
  6 | import os
  7 | from optparse import OptionParser, OptionGroup, SUPPRESS_HELP, SUPPRESS_USAGE
  8 | 
  9 | class MyCallback(object):
 10 |     def __init__(self):
 11 |         self.counter = 0
 12 |     def __call__(self, option, opt, val, parser):
 13 |         self.counter += 1
 14 |         print "--- MyCallback --- " + str(self.counter) + ". time called"
 15 |         print "--- MyCallback --- option.action(): " + option.action
 16 |         print "--- MyCallback --- option.type(): " + (option.type if option.type else "")
 17 |         print "--- MyCallback --- opt: " + opt
 18 |         print "--- MyCallback --- val: " + (val if val else "")
 19 |         print "--- MyCallback --- parser.usage(): " + parser.usage
 20 |         print
 21 | 
 22 | def main():
 23 |     usage = \
 24 |         "usage: %prog [OPTION]... DIR [FILE]..." \
 25 |         if "DISABLE_USAGE" not in os.environ else \
 26 |         SUPPRESS_USAGE
 27 |     version = (
 28 |         "%prog 1.0\nCopyright (C) 2010 Johannes Weißl\n"
 29 |         "License GPLv3+: GNU GPL version 3 or later "
 30 |         "<http://gnu.org/licenses/gpl.html>.\n"
 31 |         "This is free software: you are free to change and redistribute it.\n"
 32 |         "There is NO WARRANTY, to the extent permitted by law."
 33 |     )
 34 |     desc = (
 35 |         "Lorem ipsum dolor sit amet, consectetur adipisicing"
 36 |         " elit, sed do eiusmod tempor incididunt ut labore et dolore magna"
 37 |         " aliqua.\nUt enim ad minim veniam, quis nostrud exercitation ullamco"
 38 |         " laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor"
 39 |         " in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla"
 40 |         " pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa"
 41 |         " qui officia deserunt mollit anim id est laborum."
 42 |     )
 43 |     epilog = (
 44 |         "Sed ut perspiciatis unde omnis iste natus error sit"
 45 |         " voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque"
 46 |         " ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae"
 47 |         " dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit"
 48 |         " aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos"
 49 |         " qui ratione voluptatem sequi nesciunt.\nNeque porro quisquam est, qui"
 50 |         " dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia"
 51 |         " non numquam eius modi tempora incidunt ut labore et dolore magnam"
 52 |         " aliquam quaerat voluptatem."
 53 |     )
 54 | 
 55 |     parser = OptionParser(
 56 |         usage=usage,
 57 |         version=version,
 58 |         description=desc,
 59 |         epilog=epilog
 60 |     )
 61 |     if "DISABLE_INTERSPERSED_ARGS" in os.environ:
 62 |         parser.disable_interspersed_args()
 63 | 
 64 |     parser.set_defaults(verbosity="50")
 65 |     parser.set_defaults(no_clear=False)
 66 | 
 67 |     parser.add_option("--clear", action="store_false", dest="no_clear", help="clear (default)")
 68 |     parser.add_option("--no-clear", action="store_true", help="not clear")
 69 |     parser.add_option("--string",
 70 |         help="This is a really long text... very long indeed! It must be wrapped on normal terminals.")
 71 |     parser.add_option("-x", "--clause", "--sentence", metavar="SENTENCE", default="I'm a sentence",
 72 |         help="This is a really long text... very long indeed! It must be wrapped on normal terminals. "
 73 |              "Also it should appear not on the same line as the option.")
 74 |     parser.add_option("-k", action="count", help="how many times?")
 75 |     parser.add_option("-v", "--verbose", action="store_const", const="100", dest="verbosity", help="be verbose!")
 76 |     parser.add_option("-s", "--silent", action="store_const", const="0", dest="verbosity", help="be silent!")
 77 |     parser.add_option("-n", "--number", type="int", default=1, metavar="NUM", help="number of files (default: %default)")
 78 |     parser.add_option("-H", action="help", help="alternative help")
 79 |     parser.add_option("-V", action="version", help="alternative version")
 80 |     parser.add_option("-i", "--int", action="store", type="int", default=3, help="default: %default")
 81 |     parser.add_option("-f", "--float", action="store", type="float", default=5.3, help="default: %default")
 82 |     parser.add_option("-c", "--complex", action="store", type="complex")
 83 |     choices = ["foo", "bar", "baz"]
 84 |     parser.add_option("-C", "--choices", choices=choices, help="choose from [{0}]".format("|".join(choices)))
 85 |     choices_list = ["item1", "item2", "item3"]
 86 |     parser.add_option("--choices-list", choices=choices_list, help="choose from [{0}]".format("|".join(choices_list)))
 87 |     parser.add_option("-m", "--more", action="append")
 88 |     parser.add_option("--more-milk", action="append_const", const="milk")
 89 |     parser.add_option("--hidden", help=SUPPRESS_HELP)
 90 | 
 91 |     # test for 325cb47
 92 |     parser.add_option("--option1", action="store", type="int", default=1)
 93 |     parser.add_option("--option2", action="store", type="int", default="1")
 94 |     parser.set_defaults(option1="640")
 95 |     parser.set_defaults(option2=640) # now works
 96 | 
 97 |     mc = MyCallback()
 98 |     parser.add_option("-K", "--callback", action="callback", callback=mc, help="callback test")
 99 |     parser.add_option("--string-callback", action="callback", callback=mc, type="string", help="callback test")
100 | 
101 |     group1 = OptionGroup(parser, "Dangerous Options",
102 |         "Caution: use these options at your own risk. "
103 |         "It is believed that some of them\nbite.")
104 |     group1.add_option("-g", action="store_true", help="Group option.", default=False)
105 |     parser.add_option_group(group1)
106 | 
107 |     group2 = OptionGroup(parser, "Size Options", "Image Size Options.")
108 |     group2.add_option("-w", "--width", action="store", type="int", default=640, help="default: %default")
109 |     group2.add_option("--height", action="store", type="int", help="default: %default")
110 |     parser.set_defaults(height=480)
111 |     parser.add_option_group(group2)
112 | 
113 |     options, args = parser.parse_args()
114 | 
115 |     print "clear:", ("false" if options.no_clear else "true")
116 |     print "string:", options.string if options.string else ""
117 |     print "clause:", options.clause
118 |     print "k:", options.k if options.k else ""
119 |     print "verbosity:", options.verbosity
120 |     print "number:", options.number
121 |     print "int:", options.int
122 |     print "float: %g" % (options.float,)
123 |     c = complex(0)
124 |     if options.complex is not None:
125 |         c = options.complex
126 |     print "complex: (%g,%g)" % (c.real, c.imag)
127 |     print "choices:", options.choices if options.choices else ""
128 |     print "choices-list:", options.choices_list if options.choices_list else ""
129 |     print "more:",
130 |     print ", ".join(options.more if options.more else [])
131 | 
132 |     print "more_milk:"
133 |     for opt in (options.more_milk if options.more_milk else []):
134 |         print "-", opt
135 | 
136 |     print "hidden:", options.hidden if options.hidden else ""
137 |     print "group:", ("true" if options.g else "false")
138 | 
139 |     print "option1:", options.option1
140 |     print "option2:", options.option2
141 | 
142 |     print "width:", options.width
143 |     print "height:", options.height
144 | 
145 |     print
146 |     print "leftover arguments: "
147 |     for arg in args:
148 |         print "arg: " + arg
149 | 
150 |     return 0
151 | 
152 | if __name__ == "__main__":
153 |     main()
154 | 


--------------------------------------------------------------------------------
/test.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # -*- mode: sh; coding: utf-8; indent-tabs-mode: nil -*-
 3 | # vim: set filetype=sh fileencoding=utf-8 expandtab sw=4 sts=4:
 4 | 
 5 | export COLUMNS=80
 6 | 
 7 | c () {
 8 |     echo "$(printf "%q " ./testprog "$@")"
 9 |     local t_stdout_cpp=$(mktemp --tmpdir cpp-stdout-optparse.XXXXXXXXXX)
10 |     local t_stderr_cpp=$(mktemp --tmpdir cpp-stderr-optparse.XXXXXXXXXX)
11 |     local t_stdout_pyt=$(mktemp --tmpdir pyt-stdout-optparse.XXXXXXXXXX)
12 |     local t_stderr_pyt=$(mktemp --tmpdir pyt-stderr-optparse.XXXXXXXXXX)
13 |     ./testprog "$@" >"$t_stdout_cpp" 2>"$t_stderr_cpp"
14 |     status_cpp=$?
15 |     ./t/testprog "$@" >"$t_stdout_pyt" 2>"$t_stderr_pyt"
16 |     status_pyt=$?
17 |     if ! cmp -s "$t_stderr_cpp" "$t_stderr_pyt" ; then
18 |         diff -au "$t_stderr_cpp" "$t_stderr_pyt"
19 |         exit 1
20 |     fi
21 |     rm -f "$t_stderr_cpp" "$t_stderr_pyt"
22 |     if ! cmp -s "$t_stdout_cpp" "$t_stdout_pyt" ; then
23 |         diff -au "$t_stdout_cpp" "$t_stdout_pyt"
24 |         exit 1
25 |     fi
26 |     rm -f "$t_stdout_cpp" "$t_stdout_pyt"
27 |     if [[ $status_cpp -ne $status_pyt ]] ; then
28 |         echo >&2 "status $status_pyt expected, got $status_cpp"
29 |         exit 1
30 |     fi
31 | }
32 | 
33 | c
34 | c --str # ambiguous option
35 | c -Z # unknown argument
36 | c --argument-does-not-exist
37 | c --version
38 | c --help
39 | c "foo bar" baz ""
40 | c --clear
41 | c --no-clear
42 | c --clear --no-clear
43 | c --clear --no-clear --clear
44 | c --string "foo bar"
45 | c --string # requires argument
46 | c -x foo
47 | c --clause foo
48 | c --sentence foo
49 | c -k -k -k -k -k
50 | c -v
51 | c --verbose
52 | c -s
53 | c --silent
54 | c -v -s
55 | c -n-10
56 | c -n 300
57 | c --number=0
58 | c -H
59 | c -V
60 | c -i-10
61 | c -i 300
62 | c --int=0
63 | # c -i 2.3 # TODO: ignores suffix
64 | c -i no-number
65 | c -f-2.3
66 | c -f 300
67 | c --float=0
68 | c -f no-number
69 | c -c-2.3
70 | c -c 300
71 | c --complex=0
72 | c -c no-number
73 | c -C foo
74 | c --choices baz
75 | c -C wrong-choice
76 | c --choices-list item2
77 | c --choices-list wrong-item
78 | c -m a -m b
79 | c -m a --more b -m c
80 | c --more-milk --more-milk
81 | c --hidden foo
82 | c -K -K -K
83 | c --string-callback x
84 | c --no-clear foo bar -k -k z -v -n3 "x y" -i 8 -f 3.2 -c 2
85 | DISABLE_INTERSPERSED_ARGS=1 c -k a -k b
86 | DISABLE_USAGE=1 c --argument-does-not-exist
87 | DISABLE_USAGE=1 c --help
88 | 


--------------------------------------------------------------------------------
/testprog.cpp:
--------------------------------------------------------------------------------
  1 | #include "OptionParser.h"
  2 | 
  3 | #include <iostream>
  4 | #include <cstdlib>
  5 | #include <sstream>
  6 | #include <string>
  7 | #include <complex>
  8 | #include <algorithm>
  9 | 
 10 | using namespace std;
 11 | 
 12 | using namespace optparse;
 13 | 
 14 | class Output {
 15 | public:
 16 |   Output(stringstream& ss, const string& d) : stream(ss), delim(d), first(true) {}
 17 |   void operator() (const string& s) {
 18 |     if (first)
 19 |       first = false;
 20 |     else
 21 |       stream << delim;
 22 |     stream << s;
 23 |   }
 24 |   stringstream& stream;
 25 |   const string& delim;
 26 |   bool first;
 27 | };
 28 | 
 29 | class MyCallback : public optparse::Callback {
 30 | public:
 31 |   MyCallback() : counter(0) {}
 32 |   void operator() (const Option& option, const string& opt, const string& val, const OptionParser& parser) {
 33 |     counter++;
 34 |     cout << "--- MyCallback --- " << counter << ". time called" << endl;
 35 |     cout << "--- MyCallback --- option.action(): " << option.action() << endl;
 36 |     cout << "--- MyCallback --- option.type(): " << option.type() << endl;
 37 |     cout << "--- MyCallback --- opt: " << opt << endl;
 38 |     cout << "--- MyCallback --- val: " << val << endl;
 39 |     cout << "--- MyCallback --- parser.usage(): " << parser.usage() << endl;
 40 |     cout << endl;
 41 |   }
 42 |   int counter;
 43 | };
 44 | 
 45 | int main(int argc, char *argv[])
 46 | {
 47 |   const string usage =
 48 |     (!getenv("DISABLE_USAGE")) ?
 49 |     "usage: %prog [OPTION]... DIR [FILE]..." : SUPPRESS_USAGE;
 50 |   const string version = "%prog 1.0\nCopyright (C) 2010 Johannes Weißl\n"
 51 |     "License GPLv3+: GNU GPL version 3 or later "
 52 |     "<http://gnu.org/licenses/gpl.html>.\n"
 53 |     "This is free software: you are free to change and redistribute it.\n"
 54 |     "There is NO WARRANTY, to the extent permitted by law.";
 55 |   const string desc = "Lorem ipsum dolor sit amet, consectetur adipisicing"
 56 |     " elit, sed do eiusmod tempor incididunt ut labore et dolore magna"
 57 |     " aliqua.\nUt enim ad minim veniam, quis nostrud exercitation ullamco"
 58 |     " laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor"
 59 |     " in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla"
 60 |     " pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa"
 61 |     " qui officia deserunt mollit anim id est laborum.";
 62 |   const string epilog = "Sed ut perspiciatis unde omnis iste natus error sit"
 63 |     " voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque"
 64 |     " ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae"
 65 |     " dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit"
 66 |     " aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos"
 67 |     " qui ratione voluptatem sequi nesciunt.\nNeque porro quisquam est, qui"
 68 |     " dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia"
 69 |     " non numquam eius modi tempora incidunt ut labore et dolore magnam"
 70 |     " aliquam quaerat voluptatem.";
 71 | 
 72 |   OptionParser parser = OptionParser()
 73 |     .usage(usage)
 74 |     .version(version)
 75 |     .description(desc)
 76 |     .epilog(epilog)
 77 |   ;
 78 |   if (getenv("DISABLE_INTERSPERSED_ARGS"))
 79 |     parser.disable_interspersed_args();
 80 | 
 81 |   parser.set_defaults("verbosity", "50");
 82 |   parser.set_defaults("no_clear", "0");
 83 | 
 84 |   // test all actions
 85 |   parser.add_option("--clear") .action("store_false") .dest("no_clear") .help("clear (default)");
 86 |   parser.add_option("--no-clear") .action("store_true") .help("not clear");
 87 |   parser.add_option("--string")
 88 |     .help("This is a really long text... very long indeed! It must be wrapped on normal terminals.");
 89 |   parser.add_option("-x", "--clause", "--sentence") .metavar("SENTENCE") .set_default("I'm a sentence")
 90 |     .help("This is a really long text... very long indeed! It must be wrapped on normal terminals. "
 91 |           "Also it should appear not on the same line as the option.");
 92 |   parser.add_option("-k") .action("count") .help("how many times?");
 93 |   parser.add_option("-v", "--verbose") .action("store_const") .set_const("100") .dest("verbosity") .help("be verbose!");
 94 |   parser.add_option("-s", "--silent") .action("store_const") .set_const("0") .dest("verbosity") .help("be silent!");
 95 |   parser.add_option("-n", "--number") .type("int") .set_default("1") .metavar("NUM") .help("number of files (default: %default)");
 96 |   parser.add_option("-H") .action("help") .help("alternative help");
 97 |   parser.add_option("-V") .action("version") .help("alternative version");
 98 |   parser.add_option("-i", "--int") .action("store") .type("int") .set_default(3) .help("default: %default");
 99 |   parser.add_option("-f", "--float") .action("store") .type("float") .set_default(5.3) .help("default: %default");
100 |   parser.add_option("-c", "--complex") .action("store") .type("complex");
101 |   char const* const choices[] = { "foo", "bar", "baz" };
102 |   parser.add_option("-C", "--choices") .choices(&choices[0], &choices[3]). help("choose from [%choices]");
103 | #if __cplusplus >= 201103L
104 |   parser.add_option("--choices-list") .choices({"item1", "item2", "item3"}). help("choose from [%choices]");
105 | #else
106 |   char const* const choices_list[] = { "item1", "item2", "item3" };
107 |   parser.add_option("--choices-list") .choices(&choices_list[0], &choices_list[3]). help("choose from [%choices]");
108 | #endif
109 |   parser.add_option("-m", "--more") .action("append");
110 |   parser.add_option("--more-milk") .action("append_const") .set_const("milk");
111 |   parser.add_option("--hidden") .help(SUPPRESS_HELP);
112 | 
113 |   // test for 325cb47
114 |   parser.add_option("--option1") .action("store") .type("int") .set_default(1);
115 |   parser.add_option("--option2") .action("store") .type("int") .set_default("1");
116 |   parser.set_defaults("option1", "640");
117 |   parser.set_defaults("option2", 640); // now works
118 | 
119 |   MyCallback mc;
120 |   parser.add_option("-K", "--callback") .action("callback") .callback(mc) .help("callback test");
121 |   parser.add_option("--string-callback") .action("callback") .callback(mc) .type("string") .help("callback test");
122 | 
123 |   OptionGroup group1 = OptionGroup(parser, "Dangerous Options",
124 |       "Caution: use these options at your own risk. "
125 |       "It is believed that some of them\nbite.");
126 |   group1.add_option("-g") .action("store_true") .help("Group option.") .set_default("0");
127 |   parser.add_option_group(group1);
128 | 
129 |   OptionGroup group2 = OptionGroup(parser, "Size Options", "Image Size Options.");
130 |   group2.add_option("-w", "--width") .action("store") .type("int") .set_default(640) .help("default: %default");
131 |   group2.add_option("--height") .action("store") .type("int") .help("default: %default");
132 |   parser.set_defaults("height", 480);
133 |   parser.add_option_group(group2);
134 | 
135 |   Values& options = parser.parse_args(argc, argv);
136 |   vector<string> args = parser.args();
137 | 
138 |   cout << "clear: " << (options.get("no_clear") ? "false" : "true") << endl;
139 |   cout << "string: " << options["string"] << endl;
140 |   cout << "clause: " << options["clause"] << endl;
141 |   cout << "k: " << options["k"] << endl;
142 |   cout << "verbosity: " << options["verbosity"] << endl;
143 |   cout << "number: " << (int) options.get("number") << endl;
144 |   cout << "int: " << (int) options.get("int") << endl;
145 |   cout << "float: " << (float) options.get("float") << endl;
146 |   complex<double> c = 0;
147 |   if (options.is_set("complex")) {
148 |     stringstream ss;
149 |     ss << options["complex"];
150 |     ss >> c;
151 |   }
152 |   cout << "complex: " << c << endl;
153 |   cout << "choices: " << (const char*) options.get("choices") << endl;
154 |   cout << "choices-list: " << (const char*) options.get("choices_list") << endl;
155 |   {
156 |     stringstream ss;
157 |     for_each(options.all("more").begin(), options.all("more").end(), Output(ss, ", "));
158 |     cout << "more: " << ss.str() << endl;
159 |   }
160 |   cout << "more_milk:" << endl;
161 |   for (Values::iterator it = options.all("more_milk").begin(); it != options.all("more_milk").end(); ++it)
162 |     cout << "- " << *it << endl;
163 |   cout << "hidden: " << options["hidden"] << endl;
164 |   cout << "group: " << (options.get("g") ? "true" : "false") << endl;
165 | 
166 |   cout << "option1: " << (int) options.get("option1") << std::endl;
167 |   cout << "option2: " << (int) options.get("option2") << std::endl;
168 | 
169 |   cout << "width: " << (int) options.get("width") << std::endl;
170 |   cout << "height: " << (int) options.get("height") << std::endl;
171 | 
172 |   cout << endl << "leftover arguments: " << endl;
173 |   for (vector<string>::const_iterator it = args.begin(); it != args.end(); ++it) {
174 |     cout << "arg: " << *it << endl;
175 |   }
176 | 
177 |   return 0;
178 | }
179 | 


--------------------------------------------------------------------------------