Tokens(std::vector<std::string> tokens, bool isParsingArgv = true)

: fTokens(std::move(tokens)),

fIsParsingArgv(isParsingArgv)

{}

explicit operator bool() const {

return fIndex < fTokens.size();

}

static Tokens from_pattern(std::string const& source) {

static const std::regex re_separators {

"(?:\\s*)" // any spaces (non-matching subgroup)

"("

"[\\[\\]\\(\\)\\|]" // one character of brackets or parens or pipe character

"|"

"\\.\\.\\." // elipsis

")" };

static const std::regex re_strings {

"(?:\\s*)" // any spaces (non-matching subgroup)

"("

"\\S*<.*?>" // strings, but make sure to keep "< >" strings together

"|"

"[^<>\\s]+" // string without <>

")" };

// We do two stages of regex matching. The '[]()' and '...' are strong delimeters

// and need to be split out anywhere they occur (even at the end of a token). We

// first split on those, and then parse the stuff between them to find the string

// tokens. This is a little harder than the python version, since they have regex.split

// and we dont have anything like that.

std::vector<std::string> tokens;

std::for_each(std::sregex_iterator{ source.begin(), source.end(), re_separators },

std::sregex_iterator{},

[&](std::smatch const& match)

{

// handle anything before the separator (this is the "stuff" between the delimeters)

if (match.prefix().matched) {

std::for_each(std::sregex_iterator{match.prefix().first, match.prefix().second, re_strings},

std::sregex_iterator{},

[&](std::smatch const& m)

{

tokens.push_back(m[1].str());

});

}

// handle the delimter token itself

if (match[1].matched) {

tokens.push_back(match[1].str());

}

});

return Tokens(tokens, false);

}

std::string const& current() const {

if (*this)

return fTokens[fIndex];

static std::string const empty;

return empty;

}

std::string the_rest() const {

if (!*this)

return {};

return join(fTokens.begin()+static_cast<std::ptrdiff_t>(fIndex),

fTokens.end(),

" ");

}

std::string pop() {

return std::move(fTokens.at(fIndex++));

}

bool isParsingArgv() const { return fIsParsingArgv; }

struct OptionError : std::runtime_error { using runtime_error::runtime_error; };

std::vector<std::string> fTokens;

size_t fIndex = 0;

bool fIsParsingArgv;

std::vector<Pattern*> flattened = pattern.flat([](Pattern const* p) -> bool {

return dynamic_cast<T const*>(p) != nullptr;

});

// now, we're guaranteed to have T*'s, so just use static_cast

std::vector<T*> ret;

std::transform(flattened.begin(), flattened.end(), std::back_inserter(ret), [](Pattern* p) {

return static_cast<T*>(p);

});

return ret;

// ECMAScript regex only has "?=" for a non-matching lookahead. In order to make sure we always have

// a newline to anchor our matching, we have to avoid matching the final newline of each grouping.

// Therefore, our regex is adjusted from the docopt Python one to use ?= to match the newlines before

// the following lines, rather than after.

std::regex const re_section_pattern {

"(?:^|\\n)" // anchored at a linebreak (or start of string)

"("

"[^\\n]*" + name + "[^\\n]*(?=\\n?)" // a line that contains the name

"(?:\\n[ \\t].*?(?=\\n|$))*" // followed by any number of lines that are indented

")",

std::regex::icase

};

std::vector<std::string> ret;

std::for_each(std::sregex_iterator(source.begin(), source.end(), re_section_pattern),

std::sregex_iterator(),

[&](std::smatch const& match)

{

ret.push_back(trim(match[1].str()));

});

return ret;

if (token.empty())

return false;

if (token[0]=='<' && token[token.size()-1]=='>')

return true;

if (std::all_of(token.begin(), token.end(), &::isupper))

return true;

return false;

std::vector<std::string> ret;

std::transform(iter, end,

std::back_inserter(ret),

[](typename I::reference opt) { return opt->longOption(); });

return ret;

