nel/src/misc/cmd_args.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 //
  18 // Includes
  19 //
  20 #include "stdmisc.h"
  21 #include "nel/misc/cmd_args.h"
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #ifdef DEBUG_NEW
  28         #define new DEBUG_NEW
  29 #endif
  30
  31 namespace NLMISC
  32 {
  33
  34 CCmdArgs::CCmdArgs()
  35 {
  36 #ifdef NL_VERSION
  37         _Version = NL_VERSION;
  38 #endif
  39
  40         // add help
  41         addArg("h", "help", "", "Display this help");
  42
  43         // add version
  44         addArg("v", "version", "", "Display version of this program");
  45 }
  46
  47 void CCmdArgs::addArg(const TArg &arg)
  48 {
  49         _Args.push_back(arg);
  50 }
  51
  52 void CCmdArgs::addArg(const std::string &shortName, const std::string &longName, const std::string &helpName, const std::string &helpDescription, bool onlyOnce)
  53 {
  54         TArg arg;
  55         arg.shortName = shortName;
  56         arg.longName = longName;
  57         arg.helpName = helpName;
  58         arg.helpDescription = helpDescription;
  59         arg.onlyOnce = onlyOnce;
  60         arg.found = false;
  61         arg.required = false;
  62
  63         addArg(arg);
  64 }
  65
  66 void CCmdArgs::addAdditionalArg(const std::string &helpName, const std::string &helpDescription, bool onlyOnce, bool required)
  67 {
  68         TArg arg;
  69         arg.helpName = helpName;
  70         arg.helpDescription = helpDescription;
  71         arg.onlyOnce = onlyOnce;
  72         arg.found = false;
  73         arg.required = required;
  74
  75         addArg(arg);
  76 }
  77
  78 bool CCmdArgs::haveArg(const std::string &argName) const
  79 {
  80         // process each argument
  81         for(uint i = 0; i < _Args.size(); ++i)
  82         {
  83                 const TArg &arg = _Args[i];
  84
  85                 // return true if long arg found
  86                 if (arg.shortName == argName) return arg.found;
  87         }
  88
  89         return false;
  90 }
  91
  92 std::vector<std::string> CCmdArgs::getArg(const std::string &argName) const
  93 {
  94         // process each argument
  95         for(uint i = 0; i < _Args.size(); ++i)
  96         {
  97                 const TArg &arg = _Args[i];
  98
  99                 // return values if short arg found
 100                 if (arg.shortName == argName && arg.found) return arg.values;
 101         }
 102
 103         // return an empty vector
 104         return std::vector<std::string>();
 105 }
 106
 107 bool CCmdArgs::haveLongArg(const std::string &argName) const
 108 {
 109         // process each argument
 110         for(uint i = 0; i < _Args.size(); ++i)
 111         {
 112                 const TArg &arg = _Args[i];
 113
 114                 // return true if long arg found
 115                 if (arg.longName == argName) return arg.found;
 116         }
 117
 118         return false;
 119 }
 120
 121 std::vector<std::string> CCmdArgs::getLongArg(const std::string &argName) const
 122 {
 123         // process each argument
 124         for(uint i = 0; i < _Args.size(); ++i)
 125         {
 126                 const TArg &arg = _Args[i];
 127
 128                 // return values if long arg found
 129                 if (arg.longName == argName && arg.found) return arg.values;
 130         }
 131
 132         // return an empty vector
 133         return std::vector<std::string>();
 134 }
 135
 136 bool CCmdArgs::needAdditionalArg() const
 137 {
 138         // process each argument
 139         for(uint i = 0; i < _Args.size(); ++i)
 140         {
 141                 const TArg &arg = _Args[i];
 142
 143                 // they don't have any short or long name, but need a name in help
 144                 if (arg.shortName.empty() && arg.longName.empty() && !arg.helpName.empty() && arg.required && !arg.found)
 145                         return true;
 146         }
 147
 148         return false;
 149 }
 150
 151 bool CCmdArgs::haveAdditionalArg() const
 152 {
 153         // process each argument
 154         for(uint i = 0; i < _Args.size(); ++i)
 155         {
 156                 const TArg &arg = _Args[i];
 157
 158                 // they don't have any short or long name, but need a name in help
 159                 if (arg.shortName.empty() && arg.longName.empty() && !arg.helpName.empty() && arg.found)
 160                         return true;
 161         }
 162
 163         return false;
 164 }
 165
 166 bool CCmdArgs::haveAdditionalArg(const std::string &name) const
 167 {
 168         // process each argument
 169         for(uint i = 0; i < _Args.size(); ++i)
 170         {
 171                 const TArg &arg = _Args[i];
 172
 173                 // they don't have any short or long name, but need a name in help
 174                 if (arg.shortName.empty() && arg.longName.empty() && !arg.helpName.empty() && arg.helpName == name && arg.found)
 175                         return true;
 176         }
 177
 178         return false;
 179 }
 180
 181 std::vector<std::string> CCmdArgs::getAdditionalArg(const std::string &name) const
 182 {
 183         // process each argument
 184         for(uint i = 0; i < _Args.size(); ++i)
 185         {
 186                 const TArg &arg = _Args[i];
 187
 188                 // they don't have any short or long name, but need a name in help
 189                 if (arg.shortName.empty() && arg.longName.empty() && !arg.helpName.empty() && arg.helpName == name)
 190                         return arg.values;
 191         }
 192
 193         // return an empty vector
 194         return std::vector<std::string>();
 195 }
 196
 197 bool CCmdArgs::parse(const std::string &args)
 198 {
 199         std::vector<std::string> argv;
 200
 201 #ifdef NL_OS_WINDOWS
 202         wchar_t str[4096];
 203         uint len = GetModuleFileNameW(NULL, str, 4096);
 204
 205         // first argument should be full path to executable
 206         if (len && len < 4096)
 207                 argv.push_back(wideToUtf8(str));
 208 #endif
 209
 210         // convert string with arguments to array
 211         explodeArguments(args, argv);
 212
 213         return parse(argv);
 214 }
 215
 216 bool CCmdArgs::parse(int argc, char **argv)
 217 {
 218         // convert C strings to STL strings
 219         std::vector<std::string> args;
 220
 221         for(sint i = 0; i < argc; ++i)
 222         {
 223 #ifdef NL_OS_MAC
 224                 // get rid of -psn_* arguments under OS X
 225                 if (strncmp(argv[i], "-psn_", 5) == 0) continue;
 226 #endif
 227
 228                 args.push_back(argv[i]);
 229         }
 230
 231         return parse(args);
 232 }
 233
 234 bool CCmdArgs::parse(const std::vector<std::string> &argv)
 235 {
 236         // no parameters
 237         if (argv.empty()) return false;
 238
 239         // first argument is always the program name
 240         _ProgramName = CFile::getFilename(argv.front());
 241         _ProgramPath = CPath::makePathAbsolute(CPath::standardizePath(CFile::getPath(argv.front())), CPath::getCurrentPath(), true);
 242
 243         // current path
 244         _StartupPath = CPath::standardizePath(CPath::getCurrentPath());
 245
 246         // set process name for logs
 247         CLog::setProcessName(_ProgramName);
 248
 249         // arguments count
 250         uint argc = argv.size();
 251
 252         // process each argument
 253         for (uint i = 1; i < argc; i++)
 254         {
 255                 std::string name = argv[i];
 256
 257 #ifdef NL_OS_WINDOWS
 258                 // support / and - under Windows, arguments should be at least 2 characters
 259                 if (name.size() > 1 && (name[0] == '-' || name[0] == '/'))
 260 #else
 261                 if (name.size() > 1 && name[0] == '-')
 262 #endif
 263                 {
 264                         // it's a long name if using --
 265                         bool useLongName = name[0] == '-' && name[1] == '-';
 266
 267                         // extract argument name
 268                         name = name.substr(useLongName ? 2:1);
 269
 270                         std::string value;
 271
 272                         if (useLongName)
 273                         {
 274                                 // look if using = to define value
 275                                 std::string::size_type pos = name.find('=');
 276
 277                                 if (pos != std::string::npos)
 278                                 {
 279                                         // value is second part, name the first one
 280                                         value = name.substr(pos+1);
 281                                         name = name.substr(0, pos);
 282                                 }
 283                         }
 284                         else if (name.length() > 1)
 285                         {
 286                                 value = name.substr(1);
 287                                 name = name.substr(0, 1);
 288                         }
 289
 290                         bool found = false;
 291
 292                         // process each argument definition
 293                         for(uint j = 0; j < _Args.size(); ++j)
 294                         {
 295                                 TArg &arg = _Args[j];
 296
 297                                 // only process arguments of the right type
 298                                 if ((useLongName && name != arg.longName) || (!useLongName && name != arg.shortName)) continue;
 299
 300                                 // already get the only once argument
 301                                 if (arg.found && arg.onlyOnce)
 302                                 {
 303                                         // the last one is the only kept, so discard previous ones
 304                                         arg.values.clear();
 305                                 }
 306
 307                                 // argument is found
 308                                 found = arg.found = true;
 309
 310                                 // another argument is required
 311                                 if (!arg.helpName.empty())
 312                                 {
 313                                         // if the value hasn't be specified by =
 314                                         if (value.empty() && i+1 < argc)
 315                                         {
 316                                                 // take next argument
 317                                                 value = argv[++i];
 318                                         }
 319
 320                                         // add argument value if not empty
 321                                         if (!value.empty())
 322                                         {
 323                                                 arg.values.push_back(value);
 324                                         }
 325                                 }
 326
 327                                 break;
 328                         }
 329
 330                         if (!found)
 331                         {
 332                                 printf("Warning: Argument %s not recognized, skip it!\n", name.c_str());
 333                         }
 334                 }
 335                 else
 336                 {
 337                         // process each argument definition
 338                         for(uint j = 0, len = _Args.size(); j < len; ++j)
 339                         {
 340                                 TArg &arg = _Args[j];
 341
 342                                 // only process arguments that don't have a name
 343                                 if (!arg.shortName.empty() || !arg.longName.empty()) continue;
 344
 345                                 // already get the only once argument
 346                                 if (arg.found && arg.onlyOnce) continue;
 347
 348                                 arg.found = true;
 349
 350                                 // in fact, if there are more than one required arguments, all arguments are added in first one to simplify
 351                                 arg.values.push_back(name);
 352
 353                                 break;
 354                         }
 355                 }
 356         }
 357
 358         // process version
 359         if (haveLongArg("version"))
 360         {
 361                 displayVersion();
 362                 return false;
 363         }
 364
 365         // process help if requested or if required arguments are missing
 366         if (haveLongArg("help") || needAdditionalArg())
 367         {
 368                 displayHelp();
 369                 return false;
 370         }
 371
 372         return true;
 373 }
 374
 375 void CCmdArgs::displayHelp()
 376 {
 377         // display program name
 378         printf("Usage: %s ", _ProgramName.c_str());
 379
 380         // display optional parameters
 381         for(uint i = 0; i < _Args.size(); ++i)
 382         {
 383                 const TArg &arg = _Args[i];
 384
 385                 // only short argument is displayed
 386                 if (!arg.shortName.empty())
 387                 {
 388                         printf("[-%s", arg.shortName.c_str());
 389
 390                         // a parameter is required
 391                         if (!arg.helpName.empty())
 392                         {
 393                                 printf("<%s>", arg.helpName.c_str());
 394                         }
 395
 396                         printf("]");
 397                 }
 398         }
 399
 400         // display required arguments
 401         for(uint i = 0; i < _Args.size(); ++i)
 402         {
 403                 const TArg &arg = _Args[i];
 404
 405                 // they don't have any short or long name, but need a name in help
 406                 if (arg.shortName.empty() && arg.longName.empty() && !arg.helpName.empty())
 407                 {
 408                         printf(" %c%s", arg.required ? '<':'[', arg.helpName.c_str());
 409
 410                         // if support more than once argument
 411                         if (!arg.onlyOnce) printf("...");
 412
 413                         printf("%c", arg.required ? '>':']');
 414                 }
 415         }
 416
 417         printf("\n");
 418
 419         if (!_Description.empty())
 420         {
 421                 printf("\n%s\n", _Description.c_str());
 422         }
 423
 424         printf("\nWhere options are:\n");
 425
 426         // display details on each argument
 427         for(uint i = 0; i < _Args.size(); ++i)
 428         {
 429                 const TArg &arg = _Args[i];
 430
 431                 // not an optional argument
 432                 if (arg.shortName.empty() && arg.longName.empty()) continue;
 433
 434                 // 2 spaces
 435                 printf("  ");
 436
 437                 std::vector<std::string> syntaxes;
 438
 439                 // display short argument
 440                 if (!arg.shortName.empty())
 441                 {
 442                         // and it's required argument
 443                         if (!arg.helpName.empty())
 444                         {
 445                                 syntaxes.push_back(toString("-%s <%s>", arg.shortName.c_str(), arg.helpName.c_str()));
 446                         }
 447                         else
 448                         {
 449                                 syntaxes.push_back(toString("-%s", arg.shortName.c_str()));
 450                         }
 451                 }
 452
 453                 // display long argument
 454                 if (!arg.longName.empty())
 455                 {
 456                         if (!arg.helpName.empty())
 457                         {
 458                                 // display first syntax for long argument, --arg <value>
 459                                 syntaxes.push_back(toString("--%s <%s>", arg.longName.c_str(), arg.helpName.c_str()));
 460                         }
 461                         else
 462                         {
 463                                 syntaxes.push_back(toString("--%s", arg.longName.c_str()));
 464                         }
 465                 }
 466
 467                 for(uint j = 0; j < syntaxes.size(); ++j)
 468                 {
 469                         if (j > 0)
 470                         {
 471                                 printf("%s ", (j == syntaxes.size() - 1) ? " or":",");
 472                         }
 473
 474                         printf("%s", syntaxes[j].c_str());
 475                 }
 476
 477                 // display argument description
 478                 if (!arg.helpDescription.empty())
 479                 {
 480                         printf(" : %s", arg.helpDescription.c_str());
 481                 }
 482
 483                 printf("\n");
 484         }
 485
 486         // process each argument
 487         for(uint i = 0; i < _Args.size(); ++i)
 488         {
 489                 const TArg &arg = _Args[i];
 490
 491                 // only display required arguments
 492                 if (arg.shortName.empty() && arg.longName.empty() && !arg.helpName.empty() && !arg.helpDescription.empty())
 493                 {
 494                         printf("  %s : %s\n", arg.helpName.c_str(), arg.helpDescription.c_str());
 495                 }
 496         }
 497 }
 498
 499 void CCmdArgs::displayVersion()
 500 {
 501         // display a verbose version string
 502 #ifdef BUILD_DATE
 503         printf("%s %s (built on %s)\nCopyright (C) %s\n", _ProgramName.c_str(), _Version.c_str(), BUILD_DATE, COPYRIGHT);
 504 #endif
 505 }
 506
 507 }; // NAMESPACE NLMISC
 508