• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*-------------------------------------------------------------------------
2  * drawElements C++ Base Library
3  * -----------------------------
4  *
5  * Copyright 2014 The Android Open Source Project
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  *//*!
20  * \file
21  * \brief Command line parser.
22  *//*--------------------------------------------------------------------*/
23 
24 #include "deCommandLine.hpp"
25 
26 #include <set>
27 #include <sstream>
28 #include <cstring>
29 #include <stdexcept>
30 #include <algorithm>
31 
32 namespace de
33 {
34 namespace cmdline
35 {
36 
37 namespace
38 {
39 struct Help { typedef bool ValueType; };
40 }
41 
42 namespace detail
43 {
44 
getNamedValueName(const void * namedValue)45 inline const char* getNamedValueName (const void* namedValue)
46 {
47 	return static_cast<const NamedValue<deUint8>*>(namedValue)->name;
48 }
49 
50 using std::set;
51 
TypedFieldMap(void)52 TypedFieldMap::TypedFieldMap (void)
53 {
54 }
55 
~TypedFieldMap(void)56 TypedFieldMap::~TypedFieldMap (void)
57 {
58 	clear();
59 }
60 
clear(void)61 void TypedFieldMap::clear (void)
62 {
63 	for (Map::const_iterator iter = m_fields.begin(); iter != m_fields.end(); ++iter)
64 	{
65 		if (iter->second.value)
66 			iter->second.destructor(iter->second.value);
67 	}
68 	m_fields.clear();
69 }
70 
contains(const std::type_info * key) const71 bool TypedFieldMap::contains (const std::type_info* key) const
72 {
73 	return m_fields.find(key) != m_fields.end();
74 }
75 
get(const std::type_info * key) const76 const TypedFieldMap::Entry& TypedFieldMap::get (const std::type_info* key) const
77 {
78 	Map::const_iterator pos = m_fields.find(key);
79 	if (pos != m_fields.end())
80 		return pos->second;
81 	else
82 		throw std::out_of_range("Value not set");
83 }
84 
set(const std::type_info * key,const Entry & value)85 void TypedFieldMap::set (const std::type_info* key, const Entry& value)
86 {
87 	Map::iterator pos = m_fields.find(key);
88 
89 	if (pos != m_fields.end())
90 	{
91 		pos->second.destructor(pos->second.value);
92 		pos->second.value = DE_NULL;
93 
94 		pos->second = value;
95 	}
96 	else
97 		m_fields.insert(std::make_pair(key, value));
98 }
99 
Parser(void)100 Parser::Parser (void)
101 {
102 	addOption(Option<Help>("h", "help", "Show this help"));
103 }
104 
~Parser(void)105 Parser::~Parser (void)
106 {
107 }
108 
addOption(const OptInfo & option)109 void Parser::addOption (const OptInfo& option)
110 {
111 	m_options.push_back(option);
112 }
113 
parse(int numArgs,const char * const * args,CommandLine * dst,std::ostream & err) const114 bool Parser::parse (int numArgs, const char* const* args, CommandLine* dst, std::ostream& err) const
115 {
116 	typedef map<string, const OptInfo*> OptMap;
117 	typedef set<const OptInfo*> OptSet;
118 
119 	OptMap	shortOptMap;
120 	OptMap	longOptMap;
121 	OptSet	seenOpts;
122 	bool	allOk			= true;
123 
124 	DE_ASSERT(dst->m_args.empty() && dst->m_options.empty());
125 
126 	for (vector<OptInfo>::const_iterator optIter = m_options.begin(); optIter != m_options.end(); optIter++)
127 	{
128 		const OptInfo& opt = *optIter;
129 
130 		DE_ASSERT(opt.shortName || opt.longName);
131 
132 		if (opt.shortName)
133 		{
134 			DE_ASSERT(shortOptMap.find(opt.shortName) == shortOptMap.end());
135 			shortOptMap[opt.shortName] = &opt;
136 		}
137 
138 		if (opt.longName)
139 		{
140 			DE_ASSERT(longOptMap.find(opt.longName) == longOptMap.end());
141 			longOptMap[opt.longName] = &opt;
142 		}
143 
144 		// Set default values.
145 		if (opt.defaultValue)
146 			opt.dispatchParse(&opt, opt.defaultValue, &dst->m_options);
147 		else if (opt.setDefault)
148 			opt.setDefault(&dst->m_options);
149 	}
150 
151 	DE_ASSERT(!dst->m_options.get<Help>());
152 
153 	for (int argNdx = 0; argNdx < numArgs; argNdx++)
154 	{
155 		const char*		arg		= args[argNdx];
156 		int				argLen	= (int)strlen(arg);
157 
158 		if (arg[0] == '-' && arg[1] == '-' && arg[2] == 0)
159 		{
160 			// End of option list (--)
161 			for (int optNdx = argNdx+1; optNdx < numArgs; optNdx++)
162 				dst->m_args.push_back(args[optNdx]);
163 			break;
164 		}
165 		else if (arg[0] == '-')
166 		{
167 			const bool				isLongName	= arg[1] == '-';
168 			const char*				nameStart	= arg + (isLongName ? 2 : 1);
169 			const char*				nameEnd		= std::find(nameStart, arg+argLen, '=');
170 			const bool				hasImmValue	= nameEnd != (arg+argLen);
171 			const OptMap&			optMap		= isLongName ? longOptMap : shortOptMap;
172 			OptMap::const_iterator	optPos		= optMap.find(string(nameStart, nameEnd));
173 			const OptInfo*			opt			= optPos != optMap.end() ? optPos->second : DE_NULL;
174 
175 			if (!opt)
176 			{
177 				err << "Unrecognized command line option '" << arg << "'\n";
178 				allOk = false;
179 				continue;
180 			}
181 
182 			if (seenOpts.find(opt) != seenOpts.end())
183 			{
184 				err << "Command line option '--" << opt->longName << "' specified multiple times\n";
185 				allOk = false;
186 				continue;
187 			}
188 
189 			seenOpts.insert(opt);
190 
191 			if (opt->isFlag)
192 			{
193 				if (!hasImmValue)
194 				{
195 					opt->dispatchParse(opt, DE_NULL, &dst->m_options);
196 				}
197 				else
198 				{
199 					err << "No value expected for command line option '--" << opt->longName << "'\n";
200 					allOk = false;
201 				}
202 			}
203 			else
204 			{
205 				const bool	hasValue	= hasImmValue || (argNdx+1 < numArgs);
206 
207 				if (hasValue)
208 				{
209 					const char*	value	= hasValue ? (hasImmValue ? nameEnd+1 : args[argNdx+1]) : DE_NULL;
210 
211 					if (!hasImmValue)
212 						argNdx += 1; // Skip value
213 
214 					try
215 					{
216 						opt->dispatchParse(opt, value, &dst->m_options);
217 					}
218 					catch (const std::exception& e)
219 					{
220 						err << "Got error parsing command line option '--" << opt->longName << "': " << e.what() << "\n";
221 						allOk = false;
222 					}
223 				}
224 				else
225 				{
226 					err << "Expected value for command line option '--" << opt->longName << "'\n";
227 					allOk = false;
228 				}
229 			}
230 		}
231 		else
232 		{
233 			// Not an option
234 			dst->m_args.push_back(arg);
235 		}
236 	}
237 
238 	// Help specified?
239 	if (dst->m_options.get<Help>())
240 		allOk = false;
241 
242 	return allOk;
243 }
244 
help(std::ostream & str) const245 void Parser::help (std::ostream& str) const
246 {
247 	for (vector<OptInfo>::const_iterator optIter = m_options.begin(); optIter != m_options.end(); ++optIter)
248 	{
249 		const OptInfo& opt = *optIter;
250 
251 		str << "  ";
252 		if (opt.shortName)
253 			str << "-" << opt.shortName;
254 
255 		if (opt.shortName && opt.longName)
256 			str << ", ";
257 
258 		if (opt.longName)
259 			str << "--" << opt.longName;
260 
261 		if (opt.namedValues)
262 		{
263 			str << "=[";
264 
265 			for (const void* curValue = opt.namedValues; curValue != opt.namedValuesEnd; curValue = (const void*)((deUintptr)curValue + opt.namedValueStride))
266 			{
267 				if (curValue != opt.namedValues)
268 					str << "|";
269 				str << getNamedValueName(curValue);
270 			}
271 
272 			str << "]";
273 		}
274 		else if (!opt.isFlag)
275 			str << "=<value>";
276 
277 		str << "\n";
278 
279 		if (opt.description)
280 			str << "    " << opt.description << "\n";
281 
282 		if (opt.defaultValue)
283 			str << "    default: '" << opt.defaultValue << "'\n";
284 
285 		str << "\n";
286 	}
287 }
288 
clear(void)289 void CommandLine::clear (void)
290 {
291 	m_options.clear();
292 	m_args.clear();
293 }
294 
findNamedValueMatch(const char * src,const void * namedValues,const void * namedValuesEnd,size_t stride)295 const void* findNamedValueMatch (const char* src, const void* namedValues, const void* namedValuesEnd, size_t stride)
296 {
297 	std::string srcStr(src);
298 
299 	for (const void* curValue = namedValues; curValue != namedValuesEnd; curValue = (const void*)((deUintptr)curValue + stride))
300 	{
301 		if (srcStr == getNamedValueName(curValue))
302 			return curValue;
303 	}
304 
305 	throw std::invalid_argument("unrecognized value '" + srcStr + "'");
306 }
307 
308 } // detail
309 
310 // Default / parsing functions
311 
312 template<>
getTypeDefault(bool * dst)313 void getTypeDefault (bool* dst)
314 {
315 	*dst = false;
316 }
317 
318 template<>
parseType(const char *,bool * dst)319 void parseType<bool> (const char*, bool* dst)
320 {
321 	*dst = true;
322 }
323 
324 template<>
parseType(const char * src,std::string * dst)325 void parseType<std::string> (const char* src, std::string* dst)
326 {
327 	*dst = src;
328 }
329 
330 template<>
parseType(const char * src,int * dst)331 void parseType<int> (const char* src, int* dst)
332 {
333 	std::istringstream str(src);
334 	str >> *dst;
335 	if (str.bad() || !str.eof())
336 		throw std::invalid_argument("invalid integer literal");
337 }
338 
339 // Tests
340 
341 DE_DECLARE_COMMAND_LINE_OPT(TestStringOpt,		std::string);
342 DE_DECLARE_COMMAND_LINE_OPT(TestStringDefOpt,	std::string);
343 DE_DECLARE_COMMAND_LINE_OPT(TestIntOpt,			int);
344 DE_DECLARE_COMMAND_LINE_OPT(TestBoolOpt,		bool);
345 DE_DECLARE_COMMAND_LINE_OPT(TestNamedOpt,		deUint64);
346 
selfTest(void)347 void selfTest (void)
348 {
349 	// Parsing with no options.
350 	{
351 		Parser parser;
352 
353 		{
354 			std::ostringstream	err;
355 			CommandLine			cmdLine;
356 			const bool			parseOk		= parser.parse(0, DE_NULL, &cmdLine, err);
357 
358 			DE_TEST_ASSERT(parseOk && err.str().empty());
359 		}
360 
361 		{
362 			const char*			args[]		= { "-h" };
363 			std::ostringstream	err;
364 			CommandLine			cmdLine;
365 			const bool			parseOk		= parser.parse(DE_LENGTH_OF_ARRAY(args), &args[0], &cmdLine, err);
366 
367 			DE_TEST_ASSERT(!parseOk);
368 			DE_TEST_ASSERT(err.str().empty()); // No message about -h
369 		}
370 
371 		{
372 			const char*			args[]		= { "--help" };
373 			std::ostringstream	err;
374 			CommandLine			cmdLine;
375 			const bool			parseOk		= parser.parse(DE_LENGTH_OF_ARRAY(args), &args[0], &cmdLine, err);
376 
377 			DE_TEST_ASSERT(!parseOk);
378 			DE_TEST_ASSERT(err.str().empty()); // No message about -h
379 		}
380 
381 		{
382 			const char*			args[]		= { "foo", "bar", "baz baz" };
383 			std::ostringstream	err;
384 			CommandLine			cmdLine;
385 			const bool			parseOk		= parser.parse(DE_LENGTH_OF_ARRAY(args), &args[0], &cmdLine, err);
386 
387 			DE_TEST_ASSERT(parseOk && err.str().empty());
388 			DE_TEST_ASSERT(cmdLine.getArgs().size() == DE_LENGTH_OF_ARRAY(args));
389 
390 			for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(args); ndx++)
391 				DE_TEST_ASSERT(cmdLine.getArgs()[ndx] == args[ndx]);
392 		}
393 	}
394 
395 	// Parsing with options.
396 	{
397 		Parser parser;
398 
399 		static const NamedValue<deUint64> s_namedValues[] =
400 		{
401 			{ "zero",	0		},
402 			{ "one",	1		},
403 			{ "huge",	~0ull	}
404 		};
405 
406 		parser << Option<TestStringOpt>		("s",	"string",	"String option")
407 			   << Option<TestStringDefOpt>	("x",	"xyz",		"String option w/ default value",	"foo")
408 			   << Option<TestIntOpt>		("i",	"int",		"Int option")
409 			   << Option<TestBoolOpt>		("b",	"bool",		"Test boolean flag")
410 			   << Option<TestNamedOpt>		("n",	"named",	"Test named opt",	DE_ARRAY_BEGIN(s_namedValues),	DE_ARRAY_END(s_namedValues),	"one");
411 
412 		{
413 			std::ostringstream err;
414 			DE_TEST_ASSERT(err.str().empty());
415 			parser.help(err);
416 			DE_TEST_ASSERT(!err.str().empty());
417 		}
418 
419 		// Default values
420 		{
421 			CommandLine			cmdLine;
422 			std::ostringstream	err;
423 			bool				parseOk	= parser.parse(0, DE_NULL, &cmdLine, err);
424 
425 			DE_TEST_ASSERT(parseOk);
426 			DE_TEST_ASSERT(err.str().empty());
427 
428 			DE_TEST_ASSERT(!cmdLine.hasOption<TestStringOpt>());
429 			DE_TEST_ASSERT(!cmdLine.hasOption<TestIntOpt>());
430 			DE_TEST_ASSERT(cmdLine.getOption<TestNamedOpt>() == 1);
431 			DE_TEST_ASSERT(cmdLine.getOption<TestBoolOpt>() == false);
432 			DE_TEST_ASSERT(cmdLine.getOption<TestStringDefOpt>() == "foo");
433 		}
434 
435 		// Basic parsing
436 		{
437 			const char*			args[]	= { "-s", "test value", "-b", "-i=9", "--named=huge" };
438 			CommandLine			cmdLine;
439 			std::ostringstream	err;
440 			bool				parseOk	= parser.parse(DE_LENGTH_OF_ARRAY(args), &args[0], &cmdLine, err);
441 
442 			DE_TEST_ASSERT(parseOk);
443 			DE_TEST_ASSERT(err.str().empty());
444 
445 			DE_TEST_ASSERT(cmdLine.getOption<TestStringOpt>() == "test value");
446 			DE_TEST_ASSERT(cmdLine.getOption<TestIntOpt>() == 9);
447 			DE_TEST_ASSERT(cmdLine.getOption<TestBoolOpt>());
448 			DE_TEST_ASSERT(cmdLine.getOption<TestNamedOpt>() == ~0ull);
449 			DE_TEST_ASSERT(cmdLine.getOption<TestStringDefOpt>() == "foo");
450 		}
451 
452 		// End of argument list (--)
453 		{
454 			const char*			args[]	= { "--string=foo", "-b", "--", "--int=2", "-b" };
455 			CommandLine			cmdLine;
456 			std::ostringstream	err;
457 			bool				parseOk	= parser.parse(DE_LENGTH_OF_ARRAY(args), &args[0], &cmdLine, err);
458 
459 			DE_TEST_ASSERT(parseOk);
460 			DE_TEST_ASSERT(err.str().empty());
461 
462 			DE_TEST_ASSERT(cmdLine.getOption<TestStringOpt>() == "foo");
463 			DE_TEST_ASSERT(cmdLine.getOption<TestBoolOpt>());
464 			DE_TEST_ASSERT(!cmdLine.hasOption<TestIntOpt>());
465 
466 			DE_TEST_ASSERT(cmdLine.getArgs().size() == 2);
467 			DE_TEST_ASSERT(cmdLine.getArgs()[0] == "--int=2");
468 			DE_TEST_ASSERT(cmdLine.getArgs()[1] == "-b");
469 		}
470 
471 		// Value --
472 		{
473 			const char*			args[]	= { "--string", "--", "-b", "foo" };
474 			CommandLine			cmdLine;
475 			std::ostringstream	err;
476 			bool				parseOk	= parser.parse(DE_LENGTH_OF_ARRAY(args), &args[0], &cmdLine, err);
477 
478 			DE_TEST_ASSERT(parseOk);
479 			DE_TEST_ASSERT(err.str().empty());
480 
481 			DE_TEST_ASSERT(cmdLine.getOption<TestStringOpt>() == "--");
482 			DE_TEST_ASSERT(cmdLine.getOption<TestBoolOpt>());
483 			DE_TEST_ASSERT(!cmdLine.hasOption<TestIntOpt>());
484 
485 			DE_TEST_ASSERT(cmdLine.getArgs().size() == 1);
486 			DE_TEST_ASSERT(cmdLine.getArgs()[0] == "foo");
487 		}
488 
489 		// Invalid flag usage
490 		{
491 			const char*			args[]	= { "-b=true" };
492 			CommandLine			cmdLine;
493 			std::ostringstream	err;
494 			bool				parseOk	= parser.parse(DE_LENGTH_OF_ARRAY(args), &args[0], &cmdLine, err);
495 
496 			DE_TEST_ASSERT(!parseOk);
497 			DE_TEST_ASSERT(!err.str().empty());
498 		}
499 
500 		// Invalid named option
501 		{
502 			const char*			args[]	= { "-n=two" };
503 			CommandLine			cmdLine;
504 			std::ostringstream	err;
505 			bool				parseOk	= parser.parse(DE_LENGTH_OF_ARRAY(args), &args[0], &cmdLine, err);
506 
507 			DE_TEST_ASSERT(!parseOk);
508 			DE_TEST_ASSERT(!err.str().empty());
509 		}
510 
511 		// Unrecognized option (-x)
512 		{
513 			const char*			args[]	= { "-x" };
514 			CommandLine			cmdLine;
515 			std::ostringstream	err;
516 			bool				parseOk	= parser.parse(DE_LENGTH_OF_ARRAY(args), &args[0], &cmdLine, err);
517 
518 			DE_TEST_ASSERT(!parseOk);
519 			DE_TEST_ASSERT(!err.str().empty());
520 		}
521 
522 		// Unrecognized option (--xxx)
523 		{
524 			const char*			args[]	= { "--xxx" };
525 			CommandLine			cmdLine;
526 			std::ostringstream	err;
527 			bool				parseOk	= parser.parse(DE_LENGTH_OF_ARRAY(args), &args[0], &cmdLine, err);
528 
529 			DE_TEST_ASSERT(!parseOk);
530 			DE_TEST_ASSERT(!err.str().empty());
531 		}
532 
533 		// Invalid int value
534 		{
535 			const char*			args[]	= { "--int", "1x" };
536 			CommandLine			cmdLine;
537 			std::ostringstream	err;
538 			bool				parseOk	= parser.parse(DE_LENGTH_OF_ARRAY(args), &args[0], &cmdLine, err);
539 
540 			DE_TEST_ASSERT(!parseOk);
541 			DE_TEST_ASSERT(!err.str().empty());
542 		}
543 
544 		// Arg specified multiple times
545 		{
546 			const char*			args[]	= { "-s=2", "-s=3" };
547 			CommandLine			cmdLine;
548 			std::ostringstream	err;
549 			bool				parseOk	= parser.parse(DE_LENGTH_OF_ARRAY(args), &args[0], &cmdLine, err);
550 
551 			DE_TEST_ASSERT(!parseOk);
552 			DE_TEST_ASSERT(!err.str().empty());
553 		}
554 
555 		// Missing value
556 		{
557 			const char*			args[]	= { "--int" };
558 			CommandLine			cmdLine;
559 			std::ostringstream	err;
560 			bool				parseOk	= parser.parse(DE_LENGTH_OF_ARRAY(args), &args[0], &cmdLine, err);
561 
562 			DE_TEST_ASSERT(!parseOk);
563 			DE_TEST_ASSERT(!err.str().empty());
564 		}
565 
566 		// Empty value --arg=
567 		{
568 			const char*			args[]	= { "--string=", "-b", "-x", "" };
569 			CommandLine			cmdLine;
570 			std::ostringstream	err;
571 			bool				parseOk	= parser.parse(DE_LENGTH_OF_ARRAY(args), &args[0], &cmdLine, err);
572 
573 			DE_TEST_ASSERT(parseOk);
574 			DE_TEST_ASSERT(err.str().empty());
575 			DE_TEST_ASSERT(cmdLine.getOption<TestStringOpt>() == "");
576 			DE_TEST_ASSERT(cmdLine.getOption<TestStringDefOpt>() == "");
577 			DE_TEST_ASSERT(cmdLine.getOption<TestBoolOpt>());
578 		}
579 	}
580 }
581 
582 } // cmdline
583 } // de
584