Mercurial > hg > forks > libbpg
comparison jctvc/program_options_lite.cpp @ 0:772086c29cc7
Initial import.
author | Matti Hamalainen <ccr@tnsp.org> |
---|---|
date | Wed, 16 Nov 2016 11:16:33 +0200 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:772086c29cc7 |
---|---|
1 /* The copyright in this software is being made available under the BSD | |
2 * License, included below. This software may be subject to other third party | |
3 * and contributor rights, including patent rights, and no such rights are | |
4 * granted under this license. | |
5 * | |
6 * Copyright (c) 2010-2014, ITU/ISO/IEC | |
7 * All rights reserved. | |
8 * | |
9 * Redistribution and use in source and binary forms, with or without | |
10 * modification, are permitted provided that the following conditions are met: | |
11 * | |
12 * * Redistributions of source code must retain the above copyright notice, | |
13 * this list of conditions and the following disclaimer. | |
14 * * Redistributions in binary form must reproduce the above copyright notice, | |
15 * this list of conditions and the following disclaimer in the documentation | |
16 * and/or other materials provided with the distribution. | |
17 * * Neither the name of the ITU/ISO/IEC nor the names of its contributors may | |
18 * be used to endorse or promote products derived from this software without | |
19 * specific prior written permission. | |
20 * | |
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS | |
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | |
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | |
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | |
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF | |
31 * THE POSSIBILITY OF SUCH DAMAGE. | |
32 */ | |
33 #include <stdlib.h> | |
34 #include <iostream> | |
35 #include <fstream> | |
36 #include <sstream> | |
37 #include <string> | |
38 #include <list> | |
39 #include <map> | |
40 #include <algorithm> | |
41 #include "program_options_lite.h" | |
42 | |
43 using namespace std; | |
44 | |
45 //! \ingroup TAppCommon | |
46 //! \{ | |
47 | |
48 namespace df | |
49 { | |
50 namespace program_options_lite | |
51 { | |
52 | |
53 Options::~Options() | |
54 { | |
55 for(Options::NamesPtrList::iterator it = opt_list.begin(); it != opt_list.end(); it++) | |
56 { | |
57 delete *it; | |
58 } | |
59 } | |
60 | |
61 void Options::addOption(OptionBase *opt) | |
62 { | |
63 Names* names = new Names(); | |
64 names->opt = opt; | |
65 string& opt_string = opt->opt_string; | |
66 | |
67 size_t opt_start = 0; | |
68 for (size_t opt_end = 0; opt_end != string::npos;) | |
69 { | |
70 opt_end = opt_string.find_first_of(',', opt_start); | |
71 bool force_short = 0; | |
72 if (opt_string[opt_start] == '-') | |
73 { | |
74 opt_start++; | |
75 force_short = 1; | |
76 } | |
77 string opt_name = opt_string.substr(opt_start, opt_end - opt_start); | |
78 if (force_short || opt_name.size() == 1) | |
79 { | |
80 names->opt_short.push_back(opt_name); | |
81 opt_short_map[opt_name].push_back(names); | |
82 } | |
83 else | |
84 { | |
85 names->opt_long.push_back(opt_name); | |
86 opt_long_map[opt_name].push_back(names); | |
87 } | |
88 opt_start += opt_end + 1; | |
89 } | |
90 opt_list.push_back(names); | |
91 } | |
92 | |
93 /* Helper method to initiate adding options to Options */ | |
94 OptionSpecific Options::addOptions() | |
95 { | |
96 return OptionSpecific(*this); | |
97 } | |
98 | |
99 static void setOptions(Options::NamesPtrList& opt_list, const string& value) | |
100 { | |
101 /* multiple options may be registered for the same name: | |
102 * allow each to parse value */ | |
103 for (Options::NamesPtrList::iterator it = opt_list.begin(); it != opt_list.end(); ++it) | |
104 { | |
105 (*it)->opt->parse(value); | |
106 } | |
107 } | |
108 | |
109 static const char spaces[41] = " "; | |
110 | |
111 /* format help text for a single option: | |
112 * using the formatting: "-x, --long", | |
113 * if a short/long option isn't specified, it is not printed | |
114 */ | |
115 static void doHelpOpt(ostream& out, const Options::Names& entry, unsigned pad_short = 0) | |
116 { | |
117 pad_short = min(pad_short, 8u); | |
118 | |
119 if (!entry.opt_short.empty()) | |
120 { | |
121 unsigned pad = max((int)pad_short - (int)entry.opt_short.front().size(), 0); | |
122 out << "-" << entry.opt_short.front(); | |
123 if (!entry.opt_long.empty()) | |
124 { | |
125 out << ", "; | |
126 } | |
127 out << &(spaces[40 - pad]); | |
128 } | |
129 else | |
130 { | |
131 out << " "; | |
132 out << &(spaces[40 - pad_short]); | |
133 } | |
134 | |
135 if (!entry.opt_long.empty()) | |
136 { | |
137 out << "--" << entry.opt_long.front(); | |
138 } | |
139 } | |
140 | |
141 /* format the help text */ | |
142 void doHelp(ostream& out, Options& opts, unsigned columns) | |
143 { | |
144 const unsigned pad_short = 3; | |
145 /* first pass: work out the longest option name */ | |
146 unsigned max_width = 0; | |
147 for(Options::NamesPtrList::iterator it = opts.opt_list.begin(); it != opts.opt_list.end(); it++) | |
148 { | |
149 ostringstream line(ios_base::out); | |
150 doHelpOpt(line, **it, pad_short); | |
151 max_width = max(max_width, (unsigned) line.tellp()); | |
152 } | |
153 | |
154 unsigned opt_width = min(max_width+2, 28u + pad_short) + 2; | |
155 unsigned desc_width = columns - opt_width; | |
156 | |
157 /* second pass: write out formatted option and help text. | |
158 * - align start of help text to start at opt_width | |
159 * - if the option text is longer than opt_width, place the help | |
160 * text at opt_width on the next line. | |
161 */ | |
162 for(Options::NamesPtrList::iterator it = opts.opt_list.begin(); it != opts.opt_list.end(); it++) | |
163 { | |
164 ostringstream line(ios_base::out); | |
165 line << " "; | |
166 doHelpOpt(line, **it, pad_short); | |
167 | |
168 const string& opt_desc = (*it)->opt->opt_desc; | |
169 if (opt_desc.empty()) | |
170 { | |
171 /* no help text: output option, skip further processing */ | |
172 cout << line.str() << endl; | |
173 continue; | |
174 } | |
175 size_t currlength = size_t(line.tellp()); | |
176 if (currlength > opt_width) | |
177 { | |
178 /* if option text is too long (and would collide with the | |
179 * help text, split onto next line */ | |
180 line << endl; | |
181 currlength = 0; | |
182 } | |
183 /* split up the help text, taking into account new lines, | |
184 * (add opt_width of padding to each new line) */ | |
185 for (size_t newline_pos = 0, cur_pos = 0; cur_pos != string::npos; currlength = 0) | |
186 { | |
187 /* print any required padding space for vertical alignment */ | |
188 line << &(spaces[40 - opt_width + currlength]); | |
189 newline_pos = opt_desc.find_first_of('\n', newline_pos); | |
190 if (newline_pos != string::npos) | |
191 { | |
192 /* newline found, print substring (newline needn't be stripped) */ | |
193 newline_pos++; | |
194 line << opt_desc.substr(cur_pos, newline_pos - cur_pos); | |
195 cur_pos = newline_pos; | |
196 continue; | |
197 } | |
198 if (cur_pos + desc_width > opt_desc.size()) | |
199 { | |
200 /* no need to wrap text, remainder is less than avaliable width */ | |
201 line << opt_desc.substr(cur_pos); | |
202 break; | |
203 } | |
204 /* find a suitable point to split text (avoid spliting in middle of word) */ | |
205 size_t split_pos = opt_desc.find_last_of(' ', cur_pos + desc_width); | |
206 if (split_pos != string::npos) | |
207 { | |
208 /* eat up multiple space characters */ | |
209 split_pos = opt_desc.find_last_not_of(' ', split_pos) + 1; | |
210 } | |
211 | |
212 /* bad split if no suitable space to split at. fall back to width */ | |
213 bool bad_split = split_pos == string::npos || split_pos <= cur_pos; | |
214 if (bad_split) | |
215 { | |
216 split_pos = cur_pos + desc_width; | |
217 } | |
218 line << opt_desc.substr(cur_pos, split_pos - cur_pos); | |
219 | |
220 /* eat up any space for the start of the next line */ | |
221 if (!bad_split) | |
222 { | |
223 split_pos = opt_desc.find_first_not_of(' ', split_pos); | |
224 } | |
225 cur_pos = newline_pos = split_pos; | |
226 | |
227 if (cur_pos >= opt_desc.size()) | |
228 { | |
229 break; | |
230 } | |
231 line << endl; | |
232 } | |
233 | |
234 cout << line.str() << endl; | |
235 } | |
236 } | |
237 | |
238 bool storePair(Options& opts, bool allow_long, bool allow_short, const string& name, const string& value) | |
239 { | |
240 bool found = false; | |
241 Options::NamesMap::iterator opt_it; | |
242 if (allow_long) | |
243 { | |
244 opt_it = opts.opt_long_map.find(name); | |
245 if (opt_it != opts.opt_long_map.end()) | |
246 { | |
247 found = true; | |
248 } | |
249 } | |
250 | |
251 /* check for the short list */ | |
252 if (allow_short && !(found && allow_long)) | |
253 { | |
254 opt_it = opts.opt_short_map.find(name); | |
255 if (opt_it != opts.opt_short_map.end()) | |
256 { | |
257 found = true; | |
258 } | |
259 } | |
260 | |
261 if (!found) | |
262 { | |
263 /* not found */ | |
264 cerr << "Unknown option: `" << name << "' (value:`" << value << "')" << endl; | |
265 return false; | |
266 } | |
267 | |
268 setOptions((*opt_it).second, value); | |
269 return true; | |
270 } | |
271 | |
272 bool storePair(Options& opts, const string& name, const string& value) | |
273 { | |
274 return storePair(opts, true, true, name, value); | |
275 } | |
276 | |
277 /** | |
278 * returns number of extra arguments consumed | |
279 */ | |
280 unsigned parseGNU(Options& opts, unsigned argc, const char* argv[]) | |
281 { | |
282 /* gnu style long options can take the forms: | |
283 * --option=arg | |
284 * --option arg | |
285 */ | |
286 string arg(argv[0]); | |
287 size_t arg_opt_start = arg.find_first_not_of('-'); | |
288 size_t arg_opt_sep = arg.find_first_of('='); | |
289 string option = arg.substr(arg_opt_start, arg_opt_sep - arg_opt_start); | |
290 | |
291 unsigned extra_argc_consumed = 0; | |
292 if (arg_opt_sep == string::npos) | |
293 { | |
294 /* no argument found => argument in argv[1] (maybe) */ | |
295 /* xxx, need to handle case where option isn't required */ | |
296 #if 0 | |
297 /* commented out, to return to true GNU style processing | |
298 * where longopts have to include an =, otherwise they are | |
299 * booleans */ | |
300 if (argc == 1) | |
301 return 0; /* run out of argv for argument */ | |
302 extra_argc_consumed = 1; | |
303 #endif | |
304 if(!storePair(opts, true, false, option, "1")) | |
305 { | |
306 return 0; | |
307 } | |
308 } | |
309 else | |
310 { | |
311 /* argument occurs after option_sep */ | |
312 string val = arg.substr(arg_opt_sep + 1); | |
313 storePair(opts, true, false, option, val); | |
314 } | |
315 | |
316 return extra_argc_consumed; | |
317 } | |
318 | |
319 unsigned parseSHORT(Options& opts, unsigned argc, const char* argv[]) | |
320 { | |
321 /* short options can take the forms: | |
322 * --option arg | |
323 * -option arg | |
324 */ | |
325 string arg(argv[0]); | |
326 size_t arg_opt_start = arg.find_first_not_of('-'); | |
327 string option = arg.substr(arg_opt_start); | |
328 /* lookup option */ | |
329 | |
330 /* argument in argv[1] */ | |
331 /* xxx, need to handle case where option isn't required */ | |
332 if (argc == 1) | |
333 { | |
334 cerr << "Not processing option without argument `" << option << "'" << endl; | |
335 return 0; /* run out of argv for argument */ | |
336 } | |
337 storePair(opts, false, true, option, string(argv[1])); | |
338 | |
339 return 1; | |
340 } | |
341 | |
342 list<const char*> | |
343 scanArgv(Options& opts, unsigned argc, const char* argv[]) | |
344 { | |
345 /* a list for anything that didn't get handled as an option */ | |
346 list<const char*> non_option_arguments; | |
347 | |
348 for(unsigned i = 1; i < argc; i++) | |
349 { | |
350 if (argv[i][0] != '-') | |
351 { | |
352 non_option_arguments.push_back(argv[i]); | |
353 continue; | |
354 } | |
355 | |
356 if (argv[i][1] == 0) | |
357 { | |
358 /* a lone single dash is an argument (usually signifying stdin) */ | |
359 non_option_arguments.push_back(argv[i]); | |
360 continue; | |
361 } | |
362 | |
363 if (argv[i][1] != '-') | |
364 { | |
365 /* handle short (single dash) options */ | |
366 #if 0 | |
367 i += parsePOSIX(opts, argc - i, &argv[i]); | |
368 #else | |
369 i += parseSHORT(opts, argc - i, &argv[i]); | |
370 #endif | |
371 continue; | |
372 } | |
373 | |
374 if (argv[i][2] == 0) | |
375 { | |
376 /* a lone double dash ends option processing */ | |
377 while (++i < argc) | |
378 non_option_arguments.push_back(argv[i]); | |
379 break; | |
380 } | |
381 | |
382 /* handle long (double dash) options */ | |
383 i += parseGNU(opts, argc - i, &argv[i]); | |
384 } | |
385 | |
386 return non_option_arguments; | |
387 } | |
388 | |
389 void scanLine(Options& opts, string& line) | |
390 { | |
391 /* strip any leading whitespace */ | |
392 size_t start = line.find_first_not_of(" \t\n\r"); | |
393 if (start == string::npos) | |
394 { | |
395 /* blank line */ | |
396 return; | |
397 } | |
398 if (line[start] == '#') | |
399 { | |
400 /* comment line */ | |
401 return; | |
402 } | |
403 /* look for first whitespace or ':' after the option end */ | |
404 size_t option_end = line.find_first_of(": \t\n\r",start); | |
405 string option = line.substr(start, option_end - start); | |
406 | |
407 /* look for ':', eat up any whitespace first */ | |
408 start = line.find_first_not_of(" \t\n\r", option_end); | |
409 if (start == string::npos) | |
410 { | |
411 /* error: badly formatted line */ | |
412 return; | |
413 } | |
414 if (line[start] != ':') | |
415 { | |
416 /* error: badly formatted line */ | |
417 return; | |
418 } | |
419 | |
420 /* look for start of value string -- eat up any leading whitespace */ | |
421 start = line.find_first_not_of(" \t\n\r", ++start); | |
422 if (start == string::npos) | |
423 { | |
424 /* error: badly formatted line */ | |
425 return; | |
426 } | |
427 | |
428 /* extract the value part, which may contain embedded spaces | |
429 * by searching for a word at a time, until we hit a comment or end of line */ | |
430 size_t value_end = start; | |
431 do | |
432 { | |
433 if (line[value_end] == '#') | |
434 { | |
435 /* rest of line is a comment */ | |
436 value_end--; | |
437 break; | |
438 } | |
439 value_end = line.find_first_of(" \t\n\r", value_end); | |
440 /* consume any white space, incase there is another word. | |
441 * any trailing whitespace will be removed shortly */ | |
442 value_end = line.find_first_not_of(" \t\n\r", value_end); | |
443 } | |
444 while (value_end != string::npos); | |
445 /* strip any trailing space from value*/ | |
446 value_end = line.find_last_not_of(" \t\n\r", value_end); | |
447 | |
448 string value; | |
449 if (value_end >= start) | |
450 { | |
451 value = line.substr(start, value_end +1 - start); | |
452 } | |
453 else | |
454 { | |
455 /* error: no value */ | |
456 return; | |
457 } | |
458 | |
459 /* store the value in option */ | |
460 storePair(opts, true, false, option, value); | |
461 } | |
462 | |
463 void scanFile(Options& opts, istream& in) | |
464 { | |
465 do | |
466 { | |
467 string line; | |
468 getline(in, line); | |
469 scanLine(opts, line); | |
470 } | |
471 while(!!in); | |
472 } | |
473 | |
474 /* for all options in opts, set their storage to their specified | |
475 * default value */ | |
476 void setDefaults(Options& opts) | |
477 { | |
478 for(Options::NamesPtrList::iterator it = opts.opt_list.begin(); it != opts.opt_list.end(); it++) | |
479 { | |
480 (*it)->opt->setDefault(); | |
481 } | |
482 } | |
483 | |
484 void parseConfigFile(Options& opts, const string& filename) | |
485 { | |
486 ifstream cfgstream(filename.c_str(), ifstream::in); | |
487 if (!cfgstream) | |
488 { | |
489 cerr << "Failed to open config file: `" << filename << "'" << endl; | |
490 exit(EXIT_FAILURE); | |
491 } | |
492 scanFile(opts, cfgstream); | |
493 } | |
494 | |
495 } | |
496 } | |
497 | |
498 //! \} |