khanat-code-old/code/nel/src/misc/cmd_args.cpp

534 lines
12 KiB
C++
Raw Normal View History

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// Includes
//
#include "stdmisc.h"
#include "nel/misc/cmd_args.h"
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#ifdef DEBUG_NEW
#define new DEBUG_NEW
#endif
namespace NLMISC
{
CCmdArgs::CCmdArgs()
{
2016-01-18 20:22:57 +00:00
#ifdef NL_VERSION
_Version = NL_VERSION;
#endif
// add help
addArg("h", "help", "", "Display this help");
// add version
addArg("v", "version", "", "Display version of this program");
}
void CCmdArgs::addArg(const TArg &arg)
{
_Args.push_back(arg);
}
2016-01-18 20:22:57 +00:00
void CCmdArgs::addArg(const std::string &shortName, const std::string &longName, const std::string &helpName, const std::string &helpDescription, bool onlyOnce)
{
TArg arg;
arg.shortName = shortName;
arg.longName = longName;
arg.helpName = helpName;
arg.helpDescription = helpDescription;
2016-01-18 20:22:57 +00:00
arg.onlyOnce = onlyOnce;
arg.found = false;
2016-01-18 20:22:57 +00:00
arg.required = false;
addArg(arg);
}
2016-01-18 20:22:57 +00:00
void CCmdArgs::addAdditionalArg(const std::string &helpName, const std::string &helpDescription, bool onlyOnce, bool required)
{
TArg arg;
arg.helpName = helpName;
arg.helpDescription = helpDescription;
2016-01-18 20:22:57 +00:00
arg.onlyOnce = onlyOnce;
arg.found = false;
2016-01-18 20:22:57 +00:00
arg.required = required;
addArg(arg);
}
bool CCmdArgs::haveArg(const std::string &argName) const
{
// process each argument
2016-01-16 22:48:44 +00:00
for(uint i = 0; i < _Args.size(); ++i)
{
const TArg &arg = _Args[i];
// return true if long arg found
if (arg.shortName == argName) return arg.found;
}
return false;
}
std::vector<std::string> CCmdArgs::getArg(const std::string &argName) const
{
// process each argument
for(uint i = 0; i < _Args.size(); ++i)
{
const TArg &arg = _Args[i];
// return values if short arg found
if (arg.shortName == argName && arg.found) return arg.values;
}
// return an empty vector
return std::vector<std::string>();
}
bool CCmdArgs::haveLongArg(const std::string &argName) const
{
// process each argument
for(uint i = 0; i < _Args.size(); ++i)
{
const TArg &arg = _Args[i];
// return true if long arg found
if (arg.longName == argName) return arg.found;
}
return false;
}
std::vector<std::string> CCmdArgs::getLongArg(const std::string &argName) const
{
// process each argument
for(uint i = 0; i < _Args.size(); ++i)
{
const TArg &arg = _Args[i];
// return values if long arg found
if (arg.longName == argName && arg.found) return arg.values;
}
// return an empty vector
return std::vector<std::string>();
}
2016-01-18 20:22:57 +00:00
bool CCmdArgs::needAdditionalArg() const
{
// process each argument
for(uint i = 0; i < _Args.size(); ++i)
{
const TArg &arg = _Args[i];
// they don't have any short or long name, but need a name in help
2016-01-18 20:22:57 +00:00
if (arg.shortName.empty() && arg.longName.empty() && !arg.helpName.empty() && arg.required)
return true;
}
return false;
}
2016-01-18 20:22:57 +00:00
bool CCmdArgs::haveAdditionalArg() const
{
// process each argument
for(uint i = 0; i < _Args.size(); ++i)
{
const TArg &arg = _Args[i];
// they don't have any short or long name, but need a name in help
2016-01-18 20:22:57 +00:00
if (arg.shortName.empty() && arg.longName.empty() && !arg.helpName.empty() && arg.found)
return true;
}
return false;
}
2016-01-18 20:22:57 +00:00
bool CCmdArgs::haveAdditionalArg(const std::string &name) const
{
// process each argument
for(uint i = 0; i < _Args.size(); ++i)
{
const TArg &arg = _Args[i];
// they don't have any short or long name, but need a name in help
2016-01-18 20:22:57 +00:00
if (arg.shortName.empty() && arg.longName.empty() && !arg.helpName.empty() && arg.helpName == name && arg.found)
return false;
}
return false;
}
std::vector<std::string> CCmdArgs::getAdditionalArg(const std::string &name) const
{
// process each argument
for(uint i = 0; i < _Args.size(); ++i)
{
const TArg &arg = _Args[i];
// they don't have any short or long name, but need a name in help
if (arg.shortName.empty() && arg.longName.empty() && !arg.helpName.empty() && arg.helpName == name)
return arg.values;
}
// return an empty vector
return std::vector<std::string>();
}
bool CCmdArgs::parse(const std::string &args)
{
std::vector<std::string> argv;
2016-01-18 20:22:57 +00:00
#ifdef NL_OS_WINDOWS
char str[4096];
uint len = GetModuleFileNameA(NULL, str, 4096);
if (len && len < 4096)
argv.push_back(str);
#endif
std::string::size_type pos1 = 0, pos2 = 0;
do
{
// Look for the first non space character
pos1 = args.find_first_not_of (" ", pos2);
if(pos1 == std::string::npos) break;
// Look for the first space or "
pos2 = args.find_first_of (" \"", pos1);
if(pos2 != std::string::npos)
{
// " ?
if(args[pos2] == '"')
{
// Look for the final \"
pos2 = args.find_first_of ("\"", pos2+1);
if(pos2 != std::string::npos)
{
// Look for the first space
pos2 = args.find_first_of (" ", pos2+1);
}
}
}
// Compute the size of the string to extract
std::string::difference_type length = (pos2 != std::string::npos) ? pos2-pos1 : std::string::npos;
std::string tmp = args.substr (pos1, length);
argv.push_back (tmp);
}
while(pos2 != std::string::npos);
return parse(argv);
}
bool CCmdArgs::parse(int argc, char **argv)
{
// convert C strings to STL strings
std::vector<std::string> args;
for(sint i = 0; i < argc; ++i)
{
args.push_back(argv[i]);
}
return parse(args);
}
bool CCmdArgs::parse(const std::vector<std::string> &argv)
{
// no parameters
if (argv.empty()) return false;
// first argument is always the program name
_ProgramName = CFile::getFilename(argv.front());
2016-01-18 20:22:57 +00:00
_ProgramPath = CPath::standardizePath(CFile::getPath(argv.front()));
// arguments count
uint argc = argv.size();
// process each argument
for (sint i = 1; i < argc; i++)
{
std::string name = argv[i];
#ifdef NL_OS_WINDOWS
// support / and - under Windows, arguments should be at least 2 characters
if (name.size() > 1 && (name[0] == '-' || name[0] == '/'))
#else
if (name.size() > 1 && name[0] == '-')
#endif
{
// it's a long name if using --
bool useLongName = name[0] == '-' && name[1] == '-';
// extract argument name
name = name.substr(useLongName ? 2:1);
std::string value;
if (useLongName)
{
// look if using = to define value
std::string::size_type pos = name.find('=');
if (pos != std::string::npos)
{
// value is second part, name the first one
value = name.substr(pos+1);
name = name.substr(0, pos);
}
}
else if (name.length() > 1)
{
value = name.substr(1);
name = name.substr(0, 1);
}
2016-01-18 20:22:57 +00:00
bool found = false;
// process each argument definition
for(uint j = 0; j < _Args.size(); ++j)
{
TArg &arg = _Args[j];
// only process arguments of the right type
if ((useLongName && name != arg.longName) || (!useLongName && name != arg.shortName)) continue;
2016-01-18 20:22:57 +00:00
// already get the only once argument
if (arg.found && arg.onlyOnce)
{
// the last one is the only kept, so discard previous ones
arg.values.clear();
}
// argument is found
2016-01-18 20:22:57 +00:00
found = arg.found = true;
// another argument is required
if (!arg.helpName.empty())
{
// if the value hasn't be specified by =
if (value.empty() && i+1 < argc)
{
// take next argument
value = argv[++i];
}
// add argument value if not empty
if (!value.empty())
{
arg.values.push_back(value);
}
}
break;
}
2016-01-18 20:22:57 +00:00
if (!found)
{
printf("Warning: Argument %s not recognized, skip it!\n", name.c_str());
}
}
else
{
// process each argument definition
for(uint j = 0, len = _Args.size(); j < len; ++j)
{
TArg &arg = _Args[j];
// only process arguments that don't have a name
if (!arg.shortName.empty() || !arg.longName.empty()) continue;
2016-01-18 20:22:57 +00:00
// already get the only once argument
if (arg.found && arg.onlyOnce) continue;
arg.found = true;
// in fact, if there are more than one required arguments, all arguments are added in first one to simplify
arg.values.push_back(name);
break;
}
}
}
// process version
if (haveLongArg("version"))
{
displayVersion();
return false;
}
// process help if requested or if required arguments are missing
2016-01-18 20:22:57 +00:00
if (haveLongArg("help") || (needAdditionalArg() && !haveAdditionalArg()))
{
displayHelp();
return false;
}
return true;
}
void CCmdArgs::displayHelp()
{
// display program name
printf("Usage: %s ", _ProgramName.c_str());
// display optional parameters
for(uint i = 0; i < _Args.size(); ++i)
{
const TArg &arg = _Args[i];
// only short argument is displayed
if (!arg.shortName.empty())
{
printf("[-%s", arg.shortName.c_str());
// a parameter is required
if (!arg.helpName.empty())
{
printf("<%s>", arg.helpName.c_str());
}
printf("]");
}
}
// display required arguments
for(uint i = 0; i < _Args.size(); ++i)
{
const TArg &arg = _Args[i];
// they don't have any short or long name, but need a name in help
if (arg.shortName.empty() && arg.longName.empty() && !arg.helpName.empty())
{
2016-01-18 20:22:57 +00:00
printf(" %c%s", arg.required ? '<':'[', arg.helpName.c_str());
2016-01-18 20:22:57 +00:00
// if support more than once argument
if (!arg.onlyOnce) printf("...");
printf("%c", arg.required ? '>':']');
}
}
printf("\n");
2016-01-18 20:22:57 +00:00
if (!_Description.empty())
{
printf("\n%s", _Description.c_str());
}
printf("\nWhere options are:\n");
// display details on each argument
for(uint i = 0; i < _Args.size(); ++i)
{
const TArg &arg = _Args[i];
// not an optional argument
if (arg.shortName.empty() && arg.longName.empty()) continue;
2016-01-18 20:22:57 +00:00
// 2 spaces
printf(" ");
std::vector<std::string> syntaxes;
// display short argument
if (!arg.shortName.empty())
{
// and it's required argument
if (!arg.helpName.empty())
{
2016-01-18 20:22:57 +00:00
syntaxes.push_back(toString("-%s <%s>", arg.shortName.c_str(), arg.helpName.c_str()));
syntaxes.push_back(toString("-%s<%s>", arg.shortName.c_str(), arg.helpName.c_str()));
}
else
{
syntaxes.push_back(toString("-%s", arg.shortName.c_str()));
}
}
// display long argument
if (!arg.longName.empty())
{
if (!arg.helpName.empty())
{
// display first syntax for long argument, --arg <value>
2016-01-18 20:22:57 +00:00
syntaxes.push_back(toString("--%s <%s>", arg.longName.c_str(), arg.helpName.c_str()));
}
2016-01-18 20:22:57 +00:00
if (!arg.helpName.empty())
{
2016-01-18 20:22:57 +00:00
// display second syntax for long argument, --arg=<value>
syntaxes.push_back(toString("--%s=<%s>", arg.longName.c_str(), arg.helpName.c_str()));
}
2016-01-18 20:22:57 +00:00
else
{
syntaxes.push_back(toString("--%s", arg.longName.c_str()));
}
}
2016-01-18 20:22:57 +00:00
for(uint j = 0; j < syntaxes.size(); ++j)
{
if (j > 0)
{
2016-01-18 20:22:57 +00:00
printf("%s ", (j == syntaxes.size() - 1) ? " or":",");
}
2016-01-18 20:22:57 +00:00
printf("%s", syntaxes[j].c_str());
}
// display argument description
if (!arg.helpDescription.empty())
{
printf(" : %s", arg.helpDescription.c_str());
}
printf("\n");
}
// process each argument
for(uint i = 0; i < _Args.size(); ++i)
{
const TArg &arg = _Args[i];
// only display required arguments
if (arg.shortName.empty() && arg.longName.empty() && !arg.helpName.empty() && !arg.helpDescription.empty())
{
2016-01-18 20:22:57 +00:00
printf(" %s : %s\n", arg.helpName.c_str(), arg.helpDescription.c_str());
}
}
}
void CCmdArgs::displayVersion()
{
// display a verbose version string
#ifdef BUILD_DATE
2016-01-18 20:22:57 +00:00
printf("%s %s (built on %s)\nCopyright (C) %s\n", _ProgramName.c_str(), _Version.c_str(), BUILD_DATE, COPYRIGHT);
#endif
}
}; // NAMESPACE NLMISC