if (token.size() > 1 && token.front() == '+') {

token.remove_prefix(1);

}

return token;

T (*convert)(const char *, char **)) {

if (token.empty()) {

return false;

}

std::string buf(token);

errno = 0;

char *end = nullptr;

T value = convert(buf.c_str(), &end);

if (end != buf.c_str() + buf.size() || end == buf.c_str() || errno == ERANGE) {

return false;

}

*out = value;

return true;

token = drop_leading_plus(token);

if (token.empty()) {

return false;

}

int64_t v = 0;

auto res = std::from_chars(token.data(), token.data() + token.size(), v);

if (res.ec != std::errc{} || !consumed_all(token, res.ptr)) {

return false;

}

if (v < min || v > max) {

return false;

}

*out = v;

return true;

token = drop_leading_plus(token);

if (token.empty()) {

return false;

}

// No sign to refuse by hand: from_chars into an unsigned rejects a minus outright.

// Checked on all three of MSVC, libstdc++ and libc++, each answering invalid_argument

// and leaving the output alone. The test says so too, since it is their promise this

// relies on rather than ours.

uint64_t v = 0;

auto res = std::from_chars(token.data(), token.data() + token.size(), v);

if (res.ec != std::errc{} || !consumed_all(token, res.ptr)) {

return false;

}

if (v > max) {

return false;

}

*out = v;

return true;

static const std::string_view yes[] = {"true", "yes", "on", "1"};

static const std::string_view no[] = {"false", "no", "off", "0"};

for (auto word : yes) {

if (str::ascii_casecmp(token, word) == 0) {

*out = true;

return true;

}

}

for (auto word : no) {

if (str::ascii_casecmp(token, word) == 0) {

*out = false;

return true;

}

}

return false;

OptionData *data = nullptr;

/// What was written against the spelling, by an equals sign or by being stuck to

/// it. Absent where the token was the spelling and nothing else, which is not the

/// same as present and empty: \c --prefix= sets an empty string.

std::string_view value;

/// The spelling as it was written, so that a complaint about the option names it

/// the way the reader typed it rather than the way it was declared.

std::string_view spelling;

explicit operator bool() const {

return data != nullptr;

}

bool has_one = false) {

const auto &argument = declared[index];

if (argument.arity() == Argument::Single) {

return 1;

}

if (argument.arity() == Argument::Remainder) {

return available;

}

size_t reserved = 0;

for (size_t j = index + 1; j < declared.size(); ++j) {

if (declared[j].isRequired()) {

++reserved;

}

}

if (available > reserved) {

return available - reserved;

}

return has_one ? 0 : 1;

if (!ignore_case) {

return a == b;

}

return str::ascii_casecmp(a, b) == 0;

std::vector<std::string_view> res;

if (index < 0) {

return res;

}

auto data = static_cast<const OptionData *>(_data);

for (const auto &slots : data->occurrences) {

if (size_t(index) >= slots.size()) {

continue;

}

for (const auto &item : slots[size_t(index)]) {

res.emplace_back(item);

}

}

return res;

std::vector<size_t> row(b.size() + 1);

for (size_t j = 0; j <= b.size(); ++j) {

row[j] = j;

}

for (size_t i = 1; i <= a.size(); ++i) {

size_t diagonal = row[0];

row[0] = i;

for (size_t j = 1; j <= b.size(); ++j) {

size_t above = row[j];

row[j] = std::min(

{row[j] + 1, row[j - 1] + 1, diagonal + (a[i - 1] == b[j - 1] ? 0 : 1)});

diagonal = above;

}

}

return row[b.size()];

stdc_impl_t;

const auto &input = impl.error_token;

if (input.empty() || impl.error_candidates.empty()) {

return {};

}

// Half of what was typed. Looser than that and every short name is a candidate for every

// short typo, which is worse than saying nothing.

const size_t threshold = input.size() / 2;

// Set in as far as the help text sets a section body in, since this is a list under a

// line that introduces it and reads as one.

const std::string margin(size_t(impl.indent < 0 ? 0 : impl.indent), ' ');

std::string suggestions;

for (const auto &item : impl.error_candidates) {

if (edit_distance(input, item) <= threshold) {

suggestions += "\n" + margin + item;

}

}

if (suggestions.empty()) {

return {};

}

return "\"" + input + "\" is not matched. Do you mean one of the following?" + suggestions;

stdc_impl_t;

std::string res;

const Command *at = impl.root.get();

for (size_t i = 0; at; ++i) {

if (!at->version().empty()) {

res = at->version();

}

at = i + 1 < impl.path.size() ? at->findCommand(impl.path[i + 1]) : nullptr;

}

return res;

if (role == Option::NoRole) {

return false;

}

stdc_impl_t;

for (const auto &item : impl.options) {

if (item.option->role() == role && !item.occurrences.empty()) {

return true;

}

}

return false;

stdc_impl_t;

auto data = impl.find(token);

if (!data || data->occurrences.empty()) {

return std::nullopt;

}

return OptionResult(data);

stdc_impl_t;

if (index < 0 || size_t(index) >= impl.arguments.size() ||

impl.arguments[size_t(index)].empty()) {

return std::nullopt;

}

return std::string_view(impl.arguments[size_t(index)].front());

stdc_impl_t;

std::vector<std::string_view> res;

if (index < 0 || size_t(index) >= impl.arguments.size()) {

return res;

}

for (const auto &item : impl.arguments[size_t(index)]) {

res.emplace_back(item);

}

return res;

stdc_impl_t;

std::vector<const Option *> res;

if (!impl.root || impl.path.size() <= 1) {

return res;

}

const Command *at = impl.root.get();

for (size_t i = 1; i < impl.path.size() && at; ++i) {

for (const auto &option : at->options()) {

if (option.isRecursive()) {

res.push_back(&option);

}

}

at = at->findCommand(impl.path[i]);

}

return res;

HelpSizes res;

res.indent = data->indent;

res.spacing = data->spacing;

// Zero means ask, and the answer is whatever stdout is: a terminal's width, or 80

// columns for a pipe or a file, so help captured into one reads the same everywhere.

res.textWidth = data->text_width > 0 ? data->text_width : console::width(stdout);

res.displayOptions = data->display_options;

return res;

const detail::parse_data *data) {

if (!data->target || !data->formatter) {

return {};

}

HelpSizes sizes = sizesOf(data);

return data->formatter->render(data->formatter->blocks(result, sizes), sizes);

stdc_impl_t;

if (!impl.target || !impl.formatter) {

return {};

}

return impl.formatter->blocks(*this, sizesOf(&impl));

stdc_impl_t;

std::string out;

for (const auto &run : helpRuns(*this, &impl)) {

out += run.text;

}

return out;

stdc_impl_t;

// Through the library's own console rather than fwrite, so that one program does not

// talk to the terminal two different ways, and so a Windows console gets the transcoding

// it needs.

for (const auto &run : helpRuns(*this, &impl)) {

console::fputs(run.style.style, run.style.foreground, run.style.background, run.text,

stdout);

}

if (isValid()) {

return;

}

stdc_impl_t;

// What went wrong is worth a color where there is one to be had, and console works out

// for itself whether stderr is somewhere escapes belong.

console::fputs(console::bold, console::red, console::nocolor, impl.error_text + "\n",

stderr);

if (!impl.display_options.test_flag(Parser::SkipCorrection)) {

auto correction = correctionText();

if (!correction.empty()) {

console::fputs(console::nostyle, console::nocolor, console::nocolor,

correction + "\n", stderr);

}

}

// How this program spells asking for help rather than how most of them do. A tree that

// does not offer it at all gets no line, since pointing at something nobody declared is

// worse than saying nothing.

std::string help;

for (const auto &item : impl.options) {

if (item.option->role() != Option::Help) {

continue;

}

for (const auto &token : item.option->tokens()) {

// The long spelling where there is one, since that is the one worth reading.

if (help.empty() || (help.rfind("--", 0) != 0 && token.rfind("--", 0) == 0)) {

help = token;

}

}

break;

}

if (impl.target && !help.empty()) {

std::string name;

for (size_t i = 0; i < impl.path.size(); ++i) {

name += (i ? " " : "") + impl.path[i];

}

console::fputs(console::nostyle, console::nocolor, console::nocolor,

"Try \"" + name + " " + help + "\" for more information.\n", stderr);

}

std::vector<std::string> lines;

if (columns < 1) {

lines.push_back(text);

return lines;

}

auto points = utf::utf8_to_utf32(text);

std::u32string line;

int width = 0;

const auto emit = [&lines](std::u32string piece) {

while (!piece.empty() && piece.back() == U' ') {

piece.pop_back();

}

lines.push_back(utf::utf32_to_utf8(piece));

};

const auto measure = [](const std::u32string &piece) {

int res = 0;

for (char32_t c : piece) {

res += console::display_width(c);

}

return res;

};

for (char32_t c : points) {

if (c == U'\n') {

emit(std::move(line));

line.clear();

width = 0;

continue;

}

int w = console::display_width(c);

if (width + w > columns && !line.empty()) {

// Back up to the last space, so a word is not cut in half. A word longer than

// the whole column has no space to back up to and is broken where it reached

// the edge.

auto space = line.find_last_of(U' ');

if (space == std::u32string::npos) {

emit(line);

line.clear();

} else {

auto tail = line.substr(space + 1);

emit(line.substr(0, space));

line = tail;

}

width = measure(line);

}

line.push_back(c);

width += w;

}

emit(std::move(line));

return lines;

std::string res = "<" + argument.displayName() + ">";

if (argument.arity() != Argument::Single) {

res += "...";

}

return argument.isRequired() ? res : "[" + res + "]";

std::string res;

if (allSpellings) {

for (size_t i = 0; i < option.tokens().size(); ++i) {

res += (i ? ", " : "") + option.tokens()[i];

}

} else {

res = option.token();

}

// Through this rather than straight to the one above, so that a formatter overriding

// only the argument rung reaches every metavar there is.

for (const auto &argument : option.arguments()) {

res += " " + displayed(argument);

}

return res;

HelpBlock res;

res.role = slot.role;

res.title = std::move(title);

res.titleStyle = slot.titleStyle;

res.bodyStyle = slot.bodyStyle;

res.entryStyle = slot.entryStyle;

return res;

const HelpBlock &slot, const std::string &fallback, Name name, Line line) {

std::vector<HelpBlock> res;

std::vector<bool> taken(items.size(), false);

for (const auto &group : groups) {

HelpBlock block = blockLike(slot, group.name);

for (const auto &wanted : group.members) {

for (size_t i = 0; i < items.size(); ++i) {

if (!taken[i] && name(items[i]) == wanted) {

block.entries.push_back(line(items[i]));

taken[i] = true;

break;

}

}

}

if (!block.entries.empty()) {

res.push_back(std::move(block));

}

}

HelpBlock rest = blockLike(slot, fallback);

for (size_t i = 0; i < items.size(); ++i) {

if (!taken[i]) {

rest.entries.push_back(line(items[i]));

}

}

if (!rest.entries.empty()) {

res.push_back(std::move(rest));

}

return res;

const std::string &text) {

if (text.empty()) {

return;

}

if (!out.empty() && out.back().style == style) {

out.back().text += text;

return;

}

out.push_back({style, text});

const std::vector<HelpFormatter::Run> &more) {

for (const auto &run : more) {

appendRun(out, run.style, run.text);

}

const std::vector<std::string> &path,

const std::vector<Option> &inherited, int indent, int text_width) {

std::string head;

for (size_t i = 0; i < path.size(); ++i) {

head += (i ? " " : "") + path[i];

}

// An option that has to be given is not optional information, so it is spelled out

// where a reader looks first rather than left inside "[options]". The hint stays for

// whatever is left, and goes away when nothing is.

// A subcommand's name comes first or not at all, so it is written first here. An

// option before it ends the command path, which is why the other order was the one

// arrangement the parser refuses.

std::vector<std::string> parts;

if (!command.commands().empty()) {

parts.push_back("[commands]");

}

size_t optional_count = 0;

const auto &take = [&](const Option &option) {

if (!spelled(option)) {

return;

}

if (option.isRequired()) {

parts.push_back(formatter.displayed(option, false));

} else {

optional_count++;

}

};

for (const auto &option : command.options()) {

take(option);

}

for (const auto &option : inherited) {

take(option);

}

if (optional_count > 0) {

parts.push_back("[options]");

}

for (const auto &argument : command.arguments()) {

parts.push_back(formatter.displayed(argument));

}

int room = std::max(text_width - indent, min_description);

std::string res = head;

int line_width = console::display_width(head);

for (const auto &part : parts) {

int part_width = console::display_width(part);

if (line_width > 0 && line_width + 1 + part_width > room) {

res += "\n";

line_width = 0;

}

// At the margin the piece goes straight down under the one above. Anywhere else

// it needs the space that separates it from what came before.

res += line_width == 0 ? part : " " + part;

line_width += line_width == 0 ? part_width : 1 + part_width;

}

return res;

auto flags = sizes.displayOptions;

std::string res;

if (flags.test_flag(Parser::ShowArgumentExpectedValues) &&

!argument.expectedValues().empty()) {

std::string words;

for (const auto &item : argument.expectedValues()) {

words += (words.empty() ? "" : ", ") + item;

}

res += " [" + words + "]";

}

if (flags.test_flag(Parser::ShowArgumentDefaultValue) && argument.hasDefaultValue()) {

res += " (default: " + argument.defaultValue() + ")";

}

return res;

std::string right = option.description();

for (const auto &argument : option.arguments()) {

right += argument_extras(argument, sizes);

}

if (sizes.displayOptions.test_flag(Parser::ShowOptionIsRequired) && option.isRequired()) {

right += " (required)";

}

return {displayed(option, true), right};

const std::vector<std::string> &path,

const std::vector<Option> &inherited,

const HelpSizes &sizes) const {

return usage_text(*this, command, path, inherited, sizes.indent, sizes.textWidth);

const HelpSizes &sizes) const {

if (!result.command()) {

return {};

}

const Command &command = *result.command();

const auto &catalogue = command.catalogue();

auto flags = sizes.displayOptions;

// A row at a time, through the rung that makes one, so that a formatter changing what a

// row says does not have to take over this whole function to do it.

auto argument_line = [this, &sizes](const Argument &item) { return entry(item, sizes); };

auto option_line = [this, &sizes](const Option &item) { return entry(item, sizes); };

auto command_line = [this, &sizes](const Command &item) { return entry(item, sizes); };

// Only the ones that can be printed, which is spelled() and why. The help text is not

// the place to find out that a tree holds an option nobody can type.

std::vector<Option> own;

for (const auto &item : command.options()) {

if (spelled(item)) {

own.push_back(item);

}

}

// What the commands above declared recursive is in scope here and is demanded here, so

// it is listed here. Under a heading of its own, since it belongs to the program rather

// than to this command, and since the catalogue's groups were written for this

// command's own options and have nothing to say about these.

std::vector<Option> inherited_options;

for (const auto *option : result.inheritedOptions()) {

if (spelled(*option)) {

inherited_options.push_back(*option);

}

}

std::vector<HelpBlock> out;

// A block with nothing in it is not printed and not handed out, so a command with no

// subcommands says nothing about subcommands rather than showing an empty heading.

const auto push = [&out](HelpBlock block) {

if (!block.isEmpty()) {

out.push_back(std::move(block));

}

};

const auto pushAll = [&out](std::vector<HelpBlock> blocks) {

for (auto &block : blocks) {

out.push_back(std::move(block));

}

};

for (const auto &slot : result.helpLayout().blocks()) {

switch (slot.role) {

case HelpBlock::Prologue: {

auto block = blockLike(slot, {});

block.text = result.prologue();

push(std::move(block));

break;

}

case HelpBlock::Description: {

auto block = blockLike(slot, "Description");

block.text = command.description();

push(std::move(block));

break;

}

case HelpBlock::Usage: {

auto block = blockLike(slot, "Usage");

block.text = usageText(command, result.commandPath(), inherited_options, sizes);

push(std::move(block));

break;

}

case HelpBlock::Arguments: {

pushAll(grouped(

command.arguments(), catalogue.argumentGroups(), slot, "Arguments",

[](const Argument &item) { return item.name(); }, argument_line));

break;

}

// ###QUESTION: a recursive option is listed here on the page of the command

// that declared it and under "Global options" on the pages below, so the same

// spelling sits under two headings depending on which page is being read. That

// is what Cobra does with a persistent flag. The other two answers are to list

// it under "Global options" everywhere, which splits the declaring command's

// list by something a reader there cannot act on, and to drop the second block

// altogether, which is System.CommandLine's and loses the one thing worth

// saying on a subcommand's page: this is not mine, read the program's help.

// Should it be the same heading on both? Four lines here if so, filtering the

// recursive ones out of own and adding them to the block below.

case HelpBlock::Options: {

pushAll(grouped(

own, catalogue.optionGroups(), slot, "Options",

[](const Option &item) { return item.token(); }, option_line));

break;

}

case HelpBlock::InheritedOptions: {

auto block = blockLike(slot, "Global options");

for (const auto &option : inherited_options) {

block.entries.push_back(option_line(option));

}

push(std::move(block));

break;

}

case HelpBlock::Commands: {

pushAll(grouped(

command.commands(), catalogue.commandGroups(), slot, "Commands",

[](const Command &item) { return item.name(); }, command_line));

break;

}