Terminating positional arguments in subcommands

[lrowe]

My program wraps other programs and I need to parse arbitrary name and args for the other programs. For a single command this is easy since you can just use a positional separator:

prog --conflicting -- other other-arg --conflicting

However I'm stuck trying to achieve this with subcommands. I would like to support:

prog sub1 --sub1-conflicting other1 sub-conflicting --sub1-conflicting ++ sub-conflicting -- other2

However this seems to capture all of other1 sub-conflicting --sub1-conflicting ++ sub-conflicting -- other2 in sub1's positionals.

I tried adding check(!CLI::IsMember({"++"})) to the positional option and enabling validate_positionals() on the subcommand but this gives:

The following arguments were not expected: ++ sub-conflicting -- other2

[lrowe]

Adding a subcommand named ++ seems to be a workaround:

#include <CLI/CLI.hpp>
#include <iostream>
#include <string>

int main(int argc, const char *argv[]) {

    int value{0};
    CLI::App app{"Test App"};
    app.add_option("-v", value, "value");
    app.add_subcommand("++", "")->silent()->group("")->fallthrough();

    std::string program1;
    std::vector<std::string> args1;
    auto &sub1 = *app.add_subcommand("sub1", "");
    sub1.positionals_at_end();
	sub1.validate_positionals();
    sub1.add_flag("--foo", program1);
    sub1.add_option("program", program1, "program");
    sub1.add_option("args", args1, "args")->check(!CLI::IsMember({"++"}));

    std::string program2;
    std::vector<std::string> args2;
    auto &sub2 = *app.add_subcommand("sub2", "");
    sub2.positionals_at_end();
	sub2.validate_positionals();
    sub2.add_option("program", program2, "program");
    sub2.add_option("args", args2, "args")->check(!CLI::IsMember({"++"}));

    CLI11_PARSE(app, argc, argv);

    std::cout << "value=" << value << '\n';
    std::cout << (sub1["--foo"]->as<bool>() ? "sub1 (--foo): " : "sub1: ") << program1 << " ";
    for(const auto &aarg : args1) {
        std::cout << aarg << " ";
    }
    std::cout << '\n';

    std::cout << "sub2: " << program2 << " ";
    for(const auto &aarg : args2) {
        std::cout << aarg << " ";
    }
    std::cout << '\n';
}

$ examples/myexample sub1 --foo other1 --foo --bar sub2 ++ sub2 arg1 ++ -v 1
value=1
sub1 (--foo): other1 --foo --bar sub2 
sub2: arg1 

[andry81]

I am not familiar with this cli, but in the Linux world everything which does not start by a dash is a positional argument.

[lrowe]

Sorry, I don’t understand your point here. I’m building a Linux program that runs other Linux programs so I need to specify multiple sets of child programs with their positional arguments.

[trapexit]

It may simply be easier for you to do it manually. As for how to split from a style perspective there is some prior art here: https://skarnet.org/software/execline/el_semicolon.html

[phlptp]

lets see if I understand correctly
you want

command --arg1 --arg2 value  <command> <command args...> -- <command2> <command2 args...>

[phlptp]

assuming command can be anything

CLI::App app{"Test App"};
std::vector<std::string> parameters;
std::vector<std::pair<std::string, std::vector<std::string>>> param_list;   
app.add_option("parameters", parameters, "value");

app.positionals_at_end();
CLI11_PARSE(app, argc, argv);
bool new_command{ true };
for (const auto& param : parameters) {
    if (new_command) {
        param_list.emplace_back(param, std::vector<std::string>{});
        new_command = false;
    } else {
        if(param == "--") {
            new_command = true;
        } else {
            param_list.back().second.push_back(param);
        }
    }
}

then basically anything after the arguments for your program itself gets put into a vector of strings.
Then when done you parse it into a structure with the command and arguments and process in a loop how you see fit.

[lrowe]

Thanks! In the end I decided to stick with the subcommand approach since it made for a nice configuration file:

[sub1]
foo = true
program = "other1"
args = ["--foo", "--bar"]

[sub2]
program = "other2"
args = [...]