2012-05-07 07:13:34 +04:00
|
|
|
#include "commands.hh"
|
|
|
|
|
2013-04-09 21:39:03 +04:00
|
|
|
#include "buffer.hh"
|
2012-05-07 07:13:34 +04:00
|
|
|
#include "buffer_manager.hh"
|
2014-04-30 00:37:11 +04:00
|
|
|
#include "buffer_utils.hh"
|
2014-03-31 23:07:35 +04:00
|
|
|
#include "client.hh"
|
2013-04-09 21:39:03 +04:00
|
|
|
#include "client_manager.hh"
|
|
|
|
#include "command_manager.hh"
|
|
|
|
#include "completion.hh"
|
2014-12-23 16:34:21 +03:00
|
|
|
#include "containers.hh"
|
2012-05-07 07:13:34 +04:00
|
|
|
#include "context.hh"
|
2013-04-09 21:39:03 +04:00
|
|
|
#include "event_manager.hh"
|
2014-07-11 03:27:04 +04:00
|
|
|
#include "face_registry.hh"
|
2012-05-07 07:13:34 +04:00
|
|
|
#include "file.hh"
|
2017-03-06 22:47:26 +03:00
|
|
|
#include "hash_map.hh"
|
2012-11-23 16:40:20 +04:00
|
|
|
#include "highlighter.hh"
|
2013-03-29 22:31:06 +04:00
|
|
|
#include "highlighters.hh"
|
2013-04-09 21:39:03 +04:00
|
|
|
#include "option_manager.hh"
|
|
|
|
#include "option_types.hh"
|
|
|
|
#include "parameters_parser.hh"
|
2016-02-09 23:04:23 +03:00
|
|
|
#include "ranked_match.hh"
|
2012-05-07 07:13:34 +04:00
|
|
|
#include "register_manager.hh"
|
2016-04-01 03:27:23 +03:00
|
|
|
#include "insert_completer.hh"
|
2014-03-31 23:07:35 +04:00
|
|
|
#include "remote.hh"
|
2016-11-29 02:53:50 +03:00
|
|
|
#include "regex.hh"
|
2012-05-29 09:22:18 +04:00
|
|
|
#include "shell_manager.hh"
|
2013-04-09 21:39:03 +04:00
|
|
|
#include "string.hh"
|
2016-11-29 22:53:11 +03:00
|
|
|
#include "user_interface.hh"
|
2013-04-09 21:39:03 +04:00
|
|
|
#include "window.hh"
|
2012-05-07 07:13:34 +04:00
|
|
|
|
2016-10-11 01:44:18 +03:00
|
|
|
#include <functional>
|
2017-01-09 01:30:15 +03:00
|
|
|
#include <utility>
|
2016-10-11 01:44:18 +03:00
|
|
|
|
2012-08-29 02:17:37 +04:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <fcntl.h>
|
2014-10-13 16:12:33 +04:00
|
|
|
#include <unistd.h>
|
2015-01-12 22:55:58 +03:00
|
|
|
|
2015-01-14 22:16:32 +03:00
|
|
|
#if defined(__GLIBC__) || defined(__CYGWIN__)
|
2015-01-11 22:28:03 +03:00
|
|
|
#include <malloc.h>
|
2015-01-12 22:55:58 +03:00
|
|
|
#endif
|
2012-08-29 02:17:37 +04:00
|
|
|
|
2012-05-07 07:13:34 +04:00
|
|
|
namespace Kakoune
|
|
|
|
{
|
|
|
|
|
|
|
|
namespace
|
|
|
|
{
|
|
|
|
|
2017-03-08 22:33:25 +03:00
|
|
|
Buffer* open_fifo(StringView name, StringView filename, Buffer::Flags flags, bool scroll)
|
2012-08-29 02:17:37 +04:00
|
|
|
{
|
2014-11-03 16:55:07 +03:00
|
|
|
int fd = open(parse_filename(filename).c_str(), O_RDONLY | O_NONBLOCK);
|
2013-01-30 22:08:16 +04:00
|
|
|
fcntl(fd, F_SETFD, FD_CLOEXEC);
|
2012-08-29 02:17:37 +04:00
|
|
|
if (fd < 0)
|
2015-06-01 23:15:59 +03:00
|
|
|
throw runtime_error(format("unable to open '{}'", filename));
|
2013-03-22 21:39:00 +04:00
|
|
|
|
2017-03-08 22:33:25 +03:00
|
|
|
return create_fifo_buffer(name.str(), fd, flags, scroll);
|
2012-08-29 02:17:37 +04:00
|
|
|
}
|
|
|
|
|
2016-09-18 18:07:00 +03:00
|
|
|
template<typename... Completers> struct PerArgumentCommandCompleter;
|
|
|
|
|
|
|
|
template<> struct PerArgumentCommandCompleter<>
|
|
|
|
{
|
|
|
|
Completions operator()(const Context&, CompletionFlags, CommandParameters,
|
|
|
|
size_t, ByteCount) const { return {}; }
|
|
|
|
};
|
|
|
|
|
|
|
|
template<typename Completer, typename... Rest>
|
|
|
|
struct PerArgumentCommandCompleter<Completer, Rest...> : PerArgumentCommandCompleter<Rest...>
|
|
|
|
{
|
|
|
|
template<typename C, typename... R,
|
2017-07-19 09:55:24 +03:00
|
|
|
typename = std::enable_if_t<not std::is_base_of<PerArgumentCommandCompleter<>,
|
|
|
|
std::remove_reference_t<C>>::value>>
|
2016-09-18 18:07:00 +03:00
|
|
|
PerArgumentCommandCompleter(C&& completer, R&&... rest)
|
|
|
|
: PerArgumentCommandCompleter<Rest...>(std::forward<R>(rest)...),
|
|
|
|
m_completer(std::forward<C>(completer)) {}
|
|
|
|
|
|
|
|
Completions operator()(const Context& context, CompletionFlags flags,
|
|
|
|
CommandParameters params, size_t token_to_complete,
|
|
|
|
ByteCount pos_in_token) const
|
|
|
|
{
|
|
|
|
if (token_to_complete == 0)
|
|
|
|
{
|
|
|
|
const String& arg = token_to_complete < params.size() ?
|
|
|
|
params[token_to_complete] : String();
|
|
|
|
return m_completer(context, flags, arg, pos_in_token);
|
|
|
|
}
|
|
|
|
return PerArgumentCommandCompleter<Rest...>::operator()(
|
2016-11-20 14:16:34 +03:00
|
|
|
context, flags, params.subrange(1),
|
|
|
|
token_to_complete-1, pos_in_token);
|
2016-09-18 18:07:00 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
Completer m_completer;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<typename... Completers>
|
2017-05-11 01:22:24 +03:00
|
|
|
PerArgumentCommandCompleter<std::decay_t<Completers>...>
|
2016-09-18 18:07:00 +03:00
|
|
|
make_completer(Completers&&... completers)
|
|
|
|
{
|
|
|
|
return {std::forward<Completers>(completers)...};
|
|
|
|
}
|
|
|
|
|
|
|
|
auto filename_completer = make_completer(
|
|
|
|
[](const Context& context, CompletionFlags flags, const String& prefix, ByteCount cursor_pos)
|
|
|
|
{ return Completions{ 0_byte, cursor_pos,
|
|
|
|
complete_filename(prefix,
|
|
|
|
context.options()["ignored_files"].get<Regex>(),
|
2016-10-13 21:46:09 +03:00
|
|
|
cursor_pos, FilenameFlags::Expand) }; });
|
2016-09-18 18:07:00 +03:00
|
|
|
|
|
|
|
static Completions complete_buffer_name(const Context& context, CompletionFlags flags,
|
|
|
|
StringView prefix, ByteCount cursor_pos)
|
2014-12-23 20:42:17 +03:00
|
|
|
{
|
2016-03-02 16:51:50 +03:00
|
|
|
struct RankedMatchAndBuffer : RankedMatch
|
|
|
|
{
|
2017-01-09 01:30:15 +03:00
|
|
|
RankedMatchAndBuffer(RankedMatch m, const Buffer* b)
|
|
|
|
: RankedMatch{std::move(m)}, buffer{b} {}
|
2016-02-10 16:33:49 +03:00
|
|
|
|
2016-03-02 16:51:50 +03:00
|
|
|
using RankedMatch::operator==;
|
|
|
|
using RankedMatch::operator<;
|
|
|
|
|
|
|
|
const Buffer* buffer;
|
|
|
|
};
|
|
|
|
|
2016-09-18 18:07:00 +03:00
|
|
|
StringView query = prefix.substr(0, cursor_pos);
|
2016-03-02 16:51:50 +03:00
|
|
|
Vector<RankedMatchAndBuffer> filename_matches;
|
|
|
|
Vector<RankedMatchAndBuffer> matches;
|
|
|
|
for (const auto& buffer : BufferManager::instance())
|
|
|
|
{
|
|
|
|
StringView bufname = buffer->display_name();
|
|
|
|
if (buffer->flags() & Buffer::Flags::File)
|
|
|
|
{
|
|
|
|
if (RankedMatch match{split_path(bufname).second, query})
|
|
|
|
{
|
|
|
|
filename_matches.emplace_back(match, buffer.get());
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (RankedMatch match{bufname, query})
|
|
|
|
matches.emplace_back(match, buffer.get());
|
|
|
|
}
|
|
|
|
std::sort(filename_matches.begin(), filename_matches.end());
|
|
|
|
std::sort(matches.begin(), matches.end());
|
|
|
|
|
|
|
|
CandidateList res;
|
|
|
|
for (auto& match : filename_matches)
|
|
|
|
res.push_back(match.buffer->display_name());
|
|
|
|
for (auto& match : matches)
|
|
|
|
res.push_back(match.buffer->display_name());
|
|
|
|
|
2016-09-18 18:07:00 +03:00
|
|
|
return { 0, cursor_pos, res };
|
2014-12-23 20:42:17 +03:00
|
|
|
}
|
|
|
|
|
2016-09-20 01:26:52 +03:00
|
|
|
auto buffer_completer = make_completer(complete_buffer_name);
|
2014-02-14 06:21:06 +04:00
|
|
|
|
2015-03-14 20:30:34 +03:00
|
|
|
const ParameterDesc no_params{ {}, ParameterDesc::Flags::None, 0, 0 };
|
2017-02-27 23:44:38 +03:00
|
|
|
const ParameterDesc single_param{ {}, ParameterDesc::Flags::None, 1, 1 };
|
|
|
|
const ParameterDesc single_optional_param{ {}, ParameterDesc::Flags::None, 0, 1 };
|
2014-02-08 05:02:58 +04:00
|
|
|
|
2014-10-30 02:22:54 +03:00
|
|
|
static constexpr auto scopes = { "global", "buffer", "window" };
|
|
|
|
|
2016-09-18 18:27:34 +03:00
|
|
|
static Completions complete_scope(const Context&, CompletionFlags,
|
|
|
|
const String& prefix, ByteCount cursor_pos)
|
|
|
|
{
|
|
|
|
return { 0_byte, cursor_pos, complete(prefix, cursor_pos, scopes) };
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static Completions complete_command_name(const Context& context, CompletionFlags,
|
|
|
|
const String& prefix, ByteCount cursor_pos)
|
|
|
|
{
|
|
|
|
return CommandManager::instance().complete_command_name(
|
2017-06-29 09:43:20 +03:00
|
|
|
context, prefix.substr(0, cursor_pos));
|
2016-09-18 18:27:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-11-23 22:49:59 +03:00
|
|
|
Scope* get_scope_ifp(StringView scope, const Context& context)
|
2014-10-30 17:00:42 +03:00
|
|
|
{
|
|
|
|
if (prefix_match("global", scope))
|
|
|
|
return &GlobalScope::instance();
|
|
|
|
else if (prefix_match("buffer", scope))
|
|
|
|
return &context.buffer();
|
|
|
|
else if (prefix_match("window", scope))
|
|
|
|
return &context.window();
|
|
|
|
else if (prefix_match(scope, "buffer="))
|
|
|
|
return &BufferManager::instance().get_buffer(scope.substr(7_byte));
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2014-11-23 22:49:59 +03:00
|
|
|
Scope& get_scope(StringView scope, const Context& context)
|
2014-10-30 17:00:42 +03:00
|
|
|
{
|
|
|
|
if (auto s = get_scope_ifp(scope, context))
|
|
|
|
return *s;
|
2015-06-01 23:15:59 +03:00
|
|
|
throw runtime_error(format("error: no such scope '{}'", scope));
|
2014-10-30 17:00:42 +03:00
|
|
|
}
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
struct CommandDesc
|
|
|
|
{
|
|
|
|
const char* name;
|
|
|
|
const char* alias;
|
|
|
|
const char* docstring;
|
|
|
|
ParameterDesc params;
|
|
|
|
CommandFlags flags;
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper helper;
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandCompleter completer;
|
2015-10-22 15:59:23 +03:00
|
|
|
void (*func)(const ParametersParser&, Context&, const ShellContext&);
|
2014-02-14 06:21:06 +04:00
|
|
|
};
|
2014-02-12 13:02:09 +04:00
|
|
|
|
2012-05-07 07:13:34 +04:00
|
|
|
template<bool force_reload>
|
2015-10-22 15:59:23 +03:00
|
|
|
void edit(const ParametersParser& parser, Context& context, const ShellContext&)
|
2012-05-07 07:13:34 +04:00
|
|
|
{
|
2014-07-08 22:24:51 +04:00
|
|
|
if (parser.positional_count() == 0 and not force_reload)
|
|
|
|
throw wrong_argument_count();
|
|
|
|
|
|
|
|
auto& name = parser.positional_count() > 0 ? parser[0]
|
|
|
|
: context.buffer().name();
|
2015-04-23 22:15:17 +03:00
|
|
|
auto& buffer_manager = BufferManager::instance();
|
2012-05-07 07:13:34 +04:00
|
|
|
|
2015-10-16 03:33:17 +03:00
|
|
|
Buffer* buffer = buffer_manager.get_buffer_ifp(name);
|
2016-11-14 16:59:33 +03:00
|
|
|
const bool no_hooks = context.hooks_disabled();
|
2017-03-08 22:33:25 +03:00
|
|
|
const auto flags = (no_hooks ? Buffer::Flags::NoHooks : Buffer::Flags::None) |
|
|
|
|
(parser.get_switch("debug") ? Buffer::Flags::Debug : Buffer::Flags::None);
|
2015-10-16 15:58:56 +03:00
|
|
|
|
2015-10-16 03:33:17 +03:00
|
|
|
if (force_reload and buffer and buffer->flags() & Buffer::Flags::File)
|
|
|
|
reload_file_buffer(*buffer);
|
|
|
|
else
|
2012-08-08 01:20:11 +04:00
|
|
|
{
|
2015-03-14 22:16:46 +03:00
|
|
|
if (parser.get_switch("scratch"))
|
2013-04-12 01:09:17 +04:00
|
|
|
{
|
2016-05-17 21:41:24 +03:00
|
|
|
if (buffer and (force_reload or buffer->flags() != Buffer::Flags::None))
|
|
|
|
{
|
|
|
|
buffer_manager.delete_buffer(*buffer);
|
|
|
|
buffer = nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (not buffer)
|
2016-11-14 16:59:33 +03:00
|
|
|
buffer = buffer_manager.create_buffer(name, flags);
|
2013-04-12 01:09:17 +04:00
|
|
|
}
|
2015-03-14 22:16:46 +03:00
|
|
|
else if (auto fifo = parser.get_switch("fifo"))
|
2017-03-08 22:33:25 +03:00
|
|
|
buffer = open_fifo(name, *fifo, flags, (bool)parser.get_switch("scroll"));
|
2015-10-16 03:33:17 +03:00
|
|
|
else if (not buffer)
|
2014-08-01 01:10:01 +04:00
|
|
|
{
|
2016-11-14 16:59:33 +03:00
|
|
|
buffer = parser.get_switch("existing") ? open_file_buffer(name, flags)
|
|
|
|
: open_or_create_file_buffer(name, flags);
|
2015-10-16 15:58:56 +03:00
|
|
|
if (buffer->flags() & Buffer::Flags::New)
|
2015-06-01 23:15:59 +03:00
|
|
|
context.print_status({ format("new file '{}'", name),
|
|
|
|
get_face("StatusLine") });
|
2014-08-01 01:10:01 +04:00
|
|
|
}
|
2016-11-14 16:59:33 +03:00
|
|
|
|
|
|
|
buffer->flags() &= ~Buffer::Flags::NoHooks;
|
2012-08-08 01:20:11 +04:00
|
|
|
}
|
2012-05-07 07:13:34 +04:00
|
|
|
|
2013-03-27 17:27:12 +04:00
|
|
|
const size_t param_count = parser.positional_count();
|
2012-11-12 22:59:25 +04:00
|
|
|
if (buffer != &context.buffer() or param_count > 1)
|
|
|
|
context.push_jump();
|
|
|
|
|
2012-11-07 17:04:47 +04:00
|
|
|
if (buffer != &context.buffer())
|
2013-12-21 00:10:08 +04:00
|
|
|
context.change_buffer(*buffer);
|
2012-05-07 07:13:34 +04:00
|
|
|
|
2013-08-28 22:05:01 +04:00
|
|
|
if (param_count > 1 and not parser[1].empty())
|
2012-05-07 07:13:34 +04:00
|
|
|
{
|
2013-05-17 16:09:42 +04:00
|
|
|
int line = std::max(0, str_to_int(parser[1]) - 1);
|
2013-08-28 22:05:01 +04:00
|
|
|
int column = param_count > 2 and not parser[2].empty() ?
|
2013-05-17 16:09:42 +04:00
|
|
|
std::max(0, str_to_int(parser[2]) - 1) : 0;
|
2012-05-07 07:13:34 +04:00
|
|
|
|
2014-05-13 02:25:15 +04:00
|
|
|
auto& buffer = context.buffer();
|
2015-04-19 17:12:16 +03:00
|
|
|
context.selections_write_only() = { buffer, buffer.clamp({ line, column }) };
|
2012-11-07 17:04:47 +04:00
|
|
|
if (context.has_window())
|
2014-01-28 23:05:49 +04:00
|
|
|
context.window().center_line(context.selections().main().cursor().line);
|
2012-05-07 07:13:34 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
ParameterDesc edit_params{
|
2015-03-14 20:30:34 +03:00
|
|
|
{ { "existing", { false, "fail if the file does not exists, do not open a new file" } },
|
|
|
|
{ "scratch", { false, "create a scratch buffer, not linked to a file" } },
|
2017-05-10 13:17:11 +03:00
|
|
|
{ "debug", { false, "create buffer as debug output" } },
|
2015-03-14 20:30:34 +03:00
|
|
|
{ "fifo", { true, "create a buffer reading its content from a named fifo" } },
|
|
|
|
{ "scroll", { false, "place the initial cursor so that the fifo will scroll to show new data" } } },
|
|
|
|
ParameterDesc::Flags::None, 0, 3
|
2014-02-14 06:21:06 +04:00
|
|
|
};
|
2015-12-28 02:07:06 +03:00
|
|
|
const CommandDesc edit_cmd = {
|
|
|
|
"edit",
|
|
|
|
"e",
|
2015-06-19 18:10:16 +03:00
|
|
|
"edit [<switches>] <filename> [<line> [<column>]]: open the given filename in a buffer",
|
2014-02-14 06:21:06 +04:00
|
|
|
edit_params,
|
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
filename_completer,
|
|
|
|
edit<false>
|
2014-02-08 05:02:58 +04:00
|
|
|
};
|
2012-05-07 07:13:34 +04:00
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc force_edit_cmd = {
|
|
|
|
"edit!",
|
|
|
|
"e!",
|
2015-06-19 18:10:16 +03:00
|
|
|
"edit! [<switches>] <filename> [<line> [<column>]]: open the given filename in a buffer, "
|
2015-03-14 15:17:43 +03:00
|
|
|
"force reload if needed",
|
2014-02-14 06:21:06 +04:00
|
|
|
edit_params,
|
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
filename_completer,
|
|
|
|
edit<true>
|
|
|
|
};
|
2014-02-12 13:02:09 +04:00
|
|
|
|
2017-04-19 18:47:07 +03:00
|
|
|
template<bool force = false>
|
2015-10-22 15:59:23 +03:00
|
|
|
void write_buffer(const ParametersParser& parser, Context& context, const ShellContext&)
|
2014-02-08 05:02:58 +04:00
|
|
|
{
|
2012-08-11 13:48:54 +04:00
|
|
|
Buffer& buffer = context.buffer();
|
2012-08-08 01:20:53 +04:00
|
|
|
|
2014-02-08 05:02:58 +04:00
|
|
|
if (parser.positional_count() == 0 and !(buffer.flags() & Buffer::Flags::File))
|
2012-11-20 22:47:56 +04:00
|
|
|
throw runtime_error("cannot write a non file buffer without a filename");
|
2012-08-08 01:20:53 +04:00
|
|
|
|
2016-07-20 20:45:50 +03:00
|
|
|
// if the buffer is in read-only mode and we try to save it directly
|
|
|
|
// or we try to write to it indirectly using e.g. a symlink, throw an error
|
|
|
|
if ((context.buffer().flags() & Buffer::Flags::ReadOnly)
|
2016-07-24 08:34:49 +03:00
|
|
|
and (parser.positional_count() == 0 or real_path(parser[0]) == buffer.name()))
|
2016-07-20 20:45:50 +03:00
|
|
|
throw runtime_error("cannot overwrite the buffer when in readonly mode");
|
|
|
|
|
2015-03-14 15:17:43 +03:00
|
|
|
auto filename = parser.positional_count() == 0 ?
|
2017-04-20 11:37:04 +03:00
|
|
|
buffer.name() : parse_filename(parser[0]);
|
2016-10-01 19:07:50 +03:00
|
|
|
|
|
|
|
context.hooks().run_hook("BufWritePre", filename, context);
|
2017-04-19 18:47:07 +03:00
|
|
|
write_buffer_to_file(buffer, filename, force);
|
2016-10-01 19:07:50 +03:00
|
|
|
context.hooks().run_hook("BufWritePost", filename, context);
|
2012-05-07 07:13:34 +04:00
|
|
|
}
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc write_cmd = {
|
|
|
|
"write",
|
|
|
|
"w",
|
2016-10-31 19:42:10 +03:00
|
|
|
"write [filename]: write the current buffer to its file "
|
2015-03-14 15:17:43 +03:00
|
|
|
"or to [filename] if specified",
|
2017-02-27 23:44:38 +03:00
|
|
|
single_optional_param,
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
filename_completer,
|
|
|
|
write_buffer,
|
2014-02-08 05:02:58 +04:00
|
|
|
};
|
2012-08-14 16:20:18 +04:00
|
|
|
|
2017-04-19 18:47:07 +03:00
|
|
|
const CommandDesc force_write_cmd = {
|
|
|
|
"write!",
|
|
|
|
"w!",
|
|
|
|
"write [filename]: write the current buffer to its file "
|
|
|
|
"or to [filename] if specified, even when the file is write protected",
|
|
|
|
single_optional_param,
|
|
|
|
CommandFlags::None,
|
|
|
|
CommandHelper{},
|
|
|
|
filename_completer,
|
|
|
|
write_buffer<true>,
|
|
|
|
};
|
|
|
|
|
2016-11-24 16:35:42 +03:00
|
|
|
void write_all_buffers(Context& context)
|
2014-07-01 12:56:11 +04:00
|
|
|
{
|
2016-11-24 02:51:16 +03:00
|
|
|
// Copy buffer list because hooks might be creating/deleting buffers
|
|
|
|
Vector<SafePtr<Buffer>> buffers;
|
2014-07-01 12:56:11 +04:00
|
|
|
for (auto& buffer : BufferManager::instance())
|
2016-11-24 02:51:16 +03:00
|
|
|
buffers.emplace_back(buffer.get());
|
|
|
|
|
|
|
|
for (auto& buffer : buffers)
|
2014-07-01 12:56:11 +04:00
|
|
|
{
|
2016-07-20 20:45:50 +03:00
|
|
|
if ((buffer->flags() & Buffer::Flags::File) and buffer->is_modified()
|
|
|
|
and !(buffer->flags() & Buffer::Flags::ReadOnly))
|
2016-10-01 19:07:50 +03:00
|
|
|
{
|
2016-11-24 16:35:42 +03:00
|
|
|
buffer->run_hook_in_own_context("BufWritePre", buffer->name(), context.name());
|
2014-07-01 12:56:11 +04:00
|
|
|
write_buffer_to_file(*buffer, buffer->name());
|
2016-11-24 16:35:42 +03:00
|
|
|
buffer->run_hook_in_own_context("BufWritePost", buffer->name(), context.name());
|
2016-10-01 19:07:50 +03:00
|
|
|
}
|
2014-07-01 12:56:11 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-15 16:49:06 +03:00
|
|
|
const CommandDesc write_all_cmd = {
|
2016-11-14 03:27:14 +03:00
|
|
|
"write-all",
|
2014-02-14 06:21:06 +04:00
|
|
|
"wa",
|
|
|
|
"write all buffers that are associated to a file",
|
|
|
|
no_params,
|
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandCompleter{},
|
2016-11-24 16:35:42 +03:00
|
|
|
[](const ParametersParser&, Context& context, const ShellContext&){ write_all_buffers(context); }
|
2014-02-14 06:21:06 +04:00
|
|
|
};
|
2014-02-12 13:02:09 +04:00
|
|
|
|
2016-04-29 23:58:04 +03:00
|
|
|
static void ensure_all_buffers_are_saved()
|
|
|
|
{
|
2016-11-24 02:31:17 +03:00
|
|
|
auto is_modified = [](const std::unique_ptr<Buffer>& buf) {
|
|
|
|
return (buf->flags() & Buffer::Flags::File) and buf->is_modified();
|
|
|
|
};
|
|
|
|
|
|
|
|
auto it = find_if(BufferManager::instance(), is_modified);
|
|
|
|
const auto end = BufferManager::instance().end();
|
|
|
|
if (it == end)
|
|
|
|
return;
|
|
|
|
|
|
|
|
String message = "modified buffers remaining: [";
|
|
|
|
while (it != end)
|
2016-04-29 23:58:04 +03:00
|
|
|
{
|
2016-11-24 02:31:17 +03:00
|
|
|
message += (*it)->name();
|
|
|
|
it = std::find_if(it+1, end, is_modified);
|
|
|
|
message += (it != end) ? ", " : "]";
|
2016-04-29 23:58:04 +03:00
|
|
|
}
|
2016-11-24 02:31:17 +03:00
|
|
|
throw runtime_error(message);
|
2016-04-29 23:58:04 +03:00
|
|
|
}
|
|
|
|
|
2015-08-26 21:34:19 +03:00
|
|
|
const CommandDesc kill_cmd = {
|
|
|
|
"kill",
|
|
|
|
nullptr,
|
|
|
|
"kill current session, quit all clients and server",
|
|
|
|
no_params,
|
|
|
|
CommandFlags::None,
|
|
|
|
CommandHelper{},
|
|
|
|
CommandCompleter{},
|
2016-04-29 23:58:04 +03:00
|
|
|
[](const ParametersParser&, Context&, const ShellContext&){
|
|
|
|
ensure_all_buffers_are_saved();
|
|
|
|
throw kill_session{};
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
const CommandDesc force_kill_cmd = {
|
|
|
|
"kill!",
|
|
|
|
nullptr,
|
|
|
|
"kill current session, quit all clients and server, do not check for unsaved buffers",
|
|
|
|
no_params,
|
|
|
|
CommandFlags::None,
|
|
|
|
CommandHelper{},
|
|
|
|
CommandCompleter{},
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser&, Context&, const ShellContext&){ throw kill_session{}; }
|
2015-08-26 21:34:19 +03:00
|
|
|
};
|
|
|
|
|
2012-05-07 07:13:34 +04:00
|
|
|
template<bool force>
|
2016-09-04 19:54:07 +03:00
|
|
|
void quit(Context& context)
|
2012-05-07 07:13:34 +04:00
|
|
|
{
|
2012-10-30 17:00:44 +04:00
|
|
|
if (not force and ClientManager::instance().count() == 1)
|
2016-04-29 23:58:04 +03:00
|
|
|
ensure_all_buffers_are_saved();
|
2016-09-04 19:54:07 +03:00
|
|
|
|
|
|
|
ClientManager::instance().remove_client(context.client(), true);
|
2012-05-07 07:13:34 +04:00
|
|
|
}
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc quit_cmd = {
|
|
|
|
"quit",
|
|
|
|
"q",
|
2015-03-14 15:17:43 +03:00
|
|
|
"quit current client, and the kakoune session if the client is the last "
|
|
|
|
"(if not running in daemon mode)",
|
2014-02-14 06:21:06 +04:00
|
|
|
no_params,
|
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandCompleter{},
|
2016-09-04 19:54:07 +03:00
|
|
|
[](const ParametersParser&, Context& context, const ShellContext&){ quit<false>(context); }
|
2014-02-14 06:21:06 +04:00
|
|
|
};
|
2012-05-07 07:13:34 +04:00
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc force_quit_cmd = {
|
|
|
|
"quit!",
|
|
|
|
"q!",
|
2015-03-14 15:17:43 +03:00
|
|
|
"quit current client, and the kakoune session if the client is the last "
|
|
|
|
"(if not running in daemon mode). force quit even if the client is the "
|
|
|
|
"last and some buffers are not saved.",
|
2014-02-14 06:21:06 +04:00
|
|
|
no_params,
|
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandCompleter{},
|
2016-09-04 19:54:07 +03:00
|
|
|
[](const ParametersParser&, Context& context, const ShellContext&){ quit<true>(context); }
|
2014-02-14 06:21:06 +04:00
|
|
|
};
|
2014-02-12 13:02:09 +04:00
|
|
|
|
2015-12-28 02:09:32 +03:00
|
|
|
template<bool force>
|
|
|
|
void write_quit(const ParametersParser& parser, Context& context,
|
|
|
|
const ShellContext& shell_context)
|
|
|
|
{
|
|
|
|
write_buffer(parser, context, shell_context);
|
2016-09-04 19:54:07 +03:00
|
|
|
quit<force>(context);
|
2015-12-28 02:09:32 +03:00
|
|
|
}
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc write_quit_cmd = {
|
2016-11-14 03:27:14 +03:00
|
|
|
"write-quit",
|
2014-02-14 06:21:06 +04:00
|
|
|
"wq",
|
|
|
|
"write current buffer and quit current client",
|
|
|
|
no_params,
|
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandCompleter{},
|
2015-12-28 02:09:32 +03:00
|
|
|
write_quit<false>
|
2014-02-14 06:21:06 +04:00
|
|
|
};
|
2012-11-07 17:04:47 +04:00
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc force_write_quit_cmd = {
|
2016-11-14 03:27:14 +03:00
|
|
|
"write-quit!",
|
2014-02-14 06:21:06 +04:00
|
|
|
"wq!",
|
2015-03-14 15:17:43 +03:00
|
|
|
"write current buffer and quit current client, even if other buffers are "
|
|
|
|
"not saved",
|
2014-02-14 06:21:06 +04:00
|
|
|
no_params,
|
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandCompleter{},
|
2015-12-28 02:09:32 +03:00
|
|
|
write_quit<true>
|
2014-07-01 12:56:11 +04:00
|
|
|
};
|
|
|
|
|
2016-11-15 16:49:06 +03:00
|
|
|
const CommandDesc write_all_quit_cmd = {
|
2016-11-14 03:27:14 +03:00
|
|
|
"write-all-quit",
|
2014-07-01 12:56:11 +04:00
|
|
|
"waq",
|
|
|
|
"write all buffers associated to a file and quit current client",
|
|
|
|
no_params,
|
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-07-01 12:56:11 +04:00
|
|
|
CommandCompleter{},
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2014-07-01 12:56:11 +04:00
|
|
|
{
|
2016-11-24 16:35:42 +03:00
|
|
|
write_all_buffers(context);
|
2016-09-04 19:54:07 +03:00
|
|
|
quit<false>(context);
|
2012-11-07 17:04:47 +04:00
|
|
|
}
|
2014-02-14 06:21:06 +04:00
|
|
|
};
|
2012-05-29 02:51:12 +04:00
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc buffer_cmd = {
|
|
|
|
"buffer",
|
|
|
|
"b",
|
|
|
|
"buffer <name>: set buffer to edit in current client",
|
2017-02-27 23:44:38 +03:00
|
|
|
single_param,
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
buffer_completer,
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2014-02-14 06:21:06 +04:00
|
|
|
{
|
|
|
|
Buffer& buffer = BufferManager::instance().get_buffer(parser[0]);
|
2015-11-07 21:24:08 +03:00
|
|
|
if (&buffer != &context.buffer())
|
2014-02-14 06:21:06 +04:00
|
|
|
{
|
|
|
|
context.push_jump();
|
|
|
|
context.change_buffer(buffer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
2014-02-12 13:02:09 +04:00
|
|
|
|
2015-04-15 03:43:16 +03:00
|
|
|
template<bool next>
|
2015-10-22 15:59:23 +03:00
|
|
|
void cycle_buffer(const ParametersParser& parser, Context& context, const ShellContext&)
|
2015-04-15 03:43:16 +03:00
|
|
|
{
|
|
|
|
Buffer* oldbuf = &context.buffer();
|
|
|
|
auto it = find_if(BufferManager::instance(),
|
2016-05-14 10:33:50 +03:00
|
|
|
[oldbuf](const std::unique_ptr<Buffer>& lhs)
|
2015-04-15 03:43:16 +03:00
|
|
|
{ return lhs.get() == oldbuf; });
|
|
|
|
kak_assert(it != BufferManager::instance().end());
|
|
|
|
|
2016-12-23 19:37:54 +03:00
|
|
|
Buffer* newbuf = nullptr;
|
|
|
|
auto cycle = [&] {
|
|
|
|
if (not next)
|
|
|
|
{
|
|
|
|
if (it == BufferManager::instance().begin())
|
|
|
|
it = BufferManager::instance().end();
|
|
|
|
--it;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (++it == BufferManager::instance().end())
|
|
|
|
it = BufferManager::instance().begin();
|
|
|
|
}
|
|
|
|
newbuf = it->get();
|
|
|
|
};
|
|
|
|
cycle();
|
2017-03-08 22:33:25 +03:00
|
|
|
while (newbuf != oldbuf and newbuf->flags() & Buffer::Flags::Debug)
|
2016-12-23 19:37:54 +03:00
|
|
|
cycle();
|
2015-04-09 17:14:28 +03:00
|
|
|
|
2015-04-15 03:43:16 +03:00
|
|
|
if (newbuf != oldbuf)
|
|
|
|
{
|
|
|
|
context.push_jump();
|
|
|
|
context.change_buffer(*newbuf);
|
2015-04-09 17:14:28 +03:00
|
|
|
}
|
2015-04-15 03:43:16 +03:00
|
|
|
}
|
|
|
|
|
2016-11-15 16:49:06 +03:00
|
|
|
const CommandDesc buffer_next_cmd = {
|
2016-11-14 03:27:14 +03:00
|
|
|
"buffer-next",
|
2015-04-15 03:43:16 +03:00
|
|
|
"bn",
|
2016-11-14 03:27:14 +03:00
|
|
|
"buffer-next: move to the next buffer in the list",
|
2015-04-15 03:43:16 +03:00
|
|
|
no_params,
|
|
|
|
CommandFlags::None,
|
|
|
|
CommandHelper{},
|
|
|
|
CommandCompleter{},
|
|
|
|
cycle_buffer<true>
|
|
|
|
};
|
|
|
|
|
2016-11-15 16:49:06 +03:00
|
|
|
const CommandDesc buffer_previous_cmd = {
|
|
|
|
"buffer-previous",
|
2015-04-15 03:43:16 +03:00
|
|
|
"bp",
|
2016-11-15 16:49:06 +03:00
|
|
|
"buffer-previous: move to the previous buffer in the list",
|
2015-04-15 03:43:16 +03:00
|
|
|
no_params,
|
|
|
|
CommandFlags::None,
|
|
|
|
CommandHelper{},
|
|
|
|
CommandCompleter{},
|
|
|
|
cycle_buffer<false>
|
2015-04-09 17:14:28 +03:00
|
|
|
};
|
|
|
|
|
2012-12-28 17:07:35 +04:00
|
|
|
template<bool force>
|
2015-10-22 15:59:23 +03:00
|
|
|
void delete_buffer(const ParametersParser& parser, Context& context, const ShellContext&)
|
2012-05-29 02:51:12 +04:00
|
|
|
{
|
|
|
|
BufferManager& manager = BufferManager::instance();
|
2014-02-08 05:02:58 +04:00
|
|
|
Buffer& buffer = parser.positional_count() == 0 ? context.buffer() : manager.get_buffer(parser[0]);
|
2013-03-21 22:09:31 +04:00
|
|
|
if (not force and (buffer.flags() & Buffer::Flags::File) and buffer.is_modified())
|
2015-06-01 23:15:59 +03:00
|
|
|
throw runtime_error(format("buffer '{}' is modified", buffer.name()));
|
2012-05-29 02:51:12 +04:00
|
|
|
|
2013-04-10 20:54:01 +04:00
|
|
|
manager.delete_buffer(buffer);
|
2012-05-07 07:13:34 +04:00
|
|
|
}
|
|
|
|
|
2016-11-15 16:49:06 +03:00
|
|
|
const CommandDesc delete_buffer_cmd = {
|
2016-11-14 03:27:14 +03:00
|
|
|
"delete-buffer",
|
2014-02-14 06:21:06 +04:00
|
|
|
"db",
|
2016-11-14 03:27:14 +03:00
|
|
|
"delete-buffer [name]: delete current buffer or the buffer named <name> if given",
|
2017-02-27 23:44:38 +03:00
|
|
|
single_optional_param,
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
buffer_completer,
|
|
|
|
delete_buffer<false>
|
|
|
|
};
|
2014-02-12 13:02:09 +04:00
|
|
|
|
2016-11-15 16:49:06 +03:00
|
|
|
const CommandDesc force_delete_buffer_cmd = {
|
2016-11-14 03:27:14 +03:00
|
|
|
"delete-buffer!",
|
2014-02-14 06:21:06 +04:00
|
|
|
"db!",
|
2016-11-14 03:27:14 +03:00
|
|
|
"delete-buffer! [name]: delete current buffer or the buffer named <name> if "
|
2015-03-14 15:17:43 +03:00
|
|
|
"given, even if the buffer is unsaved",
|
2017-02-27 23:44:38 +03:00
|
|
|
single_optional_param,
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
buffer_completer,
|
2014-05-13 22:48:16 +04:00
|
|
|
delete_buffer<true>
|
2014-02-14 06:21:06 +04:00
|
|
|
};
|
|
|
|
|
2016-11-15 16:49:06 +03:00
|
|
|
const CommandDesc rename_buffer_cmd = {
|
2016-11-14 03:27:14 +03:00
|
|
|
"rename-buffer",
|
2014-02-14 06:21:06 +04:00
|
|
|
nullptr,
|
2016-11-14 03:27:14 +03:00
|
|
|
"rename-buffer <name>: change current buffer name",
|
2017-02-27 23:44:38 +03:00
|
|
|
single_param,
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandCompleter{},
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2014-02-14 06:21:06 +04:00
|
|
|
{
|
|
|
|
if (not context.buffer().set_name(parser[0]))
|
2015-06-01 23:15:59 +03:00
|
|
|
throw runtime_error(format("unable to change buffer name to '{}'", parser[0]));
|
2014-02-14 06:21:06 +04:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-10-22 03:20:09 +04:00
|
|
|
Completions complete_highlighter(const Context& context,
|
|
|
|
StringView arg, ByteCount pos_in_token, bool only_group)
|
2013-04-22 15:48:18 +04:00
|
|
|
{
|
2015-03-10 22:33:46 +03:00
|
|
|
const bool shared = not arg.empty() and arg[0_byte] == '/';
|
2014-06-15 19:04:38 +04:00
|
|
|
if (shared)
|
|
|
|
{
|
|
|
|
auto& group = DefinedHighlighters::instance();
|
2014-10-22 03:20:09 +04:00
|
|
|
return offset_pos(group.complete_child(arg.substr(1_byte), pos_in_token-1, only_group), 1);
|
2014-06-15 19:04:38 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
auto& group = context.window().highlighters();
|
2014-10-22 03:20:09 +04:00
|
|
|
return group.complete_child(arg, pos_in_token, only_group);
|
2014-06-15 19:04:38 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-15 16:49:06 +03:00
|
|
|
Completions remove_highlighter_completer(
|
2014-06-15 19:04:38 +04:00
|
|
|
const Context& context, CompletionFlags flags, CommandParameters params,
|
|
|
|
size_t token_to_complete, ByteCount pos_in_token)
|
|
|
|
{
|
|
|
|
const String& arg = params[token_to_complete];
|
|
|
|
if (token_to_complete == 0 and not arg.empty() and arg.front() == '/')
|
|
|
|
{
|
|
|
|
auto& group = DefinedHighlighters::instance();
|
2014-10-22 03:20:09 +04:00
|
|
|
return offset_pos(group.complete_child(arg.substr(1_byte), pos_in_token-1, false), 1);
|
2014-06-15 19:04:38 +04:00
|
|
|
}
|
|
|
|
else if (token_to_complete == 0)
|
2014-10-22 03:20:09 +04:00
|
|
|
return context.window().highlighters().complete_child(arg, pos_in_token, false);
|
2014-06-15 19:04:38 +04:00
|
|
|
return {};
|
2013-04-22 15:48:18 +04:00
|
|
|
}
|
|
|
|
|
2014-06-15 19:04:38 +04:00
|
|
|
Completions add_highlighter_completer(
|
|
|
|
const Context& context, CompletionFlags flags, CommandParameters params,
|
|
|
|
size_t token_to_complete, ByteCount pos_in_token)
|
2012-12-09 21:58:58 +04:00
|
|
|
{
|
2014-06-15 19:04:38 +04:00
|
|
|
StringView arg = params[token_to_complete];
|
|
|
|
if (token_to_complete == 1 and params[0] == "-group")
|
2014-10-22 03:20:09 +04:00
|
|
|
return complete_highlighter(context, params[1], pos_in_token, true);
|
2014-06-15 19:04:38 +04:00
|
|
|
else if (token_to_complete == 0 or (token_to_complete == 2 and params[0] == "-group"))
|
2017-03-07 04:12:37 +03:00
|
|
|
return { 0_byte, arg.length(), complete(arg, pos_in_token, HighlighterRegistry::instance() | transform(std::mem_fn(&HighlighterRegistry::Item::key))) };
|
2014-06-15 19:04:38 +04:00
|
|
|
return Completions{};
|
2012-12-09 21:58:58 +04:00
|
|
|
}
|
|
|
|
|
2014-10-22 03:20:09 +04:00
|
|
|
Highlighter& get_highlighter(const Context& context, StringView path)
|
2014-06-15 19:04:38 +04:00
|
|
|
{
|
|
|
|
if (path.empty())
|
|
|
|
throw runtime_error("group path should not be empty");
|
|
|
|
|
2014-10-22 03:20:09 +04:00
|
|
|
Highlighter* root = nullptr;
|
2015-03-10 22:33:46 +03:00
|
|
|
if (path[0_byte] == '/')
|
2014-06-15 19:04:38 +04:00
|
|
|
{
|
2014-10-22 03:20:09 +04:00
|
|
|
root = &DefinedHighlighters::instance();
|
2014-06-15 19:04:38 +04:00
|
|
|
path = path.substr(1_byte);
|
|
|
|
}
|
|
|
|
else
|
2014-10-22 03:20:09 +04:00
|
|
|
root = &context.window().highlighters();
|
2014-06-15 19:04:38 +04:00
|
|
|
|
|
|
|
if (path.back() == '/')
|
|
|
|
path = path.substr(0_byte, path.length() - 1);
|
|
|
|
|
|
|
|
if (not path.empty())
|
2014-10-22 03:20:09 +04:00
|
|
|
return root->get_child(path);
|
|
|
|
return *root;
|
2014-06-15 19:04:38 +04:00
|
|
|
}
|
2014-02-14 06:21:06 +04:00
|
|
|
|
|
|
|
const CommandDesc add_highlighter_cmd = {
|
2016-11-14 03:27:14 +03:00
|
|
|
"add-highlighter",
|
2014-02-14 06:21:06 +04:00
|
|
|
"addhl",
|
2016-11-14 03:27:14 +03:00
|
|
|
"add-highlighter <type> <type params>...: add an highlighter",
|
2014-02-14 06:21:06 +04:00
|
|
|
ParameterDesc{
|
2015-03-14 20:30:34 +03:00
|
|
|
{ { "group", { true, "Set the group in which to put the highlighter. "
|
|
|
|
"If starting with /, search in shared highlighters, "
|
|
|
|
"else search in the current window" } } },
|
|
|
|
ParameterDesc::Flags::SwitchesOnlyAtStart, 1
|
|
|
|
},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandFlags::None,
|
2015-02-19 16:54:03 +03:00
|
|
|
[](const Context& context, CommandParameters params) -> String
|
|
|
|
{
|
|
|
|
if (params.size() > 0)
|
|
|
|
{
|
|
|
|
HighlighterRegistry& registry = HighlighterRegistry::instance();
|
|
|
|
auto it = registry.find(params[0]);
|
|
|
|
if (it != registry.end())
|
2015-09-16 21:57:57 +03:00
|
|
|
return format("{}:\n{}", params[0], indent(it->value.docstring));
|
2015-02-19 16:54:03 +03:00
|
|
|
}
|
|
|
|
return "";
|
|
|
|
},
|
2014-06-15 19:04:38 +04:00
|
|
|
add_highlighter_completer,
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2014-02-14 06:21:06 +04:00
|
|
|
{
|
|
|
|
HighlighterRegistry& registry = HighlighterRegistry::instance();
|
2014-02-08 05:02:58 +04:00
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
auto begin = parser.begin();
|
2014-06-13 00:52:23 +04:00
|
|
|
const String& name = *begin++;
|
2015-01-12 16:58:41 +03:00
|
|
|
Vector<String> highlighter_params;
|
2014-06-13 00:52:23 +04:00
|
|
|
for (; begin != parser.end(); ++begin)
|
2014-02-14 06:21:06 +04:00
|
|
|
highlighter_params.push_back(*begin);
|
2014-02-12 13:02:09 +04:00
|
|
|
|
2015-03-14 22:16:46 +03:00
|
|
|
auto group_name = parser.get_switch("group");
|
|
|
|
auto& group = group_name ? get_highlighter(context, *group_name)
|
|
|
|
: context.window().highlighters();
|
2014-12-24 01:15:53 +03:00
|
|
|
auto it = registry.find(name);
|
|
|
|
if (it == registry.end())
|
2015-06-01 23:15:59 +03:00
|
|
|
throw runtime_error(format("No such highlighter factory '{}'", name));
|
2015-09-16 21:57:57 +03:00
|
|
|
group.add_child(it->value.factory(highlighter_params));
|
2015-06-25 21:12:13 +03:00
|
|
|
|
|
|
|
if (context.has_window())
|
|
|
|
context.window().force_redraw();
|
2014-02-14 06:21:06 +04:00
|
|
|
}
|
|
|
|
};
|
2013-12-04 02:03:10 +04:00
|
|
|
|
2016-11-15 16:49:06 +03:00
|
|
|
const CommandDesc remove_highlighter_cmd = {
|
2016-11-14 03:27:14 +03:00
|
|
|
"remove-highlighter",
|
2014-02-14 06:21:06 +04:00
|
|
|
"rmhl",
|
2016-11-14 03:27:14 +03:00
|
|
|
"add-highlighter <path>: remove highlighter <name>",
|
2015-03-14 20:30:34 +03:00
|
|
|
ParameterDesc{ {}, ParameterDesc::Flags::None, 1, 1 },
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2016-11-15 16:49:06 +03:00
|
|
|
remove_highlighter_completer,
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2013-12-04 02:03:10 +04:00
|
|
|
{
|
2014-06-15 19:04:38 +04:00
|
|
|
StringView path = parser[0];
|
2016-03-09 00:35:56 +03:00
|
|
|
auto sep_it = find(path | reverse(), '/');
|
2014-06-15 19:04:38 +04:00
|
|
|
auto& group = sep_it != path.rend() ?
|
2015-09-30 02:18:37 +03:00
|
|
|
get_highlighter(context, {path.begin(), sep_it.base()})
|
2014-06-15 19:04:38 +04:00
|
|
|
: context.window().highlighters();
|
2012-05-07 07:13:34 +04:00
|
|
|
|
2014-10-22 03:20:09 +04:00
|
|
|
group.remove_child({sep_it.base(), path.end()});
|
2015-06-25 21:12:13 +03:00
|
|
|
|
|
|
|
if (context.has_window())
|
|
|
|
context.window().force_redraw();
|
2014-02-14 06:21:06 +04:00
|
|
|
}
|
2014-02-08 05:02:58 +04:00
|
|
|
};
|
2012-05-25 09:07:37 +04:00
|
|
|
|
2016-11-21 12:51:47 +03:00
|
|
|
static constexpr auto hooks = {
|
2017-02-19 17:14:22 +03:00
|
|
|
"BufCreate", "BufNewFile", "BufOpenFile", "BufClose", "BufWritePost",
|
|
|
|
"BufWritePre", "BufOpenFifo", "BufCloseFifo", "BufReadFifo", "BufSetOption",
|
2017-03-30 12:38:56 +03:00
|
|
|
"InsertBegin", "InsertChar", "InsertDelete", "InsertEnd", "InsertIdle", "InsertKey",
|
2016-11-21 12:51:47 +03:00
|
|
|
"InsertMove", "InsertCompletionHide", "InsertCompletionShow",
|
2017-07-05 14:45:45 +03:00
|
|
|
"KakBegin", "KakEnd", "FocusIn", "FocusOut", "RuntimeError", "PromptIdle",
|
2017-03-01 05:28:23 +03:00
|
|
|
"NormalBegin", "NormalEnd", "NormalIdle", "NormalKey", "RawKey",
|
2016-11-21 12:51:47 +03:00
|
|
|
"WinClose", "WinCreate", "WinDisplay", "WinResize", "WinSetOption",
|
|
|
|
};
|
|
|
|
|
2016-11-20 14:17:13 +03:00
|
|
|
static Completions complete_hooks(const Context&, CompletionFlags,
|
|
|
|
const String& prefix, ByteCount cursor_pos)
|
|
|
|
{
|
|
|
|
return { 0_byte, cursor_pos, complete(prefix, cursor_pos, hooks) };
|
|
|
|
}
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc add_hook_cmd = {
|
|
|
|
"hook",
|
|
|
|
nullptr,
|
2016-11-20 14:17:13 +03:00
|
|
|
"hook <switches> <scope> <hook_name> <filter> <command>: add <command> in <scope> "
|
|
|
|
"to be executed on hook <hook_name> when its parameter matches the <filter> regex\n"
|
2014-06-06 16:58:35 +04:00
|
|
|
"scope can be: \n"
|
|
|
|
" * global: hook is executed for any buffer or window\n"
|
|
|
|
" * buffer: hook is executed only for the current buffer\n"
|
|
|
|
" (and any window for that buffer)\n"
|
|
|
|
" * window: hook is executed only for the current window\n",
|
2014-02-14 06:21:06 +04:00
|
|
|
ParameterDesc{
|
2017-01-04 03:07:45 +03:00
|
|
|
{ { "group", { true, "set hook group, see remove-hooks" } } },
|
2014-02-14 06:21:06 +04:00
|
|
|
ParameterDesc::Flags::None, 4, 4
|
|
|
|
},
|
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2016-11-20 14:17:13 +03:00
|
|
|
make_completer(complete_scope, complete_hooks, complete_nothing,
|
2016-09-18 18:27:34 +03:00
|
|
|
[](const Context& context, CompletionFlags flags,
|
|
|
|
const String& prefix, ByteCount cursor_pos)
|
|
|
|
{ return CommandManager::instance().complete(
|
|
|
|
context, flags, prefix, cursor_pos); }),
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2014-02-14 06:21:06 +04:00
|
|
|
{
|
2016-11-21 12:51:47 +03:00
|
|
|
if (not contains(hooks, parser[1]))
|
|
|
|
throw runtime_error{format("Unknown hook '{}'", parser[1])};
|
|
|
|
|
2017-03-30 13:29:06 +03:00
|
|
|
Regex regex{parser[2], Regex::optimize | Regex::ECMAScript};
|
2015-03-12 23:39:34 +03:00
|
|
|
const String& command = parser[3];
|
2015-03-14 22:16:46 +03:00
|
|
|
auto group = parser.get_switch("group").value_or(StringView{});
|
2017-06-07 14:33:39 +03:00
|
|
|
get_scope(parser[0], context).hooks().add_hook(parser[1], group.str(), std::move(regex), command);
|
2014-02-14 06:21:06 +04:00
|
|
|
}
|
2014-02-08 05:02:58 +04:00
|
|
|
};
|
|
|
|
|
2016-11-15 16:49:06 +03:00
|
|
|
const CommandDesc remove_hook_cmd = {
|
2016-11-14 03:27:14 +03:00
|
|
|
"remove-hooks",
|
2014-02-14 06:21:06 +04:00
|
|
|
"rmhooks",
|
2016-11-14 03:27:14 +03:00
|
|
|
"remove-hooks <scope> <group>: remove all hooks whose group is <group>",
|
2015-03-14 20:30:34 +03:00
|
|
|
ParameterDesc{ {}, ParameterDesc::Flags::None, 2, 2 },
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-07-22 00:14:32 +04:00
|
|
|
[](const Context& context, CompletionFlags flags,
|
|
|
|
CommandParameters params, size_t token_to_complete,
|
|
|
|
ByteCount pos_in_token) -> Completions
|
|
|
|
{
|
|
|
|
if (token_to_complete == 0)
|
|
|
|
return { 0_byte, params[0].length(),
|
2014-12-23 20:39:12 +03:00
|
|
|
complete(params[0], pos_in_token, scopes) };
|
2014-07-22 00:14:32 +04:00
|
|
|
else if (token_to_complete == 1)
|
|
|
|
{
|
2014-10-30 17:00:42 +03:00
|
|
|
if (auto scope = get_scope_ifp(params[0], context))
|
2014-07-22 00:14:32 +04:00
|
|
|
return { 0_byte, params[0].length(),
|
2014-10-30 17:00:42 +03:00
|
|
|
scope->hooks().complete_hook_group(params[1], pos_in_token) };
|
2014-07-22 00:14:32 +04:00
|
|
|
}
|
|
|
|
return {};
|
|
|
|
},
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2014-02-14 06:21:06 +04:00
|
|
|
{
|
2014-10-30 17:00:42 +03:00
|
|
|
get_scope(parser[0], context).hooks().remove_hooks(parser[1]);
|
2014-02-14 06:21:06 +04:00
|
|
|
}
|
|
|
|
};
|
2012-05-07 07:13:34 +04:00
|
|
|
|
2015-01-12 16:58:41 +03:00
|
|
|
Vector<String> params_to_shell(const ParametersParser& parser)
|
2012-05-07 07:13:34 +04:00
|
|
|
{
|
2015-01-12 16:58:41 +03:00
|
|
|
Vector<String> vars;
|
2014-02-08 05:02:58 +04:00
|
|
|
for (size_t i = 0; i < parser.positional_count(); ++i)
|
|
|
|
vars.push_back(parser[i]);
|
|
|
|
return vars;
|
|
|
|
}
|
2012-05-07 07:13:34 +04:00
|
|
|
|
2015-10-22 15:59:23 +03:00
|
|
|
void define_command(const ParametersParser& parser, Context& context, const ShellContext&)
|
2014-02-08 05:02:58 +04:00
|
|
|
{
|
2015-03-12 22:45:05 +03:00
|
|
|
const String& cmd_name = parser[0];
|
|
|
|
auto& cm = CommandManager::instance();
|
2012-06-02 19:49:35 +04:00
|
|
|
|
2015-03-14 22:16:46 +03:00
|
|
|
if (cm.command_defined(cmd_name) and not parser.get_switch("allow-override"))
|
2015-06-01 23:15:59 +03:00
|
|
|
throw runtime_error(format("command '{}' already defined", cmd_name));
|
2012-06-02 19:49:35 +04:00
|
|
|
|
2013-11-12 23:38:19 +04:00
|
|
|
CommandFlags flags = CommandFlags::None;
|
2015-03-14 22:16:46 +03:00
|
|
|
if (parser.get_switch("hidden"))
|
2013-11-12 23:38:19 +04:00
|
|
|
flags = CommandFlags::Hidden;
|
|
|
|
|
2015-03-12 22:45:05 +03:00
|
|
|
const String& commands = parser[1];
|
2012-05-25 09:07:37 +04:00
|
|
|
Command cmd;
|
2014-02-08 05:02:58 +04:00
|
|
|
ParameterDesc desc;
|
2015-12-01 17:00:55 +03:00
|
|
|
if (auto params = parser.get_switch("params"))
|
2012-09-09 19:10:53 +04:00
|
|
|
{
|
2015-12-01 17:00:55 +03:00
|
|
|
size_t min = 0, max = -1;
|
|
|
|
StringView counts = *params;
|
|
|
|
static const Regex re{R"((\d+)?..(\d+)?)"};
|
|
|
|
MatchResults<const char*> res;
|
|
|
|
if (regex_match(counts.begin(), counts.end(), res, re))
|
|
|
|
{
|
|
|
|
if (res[1].matched)
|
|
|
|
min = (size_t)str_to_int({res[1].first, res[1].second});
|
|
|
|
if (res[2].matched)
|
|
|
|
max = (size_t)str_to_int({res[2].first, res[2].second});
|
|
|
|
}
|
|
|
|
else
|
|
|
|
min = max = (size_t)str_to_int(counts);
|
|
|
|
|
|
|
|
desc = ParameterDesc{ {}, ParameterDesc::Flags::SwitchesAsPositional, min, max };
|
2017-01-13 03:26:43 +03:00
|
|
|
cmd = [=](const ParametersParser& parser, Context& context, const ShellContext& sc) {
|
|
|
|
CommandManager::instance().execute(commands, context,
|
|
|
|
{ params_to_shell(parser), sc.env_vars });
|
2012-09-09 19:10:53 +04:00
|
|
|
};
|
|
|
|
}
|
2012-05-07 07:13:34 +04:00
|
|
|
else
|
|
|
|
{
|
2015-03-14 20:30:34 +03:00
|
|
|
desc = ParameterDesc{ {}, ParameterDesc::Flags::SwitchesAsPositional, 0, 0 };
|
2017-01-13 03:26:43 +03:00
|
|
|
cmd = [=](const ParametersParser& parser, Context& context, const ShellContext& sc) {
|
|
|
|
CommandManager::instance().execute(commands, context, { {}, sc.env_vars });
|
2012-05-25 09:07:37 +04:00
|
|
|
};
|
2012-05-07 07:13:34 +04:00
|
|
|
}
|
2012-05-29 09:22:18 +04:00
|
|
|
|
2012-09-12 16:21:42 +04:00
|
|
|
CommandCompleter completer;
|
2015-03-14 22:16:46 +03:00
|
|
|
if (parser.get_switch("file-completion"))
|
2012-09-12 16:21:42 +04:00
|
|
|
{
|
2013-11-05 01:53:10 +04:00
|
|
|
completer = [](const Context& context, CompletionFlags flags,
|
|
|
|
CommandParameters params,
|
2012-10-11 02:41:48 +04:00
|
|
|
size_t token_to_complete, ByteCount pos_in_token)
|
2012-09-12 16:21:42 +04:00
|
|
|
{
|
2014-01-26 20:14:02 +04:00
|
|
|
const String& prefix = params[token_to_complete];
|
|
|
|
auto& ignored_files = context.options()["ignored_files"].get<Regex>();
|
2015-03-12 22:45:05 +03:00
|
|
|
return Completions{ 0_byte, pos_in_token,
|
2014-01-26 20:14:02 +04:00
|
|
|
complete_filename(prefix, ignored_files,
|
2016-10-13 21:46:09 +03:00
|
|
|
pos_in_token, FilenameFlags::Expand) };
|
2012-09-12 16:21:42 +04:00
|
|
|
};
|
|
|
|
}
|
2015-03-14 22:16:46 +03:00
|
|
|
else if (parser.get_switch("client-completion"))
|
2014-04-08 00:44:17 +04:00
|
|
|
{
|
|
|
|
completer = [](const Context& context, CompletionFlags flags,
|
|
|
|
CommandParameters params,
|
|
|
|
size_t token_to_complete, ByteCount pos_in_token)
|
|
|
|
{
|
|
|
|
const String& prefix = params[token_to_complete];
|
|
|
|
auto& cm = ClientManager::instance();
|
2015-03-12 22:45:05 +03:00
|
|
|
return Completions{ 0_byte, pos_in_token,
|
2014-04-08 00:44:17 +04:00
|
|
|
cm.complete_client_name(prefix, pos_in_token) };
|
|
|
|
};
|
|
|
|
}
|
2015-03-14 22:16:46 +03:00
|
|
|
else if (parser.get_switch("buffer-completion"))
|
2014-04-08 00:44:17 +04:00
|
|
|
{
|
|
|
|
completer = [](const Context& context, CompletionFlags flags,
|
|
|
|
CommandParameters params,
|
|
|
|
size_t token_to_complete, ByteCount pos_in_token)
|
|
|
|
{
|
2016-09-18 18:07:00 +03:00
|
|
|
return complete_buffer_name(context, flags, params[token_to_complete], pos_in_token);
|
2014-04-08 00:44:17 +04:00
|
|
|
};
|
|
|
|
}
|
2015-03-14 22:16:46 +03:00
|
|
|
else if (auto shell_cmd_opt = parser.get_switch("shell-completion"))
|
2012-05-29 09:22:18 +04:00
|
|
|
{
|
2015-03-14 22:16:46 +03:00
|
|
|
String shell_cmd = shell_cmd_opt->str();
|
2013-11-05 01:53:10 +04:00
|
|
|
completer = [=](const Context& context, CompletionFlags flags,
|
|
|
|
CommandParameters params,
|
2012-10-11 02:41:48 +04:00
|
|
|
size_t token_to_complete, ByteCount pos_in_token)
|
2012-05-29 09:22:18 +04:00
|
|
|
{
|
2016-08-05 15:53:19 +03:00
|
|
|
if (flags & CompletionFlags::Fast) // no shell on fast completion
|
2014-01-26 20:14:02 +04:00
|
|
|
return Completions{};
|
2015-10-22 15:48:57 +03:00
|
|
|
|
|
|
|
ShellContext shell_context{
|
|
|
|
params,
|
|
|
|
{ { "token_to_complete", to_string(token_to_complete) },
|
|
|
|
{ "pos_in_token", to_string(pos_in_token) } }
|
2013-05-13 16:23:07 +04:00
|
|
|
};
|
2015-06-08 15:34:08 +03:00
|
|
|
String output = ShellManager::instance().eval(shell_cmd, context, {},
|
2015-06-09 00:42:51 +03:00
|
|
|
ShellManager::Flags::WaitForStdout,
|
2015-10-22 15:48:57 +03:00
|
|
|
shell_context).first;
|
2016-11-28 16:59:55 +03:00
|
|
|
CandidateList candidates;
|
|
|
|
for (auto& str : split(output, '\n', 0))
|
|
|
|
candidates.push_back(std::move(str));
|
|
|
|
|
|
|
|
return Completions{ 0_byte, pos_in_token, std::move(candidates) };
|
2012-05-29 09:22:18 +04:00
|
|
|
};
|
|
|
|
}
|
2016-03-24 17:01:59 +03:00
|
|
|
else if (auto shell_cmd_opt = parser.get_switch("shell-candidates"))
|
|
|
|
{
|
|
|
|
String shell_cmd = shell_cmd_opt->str();
|
2017-02-03 16:42:47 +03:00
|
|
|
Vector<std::pair<String, UsedLetters>, MemoryDomain::Completion> candidates;
|
2016-03-24 17:01:59 +03:00
|
|
|
int token = -1;
|
|
|
|
completer = [shell_cmd, candidates, token](
|
|
|
|
const Context& context, CompletionFlags flags, CommandParameters params,
|
|
|
|
size_t token_to_complete, ByteCount pos_in_token) mutable
|
|
|
|
{
|
2016-08-05 15:53:19 +03:00
|
|
|
if (flags & CompletionFlags::Start)
|
|
|
|
token = -1;
|
|
|
|
|
2016-03-24 17:01:59 +03:00
|
|
|
if (token != token_to_complete)
|
|
|
|
{
|
|
|
|
ShellContext shell_context{
|
|
|
|
params,
|
|
|
|
{ { "token_to_complete", to_string(token_to_complete) } }
|
|
|
|
};
|
|
|
|
String output = ShellManager::instance().eval(shell_cmd, context, {},
|
|
|
|
ShellManager::Flags::WaitForStdout,
|
|
|
|
shell_context).first;
|
2016-03-25 23:37:35 +03:00
|
|
|
candidates.clear();
|
|
|
|
for (auto c : output | split<StringView>('\n'))
|
2017-01-09 01:30:15 +03:00
|
|
|
candidates.emplace_back(c.str(), used_letters(c));
|
2016-03-24 17:01:59 +03:00
|
|
|
token = token_to_complete;
|
|
|
|
}
|
|
|
|
|
2016-03-25 23:37:35 +03:00
|
|
|
StringView query = params[token_to_complete].substr(0, pos_in_token);
|
|
|
|
UsedLetters query_letters = used_letters(query);
|
|
|
|
Vector<RankedMatch> matches;
|
|
|
|
for (const auto& candidate : candidates)
|
|
|
|
{
|
|
|
|
if (RankedMatch match{candidate.first, candidate.second, query, query_letters})
|
|
|
|
matches.push_back(match);
|
|
|
|
}
|
2016-08-30 15:42:29 +03:00
|
|
|
|
|
|
|
constexpr size_t max_count = 100;
|
|
|
|
// Gather best max_count matches
|
|
|
|
auto greater = [](const RankedMatch& lhs,
|
|
|
|
const RankedMatch& rhs) { return rhs < lhs; };
|
|
|
|
auto first = matches.begin(), last = matches.end();
|
|
|
|
std::make_heap(first, last, greater);
|
2016-03-25 23:37:35 +03:00
|
|
|
CandidateList res;
|
2016-08-31 01:23:07 +03:00
|
|
|
while (res.size() < max_count and first != last)
|
2016-08-30 15:42:29 +03:00
|
|
|
{
|
|
|
|
if (res.empty() or res.back() != first->candidate())
|
|
|
|
res.push_back(first->candidate().str());
|
|
|
|
std::pop_heap(first, last--, greater);
|
|
|
|
}
|
2016-03-25 23:37:35 +03:00
|
|
|
|
|
|
|
return Completions{ 0_byte, pos_in_token, std::move(res) };
|
2016-03-24 17:01:59 +03:00
|
|
|
};
|
|
|
|
}
|
2015-06-26 15:52:01 +03:00
|
|
|
else if (parser.get_switch("command-completion"))
|
|
|
|
{
|
|
|
|
completer = [](const Context& context, CompletionFlags flags,
|
|
|
|
CommandParameters params,
|
|
|
|
size_t token_to_complete, ByteCount pos_in_token)
|
|
|
|
{
|
|
|
|
return CommandManager::instance().complete(
|
|
|
|
context, flags, params, token_to_complete, pos_in_token);
|
|
|
|
};
|
|
|
|
}
|
2014-06-06 03:17:15 +04:00
|
|
|
|
2017-06-16 12:48:14 +03:00
|
|
|
auto docstring = trim_whitespaces(parser.get_switch("docstring").value_or(StringView{}));
|
2015-03-14 22:16:46 +03:00
|
|
|
|
|
|
|
cm.register_command(cmd_name, cmd, docstring.str(), desc, flags, CommandHelper{}, completer);
|
2012-05-07 07:13:34 +04:00
|
|
|
}
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc define_command_cmd = {
|
2016-11-14 03:27:14 +03:00
|
|
|
"define-command",
|
2014-02-14 06:21:06 +04:00
|
|
|
"def",
|
2016-11-14 03:27:14 +03:00
|
|
|
"define-command <switches> <name> <cmds>: define a command <name> executing <cmds>",
|
2014-02-14 06:21:06 +04:00
|
|
|
ParameterDesc{
|
2015-12-01 17:00:55 +03:00
|
|
|
{ { "params", { true, "take parameters, accessible to each shell escape as $0..$N\n"
|
|
|
|
"parameter should take the form <count> or <min>..<max> (both omittable)" } },
|
|
|
|
{ "allow-override", { false, "allow overriding an existing command" } },
|
|
|
|
{ "hidden", { false, "do not display the command in completion candidates" } },
|
|
|
|
{ "docstring", { true, "define the documentation string for command" } },
|
|
|
|
{ "file-completion", { false, "complete parameters using filename completion" } },
|
|
|
|
{ "client-completion", { false, "complete parameters using client name completion" } },
|
|
|
|
{ "buffer-completion", { false, "complete parameters using buffer name completion" } },
|
2015-06-26 15:52:01 +03:00
|
|
|
{ "command-completion", { false, "complete parameters using kakoune command completion" } },
|
2016-03-24 17:01:59 +03:00
|
|
|
{ "shell-completion", { true, "complete the parameters using the given shell-script" } },
|
|
|
|
{ "shell-candidates", { true, "get the parameter candidates using the given shell-script" } } },
|
2014-02-14 06:21:06 +04:00
|
|
|
ParameterDesc::Flags::None,
|
|
|
|
2, 2
|
|
|
|
},
|
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandCompleter{},
|
|
|
|
define_command
|
2014-02-08 05:02:58 +04:00
|
|
|
};
|
|
|
|
|
2014-10-30 02:22:54 +03:00
|
|
|
const CommandDesc alias_cmd = {
|
|
|
|
"alias",
|
|
|
|
nullptr,
|
2017-05-28 21:58:24 +03:00
|
|
|
"alias <scope> <alias> <command>: alias <alias> to <command> in <scope>",
|
2015-03-14 20:30:34 +03:00
|
|
|
ParameterDesc{{}, ParameterDesc::Flags::None, 3, 3},
|
2014-10-30 02:22:54 +03:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2016-09-20 01:26:52 +03:00
|
|
|
make_completer(complete_scope, complete_nothing, complete_command_name),
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2014-10-30 02:22:54 +03:00
|
|
|
{
|
2015-08-11 15:37:38 +03:00
|
|
|
if (not CommandManager::instance().command_defined(parser[2]))
|
|
|
|
throw runtime_error(format("Command '{}' does not exist", parser[2]));
|
|
|
|
|
2014-10-30 17:00:42 +03:00
|
|
|
AliasRegistry& aliases = get_scope(parser[0], context).aliases();
|
2014-10-30 02:22:54 +03:00
|
|
|
aliases.add_alias(parser[1], parser[2]);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
const CommandDesc unalias_cmd = {
|
|
|
|
"unalias",
|
|
|
|
nullptr,
|
2015-03-14 15:17:43 +03:00
|
|
|
"unalias <scope> <alias> [<expected>]: remove <alias> from <scope>\n"
|
|
|
|
"If <expected> is specified, remove <alias> only if its value is <expected>",
|
2015-03-14 20:30:34 +03:00
|
|
|
ParameterDesc{{}, ParameterDesc::Flags::None, 2, 3},
|
2014-10-30 02:22:54 +03:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2016-09-20 01:26:52 +03:00
|
|
|
make_completer(complete_scope, complete_nothing, complete_command_name),
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2014-10-30 02:22:54 +03:00
|
|
|
{
|
2014-10-30 17:00:42 +03:00
|
|
|
AliasRegistry& aliases = get_scope(parser[0], context).aliases();
|
2014-10-30 02:22:54 +03:00
|
|
|
if (parser.positional_count() == 3 and
|
|
|
|
aliases[parser[1]] != parser[2])
|
|
|
|
return;
|
|
|
|
aliases.remove_alias(parser[1]);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc echo_cmd = {
|
|
|
|
"echo",
|
|
|
|
nullptr,
|
|
|
|
"echo <params>...: display given parameters in the status line",
|
|
|
|
ParameterDesc{
|
2015-03-14 20:30:34 +03:00
|
|
|
{ { "color", { true, "set message color" } },
|
2015-09-19 14:19:17 +03:00
|
|
|
{ "markup", { false, "parse markup" } },
|
2015-03-14 20:30:34 +03:00
|
|
|
{ "debug", { false, "write to debug buffer instead of status line" } } },
|
2014-02-14 06:21:06 +04:00
|
|
|
ParameterDesc::Flags::SwitchesOnlyAtStart
|
|
|
|
},
|
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandCompleter{},
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2014-02-14 06:21:06 +04:00
|
|
|
{
|
2015-01-18 01:55:48 +03:00
|
|
|
String message = join(parser, ' ', false);
|
2015-03-14 22:16:46 +03:00
|
|
|
if (parser.get_switch("debug"))
|
2015-06-06 13:54:48 +03:00
|
|
|
write_to_debug_buffer(message);
|
2015-09-19 14:19:17 +03:00
|
|
|
else if (parser.get_switch("markup"))
|
2015-09-20 13:34:13 +03:00
|
|
|
context.print_status(parse_display_line(message));
|
2014-03-31 23:07:02 +04:00
|
|
|
else
|
|
|
|
{
|
2015-03-14 22:16:46 +03:00
|
|
|
auto face = get_face(parser.get_switch("color").value_or("StatusLine").str());
|
2014-07-11 03:27:04 +04:00
|
|
|
context.print_status({ std::move(message), face } );
|
2014-03-31 23:07:02 +04:00
|
|
|
}
|
2014-02-14 06:21:06 +04:00
|
|
|
}
|
2014-02-08 05:02:58 +04:00
|
|
|
};
|
|
|
|
|
2014-02-12 13:02:09 +04:00
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc debug_cmd = {
|
|
|
|
"debug",
|
|
|
|
nullptr,
|
2014-06-06 16:58:35 +04:00
|
|
|
"debug <command>: write some debug informations in the debug buffer\n"
|
2017-06-17 11:29:09 +03:00
|
|
|
"existing commands: info, buffers, options, memory, shared-strings, profile-hash-maps",
|
2015-03-14 20:30:34 +03:00
|
|
|
ParameterDesc{{}, ParameterDesc::Flags::SwitchesOnlyAtStart, 1},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2016-09-18 18:07:00 +03:00
|
|
|
make_completer(
|
2015-01-06 22:06:53 +03:00
|
|
|
[](const Context& context, CompletionFlags flags,
|
|
|
|
const String& prefix, ByteCount cursor_pos) -> Completions {
|
2017-03-06 22:47:26 +03:00
|
|
|
auto c = {"info", "buffers", "options", "memory", "shared-strings", "profile-hash-maps"};
|
2015-01-06 22:06:53 +03:00
|
|
|
return { 0_byte, cursor_pos, complete(prefix, cursor_pos, c) };
|
2016-09-18 18:07:00 +03:00
|
|
|
}),
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2013-12-04 04:27:19 +04:00
|
|
|
{
|
2014-03-31 23:07:35 +04:00
|
|
|
if (parser[0] == "info")
|
|
|
|
{
|
2015-06-06 13:54:48 +03:00
|
|
|
write_to_debug_buffer(format("pid: {}", getpid()));
|
|
|
|
write_to_debug_buffer(format("session: {}", Server::instance().session()));
|
2014-03-31 23:07:35 +04:00
|
|
|
}
|
2014-11-28 16:18:08 +03:00
|
|
|
else if (parser[0] == "buffers")
|
2014-09-22 22:19:34 +04:00
|
|
|
{
|
2015-06-06 13:54:48 +03:00
|
|
|
write_to_debug_buffer("Buffers:");
|
2014-09-22 22:19:34 +04:00
|
|
|
for (auto& buffer : BufferManager::instance())
|
2015-06-06 13:54:48 +03:00
|
|
|
write_to_debug_buffer(buffer->debug_description());
|
2014-09-22 22:19:34 +04:00
|
|
|
}
|
2014-11-28 16:18:08 +03:00
|
|
|
else if (parser[0] == "options")
|
2014-11-26 16:27:26 +03:00
|
|
|
{
|
2015-06-06 13:54:48 +03:00
|
|
|
write_to_debug_buffer("Options:");
|
2014-11-26 16:27:26 +03:00
|
|
|
for (auto& option : context.options().flatten_options())
|
2015-06-06 13:54:48 +03:00
|
|
|
write_to_debug_buffer(format(" * {}: {}", option->name(), option->get_as_string()));
|
2014-11-26 16:27:26 +03:00
|
|
|
}
|
2015-01-07 22:29:31 +03:00
|
|
|
else if (parser[0] == "memory")
|
|
|
|
{
|
2015-01-12 22:46:40 +03:00
|
|
|
auto total = 0;
|
2015-06-06 13:54:48 +03:00
|
|
|
write_to_debug_buffer("Memory usage:");
|
2015-01-12 22:46:40 +03:00
|
|
|
for (int domain = 0; domain < (int)MemoryDomain::Count; ++domain)
|
|
|
|
{
|
|
|
|
size_t count = domain_allocated_bytes[domain];
|
|
|
|
total += count;
|
2015-06-06 13:54:48 +03:00
|
|
|
write_to_debug_buffer(format(" {}: {}", domain_name((MemoryDomain)domain), count));
|
2015-01-12 22:46:40 +03:00
|
|
|
}
|
2015-06-06 13:54:48 +03:00
|
|
|
write_to_debug_buffer(format(" Total: {}", total));
|
2015-01-14 22:16:32 +03:00
|
|
|
#if defined(__GLIBC__) || defined(__CYGWIN__)
|
2015-06-06 13:54:48 +03:00
|
|
|
write_to_debug_buffer(format(" Malloced: {}", mallinfo().uordblks));
|
2015-01-12 22:55:58 +03:00
|
|
|
#endif
|
2015-01-07 22:29:31 +03:00
|
|
|
}
|
2015-01-15 16:54:38 +03:00
|
|
|
else if (parser[0] == "shared-strings")
|
2015-01-13 16:48:16 +03:00
|
|
|
{
|
|
|
|
StringRegistry::instance().debug_stats();
|
|
|
|
}
|
2017-03-06 22:47:26 +03:00
|
|
|
else if (parser[0] == "profile-hash-maps")
|
|
|
|
{
|
|
|
|
profile_hash_maps();
|
|
|
|
}
|
2014-03-31 23:07:35 +04:00
|
|
|
else
|
2015-03-31 01:56:33 +03:00
|
|
|
throw runtime_error(format("unknown debug command '{}'", parser[0]));
|
2013-12-04 04:27:19 +04:00
|
|
|
}
|
2014-02-14 06:21:06 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
const CommandDesc source_cmd = {
|
|
|
|
"source",
|
|
|
|
nullptr,
|
|
|
|
"source <filename>: execute commands contained in <filename>",
|
2017-02-27 23:44:38 +03:00
|
|
|
single_param,
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
filename_completer,
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2013-12-04 04:27:19 +04:00
|
|
|
{
|
2017-01-06 22:43:20 +03:00
|
|
|
String path = real_path(parse_filename(parser[0]));
|
|
|
|
String file_content = read_file(path, true);
|
2014-02-14 06:21:06 +04:00
|
|
|
try
|
|
|
|
{
|
2017-01-06 22:43:20 +03:00
|
|
|
CommandManager::instance().execute(file_content, context,
|
|
|
|
{{}, {{"source", path}}});
|
2014-02-14 06:21:06 +04:00
|
|
|
}
|
|
|
|
catch (Kakoune::runtime_error& err)
|
|
|
|
{
|
2015-06-06 13:54:48 +03:00
|
|
|
write_to_debug_buffer(format("{}:{}", parser[0], err.what()));
|
2014-02-14 06:21:06 +04:00
|
|
|
throw;
|
|
|
|
}
|
2013-12-04 04:27:19 +04:00
|
|
|
}
|
2014-02-14 06:21:06 +04:00
|
|
|
};
|
2012-05-07 07:13:34 +04:00
|
|
|
|
2015-08-10 15:54:52 +03:00
|
|
|
static String option_doc_helper(const Context& context, CommandParameters params)
|
|
|
|
{
|
|
|
|
if (params.size() < 2)
|
|
|
|
return "";
|
|
|
|
|
|
|
|
auto desc = GlobalScope::instance().option_registry().option_desc(params[1]);
|
|
|
|
if (not desc or desc->docstring().empty())
|
|
|
|
return "";
|
|
|
|
|
2017-06-04 10:37:51 +03:00
|
|
|
return format("{}:\n{}", desc->name(), indent(desc->docstring()));
|
2015-08-10 15:54:52 +03:00
|
|
|
}
|
|
|
|
|
2015-11-06 16:56:48 +03:00
|
|
|
static OptionManager& get_options(StringView scope, const Context& context, StringView option_name)
|
|
|
|
{
|
|
|
|
if (scope == "current")
|
|
|
|
return context.options()[option_name].manager();
|
|
|
|
return get_scope(scope, context).options();
|
|
|
|
}
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc set_option_cmd = {
|
2016-11-15 16:49:06 +03:00
|
|
|
"set-option",
|
2014-02-14 06:21:06 +04:00
|
|
|
"set",
|
2016-11-15 16:49:06 +03:00
|
|
|
"set-option <switches> <scope> <name> <value>: set option <name> in <scope> to <value>\n"
|
2015-11-06 16:56:48 +03:00
|
|
|
"<scope> can be global, buffer, window, or current which refers to the narrowest\n"
|
|
|
|
"scope the option is set in",
|
2014-02-14 06:21:06 +04:00
|
|
|
ParameterDesc{
|
2015-03-14 20:30:34 +03:00
|
|
|
{ { "add", { false, "add to option rather than replacing it" } } },
|
|
|
|
ParameterDesc::Flags::SwitchesOnlyAtStart, 3, 3
|
2014-02-14 06:21:06 +04:00
|
|
|
},
|
|
|
|
CommandFlags::None,
|
2015-08-10 15:54:52 +03:00
|
|
|
option_doc_helper,
|
2014-02-14 06:21:06 +04:00
|
|
|
[](const Context& context, CompletionFlags,
|
|
|
|
CommandParameters params, size_t token_to_complete,
|
|
|
|
ByteCount pos_in_token) -> Completions
|
|
|
|
{
|
2015-10-22 15:29:34 +03:00
|
|
|
const bool add = params.size() > 1 and params[0] == "-add";
|
|
|
|
const int start = add ? 1 : 0;
|
|
|
|
|
2015-11-06 16:56:48 +03:00
|
|
|
static constexpr auto scopes = { "global", "buffer", "window", "current" };
|
|
|
|
|
2015-10-22 15:29:34 +03:00
|
|
|
if (token_to_complete == start)
|
|
|
|
return { 0_byte, params[start].length(),
|
|
|
|
complete(params[start], pos_in_token, scopes) };
|
|
|
|
else if (token_to_complete == start + 1)
|
|
|
|
return { 0_byte, params[start + 1].length(),
|
|
|
|
GlobalScope::instance().option_registry().complete_option_name(params[start + 1], pos_in_token) };
|
|
|
|
else if (not add and token_to_complete == start + 2 and
|
|
|
|
GlobalScope::instance().option_registry().option_exists(params[start + 1]))
|
2014-05-05 15:55:04 +04:00
|
|
|
{
|
2015-10-22 15:29:34 +03:00
|
|
|
OptionManager& options = get_scope(params[start], context).options();
|
|
|
|
String val = options[params[start + 1]].get_as_string();
|
|
|
|
if (prefix_match(val, params[start + 2]))
|
|
|
|
return { 0_byte, params[start + 2].length(), { std::move(val) } };
|
2014-05-05 15:55:04 +04:00
|
|
|
}
|
2014-02-14 06:21:06 +04:00
|
|
|
return Completions{};
|
|
|
|
},
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2014-02-14 06:21:06 +04:00
|
|
|
{
|
2015-11-06 16:56:48 +03:00
|
|
|
Option& opt = get_options(parser[0], context, parser[1]).get_local_option(parser[1]);
|
2015-03-14 22:16:46 +03:00
|
|
|
if (parser.get_switch("add"))
|
2014-02-14 06:21:06 +04:00
|
|
|
opt.add_from_string(parser[2]);
|
|
|
|
else
|
|
|
|
opt.set_from_string(parser[2]);
|
|
|
|
}
|
2014-02-08 05:02:58 +04:00
|
|
|
};
|
|
|
|
|
2017-05-25 10:38:11 +03:00
|
|
|
Completions complete_option(const Context& context, CompletionFlags,
|
|
|
|
CommandParameters params, size_t token_to_complete,
|
|
|
|
ByteCount pos_in_token)
|
|
|
|
{
|
|
|
|
if (token_to_complete == 0)
|
|
|
|
{
|
|
|
|
static constexpr auto scopes = { "buffer", "window", "current" };
|
|
|
|
return { 0_byte, params[0].length(), complete(params[0], pos_in_token, scopes) };
|
|
|
|
}
|
|
|
|
else if (token_to_complete == 1)
|
|
|
|
return { 0_byte, params[1].length(),
|
|
|
|
GlobalScope::instance().option_registry().complete_option_name(params[1], pos_in_token) };
|
|
|
|
return Completions{};
|
|
|
|
}
|
|
|
|
|
2015-08-10 15:54:52 +03:00
|
|
|
const CommandDesc unset_option_cmd = {
|
2016-11-15 16:49:06 +03:00
|
|
|
"unset-option",
|
2015-08-10 15:54:52 +03:00
|
|
|
"unset",
|
2016-11-15 16:49:06 +03:00
|
|
|
"unset-option <scope> <name>: remove <name> option from scope, falling back on parent scope value"
|
2015-11-06 16:56:48 +03:00
|
|
|
"<scope> can be buffer, window, or current which refers to the narrowest\n"
|
|
|
|
"scope the option is set in",
|
2015-08-10 15:54:52 +03:00
|
|
|
ParameterDesc{ {}, ParameterDesc::Flags::None, 2, 2 },
|
|
|
|
CommandFlags::None,
|
|
|
|
option_doc_helper,
|
2017-05-25 10:38:11 +03:00
|
|
|
complete_option,
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2015-08-10 15:54:52 +03:00
|
|
|
{
|
2015-12-02 22:25:40 +03:00
|
|
|
auto& options = get_options(parser[0], context, parser[1]);
|
|
|
|
if (&options == &GlobalScope::instance().options())
|
2015-08-10 15:54:52 +03:00
|
|
|
throw runtime_error("Cannot unset options in global scope");
|
2015-12-02 22:25:40 +03:00
|
|
|
options.unset_option(parser[1]);
|
2015-08-10 15:54:52 +03:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-05-25 10:38:11 +03:00
|
|
|
const CommandDesc update_option_cmd = {
|
|
|
|
"update-option",
|
|
|
|
nullptr,
|
|
|
|
"update-option <scope> <name>: update <name> option from scope\n"
|
|
|
|
"some option types, such as line-descs or range-descs can be updated to latest buffer timestamp\n"
|
|
|
|
"<scope> can be buffer, window, or current which refers to the narrowest\n"
|
|
|
|
"scope the option is set in",
|
|
|
|
ParameterDesc{ {}, ParameterDesc::Flags::None, 2, 2 },
|
|
|
|
CommandFlags::None,
|
|
|
|
option_doc_helper,
|
|
|
|
complete_option,
|
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
|
|
|
{
|
|
|
|
Option& opt = get_options(parser[0], context, parser[1]).get_local_option(parser[1]);
|
|
|
|
opt.update(context);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc declare_option_cmd = {
|
2016-11-14 03:27:14 +03:00
|
|
|
"declare-option",
|
2014-02-14 06:21:06 +04:00
|
|
|
"decl",
|
2016-11-14 03:27:14 +03:00
|
|
|
"declare-option <type> <name> [value]: declare option <name> of type <type>.\n"
|
2015-03-14 15:17:43 +03:00
|
|
|
"set its initial value to <value> if given and the option did not exist\n"
|
2014-02-14 06:21:06 +04:00
|
|
|
"Available types:\n"
|
|
|
|
" int: integer\n"
|
|
|
|
" bool: boolean (true/false or yes/no)\n"
|
|
|
|
" str: character string\n"
|
|
|
|
" regex: regular expression\n"
|
|
|
|
" int-list: list of integers\n"
|
|
|
|
" str-list: list of character strings\n"
|
2017-02-09 11:01:49 +03:00
|
|
|
" completions: list of completion candidates\n"
|
2017-05-24 17:41:43 +03:00
|
|
|
" line-specs: list of line specs\n"
|
2017-05-17 21:35:54 +03:00
|
|
|
" range-specs: list of range specs\n",
|
2014-02-14 06:21:06 +04:00
|
|
|
ParameterDesc{
|
2015-03-14 20:30:34 +03:00
|
|
|
{ { "hidden", { false, "do not display option name when completing" } },
|
|
|
|
{ "docstring", { true, "specify option description" } } },
|
|
|
|
ParameterDesc::Flags::SwitchesOnlyAtStart, 2, 3
|
2014-02-14 06:21:06 +04:00
|
|
|
},
|
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2017-02-09 12:18:13 +03:00
|
|
|
make_completer(
|
|
|
|
[](const Context& context, CompletionFlags flags,
|
|
|
|
const String& prefix, ByteCount cursor_pos) -> Completions {
|
2017-05-24 17:41:43 +03:00
|
|
|
auto c = {"int", "bool", "str", "regex", "int-list", "str-list", "completions", "line-specs", "range-specs"};
|
2017-02-09 12:18:13 +03:00
|
|
|
return { 0_byte, cursor_pos, complete(prefix, cursor_pos, c) };
|
|
|
|
}),
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2014-02-14 06:21:06 +04:00
|
|
|
{
|
|
|
|
Option* opt = nullptr;
|
|
|
|
|
2014-04-12 23:03:26 +04:00
|
|
|
OptionFlags flags = OptionFlags::None;
|
2015-03-14 22:16:46 +03:00
|
|
|
if (parser.get_switch("hidden"))
|
2014-04-12 23:03:26 +04:00
|
|
|
flags = OptionFlags::Hidden;
|
2014-02-14 06:21:06 +04:00
|
|
|
|
2017-06-16 12:48:14 +03:00
|
|
|
auto docstring = trim_whitespaces(parser.get_switch("docstring").value_or(StringView{})).str();
|
2014-10-30 17:00:42 +03:00
|
|
|
OptionsRegistry& reg = GlobalScope::instance().option_registry();
|
2014-02-14 06:21:06 +04:00
|
|
|
|
2017-03-16 12:57:39 +03:00
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
if (parser[0] == "int")
|
2014-10-30 17:00:42 +03:00
|
|
|
opt = ®.declare_option<int>(parser[1], docstring, 0, flags);
|
2014-04-14 22:01:00 +04:00
|
|
|
else if (parser[0] == "bool")
|
2017-01-09 01:30:15 +03:00
|
|
|
opt = ®.declare_option<bool>(parser[1], docstring, false, flags);
|
2014-02-14 06:21:06 +04:00
|
|
|
else if (parser[0] == "str")
|
2014-10-30 17:00:42 +03:00
|
|
|
opt = ®.declare_option<String>(parser[1], docstring, "", flags);
|
2014-02-14 06:21:06 +04:00
|
|
|
else if (parser[0] == "regex")
|
2014-10-30 17:00:42 +03:00
|
|
|
opt = ®.declare_option<Regex>(parser[1], docstring, Regex{}, flags);
|
2014-02-14 06:21:06 +04:00
|
|
|
else if (parser[0] == "int-list")
|
2015-01-12 16:24:30 +03:00
|
|
|
opt = ®.declare_option<Vector<int, MemoryDomain::Options>>(parser[1], docstring, {}, flags);
|
2014-02-14 06:21:06 +04:00
|
|
|
else if (parser[0] == "str-list")
|
2015-01-12 16:24:30 +03:00
|
|
|
opt = ®.declare_option<Vector<String, MemoryDomain::Options>>(parser[1], docstring, {}, flags);
|
2016-04-01 03:27:23 +03:00
|
|
|
else if (parser[0] == "completions")
|
|
|
|
opt = ®.declare_option<CompletionList>(parser[1], docstring, {}, flags);
|
2017-05-24 17:41:43 +03:00
|
|
|
else if (parser[0] == "line-specs")
|
|
|
|
opt = ®.declare_option<TimestampedList<LineAndSpec>>(parser[1], docstring, {}, flags);
|
2017-05-17 21:35:54 +03:00
|
|
|
else if (parser[0] == "range-specs")
|
|
|
|
opt = ®.declare_option<TimestampedList<RangeAndString>>(parser[1], docstring, {}, flags);
|
2014-02-14 06:21:06 +04:00
|
|
|
else
|
2015-06-01 23:15:59 +03:00
|
|
|
throw runtime_error(format("unknown type {}", parser[0]));
|
2013-03-03 20:25:40 +04:00
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
if (parser.positional_count() == 3)
|
|
|
|
opt->set_from_string(parser[2]);
|
|
|
|
}
|
2014-02-08 05:02:58 +04:00
|
|
|
};
|
|
|
|
|
2013-10-25 03:01:17 +04:00
|
|
|
KeymapMode parse_keymap_mode(const String& str)
|
|
|
|
{
|
|
|
|
if (prefix_match("normal", str)) return KeymapMode::Normal;
|
|
|
|
if (prefix_match("insert", str)) return KeymapMode::Insert;
|
|
|
|
if (prefix_match("menu", str)) return KeymapMode::Menu;
|
|
|
|
if (prefix_match("prompt", str)) return KeymapMode::Prompt;
|
2014-10-23 16:37:47 +04:00
|
|
|
if (prefix_match("goto", str)) return KeymapMode::Goto;
|
|
|
|
if (prefix_match("view", str)) return KeymapMode::View;
|
2014-12-12 16:57:02 +03:00
|
|
|
if (prefix_match("user", str)) return KeymapMode::User;
|
2015-07-01 18:47:42 +03:00
|
|
|
if (prefix_match("object", str)) return KeymapMode::Object;
|
2013-10-25 03:01:17 +04:00
|
|
|
|
2015-06-01 23:15:59 +03:00
|
|
|
throw runtime_error(format("unknown keymap mode '{}'", str));
|
2014-04-26 12:40:26 +04:00
|
|
|
}
|
|
|
|
|
2016-09-19 11:10:41 +03:00
|
|
|
auto map_key_completer =
|
|
|
|
[](const Context& context, CompletionFlags flags,
|
|
|
|
CommandParameters params, size_t token_to_complete,
|
|
|
|
ByteCount pos_in_token) -> Completions
|
|
|
|
{
|
|
|
|
if (token_to_complete == 0)
|
|
|
|
return { 0_byte, params[0].length(),
|
|
|
|
complete(params[0], pos_in_token, scopes) };
|
|
|
|
if (token_to_complete == 1)
|
|
|
|
{
|
|
|
|
constexpr const char* modes[] = { "normal", "insert", "menu", "prompt", "goto", "view", "user", "object" };
|
|
|
|
return { 0_byte, params[1].length(),
|
|
|
|
complete(params[1], pos_in_token, modes) };
|
|
|
|
}
|
|
|
|
return {};
|
|
|
|
};
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc map_key_cmd = {
|
|
|
|
"map",
|
|
|
|
nullptr,
|
2015-03-14 15:17:43 +03:00
|
|
|
"map <scope> <mode> <key> <keys>: map <key> to <keys> in given mode in <scope>.\n"
|
|
|
|
"<mode> can be:\n"
|
2014-02-14 06:21:06 +04:00
|
|
|
" normal\n"
|
|
|
|
" insert\n"
|
|
|
|
" menu\n"
|
2014-12-12 16:57:02 +03:00
|
|
|
" prompt\n"
|
2015-02-05 16:56:16 +03:00
|
|
|
" goto\n"
|
|
|
|
" view\n"
|
2015-07-01 18:47:42 +03:00
|
|
|
" user\n"
|
|
|
|
" object\n",
|
2017-03-03 19:51:29 +03:00
|
|
|
ParameterDesc{
|
|
|
|
{ { "docstring", { true, "specify mapping description" } } },
|
|
|
|
ParameterDesc::Flags::None, 4, 4
|
|
|
|
},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2016-09-19 11:10:41 +03:00
|
|
|
map_key_completer,
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2014-02-14 06:21:06 +04:00
|
|
|
{
|
2014-10-30 17:00:42 +03:00
|
|
|
KeymapManager& keymaps = get_scope(parser[0], context).keymaps();
|
2014-02-14 06:21:06 +04:00
|
|
|
KeymapMode keymap_mode = parse_keymap_mode(parser[1]);
|
2013-10-25 03:01:17 +04:00
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
KeyList key = parse_keys(parser[2]);
|
|
|
|
if (key.size() != 1)
|
|
|
|
throw runtime_error("only a single key can be mapped");
|
2013-10-25 03:01:17 +04:00
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
KeyList mapping = parse_keys(parser[3]);
|
2017-03-03 19:51:29 +03:00
|
|
|
keymaps.map_key(key[0], keymap_mode, std::move(mapping),
|
2017-06-16 12:48:14 +03:00
|
|
|
trim_whitespaces(parser.get_switch("docstring").value_or("")).str());
|
2014-02-14 06:21:06 +04:00
|
|
|
}
|
|
|
|
};
|
2013-10-25 03:01:17 +04:00
|
|
|
|
2016-09-19 11:10:41 +03:00
|
|
|
const CommandDesc unmap_key_cmd = {
|
|
|
|
"unmap",
|
|
|
|
nullptr,
|
|
|
|
"unmap <scope> <mode> <key> [<expected-keys>]: unmap <key> from given mode in <scope>.\n"
|
|
|
|
"If <expected> is specified, remove the mapping only if its value is <expected>\n"
|
|
|
|
"<mode> can be:\n"
|
|
|
|
" normal\n"
|
|
|
|
" insert\n"
|
|
|
|
" menu\n"
|
|
|
|
" prompt\n"
|
|
|
|
" goto\n"
|
|
|
|
" view\n"
|
|
|
|
" user\n"
|
|
|
|
" object\n",
|
2016-12-27 09:49:35 +03:00
|
|
|
ParameterDesc{{}, ParameterDesc::Flags::None, 3, 4},
|
2016-09-19 11:10:41 +03:00
|
|
|
CommandFlags::None,
|
|
|
|
CommandHelper{},
|
|
|
|
map_key_completer,
|
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
|
|
|
{
|
|
|
|
KeymapManager& keymaps = get_scope(parser[0], context).keymaps();
|
|
|
|
KeymapMode keymap_mode = parse_keymap_mode(parser[1]);
|
|
|
|
|
|
|
|
KeyList key = parse_keys(parser[2]);
|
|
|
|
if (key.size() != 1)
|
|
|
|
throw runtime_error("only a single key can be mapped");
|
|
|
|
|
|
|
|
if (keymaps.is_mapped(key[0], keymap_mode) and
|
|
|
|
(parser.positional_count() < 4 or
|
2017-03-03 19:51:29 +03:00
|
|
|
(keymaps.get_mapping(key[0], keymap_mode).keys ==
|
|
|
|
parse_keys(parser[3]))))
|
2016-09-19 11:10:41 +03:00
|
|
|
keymaps.unmap_key(key[0], keymap_mode);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-02-08 05:02:58 +04:00
|
|
|
const ParameterDesc context_wrap_params = {
|
2015-03-14 20:30:34 +03:00
|
|
|
{ { "client", { true, "run in given client context" } },
|
|
|
|
{ "try-client", { true, "run in given client context if it exists, or else in the current one" } },
|
|
|
|
{ "buffer", { true, "run in a disposable context for each given buffer in the comma separated list argument" } },
|
|
|
|
{ "draft", { false, "run in a disposable context" } },
|
|
|
|
{ "no-hooks", { false, "disable hooks" } },
|
|
|
|
{ "with-maps", { false, "use user defined key mapping when executing keys" } },
|
2015-11-26 02:40:38 +03:00
|
|
|
{ "itersel", { false, "run once for each selection with that selection as the only one" } },
|
2016-11-08 12:49:48 +03:00
|
|
|
{ "save-regs", { true, "restore all given registers after execution (defaults to '/\"|^@')" } },
|
2015-12-23 05:46:13 +03:00
|
|
|
{ "collapse-jumps", { false, "collapse all jumps into a single one from initial selection" } } },
|
2014-02-12 02:23:44 +04:00
|
|
|
ParameterDesc::Flags::SwitchesOnlyAtStart, 1
|
2014-02-08 05:02:58 +04:00
|
|
|
};
|
|
|
|
|
2015-11-26 02:40:38 +03:00
|
|
|
class RegisterRestorer
|
|
|
|
{
|
|
|
|
public:
|
2017-02-14 03:02:01 +03:00
|
|
|
RegisterRestorer(char name, Context& context)
|
|
|
|
: m_context{context}, m_name{name}
|
2015-11-26 02:40:38 +03:00
|
|
|
{
|
2017-02-14 03:02:01 +03:00
|
|
|
ConstArrayView<String> save = RegisterManager::instance()[name].get(context);
|
2015-11-26 02:40:38 +03:00
|
|
|
m_save = Vector<String>(save.begin(), save.end());
|
|
|
|
}
|
|
|
|
|
|
|
|
RegisterRestorer(RegisterRestorer&& other) noexcept
|
2017-02-14 03:02:01 +03:00
|
|
|
: m_context{other.m_context}, m_save{std::move(other.m_save)}, m_name{other.m_name}
|
2015-11-26 02:40:38 +03:00
|
|
|
{
|
|
|
|
other.m_name = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
~RegisterRestorer()
|
|
|
|
{
|
2017-02-14 02:31:16 +03:00
|
|
|
if (m_name != 0) try
|
|
|
|
{
|
2017-02-14 03:02:01 +03:00
|
|
|
RegisterManager::instance()[m_name].set(m_context, m_save);
|
2017-02-14 02:31:16 +03:00
|
|
|
}
|
|
|
|
catch (runtime_error& e)
|
|
|
|
{
|
|
|
|
write_to_debug_buffer(format("Could not restore register '{}': {}",
|
|
|
|
m_name, e.what()));
|
|
|
|
}
|
2015-11-26 02:40:38 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Vector<String> m_save;
|
2017-02-14 03:02:01 +03:00
|
|
|
Context& m_context;
|
2015-11-26 02:40:38 +03:00
|
|
|
char m_name;
|
|
|
|
};
|
|
|
|
|
2013-01-17 17:06:06 +04:00
|
|
|
template<typename Func>
|
2014-02-08 05:02:58 +04:00
|
|
|
void context_wrap(const ParametersParser& parser, Context& context, Func func)
|
2012-05-07 07:13:34 +04:00
|
|
|
{
|
2017-02-15 21:59:37 +03:00
|
|
|
if ((int)(bool)parser.get_switch("buffer") +
|
|
|
|
(int)(bool)parser.get_switch("client") +
|
|
|
|
(int)(bool)parser.get_switch("try-client") > 1)
|
|
|
|
throw runtime_error{"Only one of -buffer, -client or -try-client can be specified"};
|
|
|
|
|
2016-09-27 01:43:05 +03:00
|
|
|
const bool no_hooks = parser.get_switch("no-hooks") or context.hooks_disabled();
|
2015-11-27 02:25:48 +03:00
|
|
|
const bool no_keymaps = not parser.get_switch("with-maps");
|
2014-05-25 20:36:12 +04:00
|
|
|
|
2015-11-26 02:40:38 +03:00
|
|
|
Vector<RegisterRestorer> saved_registers;
|
2016-06-22 21:57:21 +03:00
|
|
|
for (auto& r : parser.get_switch("save-regs").value_or("/\"|^@"))
|
2015-11-26 16:32:29 +03:00
|
|
|
saved_registers.emplace_back(r, context);
|
2015-11-26 02:40:38 +03:00
|
|
|
|
2015-03-14 22:16:46 +03:00
|
|
|
if (auto bufnames = parser.get_switch("buffer"))
|
2014-02-19 06:59:41 +04:00
|
|
|
{
|
2015-04-21 15:40:14 +03:00
|
|
|
auto context_wrap_for_buffer = [&](Buffer& buffer) {
|
2014-12-19 02:12:58 +03:00
|
|
|
InputHandler input_handler{{ buffer, Selection{} },
|
|
|
|
Context::Flags::Transient};
|
2014-12-05 17:01:07 +03:00
|
|
|
Context& c = input_handler.context();
|
|
|
|
|
2016-09-27 01:43:05 +03:00
|
|
|
ScopedSetBool disable_hooks(c.hooks_disabled(), no_hooks);
|
2015-11-27 02:25:48 +03:00
|
|
|
ScopedSetBool disable_keymaps(c.keymaps_disabled(), no_keymaps);
|
|
|
|
ScopedSetBool disable_history(c.history_disabled());
|
2014-12-05 17:01:07 +03:00
|
|
|
|
|
|
|
func(parser, c);
|
2015-04-21 15:40:14 +03:00
|
|
|
};
|
|
|
|
if (*bufnames == "*")
|
2016-02-12 02:07:42 +03:00
|
|
|
{
|
|
|
|
// copy buffer list as we might be mutating the buffer list
|
|
|
|
// in the loop.
|
2016-05-14 10:33:50 +03:00
|
|
|
auto ptrs = BufferManager::instance() |
|
2017-06-07 22:25:39 +03:00
|
|
|
transform(std::mem_fn(&std::unique_ptr<Buffer>::get)) |
|
|
|
|
filter([](Buffer* buf) { return not (buf->flags() & Buffer::Flags::Debug); });
|
2016-05-14 10:33:50 +03:00
|
|
|
Vector<SafePtr<Buffer>> buffers{ptrs.begin(), ptrs.end()};
|
2016-02-12 02:07:42 +03:00
|
|
|
for (auto buffer : buffers)
|
2017-06-07 22:25:39 +03:00
|
|
|
context_wrap_for_buffer(*buffer);
|
2016-02-12 02:07:42 +03:00
|
|
|
}
|
2015-04-21 15:40:14 +03:00
|
|
|
else
|
|
|
|
for (auto& name : split(*bufnames, ','))
|
|
|
|
context_wrap_for_buffer(BufferManager::instance().get_buffer(name));
|
2014-02-19 06:59:41 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-06-07 22:33:34 +03:00
|
|
|
ClientManager& cm = ClientManager::instance();
|
2016-06-23 00:17:31 +03:00
|
|
|
Context* base_context = &context;
|
2015-03-14 22:16:46 +03:00
|
|
|
if (auto client_name = parser.get_switch("client"))
|
2016-06-23 00:17:31 +03:00
|
|
|
base_context = &cm.get_client(*client_name).context();
|
2015-03-14 22:16:46 +03:00
|
|
|
else if (auto client_name = parser.get_switch("try-client"))
|
2013-12-07 17:44:23 +04:00
|
|
|
{
|
2015-03-14 22:16:46 +03:00
|
|
|
if (Client* client = cm.get_client_ifp(*client_name))
|
2016-06-23 00:17:31 +03:00
|
|
|
base_context = &client->context();
|
2013-12-07 17:44:23 +04:00
|
|
|
}
|
2013-01-17 16:58:09 +04:00
|
|
|
|
2016-06-23 00:17:31 +03:00
|
|
|
Optional<InputHandler> input_handler;
|
|
|
|
Context* effective_context = base_context;
|
|
|
|
|
|
|
|
const bool draft = (bool)parser.get_switch("draft");
|
|
|
|
if (draft)
|
2013-02-07 22:25:07 +04:00
|
|
|
{
|
2016-06-23 00:17:31 +03:00
|
|
|
input_handler.emplace(base_context->selections(),
|
|
|
|
Context::Flags::Transient,
|
|
|
|
base_context->name());
|
|
|
|
effective_context = &input_handler->context();
|
2013-11-06 03:50:44 +04:00
|
|
|
|
2016-06-20 21:45:15 +03:00
|
|
|
// Preserve window so that window scope is available
|
2016-06-23 00:17:31 +03:00
|
|
|
if (base_context->has_window())
|
|
|
|
effective_context->set_window(base_context->window());
|
2016-06-20 21:45:15 +03:00
|
|
|
|
2013-12-15 22:07:51 +04:00
|
|
|
// We do not want this draft context to commit undo groups if the real one is
|
|
|
|
// going to commit the whole thing later
|
2016-06-23 00:17:31 +03:00
|
|
|
if (base_context->is_editing())
|
|
|
|
effective_context->disable_undo_handling();
|
|
|
|
}
|
2013-12-15 22:07:51 +04:00
|
|
|
|
2016-06-23 00:17:31 +03:00
|
|
|
Context& c = *effective_context;
|
2014-07-24 22:18:39 +04:00
|
|
|
|
2016-09-27 01:43:05 +03:00
|
|
|
ScopedSetBool disable_hooks(c.hooks_disabled(), no_hooks);
|
2016-06-23 00:17:31 +03:00
|
|
|
ScopedSetBool disable_keymaps(c.keymaps_disabled(), no_keymaps);
|
|
|
|
ScopedSetBool disable_history(c.history_disabled());
|
|
|
|
|
|
|
|
if (parser.get_switch("itersel"))
|
|
|
|
{
|
|
|
|
SelectionList sels{base_context->selections()};
|
2016-07-08 11:52:10 +03:00
|
|
|
Vector<Selection> new_sels;
|
|
|
|
size_t main = 0;
|
|
|
|
size_t timestamp = c.buffer().timestamp();
|
2016-06-23 00:17:31 +03:00
|
|
|
ScopedEdition edition{c};
|
|
|
|
for (auto& sel : sels)
|
2013-11-06 03:50:44 +04:00
|
|
|
{
|
2016-06-23 00:17:31 +03:00
|
|
|
c.selections_write_only() = SelectionList{ sels.buffer(), sel, sels.timestamp() };
|
|
|
|
c.selections().update();
|
2014-05-13 02:25:15 +04:00
|
|
|
|
2016-06-23 00:17:31 +03:00
|
|
|
func(parser, c);
|
2014-05-13 02:25:15 +04:00
|
|
|
|
2016-06-23 00:17:31 +03:00
|
|
|
if (&sels.buffer() != &c.buffer())
|
|
|
|
throw runtime_error("the buffer has changed while iterating on selections");
|
2016-07-08 11:52:10 +03:00
|
|
|
|
|
|
|
if (not draft)
|
|
|
|
{
|
|
|
|
update_selections(new_sels, main, c.buffer(), timestamp);
|
|
|
|
timestamp = c.buffer().timestamp();
|
|
|
|
for (auto& sel : c.selections())
|
|
|
|
new_sels.push_back(sel);
|
|
|
|
}
|
2016-06-23 00:17:31 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (not draft)
|
|
|
|
{
|
2016-07-08 11:52:10 +03:00
|
|
|
c.selections_write_only() = SelectionList(c.buffer(), new_sels);
|
|
|
|
c.selections().sort_and_merge_overlapping();
|
2013-11-06 03:50:44 +04:00
|
|
|
}
|
2013-02-07 22:25:07 +04:00
|
|
|
}
|
|
|
|
else
|
2013-11-06 03:50:44 +04:00
|
|
|
{
|
2016-06-23 00:17:31 +03:00
|
|
|
const bool collapse_jumps = not draft and (bool)parser.get_switch("collapse-jumps");
|
2015-12-23 05:46:13 +03:00
|
|
|
SelectionList jump = c.selections();
|
|
|
|
JumpList original_jump_list = collapse_jumps ? c.jump_list() : JumpList{};
|
|
|
|
|
2015-11-27 02:25:48 +03:00
|
|
|
func(parser, c);
|
2015-12-23 05:46:13 +03:00
|
|
|
|
|
|
|
if (collapse_jumps and c.jump_list() != original_jump_list)
|
|
|
|
{
|
|
|
|
c.jump_list() = std::move(original_jump_list);
|
|
|
|
c.jump_list().push(std::move(jump));
|
|
|
|
}
|
2013-11-06 03:50:44 +04:00
|
|
|
}
|
2012-12-03 21:57:57 +04:00
|
|
|
}
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc exec_string_cmd = {
|
|
|
|
"exec",
|
|
|
|
nullptr,
|
2016-08-05 11:43:33 +03:00
|
|
|
"exec <switches> <keys>: execute given keys as if entered by user",
|
2014-02-14 06:21:06 +04:00
|
|
|
context_wrap_params,
|
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandCompleter{},
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2014-02-14 06:21:06 +04:00
|
|
|
{
|
|
|
|
context_wrap(parser, context, [](const ParametersParser& parser, Context& context) {
|
|
|
|
KeyList keys;
|
|
|
|
for (auto& param : parser)
|
|
|
|
{
|
|
|
|
KeyList param_keys = parse_keys(param);
|
|
|
|
keys.insert(keys.end(), param_keys.begin(), param_keys.end());
|
|
|
|
}
|
2015-12-28 02:14:14 +03:00
|
|
|
|
|
|
|
ScopedEdition edition(context);
|
|
|
|
for (auto& key : keys)
|
|
|
|
context.input_handler().handle_key(key);
|
2014-02-14 06:21:06 +04:00
|
|
|
});
|
|
|
|
}
|
2014-02-12 02:16:17 +04:00
|
|
|
};
|
2012-05-29 03:50:11 +04:00
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc eval_string_cmd = {
|
|
|
|
"eval",
|
|
|
|
nullptr,
|
2014-06-06 16:58:35 +04:00
|
|
|
"eval <switches> <commands>...: execute commands as if entered by user",
|
2014-02-14 06:21:06 +04:00
|
|
|
context_wrap_params,
|
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandCompleter{},
|
2016-10-07 01:22:39 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext& shell_context)
|
2012-05-29 03:50:11 +04:00
|
|
|
{
|
2016-10-07 01:22:39 +03:00
|
|
|
context_wrap(parser, context, [&](const ParametersParser& parser, Context& context) {
|
2015-06-01 23:15:59 +03:00
|
|
|
String command = join(parser, ' ', false);
|
2017-03-07 19:18:09 +03:00
|
|
|
ScopedEdition edition(context);
|
2016-10-07 01:22:39 +03:00
|
|
|
CommandManager::instance().execute(command, context, shell_context);
|
2014-02-14 06:21:06 +04:00
|
|
|
});
|
2012-05-29 03:50:11 +04:00
|
|
|
}
|
2014-02-14 06:21:06 +04:00
|
|
|
};
|
2012-05-29 03:50:11 +04:00
|
|
|
|
2017-01-24 23:20:50 +03:00
|
|
|
struct CapturedShellContext
|
|
|
|
{
|
|
|
|
explicit CapturedShellContext(const ShellContext& sc)
|
|
|
|
: params{sc.params.begin(), sc.params.end()}, env_vars{sc.env_vars} {}
|
|
|
|
|
|
|
|
Vector<String> params;
|
|
|
|
EnvVarMap env_vars;
|
|
|
|
|
|
|
|
operator ShellContext() const { return { params, env_vars }; }
|
|
|
|
};
|
|
|
|
|
2014-04-13 17:15:34 +04:00
|
|
|
const CommandDesc prompt_cmd = {
|
|
|
|
"prompt",
|
|
|
|
nullptr,
|
2016-12-15 16:42:46 +03:00
|
|
|
"prompt <prompt> <command>: prompt the user to enter a text string "
|
2016-11-27 23:57:04 +03:00
|
|
|
"and then executes <command>, entered text is available in the 'text' value",
|
2014-04-26 18:09:07 +04:00
|
|
|
ParameterDesc{
|
2015-11-23 16:57:36 +03:00
|
|
|
{ { "init", { true, "set initial prompt content" } },
|
2016-04-19 11:51:09 +03:00
|
|
|
{ "password", { false, "Do not display entered text and clear reg after command" } },
|
2015-11-23 16:57:36 +03:00
|
|
|
{ "file-completion", { false, "use file completion for prompt" } },
|
|
|
|
{ "client-completion", { false, "use client completion for prompt" } },
|
|
|
|
{ "buffer-completion", { false, "use buffer completion for prompt" } },
|
2017-02-12 15:51:58 +03:00
|
|
|
{ "command-completion", { false, "use command completion for prompt" } },
|
|
|
|
{ "on-change", { true, "command to execute whenever the prompt changes" } },
|
|
|
|
{ "on-abort", { true, "command to execute whenever the prompt is canceled" } } },
|
2016-11-27 23:57:04 +03:00
|
|
|
ParameterDesc::Flags::None, 2, 2
|
2014-04-26 18:09:07 +04:00
|
|
|
},
|
2014-04-13 17:15:34 +04:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-04-13 17:15:34 +04:00
|
|
|
CommandCompleter{},
|
2015-11-23 16:57:36 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext& shell_context)
|
2014-04-13 17:15:34 +04:00
|
|
|
{
|
2016-11-27 23:57:04 +03:00
|
|
|
const String& command = parser[1];
|
2015-11-23 16:57:36 +03:00
|
|
|
auto initstr = parser.get_switch("init").value_or(StringView{});
|
|
|
|
|
|
|
|
Completer completer;
|
|
|
|
if (parser.get_switch("file-completion"))
|
|
|
|
completer = [](const Context& context, CompletionFlags,
|
|
|
|
StringView prefix, ByteCount cursor_pos) -> Completions {
|
|
|
|
auto& ignored_files = context.options()["ignored_files"].get<Regex>();
|
|
|
|
return { 0_byte, cursor_pos,
|
2016-10-13 21:46:09 +03:00
|
|
|
complete_filename(prefix, ignored_files, cursor_pos,
|
|
|
|
FilenameFlags::Expand) };
|
2015-11-23 16:57:36 +03:00
|
|
|
};
|
|
|
|
else if (parser.get_switch("client-completion"))
|
|
|
|
completer = [](const Context& context, CompletionFlags,
|
|
|
|
StringView prefix, ByteCount cursor_pos) -> Completions {
|
|
|
|
return { 0_byte, cursor_pos,
|
|
|
|
ClientManager::instance().complete_client_name(prefix, cursor_pos) };
|
|
|
|
};
|
|
|
|
else if (parser.get_switch("buffer-completion"))
|
2016-09-18 18:07:00 +03:00
|
|
|
completer = complete_buffer_name;
|
2015-11-23 16:57:36 +03:00
|
|
|
else if (parser.get_switch("command-completion"))
|
|
|
|
completer = [](const Context& context, CompletionFlags flags,
|
|
|
|
StringView prefix, ByteCount cursor_pos) -> Completions {
|
|
|
|
return CommandManager::instance().complete(
|
|
|
|
context, flags, prefix, cursor_pos);
|
|
|
|
};
|
|
|
|
|
2016-08-22 22:31:08 +03:00
|
|
|
const auto flags = parser.get_switch("password") ?
|
|
|
|
PromptFlags::Password : PromptFlags::None;
|
2014-04-26 18:09:07 +04:00
|
|
|
|
2017-02-12 15:51:58 +03:00
|
|
|
String on_change = parser.get_switch("on-change").value_or("").str();
|
|
|
|
String on_abort = parser.get_switch("on-abort").value_or("").str();
|
|
|
|
|
2017-01-24 23:20:50 +03:00
|
|
|
CapturedShellContext sc{shell_context};
|
2014-04-13 17:15:34 +04:00
|
|
|
context.input_handler().prompt(
|
2016-04-19 11:51:09 +03:00
|
|
|
parser[0], initstr.str(), get_face("Prompt"),
|
2016-08-22 22:31:08 +03:00
|
|
|
flags, std::move(completer),
|
2016-11-27 23:57:04 +03:00
|
|
|
[=](StringView str, PromptEvent event, Context& context) mutable
|
2014-04-13 17:15:34 +04:00
|
|
|
{
|
2017-02-12 15:51:58 +03:00
|
|
|
if ((event == PromptEvent::Abort and on_abort.empty()) or
|
|
|
|
(event == PromptEvent::Change and on_change.empty()))
|
2014-04-13 17:15:34 +04:00
|
|
|
return;
|
|
|
|
|
2017-03-07 03:30:54 +03:00
|
|
|
auto& text = sc.env_vars["text"_sv] = str.str();
|
2017-02-12 15:51:58 +03:00
|
|
|
auto clear_password = on_scope_end([&] {
|
|
|
|
if (flags & PromptFlags::Password)
|
|
|
|
memset(text.data(), 0, (int)text.length());
|
|
|
|
});
|
2015-11-27 02:25:48 +03:00
|
|
|
|
2017-02-12 15:51:58 +03:00
|
|
|
ScopedSetBool disable_history{context.history_disabled()};
|
2016-04-19 11:51:09 +03:00
|
|
|
|
2017-02-12 15:51:58 +03:00
|
|
|
StringView cmd;
|
|
|
|
switch (event)
|
2016-04-20 15:31:34 +03:00
|
|
|
{
|
2017-02-12 15:51:58 +03:00
|
|
|
case PromptEvent::Validate: cmd = command; break;
|
|
|
|
case PromptEvent::Change: cmd = on_change; break;
|
|
|
|
case PromptEvent::Abort: cmd = on_abort; break;
|
2016-04-20 15:31:34 +03:00
|
|
|
}
|
2017-02-12 15:51:58 +03:00
|
|
|
CommandManager::instance().execute(cmd, context, sc);
|
2014-04-13 17:15:34 +04:00
|
|
|
});
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc menu_cmd = {
|
|
|
|
"menu",
|
|
|
|
nullptr,
|
2015-03-14 15:17:43 +03:00
|
|
|
"menu <switches> <name1> <commands1> <name2> <commands2>...: display a "
|
|
|
|
"menu and execute commands for the selected item",
|
2014-02-14 06:21:06 +04:00
|
|
|
ParameterDesc{
|
2015-03-14 20:30:34 +03:00
|
|
|
{ { "auto-single", { false, "instantly validate if only one item is available" } },
|
2015-10-05 15:51:13 +03:00
|
|
|
{ "select-cmds", { false, "each item specify an additional command to run when selected" } },
|
|
|
|
{ "markup", { false, "parse menu entries as markup text" } } }
|
2014-02-14 06:21:06 +04:00
|
|
|
},
|
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandCompleter{},
|
2015-11-18 23:15:51 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext& shell_context)
|
2012-09-03 16:22:02 +04:00
|
|
|
{
|
2015-03-14 22:16:46 +03:00
|
|
|
const bool with_select_cmds = (bool)parser.get_switch("select-cmds");
|
2015-10-05 15:51:13 +03:00
|
|
|
const bool markup = (bool)parser.get_switch("markup");
|
2014-02-14 06:21:06 +04:00
|
|
|
const size_t modulo = with_select_cmds ? 3 : 2;
|
2012-05-18 09:20:46 +04:00
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const size_t count = parser.positional_count();
|
|
|
|
if (count == 0 or (count % modulo) != 0)
|
|
|
|
throw wrong_argument_count();
|
2012-05-18 09:20:46 +04:00
|
|
|
|
2015-03-14 22:16:46 +03:00
|
|
|
if (count == modulo and parser.get_switch("auto-single"))
|
2014-02-14 06:21:06 +04:00
|
|
|
{
|
2015-11-27 02:25:48 +03:00
|
|
|
ScopedSetBool disable_history{context.history_disabled()};
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandManager::instance().execute(parser[1], context);
|
|
|
|
return;
|
|
|
|
}
|
2012-12-14 22:04:34 +04:00
|
|
|
|
2015-10-05 03:25:23 +03:00
|
|
|
Vector<DisplayLine> choices;
|
2015-01-12 16:58:41 +03:00
|
|
|
Vector<String> commands;
|
|
|
|
Vector<String> select_cmds;
|
2014-02-14 06:21:06 +04:00
|
|
|
for (int i = 0; i < count; i += modulo)
|
|
|
|
{
|
2015-10-05 15:51:13 +03:00
|
|
|
choices.push_back(markup ? parse_display_line(parser[i])
|
|
|
|
: DisplayLine{ parser[i], {} });
|
2014-02-14 06:21:06 +04:00
|
|
|
commands.push_back(parser[i+1]);
|
|
|
|
if (with_select_cmds)
|
|
|
|
select_cmds.push_back(parser[i+2]);
|
|
|
|
}
|
2014-02-12 13:02:09 +04:00
|
|
|
|
2017-01-24 23:20:50 +03:00
|
|
|
CapturedShellContext sc{shell_context};
|
2016-02-27 20:23:13 +03:00
|
|
|
context.input_handler().menu(std::move(choices),
|
2014-02-14 06:21:06 +04:00
|
|
|
[=](int choice, MenuEvent event, Context& context) {
|
2015-11-27 02:25:48 +03:00
|
|
|
ScopedSetBool disable_history{context.history_disabled()};
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
if (event == MenuEvent::Validate and choice >= 0 and choice < commands.size())
|
2017-01-24 23:20:50 +03:00
|
|
|
CommandManager::instance().execute(commands[choice], context, sc);
|
2014-02-14 06:21:06 +04:00
|
|
|
if (event == MenuEvent::Select and choice >= 0 and choice < select_cmds.size())
|
2017-01-24 23:20:50 +03:00
|
|
|
CommandManager::instance().execute(select_cmds[choice], context, sc);
|
2014-02-14 06:21:06 +04:00
|
|
|
});
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2016-11-27 23:57:04 +03:00
|
|
|
const CommandDesc on_key_cmd = {
|
|
|
|
"on-key",
|
2015-04-04 15:10:39 +03:00
|
|
|
nullptr,
|
2016-11-27 23:57:04 +03:00
|
|
|
"on-key <command>: wait for next user key then and execute <command>, "
|
2017-05-27 23:37:25 +03:00
|
|
|
"with key available in the `key` value",
|
2016-11-27 23:57:04 +03:00
|
|
|
ParameterDesc{ {}, ParameterDesc::Flags::None, 1, 1 },
|
2015-04-04 15:10:39 +03:00
|
|
|
CommandFlags::None,
|
|
|
|
CommandHelper{},
|
|
|
|
CommandCompleter{},
|
2015-11-18 23:15:51 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext& shell_context)
|
2015-04-04 15:10:39 +03:00
|
|
|
{
|
2016-11-27 23:57:04 +03:00
|
|
|
String command = parser[0];
|
|
|
|
|
2017-01-24 23:20:50 +03:00
|
|
|
CapturedShellContext sc{shell_context};
|
2016-11-27 23:57:04 +03:00
|
|
|
context.input_handler().on_next_key(
|
|
|
|
KeymapMode::None, [=](Key key, Context& context) mutable {
|
2017-03-07 03:30:54 +03:00
|
|
|
sc.env_vars["key"_sv] = key_to_str(key);
|
2015-11-27 02:25:48 +03:00
|
|
|
ScopedSetBool disable_history{context.history_disabled()};
|
|
|
|
|
2016-11-27 23:57:04 +03:00
|
|
|
CommandManager::instance().execute(command, context, sc);
|
2015-04-04 15:10:39 +03:00
|
|
|
});
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc info_cmd = {
|
|
|
|
"info",
|
|
|
|
nullptr,
|
|
|
|
"info <switches> <params>...: display an info box with the params as content",
|
|
|
|
ParameterDesc{
|
2015-03-14 20:30:34 +03:00
|
|
|
{ { "anchor", { true, "set info anchoring <line>.<column>" } },
|
|
|
|
{ "placement", { true, "set placement relative to anchor (above, below)" } },
|
|
|
|
{ "title", { true, "set info title" } } },
|
2014-02-14 06:21:06 +04:00
|
|
|
ParameterDesc::Flags::None, 0, 1
|
|
|
|
},
|
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandCompleter{},
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2012-12-14 22:25:27 +04:00
|
|
|
{
|
2016-02-27 20:23:13 +03:00
|
|
|
if (not context.has_client())
|
|
|
|
return;
|
|
|
|
|
|
|
|
context.client().info_hide();
|
2014-02-14 06:21:06 +04:00
|
|
|
if (parser.positional_count() > 0)
|
2013-01-29 21:56:14 +04:00
|
|
|
{
|
2014-11-08 20:59:38 +03:00
|
|
|
InfoStyle style = InfoStyle::Prompt;
|
2016-09-22 22:36:26 +03:00
|
|
|
BufferCoord pos;
|
2015-03-14 22:16:46 +03:00
|
|
|
if (auto anchor = parser.get_switch("anchor"))
|
2014-02-14 06:21:06 +04:00
|
|
|
{
|
2015-03-14 22:16:46 +03:00
|
|
|
auto dot = find(*anchor, '.');
|
|
|
|
if (dot == anchor->end())
|
2014-11-01 00:49:36 +03:00
|
|
|
throw runtime_error("expected <line>.<column> for anchor");
|
2016-02-27 20:23:13 +03:00
|
|
|
|
2016-09-22 22:36:26 +03:00
|
|
|
pos = BufferCoord{str_to_int({anchor->begin(), dot})-1,
|
2015-03-14 22:16:46 +03:00
|
|
|
str_to_int({dot+1, anchor->end()})-1};
|
2014-11-08 20:59:38 +03:00
|
|
|
style = InfoStyle::Inline;
|
2016-02-27 20:23:13 +03:00
|
|
|
|
2015-03-14 22:16:46 +03:00
|
|
|
if (auto placement = parser.get_switch("placement"))
|
2014-11-10 16:28:06 +03:00
|
|
|
{
|
2015-03-14 22:16:46 +03:00
|
|
|
if (*placement == "above")
|
2014-11-10 16:28:06 +03:00
|
|
|
style = InfoStyle::InlineAbove;
|
2015-03-14 22:16:46 +03:00
|
|
|
else if (*placement == "below")
|
2014-11-10 16:28:06 +03:00
|
|
|
style = InfoStyle::InlineBelow;
|
|
|
|
else
|
2015-06-01 23:15:59 +03:00
|
|
|
throw runtime_error(format("invalid placement '{}'", *placement));
|
2014-11-10 16:28:06 +03:00
|
|
|
}
|
2014-02-14 06:21:06 +04:00
|
|
|
}
|
2015-03-14 22:16:46 +03:00
|
|
|
auto title = parser.get_switch("title").value_or(StringView{});
|
2016-02-27 20:23:13 +03:00
|
|
|
context.client().info_show(title.str(), parser[0], pos, style);
|
2013-01-29 21:56:14 +04:00
|
|
|
}
|
2012-12-14 22:25:27 +04:00
|
|
|
}
|
2014-02-08 05:02:58 +04:00
|
|
|
};
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc try_catch_cmd = {
|
|
|
|
"try",
|
|
|
|
nullptr,
|
2015-03-14 15:17:43 +03:00
|
|
|
"try <cmds> [catch <error_cmds>]: execute <cmds> in current context.\n"
|
|
|
|
"if an error is raised and <error_cmds> is specified, execute it; "
|
2014-02-14 06:21:06 +04:00
|
|
|
"The error is not propagated further.",
|
2015-03-14 20:30:34 +03:00
|
|
|
ParameterDesc{{}, ParameterDesc::Flags::None, 1, 3},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandCompleter{},
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext& shell_context)
|
2014-02-14 06:21:06 +04:00
|
|
|
{
|
|
|
|
if (parser.positional_count() == 2)
|
|
|
|
throw wrong_argument_count();
|
2013-10-31 23:22:00 +04:00
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const bool do_catch = parser.positional_count() == 3;
|
|
|
|
if (do_catch and parser[1] != "catch")
|
|
|
|
throw runtime_error("usage: try <commands> [catch <on error commands>]");
|
2012-06-04 18:27:34 +04:00
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandManager& command_manager = CommandManager::instance();
|
|
|
|
try
|
|
|
|
{
|
2015-10-22 15:59:23 +03:00
|
|
|
command_manager.execute(parser[0], context, shell_context);
|
2014-02-14 06:21:06 +04:00
|
|
|
}
|
|
|
|
catch (Kakoune::runtime_error& e)
|
|
|
|
{
|
|
|
|
if (do_catch)
|
2015-10-22 15:59:23 +03:00
|
|
|
command_manager.execute(parser[2], context, shell_context);
|
2014-02-14 06:21:06 +04:00
|
|
|
}
|
2012-06-04 18:27:34 +04:00
|
|
|
}
|
2014-02-14 06:21:06 +04:00
|
|
|
};
|
|
|
|
|
2014-07-12 13:55:50 +04:00
|
|
|
static Completions complete_face(const Context&, CompletionFlags flags,
|
|
|
|
const String& prefix, ByteCount cursor_pos)
|
2014-03-29 17:18:46 +04:00
|
|
|
{
|
2014-05-18 17:14:37 +04:00
|
|
|
return {0_byte, cursor_pos,
|
2014-07-11 03:27:04 +04:00
|
|
|
FaceRegistry::instance().complete_alias_name(prefix, cursor_pos)};
|
2014-03-29 17:18:46 +04:00
|
|
|
}
|
|
|
|
|
2016-11-15 16:49:06 +03:00
|
|
|
const CommandDesc set_face_cmd = {
|
|
|
|
"set-face",
|
2014-07-12 13:55:50 +04:00
|
|
|
"face",
|
2016-11-15 16:49:06 +03:00
|
|
|
"set-face <name> <facespec>: set face <name> to refer to <facespec>\n"
|
2015-06-04 00:10:37 +03:00
|
|
|
"\n"
|
|
|
|
"facespec format is <fg color>[,<bg color>][+<attributes>]\n"
|
|
|
|
"colors are either a color name, or rgb:###### values.\n"
|
|
|
|
"attributes is a combination of:\n"
|
2015-11-11 22:05:47 +03:00
|
|
|
" u: underline, i: italic, b: bold, r: reverse,\n"
|
|
|
|
" B: blink, d: dim, e: exclusive\n"
|
2015-06-04 00:10:37 +03:00
|
|
|
"facespec can as well just be the name of another face" ,
|
2015-03-14 20:30:34 +03:00
|
|
|
ParameterDesc{{}, ParameterDesc::Flags::None, 2, 2},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2016-09-20 01:26:52 +03:00
|
|
|
make_completer(complete_face, complete_face),
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2012-06-04 18:27:34 +04:00
|
|
|
{
|
2014-07-11 03:27:04 +04:00
|
|
|
FaceRegistry::instance().register_alias(parser[0], parser[1], true);
|
2015-06-30 21:12:25 +03:00
|
|
|
|
|
|
|
for (auto& client : ClientManager::instance())
|
2015-08-23 15:29:24 +03:00
|
|
|
client->force_redraw();
|
2012-06-04 18:27:34 +04:00
|
|
|
}
|
2014-02-08 05:02:58 +04:00
|
|
|
};
|
|
|
|
|
2016-11-15 16:49:06 +03:00
|
|
|
const CommandDesc rename_client_cmd = {
|
2016-11-14 03:27:14 +03:00
|
|
|
"rename-client",
|
2014-02-14 06:21:06 +04:00
|
|
|
"nc",
|
2016-11-15 16:49:06 +03:00
|
|
|
"rename-client <name>: set current client name to <name>",
|
2017-02-27 23:44:38 +03:00
|
|
|
single_param,
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandCompleter{},
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2014-02-14 06:21:06 +04:00
|
|
|
{
|
|
|
|
if (ClientManager::instance().validate_client_name(parser[0]))
|
|
|
|
context.set_name(parser[0]);
|
|
|
|
else if (context.name() != parser[0])
|
2015-06-01 23:15:59 +03:00
|
|
|
throw runtime_error(format("client name '{}' is not unique", parser[0]));
|
2014-02-14 06:21:06 +04:00
|
|
|
}
|
2014-02-08 05:02:58 +04:00
|
|
|
};
|
|
|
|
|
2014-02-14 06:21:06 +04:00
|
|
|
const CommandDesc set_register_cmd = {
|
2016-11-15 16:49:06 +03:00
|
|
|
"set-register",
|
2014-02-14 06:21:06 +04:00
|
|
|
"reg",
|
2016-11-15 16:49:06 +03:00
|
|
|
"set-register <name> <value>: set register <name> to <value>",
|
2015-03-14 20:30:34 +03:00
|
|
|
ParameterDesc{{}, ParameterDesc::Flags::None, 2, 2},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandCompleter{},
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2014-02-14 06:21:06 +04:00
|
|
|
{
|
2017-02-14 03:02:01 +03:00
|
|
|
RegisterManager::instance()[parser[0]].set(context, {parser[1]});
|
2014-02-14 06:21:06 +04:00
|
|
|
}
|
2014-02-08 05:02:58 +04:00
|
|
|
};
|
2013-03-19 01:43:48 +04:00
|
|
|
|
2015-04-13 17:21:26 +03:00
|
|
|
const CommandDesc select_cmd = {
|
|
|
|
"select",
|
|
|
|
nullptr,
|
|
|
|
"select <selections_desc>: select given selections",
|
|
|
|
ParameterDesc{{}, ParameterDesc::Flags::None, 1, 1},
|
|
|
|
CommandFlags::None,
|
|
|
|
CommandHelper{},
|
|
|
|
CommandCompleter{},
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context& context, const ShellContext&)
|
2015-04-13 17:21:26 +03:00
|
|
|
{
|
2015-04-19 17:12:16 +03:00
|
|
|
context.selections_write_only() = selection_list_from_string(context.buffer(), parser[0]);
|
2015-04-13 17:21:26 +03:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2016-11-15 16:49:06 +03:00
|
|
|
const CommandDesc change_directory_cmd = {
|
2016-11-14 03:27:14 +03:00
|
|
|
"change-directory",
|
2014-02-14 06:21:06 +04:00
|
|
|
"cd",
|
2016-11-14 03:27:14 +03:00
|
|
|
"change-directory [<directory>]: change the server's working directory to <directory>, or the home directory if unspecified",
|
2017-02-27 23:44:38 +03:00
|
|
|
single_optional_param,
|
2014-02-14 06:21:06 +04:00
|
|
|
CommandFlags::None,
|
2015-02-08 22:04:20 +03:00
|
|
|
CommandHelper{},
|
2016-09-18 18:07:00 +03:00
|
|
|
make_completer(
|
2016-04-08 00:47:41 +03:00
|
|
|
[](const Context& context, CompletionFlags flags,
|
|
|
|
const String& prefix, ByteCount cursor_pos) -> Completions {
|
|
|
|
return { 0_byte, cursor_pos,
|
|
|
|
complete_filename(prefix,
|
|
|
|
context.options()["ignored_files"].get<Regex>(),
|
2016-10-13 21:46:09 +03:00
|
|
|
cursor_pos, FilenameFlags::OnlyDirectories) };
|
2016-09-18 18:07:00 +03:00
|
|
|
}),
|
2015-10-22 15:59:23 +03:00
|
|
|
[](const ParametersParser& parser, Context&, const ShellContext&)
|
2014-02-14 06:21:06 +04:00
|
|
|
{
|
2016-05-25 00:36:20 +03:00
|
|
|
StringView target = parser.positional_count() == 1 ? StringView{parser[0]} : "~";
|
2016-05-20 11:41:29 +03:00
|
|
|
if (chdir(parse_filename(target).c_str()) != 0)
|
|
|
|
throw runtime_error(format("cannot change to directory '{}'", target));
|
2015-12-01 16:42:42 +03:00
|
|
|
for (auto& buffer : BufferManager::instance())
|
|
|
|
buffer->update_display_name();
|
2014-02-14 06:21:06 +04:00
|
|
|
}
|
2014-02-08 05:02:58 +04:00
|
|
|
};
|
2013-03-25 22:19:44 +04:00
|
|
|
|
2016-11-15 16:49:06 +03:00
|
|
|
const CommandDesc rename_session_cmd = {
|
2016-11-14 03:27:14 +03:00
|
|
|
"rename-session",
|
2016-07-20 17:52:53 +03:00
|
|
|
nullptr,
|
2016-11-14 03:27:14 +03:00
|
|
|
"rename-session <name>: change remote session name",
|
2016-07-20 17:52:53 +03:00
|
|
|
ParameterDesc{{}, ParameterDesc::Flags::None, 1, 1},
|
|
|
|
CommandFlags::None,
|
|
|
|
CommandHelper{},
|
|
|
|
CommandCompleter{},
|
|
|
|
[](const ParametersParser& parser, Context&, const ShellContext&)
|
|
|
|
{
|
|
|
|
if (not Server::instance().rename_session(parser[0]))
|
|
|
|
throw runtime_error(format("Cannot rename current session: '{}' may be already in use", parser[0]));
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-02-18 21:57:08 +04:00
|
|
|
}
|
|
|
|
|
2012-05-07 07:13:34 +04:00
|
|
|
void register_commands()
|
|
|
|
{
|
|
|
|
CommandManager& cm = CommandManager::instance();
|
2015-10-22 15:59:23 +03:00
|
|
|
cm.register_command("nop", [](const ParametersParser&, Context&, const ShellContext&){}, "do nothing", {});
|
2014-02-14 06:21:06 +04:00
|
|
|
|
2015-03-10 16:34:46 +03:00
|
|
|
auto register_command = [&](const CommandDesc& c)
|
|
|
|
{
|
|
|
|
cm.register_command(c.name, c.func, c.docstring, c.params, c.flags, c.helper, c.completer);
|
|
|
|
if (c.alias)
|
|
|
|
GlobalScope::instance().aliases().add_alias(c.alias, c.name);
|
|
|
|
};
|
|
|
|
|
|
|
|
register_command(edit_cmd);
|
|
|
|
register_command(force_edit_cmd);
|
|
|
|
register_command(write_cmd);
|
2017-04-19 18:47:07 +03:00
|
|
|
register_command(force_write_cmd);
|
2016-11-15 16:49:06 +03:00
|
|
|
register_command(write_all_cmd);
|
|
|
|
register_command(write_all_quit_cmd);
|
2015-08-26 21:34:19 +03:00
|
|
|
register_command(kill_cmd);
|
2016-04-29 23:58:04 +03:00
|
|
|
register_command(force_kill_cmd);
|
|
|
|
register_command(quit_cmd);
|
2015-03-10 16:34:46 +03:00
|
|
|
register_command(force_quit_cmd);
|
|
|
|
register_command(write_quit_cmd);
|
|
|
|
register_command(force_write_quit_cmd);
|
|
|
|
register_command(buffer_cmd);
|
2016-11-15 16:49:06 +03:00
|
|
|
register_command(buffer_next_cmd);
|
|
|
|
register_command(buffer_previous_cmd);
|
|
|
|
register_command(delete_buffer_cmd);
|
|
|
|
register_command(force_delete_buffer_cmd);
|
|
|
|
register_command(rename_buffer_cmd);
|
2015-03-10 16:34:46 +03:00
|
|
|
register_command(add_highlighter_cmd);
|
2016-11-15 16:49:06 +03:00
|
|
|
register_command(remove_highlighter_cmd);
|
2015-03-10 16:34:46 +03:00
|
|
|
register_command(add_hook_cmd);
|
2016-11-15 16:49:06 +03:00
|
|
|
register_command(remove_hook_cmd);
|
2015-03-10 16:34:46 +03:00
|
|
|
register_command(define_command_cmd);
|
|
|
|
register_command(alias_cmd);
|
|
|
|
register_command(unalias_cmd);
|
|
|
|
register_command(echo_cmd);
|
|
|
|
register_command(debug_cmd);
|
|
|
|
register_command(source_cmd);
|
|
|
|
register_command(set_option_cmd);
|
2015-08-10 15:54:52 +03:00
|
|
|
register_command(unset_option_cmd);
|
2017-05-25 10:38:11 +03:00
|
|
|
register_command(update_option_cmd);
|
2015-03-10 16:34:46 +03:00
|
|
|
register_command(declare_option_cmd);
|
|
|
|
register_command(map_key_cmd);
|
2016-09-19 11:10:41 +03:00
|
|
|
register_command(unmap_key_cmd);
|
2015-03-10 16:34:46 +03:00
|
|
|
register_command(exec_string_cmd);
|
|
|
|
register_command(eval_string_cmd);
|
|
|
|
register_command(prompt_cmd);
|
|
|
|
register_command(menu_cmd);
|
2016-11-27 23:57:04 +03:00
|
|
|
register_command(on_key_cmd);
|
2015-03-10 16:34:46 +03:00
|
|
|
register_command(info_cmd);
|
|
|
|
register_command(try_catch_cmd);
|
2016-11-15 16:49:06 +03:00
|
|
|
register_command(set_face_cmd);
|
|
|
|
register_command(rename_client_cmd);
|
2015-03-10 16:34:46 +03:00
|
|
|
register_command(set_register_cmd);
|
2015-04-13 17:21:26 +03:00
|
|
|
register_command(select_cmd);
|
2016-11-15 16:49:06 +03:00
|
|
|
register_command(change_directory_cmd);
|
|
|
|
register_command(rename_session_cmd);
|
2012-05-07 07:13:34 +04:00
|
|
|
}
|
2015-03-10 16:34:46 +03:00
|
|
|
|
2012-05-07 07:13:34 +04:00
|
|
|
}
|