void AddCommand(std::string name, const Cmd::CmdBase& cmd, std::string description) {
if (commandsInitialized) {
GetCommandMap()[name] = {&cmd, ""};
AddCommandRPC(std::move(name), std::move(description));
} else {
GetCommandMap()[std::move(name)] = {&cmd, std::move(description)};
}
}
CompletionResult CompleteArgument(const Args& args, int argNum) {
CommandMap& commands = GetCommandMap();
commandLog.Debug("Completing argument %i of '%s'", argNum, args.ConcatArgs(0));
if (args.Argc() == 0) {
return {};
}
if (argNum > 0) {
const std::string& cmdName = args.Argv(0);
auto it = commands.find(cmdName);
if (it == commands.end()) {
return {};
}
std::string prefix;
if (argNum < args.Argc()) {
prefix = args.Argv(argNum);
}
return it->second.cmd->Complete(argNum, args, prefix);
} else {
return CompleteCommandNames(args.Argv(0));
}
}
void ExecuteCommand(Str::StringRef command, bool parseCvars, Environment* env) {
CommandMap& commands = GetCommandMap();
commandLog.Debug("Execing command '%s'", command);
if (not env) {
env = &defaultEnv;
}
std::string parsedString;
if (parseCvars) {
parsedString = SubstituteCvars(command);
command = parsedString;
}
Args args(command);
currentArgs = args;
if (args.Argc() == 0) {
return;
}
const std::string& cmdName = args.Argv(0);
auto it = commands.find(cmdName);
if (it != commands.end()) {
storedEnvironment = env;
it->second.cmd->Run(args);
return;
}
//TODO: remove that and add default command handlers or something
// send it as a server command if we are connected
// (cvars are expanded locally)
CL_ForwardCommandToServer(args.EscapedArgs(0).c_str());
}
BOOL CRenoCommandFrame::ExecuteCommand(const CString& command)
{
CStringPtrArray commandElements;
// Split the command into arguments
SplitCommand(command,commandElements);
// Check if null command passed in
if(!commandElements.GetCount())
return FALSE;
// Get our command map
const RENO_COMMAND* commandMap = GetCommandMap();
ASSERT(commandMap);
// Find the command that was called
for(ULONG i = 0; commandMap[i].name && commandMap[i].function; ++i)
if(!lstrcmpi(commandMap[i].name,commandElements[0]))
return (this->*commandMap[i].function)(commandElements); // TODO Maybe just always return TRUE since the passed in command name was valid
// Unknown command
PrintFormat(TEXT("* Unknown command: %s\r\n"),commandElements[0]);
return FALSE;
}
static void InitializeProxy() {
for (auto& record : GetCommandMap()) {
AddCommandRPC(record.first, std::move(record.second.description));
}
commandsInitialized = true;
}
void ChangeDescription(std::string name, std::string description) {
CommandMap& commands = GetCommandMap();
auto it = commands.find(name);
if (it != commands.end()) {
it->second.description = std::move(description);
}
}
CompletionResult CompleteCommandNames(Str::StringRef prefix) {
CommandMap& commands = GetCommandMap();
CompletionResult res;
for (auto& entry: commands) {
if (Str::IsIPrefix(prefix, entry.first)) {
res.push_back({entry.first, entry.second.description});
}
}
return res;
}
void AddCommand(std::string name, const CmdBase& cmd, std::string description) {
CommandMap& commands = GetCommandMap();
if (!IsValidCmdName(name)) {
commandLog.Warn(_("Cmd::AddCommand: Invalid command name '%s'"), name);
return;
}
if (!commands.insert({std::move(name), commandRecord_t{std::move(description), &cmd}}).second) {
commandLog.Warn(_("Cmd::AddCommand: %s already defined"), name);
}
}
void RemoveFlaggedCommands(int flag) {
CommandMap& commands = GetCommandMap();
for (auto it = commands.cbegin(); it != commands.cend();) {
const commandRecord_t& record = it->second;
if (record.cmd->GetFlags() & flag) {
commands.erase(it ++);
} else {
++ it;
}
}
}
void ExecuteSyscall(Util::Reader& reader, IPC::Channel& channel) {
IPC::HandleMsg<VM::ExecuteMsg>(channel, std::move(reader), [](std::string command) {
Cmd::Args args(command);
auto map = GetCommandMap();
auto it = map.find(args.Argv(0));
if (it == map.end()) {
return;
}
it->second.cmd->Run(args); });
}
void CompleteSyscall(Util::Reader& reader, IPC::Channel& channel) {
IPC::HandleMsg<VM::CompleteMsg>(
channel, std::move(reader), [](int argNum, std::string command, std::string prefix, Cmd::CompletionResult& res) {
Cmd::Args args(command);
auto map = GetCommandMap();
auto it = map.find(args.Argv(0));
if (it == map.end()) {
return;
}
res = std::move(it->second.cmd->Complete(argNum, args, prefix)); });
}
BOOL CRenoCommandFrame::CmdHelp(const CStringPtrArray& commandElements)
{
PrintFormat(TEXT("* Supported commands:\r\n"));
const RENO_COMMAND* commandMap = GetCommandMap();
ASSERT(commandMap);
ULONG i;
for(i = 0; commandMap[i].name && commandMap[i].function; ++i)
PrintFormat(TEXT("* %12s - %s\r\n"),commandMap[i].name + 1,commandMap[i].description);
PrintFormat(TEXT("* %d total command(s)\r\n"),i);
return TRUE;
}
BOOL CCommand::Run()
{
CmdMapEntry* pMap = GetCommandMap();
if (pMap == NULL)
return FALSE;
while(pMap->lpCmd != NULL && pMap->pf != NULL)
{
if (lstrcmpi(pMap->lpCmd , GetCmd()) == 0) {
_XTrace(_T("'%s' Will run\n"), pMap->lpCmd);
return (this->*pMap->pf)();
}
pMap ++;
}
return FALSE;
}
bool CommandExists(const std::string& name) {
CommandMap& commands = GetCommandMap();
return commands.find(name) != commands.end();
}
void RemoveCommand(const std::string& name) {
CommandMap& commands = GetCommandMap();
commands.erase(name);
}
void RemoveCommand(const std::string& name) {
GetCommandMap().erase(name);
VM::SendMsg<VM::RemoveCommandMsg>(name);
}
