framework/delibs/decpp/deCommandLine.cpp

   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
  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
  52 TypedFieldMap::TypedFieldMap (void)
  53 {
  54 }
  55
  56 TypedFieldMap::~TypedFieldMap (void)
  57 {
  58         clear();
  59 }
  60
  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
  71 bool TypedFieldMap::contains (const std::type_info* key) const
  72 {
  73         return m_fields.find(key) != m_fields.end();
  74 }
  75
  76 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
  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
 100 Parser::Parser (void)
 101 {
 102         addOption(Option<Help>("h", "help", "Show this help"));
 103 }
 104
 105 Parser::~Parser (void)
 106 {
 107 }
 108
 109 void Parser::addOption (const OptInfo& option)
 110 {
 111         m_options.push_back(option);
 112 }
 113
 114 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
 245 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
 289 void CommandLine::clear (void)
 290 {
 291         m_options.clear();
 292         m_args.clear();
 293 }
 294
 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<>
 313 void getTypeDefault (bool* dst)
 314 {
 315         *dst = false;
 316 }
 317
 318 template<>
 319 void parseType<bool> (const char*, bool* dst)
 320 {
 321         *dst = true;
 322 }
 323
 324 template<>
 325 void parseType<std::string> (const char* src, std::string* dst)
 326 {
 327         *dst = src;
 328 }
 329
 330 template<>
 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
 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