{

// long ::= '--' chars [ ( ' ' | '=' ) chars ] ;

std::string longOpt, equal;

value val;

std::tie(longOpt, equal, val) = partition(tokens.pop(), "=");

assert(starts_with(longOpt, "--"));

if (equal.empty()) {

val = value{};

}

// detect with options match this long option

std::vector<Option const*> similar;

for(auto const& option : options) {

if (option.longOption()==longOpt)

similar.push_back(&option);

}

// maybe allow similar options that match by prefix

if (tokens.isParsingArgv() && similar.empty()) {

for(auto const& option : options) {

if (option.longOption().empty())

continue;

if (starts_with(option.longOption(), longOpt))

similar.push_back(&option);

}

}

PatternList ret;

if (similar.size() > 1) { // might be simply specified ambiguously 2+ times?

std::vector<std::string> prefixes = longOptions(similar.begin(), similar.end());

std::string error = "'" + longOpt + "' is not a unique prefix: ";

error.append(join(prefixes.begin(), prefixes.end(), ", "));

throw Tokens::OptionError(std::move(error));

} else if (similar.empty()) {

int argcount = equal.empty() ? 0 : 1;

options.emplace_back("", longOpt, argcount);

auto o = std::make_shared<Option>(options.back());

if (tokens.isParsingArgv()) {

o->setValue(argcount ? value{val} : value{true});

}

ret.push_back(o);

} else {

auto o = std::make_shared<Option>(*similar[0]);

if (o->argCount() == 0) {

if (val) {

std::string error = o->longOption() + " must not have an argument";

throw Tokens::OptionError(std::move(error));

}

} else {

if (!val) {

auto const& token = tokens.current();

if (token.empty() || token=="--") {

std::string error = o->longOption() + " requires an argument";

throw Tokens::OptionError(std::move(error));

}

val = tokens.pop();

}

}

if (tokens.isParsingArgv()) {

o->setValue(val ? std::move(val) : value{true});

}

ret.push_back(o);

}

return ret;

{

// shorts ::= '-' ( chars )* [ [ ' ' ] chars ] ;

auto token = tokens.pop();

assert(starts_with(token, "-"));

assert(!starts_with(token, "--"));

auto i = token.begin();

++i; // skip the leading '-'

PatternList ret;

while (i != token.end()) {

std::string shortOpt = { '-', *i };

++i;

std::vector<Option const*> similar;

for(auto const& option : options) {

if (option.shortOption()==shortOpt)

similar.push_back(&option);

}

if (similar.size() > 1) {

std::string error = shortOpt + " is specified ambiguously "

+ std::to_string(similar.size()) + " times";

throw Tokens::OptionError(std::move(error));

} else if (similar.empty()) {

options.emplace_back(shortOpt, "", 0);

auto o = std::make_shared<Option>(options.back());

if (tokens.isParsingArgv()) {

o->setValue(value{true});

}

ret.push_back(o);

} else {

auto o = std::make_shared<Option>(*similar[0]);

value val;

if (o->argCount()) {

if (i == token.end()) {

// consume the next token

auto const& ttoken = tokens.current();

if (ttoken.empty() || ttoken=="--") {

std::string error = shortOpt + " requires an argument";

throw Tokens::OptionError(std::move(error));

}

val = tokens.pop();

} else {

// consume all the rest

val = std::string{i, token.end()};

i = token.end();

}

}

if (tokens.isParsingArgv()) {

o->setValue(val ? std::move(val) : value{true});

}

ret.push_back(o);

}

}

return ret;

{

// atom ::= '(' expr ')' | '[' expr ']' | 'options'

// | long | shorts | argument | command ;

std::string const& token = tokens.current();

PatternList ret;

if (token == "[") {

tokens.pop();

auto expr = parse_expr(tokens, options);

auto trailing = tokens.pop();

if (trailing != "]") {

throw DocoptLanguageError("Mismatched '['");

}

ret.emplace_back(std::make_shared<Optional>(std::move(expr)));

} else if (token=="(") {

tokens.pop();

auto expr = parse_expr(tokens, options);

auto trailing = tokens.pop();

if (trailing != ")") {

throw DocoptLanguageError("Mismatched '('");

}

ret.emplace_back(std::make_shared<Required>(std::move(expr)));

} else if (token == "options") {

tokens.pop();

ret.emplace_back(std::make_shared<OptionsShortcut>());

} else if (starts_with(token, "--") && token != "--") {

ret = parse_long(tokens, options);

} else if (starts_with(token, "-") && token != "-" && token != "--") {

ret = parse_short(tokens, options);

} else if (is_argument_spec(token)) {

ret.emplace_back(std::make_shared<Argument>(tokens.pop()));

} else {

ret.emplace_back(std::make_shared<Command>(tokens.pop()));

}

return ret;

{

// seq ::= ( atom [ '...' ] )* ;"""

PatternList ret;

while (tokens) {

auto const& token = tokens.current();

if (token=="]" || token==")" || token=="|")

break;

auto atom = parse_atom(tokens, options);

if (tokens.current() == "...") {

ret.emplace_back(std::make_shared<OneOrMore>(std::move(atom)));

tokens.pop();

} else {

std::move(atom.begin(), atom.end(), std::back_inserter(ret));

}

}

return ret;

{

if (seq.size()==1) {

return std::move(seq[0]);

}

return std::make_shared<Required>(std::move(seq));

{

if (seq.size()==1) {

return std::move(seq[0]);

}

return std::make_shared<Either>(std::move(seq));

{

// expr ::= seq ( '|' seq )* ;

auto seq = parse_seq(tokens, options);

if (tokens.current() != "|")

return seq;

PatternList ret;

ret.emplace_back(maybe_collapse_to_required(std::move(seq)));

while (tokens.current() == "|") {

tokens.pop();

seq = parse_seq(tokens, options);

ret.emplace_back(maybe_collapse_to_required(std::move(seq)));

}

return { maybe_collapse_to_either(std::move(ret)) };

{

auto tokens = Tokens::from_pattern(source);

auto result = parse_expr(tokens, options);

if (tokens)

throw DocoptLanguageError("Unexpected ending: '" + tokens.the_rest() + "'");

assert(result.size() == 1 && "top level is always one big");

return Required{ std::move(result) };

std::string ret = "(";

auto i = section.find(':')+1; // skip past "usage:"

auto parts = split(section, i);

for(size_t ii = 1; ii < parts.size(); ++ii) {

if (parts[ii] == parts[0]) {

ret += " ) | (";

} else {

ret.push_back(' ');

ret += parts[ii];

}

}

ret += " )";

return ret;

{

// Parse command-line argument vector.

//

// If options_first:

// argv ::= [ long | shorts ]* [ argument ]* [ '--' [ argument ]* ] ;

// else:

// argv ::= [ long | shorts | argument ]* [ '--' [ argument ]* ] ;

PatternList ret;

while (tokens) {

auto const& token = tokens.current();

if (token=="--") {

// option list is done; convert all the rest to arguments

while (tokens) {

ret.emplace_back(std::make_shared<Argument>("", tokens.pop()));

}

} else if (starts_with(token, "--")) {

auto&& parsed = parse_long(tokens, options);

std::move(parsed.begin(), parsed.end(), std::back_inserter(ret));

} else if (token[0]=='-' && token != "-") {

auto&& parsed = parse_short(tokens, options);

std::move(parsed.begin(), parsed.end(), std::back_inserter(ret));

} else if (options_first) {

// option list is done; convert all the rest to arguments

while (tokens) {

ret.emplace_back(std::make_shared<Argument>("", tokens.pop()));

}

} else {

ret.emplace_back(std::make_shared<Argument>("", tokens.pop()));

}

}

return ret;

// This pattern is a delimiter by which we split the options.

// The delimiter is a new line followed by a whitespace(s) followed by one or two hyphens.

static std::regex const re_delimiter{

"(?:^|\\n)[ \\t]*" // a new line with leading whitespace

"(?=-{1,2})" // [split happens here] (positive lookahead) ... and followed by one or two hyphes

};

std::vector<Option> defaults;

for (auto s : parse_section("options:", doc)) {

s.erase(s.begin(), s.begin() + static_cast<std::ptrdiff_t>(s.find(':')) + 1); // get rid of "options:"

for (const auto& opt : regex_split(s, re_delimiter)) {

if (starts_with(opt, "-")) {

defaults.emplace_back(Option::parse(opt));

}

}

}

return defaults;

return std::any_of(options.begin(), options.end(), [&](std::shared_ptr<Pattern const> const& opt) -> bool {

auto const& name = opt->name();

if (name==opt1 || (!opt2.empty() && name==opt2)) {

return opt->hasValue();

}

return false;

});

if (help && isOptionSet(options, "-h", "--help")) {

throw DocoptExitHelp();

}

if (version && isOptionSet(options, "--version")) {

throw DocoptExitVersion();

}

{

auto usage_sections = parse_section("usage:", doc);

if (usage_sections.empty()) {

throw DocoptLanguageError("'usage:' (case-insensitive) not found.");

}

if (usage_sections.size() > 1) {

throw DocoptLanguageError("More than one 'usage:' (case-insensitive).");

}

std::vector<Option> options = parse_defaults(doc);

Required pattern = parse_pattern(formal_usage(usage_sections[0]), options);

std::vector<Option const*> pattern_options = flat_filter<Option const>(pattern);

using UniqueOptions = std::unordered_set<Option const*, PatternHasher, PatternPointerEquality>;

UniqueOptions const uniq_pattern_options { pattern_options.begin(), pattern_options.end() };

// Fix up any "[options]" shortcuts with the actual option tree

for(auto& options_shortcut : flat_filter<OptionsShortcut>(pattern)) {

std::vector<Option> doc_options = parse_defaults(doc);

// set(doc_options) - set(pattern_options)

UniqueOptions uniq_doc_options;

for(auto const& opt : doc_options) {

if (uniq_pattern_options.count(&opt))

continue;

uniq_doc_options.insert(&opt);

}

// turn into shared_ptr's and set as children

PatternList children;

std::transform(uniq_doc_options.begin(), uniq_doc_options.end(),

std::back_inserter(children), [](Option const* opt) {

return std::make_shared<Option>(*opt);

});

options_shortcut->setChildren(std::move(children));

}

return { std::move(pattern), std::move(options) };