2020-06-17 02:04:36 +02:00
|
|
|
//
|
|
|
|
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2020
|
|
|
|
//
|
|
|
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
|
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
//
|
|
|
|
#include "td/utils/OptionParser.h"
|
|
|
|
|
|
|
|
#include "td/utils/misc.h"
|
|
|
|
|
|
|
|
#include <cstring>
|
|
|
|
#include <unordered_map>
|
|
|
|
|
|
|
|
namespace td {
|
|
|
|
|
|
|
|
void OptionParser::set_description(string description) {
|
|
|
|
description_ = std::move(description);
|
|
|
|
}
|
|
|
|
|
|
|
|
void OptionParser::add_option(Option::Type type, char short_key, Slice long_key, Slice description,
|
|
|
|
std::function<Status(Slice)> callback) {
|
|
|
|
options_.push_back(Option{type, short_key, long_key.str(), description.str(), std::move(callback)});
|
|
|
|
}
|
|
|
|
|
2020-06-19 03:44:38 +02:00
|
|
|
void OptionParser::add_checked_option(char short_key, Slice long_key, Slice description,
|
|
|
|
std::function<Status(Slice)> callback) {
|
2020-06-17 02:04:36 +02:00
|
|
|
add_option(Option::Type::Arg, short_key, long_key, description, std::move(callback));
|
|
|
|
}
|
|
|
|
|
2020-06-19 03:44:38 +02:00
|
|
|
void OptionParser::add_checked_option(char short_key, Slice long_key, Slice description,
|
|
|
|
std::function<Status(void)> callback) {
|
2020-06-17 02:04:36 +02:00
|
|
|
add_option(Option::Type::NoArg, short_key, long_key, description,
|
2020-06-19 03:44:38 +02:00
|
|
|
[callback = std::move(callback)](Slice) { return callback(); });
|
|
|
|
}
|
|
|
|
|
|
|
|
void OptionParser::add_option(char short_key, Slice long_key, Slice description, std::function<void(Slice)> callback) {
|
|
|
|
add_option(Option::Type::Arg, short_key, long_key, description, [callback = std::move(callback)](Slice parameter) {
|
|
|
|
callback(parameter);
|
|
|
|
return Status::OK();
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
void OptionParser::add_option(char short_key, Slice long_key, Slice description, std::function<void(void)> callback) {
|
|
|
|
add_option(Option::Type::NoArg, short_key, long_key, description, [callback = std::move(callback)](Slice) {
|
|
|
|
callback();
|
|
|
|
return Status::OK();
|
|
|
|
});
|
2020-06-17 02:04:36 +02:00
|
|
|
}
|
|
|
|
|
2020-06-19 04:50:18 +02:00
|
|
|
void OptionParser::add_check(std::function<Status()> check) {
|
|
|
|
checks_.push_back(std::move(check));
|
|
|
|
}
|
|
|
|
|
2020-06-17 02:04:36 +02:00
|
|
|
Result<vector<char *>> OptionParser::run(int argc, char *argv[]) {
|
|
|
|
std::unordered_map<char, const Option *> short_options;
|
|
|
|
std::unordered_map<string, const Option *> long_options;
|
|
|
|
for (auto &opt : options_) {
|
|
|
|
if (opt.short_key != '\0') {
|
|
|
|
short_options[opt.short_key] = &opt;
|
|
|
|
}
|
|
|
|
if (!opt.long_key.empty()) {
|
|
|
|
long_options[opt.long_key] = &opt;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
vector<char *> non_options;
|
|
|
|
for (int arg_pos = 1; arg_pos < argc; arg_pos++) {
|
|
|
|
const char *arg = argv[arg_pos];
|
|
|
|
if (arg[0] != '-' || arg[1] == '\0') {
|
|
|
|
non_options.push_back(argv[arg_pos]);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (arg[1] == '-' && arg[2] == '\0') {
|
|
|
|
// "--"; after it everything is non-option
|
|
|
|
while (++arg_pos < argc) {
|
|
|
|
non_options.push_back(argv[arg_pos]);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (arg[1] == '-') {
|
|
|
|
// long option
|
|
|
|
Slice long_arg(arg + 2, std::strlen(arg + 2));
|
2020-06-19 03:44:38 +02:00
|
|
|
Slice parameter;
|
2020-06-17 02:04:36 +02:00
|
|
|
auto equal_pos = long_arg.find('=');
|
|
|
|
bool has_equal = equal_pos != Slice::npos;
|
|
|
|
if (has_equal) {
|
2020-06-19 03:44:38 +02:00
|
|
|
parameter = long_arg.substr(equal_pos + 1);
|
2020-06-17 02:04:36 +02:00
|
|
|
long_arg = long_arg.substr(0, equal_pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
auto it = long_options.find(long_arg.str());
|
|
|
|
if (it == long_options.end()) {
|
|
|
|
return Status::Error(PSLICE() << "Option " << long_arg << " was unrecognized");
|
|
|
|
}
|
|
|
|
|
|
|
|
auto option = it->second;
|
|
|
|
switch (option->type) {
|
|
|
|
case Option::Type::NoArg:
|
|
|
|
if (has_equal) {
|
|
|
|
return Status::Error(PSLICE() << "Option " << long_arg << " must not have argument");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Option::Type::Arg:
|
|
|
|
if (!has_equal) {
|
|
|
|
if (++arg_pos == argc) {
|
|
|
|
return Status::Error(PSLICE() << "Option " << long_arg << " must have argument");
|
|
|
|
}
|
2020-06-19 03:44:38 +02:00
|
|
|
parameter = Slice(argv[arg_pos], std::strlen(argv[arg_pos]));
|
2020-06-17 02:04:36 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
UNREACHABLE();
|
|
|
|
}
|
|
|
|
|
2020-06-19 03:44:38 +02:00
|
|
|
TRY_STATUS(option->arg_callback(parameter));
|
2020-06-17 02:04:36 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (size_t opt_pos = 1; arg[opt_pos] != '\0'; opt_pos++) {
|
|
|
|
auto it = short_options.find(arg[opt_pos]);
|
|
|
|
if (it == short_options.end()) {
|
|
|
|
return Status::Error(PSLICE() << "Option " << arg[opt_pos] << " was unrecognized");
|
|
|
|
}
|
|
|
|
|
|
|
|
auto option = it->second;
|
2020-06-19 03:44:38 +02:00
|
|
|
Slice parameter;
|
2020-06-17 02:04:36 +02:00
|
|
|
switch (option->type) {
|
|
|
|
case Option::Type::NoArg:
|
|
|
|
// nothing to do
|
|
|
|
break;
|
|
|
|
case Option::Type::Arg:
|
|
|
|
if (arg[opt_pos + 1] == '\0') {
|
|
|
|
if (++arg_pos == argc) {
|
|
|
|
return Status::Error(PSLICE() << "Option " << arg[opt_pos] << " must have argument");
|
|
|
|
}
|
2020-06-19 03:44:38 +02:00
|
|
|
parameter = Slice(argv[arg_pos], std::strlen(argv[arg_pos]));
|
2020-06-17 02:04:36 +02:00
|
|
|
} else {
|
2020-06-19 03:44:38 +02:00
|
|
|
parameter = Slice(arg + opt_pos + 1, std::strlen(arg + opt_pos + 1));
|
|
|
|
opt_pos += parameter.size();
|
2020-06-17 02:04:36 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
UNREACHABLE();
|
|
|
|
}
|
|
|
|
|
2020-06-19 03:44:38 +02:00
|
|
|
TRY_STATUS(option->arg_callback(parameter));
|
2020-06-17 02:04:36 +02:00
|
|
|
}
|
|
|
|
}
|
2020-06-19 04:50:18 +02:00
|
|
|
for (auto &check : checks_) {
|
|
|
|
TRY_STATUS(check());
|
|
|
|
}
|
2020-06-17 02:04:36 +02:00
|
|
|
|
|
|
|
return std::move(non_options);
|
|
|
|
}
|
|
|
|
|
|
|
|
StringBuilder &operator<<(StringBuilder &sb, const OptionParser &o) {
|
2020-06-17 05:09:53 +02:00
|
|
|
if (!o.description_.empty()) {
|
|
|
|
sb << o.description_ << ". ";
|
|
|
|
}
|
|
|
|
sb << "Options:\n";
|
|
|
|
|
|
|
|
size_t max_length = 0;
|
|
|
|
for (auto &opt : o.options_) {
|
|
|
|
bool has_short_key = opt.short_key != '\0';
|
|
|
|
bool has_long_key = !opt.long_key.empty();
|
|
|
|
size_t length = (has_short_key ? 2 : 0) + (has_long_key ? 2 + opt.long_key.size() + 2 * has_short_key : 0);
|
|
|
|
if (opt.type != OptionParser::Option::Type::NoArg) {
|
|
|
|
length += 5;
|
|
|
|
}
|
|
|
|
if (length > max_length) {
|
|
|
|
max_length = length;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
max_length++;
|
|
|
|
|
2020-06-17 02:04:36 +02:00
|
|
|
for (auto &opt : o.options_) {
|
2020-06-17 04:35:55 +02:00
|
|
|
bool has_short_key = opt.short_key != '\0';
|
2020-06-17 05:09:53 +02:00
|
|
|
sb << " ";
|
|
|
|
size_t length = max_length;
|
2020-06-17 04:35:55 +02:00
|
|
|
if (has_short_key) {
|
2020-06-17 05:09:53 +02:00
|
|
|
sb << '-' << opt.short_key;
|
|
|
|
length -= 2;
|
2020-06-17 04:35:55 +02:00
|
|
|
}
|
2020-06-17 02:04:36 +02:00
|
|
|
if (!opt.long_key.empty()) {
|
2020-06-17 04:35:55 +02:00
|
|
|
if (has_short_key) {
|
2020-06-17 05:09:53 +02:00
|
|
|
sb << ", ";
|
|
|
|
length -= 2;
|
2020-06-17 04:35:55 +02:00
|
|
|
}
|
|
|
|
sb << "--" << opt.long_key;
|
2020-06-17 05:09:53 +02:00
|
|
|
length -= 2 + opt.long_key.size();
|
2020-06-17 02:04:36 +02:00
|
|
|
}
|
|
|
|
if (opt.type != OptionParser::Option::Type::NoArg) {
|
|
|
|
sb << "<arg>";
|
2020-06-17 05:09:53 +02:00
|
|
|
length -= 5;
|
2020-06-17 02:04:36 +02:00
|
|
|
}
|
2020-06-17 05:09:53 +02:00
|
|
|
sb << string(length, ' ') << opt.description;
|
2020-06-17 04:35:55 +02:00
|
|
|
sb << '\n';
|
2020-06-17 02:04:36 +02:00
|
|
|
}
|
|
|
|
return sb;
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace td
|