forked from lix-project/lix
jade
ac78c1dcd5
This is because a dynamic_cast<nix::RootArgs *> of a (n-e-j) MyArgs
returns nullptr even though MyArgs has virtual nix::RootArgs as a
parent.
class MyArgs : virtual public nix::MixEvalArgs,
virtual public nix::MixCommonArgs,
virtual nix::RootArgs { ... };
So this should work right?? But it does not. We found out that it's
caused by -fvisibility=hidden in n-e-j, but honestly this code was bad
anyway.
The trivial solution is to simply stop relying on RTTI working properly
here, which is probably better OO architecture anyway. However, I am not
100% confident *this* is sound, since we have this horrible hierarchy:
Args (defines getRoot)
/ | \
RootArgs MixCommonArgs MixEvalArgs
(overrides)
I am not confident that this is guaranteed to resolve from Args always
in the case of this override.
Assertion failed: (res), function getRoot, file src/libutil/args.cc, line 67.
6MyArgsProcess 60503 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = hit program assert
frame #4: 0x0000000100b1a41c liblixutil.dylib`nix::Args::processArgs(std::__1::list<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>>> const&, bool) [inlined] nix::Args::getRoot(this=0x00000001000d0688) at args.cc:67:5 [opt]
64 std::cout << typeid(*p).name();
65
66 auto * res = dynamic_cast<RootArgs *>(p);
-> 67 assert(res);
68 return *res;
69 }
70
Target 0: (nix-eval-jobs) stopped.
(lldb) p this
(MyArgs *) 0x00000001000d0688
(lldb) p *this
(nix::Args) {
longFlags = size=180 { ... }
shortFlags = size=4 { ... }
expectedArgs = size=1 { ... }
processedArgs = size=0 {}
hiddenCategories = size=1 {
[0] = "Options to override configuration settings"
}
parent = nullptr
}
We also found that if we did this:
class [[gnu::visibility("default")]] RootArgs : virtual public Args
it would work properly (???!). This is of course, very strange, because
objdump -Ct output on liblixexpr.dylib is identical both with and
without it.
Possibly related: https://www.qt.io/blog/quality-assurance/one-way-dynamic_cast-across-library-boundaries-can-fail-and-how-to-fix-it
Fixes: lix-project/nix-eval-jobs#2
Change-Id: I6b9ed968ed56420a9c4d2dffd18999d78c2761bd
410 lines
10 KiB
C++
410 lines
10 KiB
C++
#pragma once
|
||
///@file
|
||
|
||
#include "experimental-features.hh"
|
||
#include "types.hh"
|
||
#include <functional>
|
||
#include <map>
|
||
#include <memory>
|
||
#include <limits>
|
||
|
||
#include <nlohmann/json_fwd.hpp>
|
||
#include <optional>
|
||
#include <set>
|
||
|
||
|
||
namespace nix {
|
||
|
||
enum HashType : char;
|
||
|
||
class MultiCommand;
|
||
|
||
class RootArgs;
|
||
|
||
class AddCompletions;
|
||
|
||
class Args
|
||
{
|
||
public:
|
||
|
||
/**
|
||
* Return a short one-line description of the command.
|
||
*/
|
||
virtual std::string description() { return ""; }
|
||
|
||
virtual bool forceImpureByDefault() { return false; }
|
||
|
||
/**
|
||
* Return documentation about this command, in Markdown format.
|
||
*/
|
||
virtual std::string doc() { return ""; }
|
||
|
||
protected:
|
||
|
||
/**
|
||
* The largest `size_t` is used to indicate the "any" arity, for
|
||
* handlers/flags/arguments that accept an arbitrary number of
|
||
* arguments.
|
||
*/
|
||
static const size_t ArityAny = std::numeric_limits<size_t>::max();
|
||
|
||
/**
|
||
* Arguments (flags/options and positional) have a "handler" which is
|
||
* caused when the argument is parsed. The handler has an arbitrary side
|
||
* effect, including possible affect further command-line parsing.
|
||
*
|
||
* There are many constructors in order to support many shorthand
|
||
* initializations, and this is used a lot.
|
||
*/
|
||
struct Handler
|
||
{
|
||
std::function<void(std::vector<std::string>)> fun;
|
||
size_t arity;
|
||
|
||
Handler() {}
|
||
|
||
Handler(std::function<void(std::vector<std::string>)> && fun)
|
||
: fun(std::move(fun))
|
||
, arity(ArityAny)
|
||
{ }
|
||
|
||
Handler(std::function<void()> && handler)
|
||
: fun([handler{std::move(handler)}](std::vector<std::string>) { handler(); })
|
||
, arity(0)
|
||
{ }
|
||
|
||
Handler(std::function<void(std::string)> && handler)
|
||
: fun([handler{std::move(handler)}](std::vector<std::string> ss) {
|
||
handler(std::move(ss[0]));
|
||
})
|
||
, arity(1)
|
||
{ }
|
||
|
||
Handler(std::function<void(std::string, std::string)> && handler)
|
||
: fun([handler{std::move(handler)}](std::vector<std::string> ss) {
|
||
handler(std::move(ss[0]), std::move(ss[1]));
|
||
})
|
||
, arity(2)
|
||
{ }
|
||
|
||
Handler(std::vector<std::string> * dest)
|
||
: fun([=](std::vector<std::string> ss) { *dest = ss; })
|
||
, arity(ArityAny)
|
||
{ }
|
||
|
||
Handler(std::string * dest)
|
||
: fun([=](std::vector<std::string> ss) { *dest = ss[0]; })
|
||
, arity(1)
|
||
{ }
|
||
|
||
Handler(std::optional<std::string> * dest)
|
||
: fun([=](std::vector<std::string> ss) { *dest = ss[0]; })
|
||
, arity(1)
|
||
{ }
|
||
|
||
template<class T>
|
||
Handler(T * dest, const T & val)
|
||
: fun([=](std::vector<std::string> ss) { *dest = val; })
|
||
, arity(0)
|
||
{ }
|
||
|
||
template<class I>
|
||
Handler(I * dest)
|
||
: fun([=](std::vector<std::string> ss) {
|
||
*dest = string2IntWithUnitPrefix<I>(ss[0]);
|
||
})
|
||
, arity(1)
|
||
{ }
|
||
|
||
template<class I>
|
||
Handler(std::optional<I> * dest)
|
||
: fun([=](std::vector<std::string> ss) {
|
||
*dest = string2IntWithUnitPrefix<I>(ss[0]);
|
||
})
|
||
, arity(1)
|
||
{ }
|
||
};
|
||
|
||
/**
|
||
* The basic function type of the completion callback.
|
||
*
|
||
* Used to define `CompleterClosure` and some common case completers
|
||
* that individual flags/arguments can use.
|
||
*
|
||
* The `AddCompletions` that is passed is an interface to the state
|
||
* stored as part of the root command
|
||
*/
|
||
typedef void CompleterFun(AddCompletions &, size_t, std::string_view);
|
||
|
||
/**
|
||
* The closure type of the completion callback.
|
||
*
|
||
* This is what is actually stored as part of each Flag / Expected
|
||
* Arg.
|
||
*/
|
||
typedef std::function<CompleterFun> CompleterClosure;
|
||
|
||
/**
|
||
* Description of flags / options
|
||
*
|
||
* These are arguments like `-s` or `--long` that can (mostly)
|
||
* appear in any order.
|
||
*/
|
||
struct Flag
|
||
{
|
||
typedef std::shared_ptr<Flag> ptr;
|
||
|
||
std::string longName;
|
||
std::set<std::string> aliases;
|
||
char shortName = 0;
|
||
std::string description;
|
||
std::string category;
|
||
Strings labels;
|
||
Handler handler;
|
||
CompleterClosure completer;
|
||
|
||
std::optional<ExperimentalFeature> experimentalFeature;
|
||
|
||
static Flag mkHashTypeFlag(std::string && longName, HashType * ht);
|
||
static Flag mkHashTypeOptFlag(std::string && longName, std::optional<HashType> * oht);
|
||
};
|
||
|
||
/**
|
||
* Index of all registered "long" flag descriptions (flags like
|
||
* `--long`).
|
||
*/
|
||
std::map<std::string, Flag::ptr> longFlags;
|
||
|
||
/**
|
||
* Index of all registered "short" flag descriptions (flags like
|
||
* `-s`).
|
||
*/
|
||
std::map<char, Flag::ptr> shortFlags;
|
||
|
||
/**
|
||
* Process a single flag and its arguments, pulling from an iterator
|
||
* of raw CLI args as needed.
|
||
*/
|
||
virtual bool processFlag(Strings::iterator & pos, Strings::iterator end);
|
||
|
||
/**
|
||
* Description of positional arguments
|
||
*
|
||
* These are arguments that do not start with a `-`, and for which
|
||
* the order does matter.
|
||
*/
|
||
struct ExpectedArg
|
||
{
|
||
std::string label;
|
||
bool optional = false;
|
||
Handler handler;
|
||
CompleterClosure completer;
|
||
};
|
||
|
||
/**
|
||
* Queue of expected positional argument forms.
|
||
*
|
||
* Positional argument descriptions are inserted on the back.
|
||
*
|
||
* As positional arguments are passed, these are popped from the
|
||
* front, until there are hopefully none left as all args that were
|
||
* expected in fact were passed.
|
||
*/
|
||
std::list<ExpectedArg> expectedArgs;
|
||
/**
|
||
* List of processed positional argument forms.
|
||
*
|
||
* All items removed from `expectedArgs` are added here. After all
|
||
* arguments were processed, this list should be exactly the same as
|
||
* `expectedArgs` was before.
|
||
*
|
||
* This list is used to extend the lifetime of the argument forms.
|
||
* If this is not done, some closures that reference the command
|
||
* itself will segfault.
|
||
*/
|
||
std::list<ExpectedArg> processedArgs;
|
||
|
||
/**
|
||
* Process some positional arugments
|
||
*
|
||
* @param finish: We have parsed everything else, and these are the only
|
||
* arguments left. Used because we accumulate some "pending args" we might
|
||
* have left over.
|
||
*/
|
||
virtual bool processArgs(const Strings & args, bool finish);
|
||
|
||
virtual Strings::iterator rewriteArgs(Strings & args, Strings::iterator pos)
|
||
{ return pos; }
|
||
|
||
std::set<std::string> hiddenCategories;
|
||
|
||
/**
|
||
* Called after all command line flags before the first non-flag
|
||
* argument (if any) have been processed.
|
||
*/
|
||
virtual void initialFlagsProcessed() {}
|
||
|
||
/**
|
||
* Returns this Args as a RootArgs if it is one, or \ref std::nullopt otherwise.
|
||
*/
|
||
virtual std::optional<std::reference_wrapper<RootArgs>> asRootArgs() {
|
||
return std::nullopt;
|
||
}
|
||
|
||
public:
|
||
|
||
void addFlag(Flag && flag);
|
||
|
||
void removeFlag(const std::string & longName);
|
||
|
||
void expectArgs(ExpectedArg && arg)
|
||
{
|
||
expectedArgs.emplace_back(std::move(arg));
|
||
}
|
||
|
||
/**
|
||
* Expect a string argument.
|
||
*/
|
||
void expectArg(const std::string & label, std::string * dest, bool optional = false)
|
||
{
|
||
expectArgs({
|
||
.label = label,
|
||
.optional = optional,
|
||
.handler = {dest}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Expect 0 or more arguments.
|
||
*/
|
||
void expectArgs(const std::string & label, std::vector<std::string> * dest)
|
||
{
|
||
expectArgs({
|
||
.label = label,
|
||
.handler = {dest}
|
||
});
|
||
}
|
||
|
||
static CompleterFun completePath;
|
||
|
||
static CompleterFun completeDir;
|
||
|
||
virtual nlohmann::json toJSON();
|
||
|
||
friend class MultiCommand;
|
||
|
||
/**
|
||
* The parent command, used if this is a subcommand.
|
||
*
|
||
* Invariant: An Args with a null parent must also be a RootArgs
|
||
*
|
||
* \todo this would probably be better in the CommandClass.
|
||
* getRoot() could be an abstract method that peels off at most one
|
||
* layer before recuring.
|
||
*/
|
||
MultiCommand * parent = nullptr;
|
||
|
||
/**
|
||
* Traverse parent pointers until we find the \ref RootArgs "root
|
||
* arguments" object.
|
||
*/
|
||
RootArgs & getRoot();
|
||
};
|
||
|
||
/**
|
||
* A command is an argument parser that can be executed by calling its
|
||
* run() method.
|
||
*/
|
||
struct Command : virtual public Args
|
||
{
|
||
friend class MultiCommand;
|
||
|
||
virtual ~Command() { }
|
||
|
||
/**
|
||
* Entry point to the command
|
||
*/
|
||
virtual void run() = 0;
|
||
|
||
typedef int Category;
|
||
|
||
static constexpr Category catDefault = 0;
|
||
|
||
virtual std::optional<ExperimentalFeature> experimentalFeature ();
|
||
|
||
virtual Category category() { return catDefault; }
|
||
};
|
||
|
||
typedef std::map<std::string, std::function<ref<Command>()>> Commands;
|
||
|
||
/**
|
||
* An argument parser that supports multiple subcommands,
|
||
* i.e. ‘<command> <subcommand>’.
|
||
*/
|
||
class MultiCommand : virtual public Args
|
||
{
|
||
public:
|
||
Commands commands;
|
||
|
||
std::map<Command::Category, std::string> categories;
|
||
|
||
/**
|
||
* Selected command, if any.
|
||
*/
|
||
std::optional<std::pair<std::string, ref<Command>>> command;
|
||
|
||
MultiCommand(const Commands & commands);
|
||
|
||
bool processFlag(Strings::iterator & pos, Strings::iterator end) override;
|
||
|
||
bool processArgs(const Strings & args, bool finish) override;
|
||
|
||
nlohmann::json toJSON() override;
|
||
};
|
||
|
||
Strings argvToStrings(int argc, char * * argv);
|
||
|
||
struct Completion {
|
||
std::string completion;
|
||
std::string description;
|
||
|
||
bool operator<(const Completion & other) const;
|
||
};
|
||
|
||
/**
|
||
* The abstract interface for completions callbacks
|
||
*
|
||
* The idea is to restrict the callback so it can only add additional
|
||
* completions to the collection, or set the completion type. By making
|
||
* it go through this interface, the callback cannot make any other
|
||
* changes, or even view the completions / completion type that have
|
||
* been set so far.
|
||
*/
|
||
class AddCompletions
|
||
{
|
||
public:
|
||
|
||
/**
|
||
* The type of completion we are collecting.
|
||
*/
|
||
enum class Type {
|
||
Normal,
|
||
Filenames,
|
||
Attrs,
|
||
};
|
||
|
||
/**
|
||
* Set the type of the completions being collected
|
||
*
|
||
* \todo it should not be possible to change the type after it has been set.
|
||
*/
|
||
virtual void setType(Type type) = 0;
|
||
|
||
/**
|
||
* Add a single completion to the collection
|
||
*/
|
||
virtual void add(std::string completion, std::string description = "") = 0;
|
||
};
|
||
|
||
}
|