kakoune/src/command_manager.cc

144 lines
4.4 KiB
C++

#include "command_manager.hh"
#include "utils.hh"
#include "assert.hh"
#include <algorithm>
namespace Kakoune
{
void CommandManager::register_command(const std::string& command_name, Command command,
const CommandCompleter& completer)
{
m_commands[command_name] = CommandAndCompleter { command, completer };
}
void CommandManager::register_command(const std::vector<std::string>& command_names, Command command,
const CommandCompleter& completer)
{
for (auto command_name : command_names)
register_command(command_name, command, completer);
}
typedef std::vector<std::pair<size_t, size_t>> TokenList;
static TokenList split(const std::string& line)
{
TokenList result;
size_t pos = 0;
while (pos != line.length())
{
while(line[pos] == ' ' and pos != line.length())
++pos;
size_t token_start = pos;
while((line[pos] != ' ' or line[pos-1] == '\\') and pos != line.length())
++pos;
result.push_back(std::make_pair(token_start, pos));
}
return result;
}
struct command_not_found : runtime_error
{
command_not_found(const std::string& command)
: runtime_error(command + " : no such command") {}
};
void CommandManager::execute(const std::string& command_line)
{
TokenList tokens = split(command_line);
if (tokens.empty())
return;
std::string command_name =
command_line.substr(tokens[0].first,
tokens[0].second - tokens[0].first);
auto command_it = m_commands.find(command_name);
if (command_it == m_commands.end())
throw command_not_found(command_name);
CommandParameters params;
for (auto it = tokens.begin() + 1; it != tokens.end(); ++it)
{
params.push_back(command_line.substr(it->first,
it->second - it->first));
}
command_it->second.command(params);
}
Completions CommandManager::complete(const std::string& command_line, size_t cursor_pos)
{
TokenList tokens = split(command_line);
size_t token_to_complete = -1;
for (size_t i = 0; i < tokens.size(); ++i)
{
if (tokens[i].first < cursor_pos and tokens[i].second >= cursor_pos)
{
token_to_complete = i;
break;
}
}
if (token_to_complete == 0) // command name completion
{
Completions result(tokens[0].first, cursor_pos);
std::string prefix = command_line.substr(tokens[0].first,
cursor_pos - tokens[0].first);
for (auto& command : m_commands)
{
if (command.first.substr(0, prefix.length()) == prefix)
result.candidates.push_back(command.first);
}
return result;
}
assert(not tokens.empty());
std::string command_name =
command_line.substr(tokens[0].first,
tokens[0].second - tokens[0].first);
auto command_it = m_commands.find(command_name);
if (command_it == m_commands.end() or not command_it->second.completer)
return Completions();
CommandParameters params;
for (auto it = tokens.begin() + 1; it != tokens.end(); ++it)
{
params.push_back(command_line.substr(it->first,
it->second - it->first));
}
Completions result(tokens[token_to_complete].first, cursor_pos);
size_t cursor_pos_in_token = cursor_pos - tokens[token_to_complete].first;
result.candidates = command_it->second.completer(params,
token_to_complete - 1,
cursor_pos_in_token);
return result;
}
CandidateList PerArgumentCommandCompleter::operator()(const CommandParameters& params,
size_t token_to_complete,
size_t pos_in_token) const
{
if (token_to_complete >= m_completers.size())
return CandidateList();
// it is possible to try to complete a new argument
assert(token_to_complete <= params.size());
const std::string& argument = token_to_complete < params.size() ?
params[token_to_complete] : std::string();
return m_completers[token_to_complete](argument, pos_in_token);
}
}