kakoune/src/main.cc

608 lines
20 KiB
C++
Raw Normal View History

2013-04-09 20:05:40 +02:00
#include "assert.hh"
2011-09-02 18:51:20 +02:00
#include "buffer.hh"
#include "buffer_manager.hh"
#include "buffer_utils.hh"
2013-04-09 20:05:40 +02:00
#include "client_manager.hh"
#include "command_manager.hh"
#include "commands.hh"
#include "containers.hh"
2013-04-09 20:05:40 +02:00
#include "context.hh"
#include "debug.hh"
2013-04-09 20:05:40 +02:00
#include "event_manager.hh"
#include "face_registry.hh"
2013-04-09 20:05:40 +02:00
#include "file.hh"
#include "highlighters.hh"
2014-12-24 14:03:17 +01:00
#include "insert_completer.hh"
#include "interned_string.hh"
#include "ncurses_ui.hh"
#include "parameters_parser.hh"
2013-04-09 20:05:40 +02:00
#include "register_manager.hh"
#include "remote.hh"
#include "scope.hh"
2014-12-24 14:03:17 +01:00
#include "shell_manager.hh"
2013-04-09 20:05:40 +02:00
#include "string.hh"
2013-04-18 14:28:53 +02:00
#include "window.hh"
2011-09-02 18:51:20 +02:00
2014-12-24 14:03:17 +01:00
#include <fcntl.h>
#include <locale>
#include <signal.h>
#include <sys/stat.h>
2014-12-24 14:03:17 +01:00
#include <sys/types.h>
2014-04-30 20:08:06 +02:00
#include <unistd.h>
2011-09-02 18:51:20 +02:00
using namespace Kakoune;
void run_unit_tests();
String runtime_directory()
{
String bin_path = get_kak_binary_path();
size_t last_slash = bin_path.find_last_of('/');
if (last_slash == String::npos)
2012-11-08 13:38:02 +01:00
throw runtime_error("unable to determine runtime directory");
return bin_path.substr(0_byte, (int)last_slash) + "/../share/kak";
}
void register_env_vars()
{
2014-01-12 22:25:21 +01:00
static const struct {
const char* name;
2014-04-20 13:15:31 +02:00
String (*func)(StringView, const Context&);
2014-01-12 22:25:21 +01:00
} env_vars[] = { {
2013-10-01 19:47:37 +02:00
"bufname",
2014-04-20 13:15:31 +02:00
[](StringView name, const Context& context)
2013-10-01 19:47:37 +02:00
{ return context.buffer().display_name(); }
}, {
"buffile",
2014-04-20 13:15:31 +02:00
[](StringView name, const Context& context) -> String
{ return context.buffer().name(); }
}, {
"buflist",
[](StringView name, const Context& context)
{ return join(transformed(BufferManager::instance(),
[](const safe_ptr<Buffer>& b)
{ return b->display_name(); }), ':'); }
2013-10-01 19:47:37 +02:00
}, {
"timestamp",
2014-04-20 13:15:31 +02:00
[](StringView name, const Context& context)
2013-10-01 19:47:37 +02:00
{ return to_string(context.buffer().timestamp()); }
}, {
"selection",
2014-04-20 13:15:31 +02:00
[](StringView name, const Context& context)
{ const Selection& sel = context.selections().main();
2013-10-01 19:47:37 +02:00
return content(context.buffer(), sel); }
}, {
"selections",
2014-04-20 13:15:31 +02:00
[](StringView name, const Context& context)
{ return join(context.selections_content(), ':'); }
2013-10-01 19:47:37 +02:00
}, {
"runtime",
2014-04-20 13:15:31 +02:00
[](StringView name, const Context& context)
2013-10-01 19:47:37 +02:00
{ return runtime_directory(); }
}, {
"opt_.+",
2014-04-20 13:15:31 +02:00
[](StringView name, const Context& context)
2013-10-01 19:47:37 +02:00
{ return context.options()[name.substr(4_byte)].get_as_string(); }
}, {
"reg_.+",
2014-04-20 13:15:31 +02:00
[](StringView name, const Context& context) -> String
{ return context.main_sel_register_value(name.substr(4_byte)); }
}, {
"client_env_.+",
2014-04-20 13:15:31 +02:00
[](StringView name, const Context& context) -> String
{ return context.client().get_env_var(name.substr(11_byte)); }
2013-10-01 19:47:37 +02:00
}, {
"session",
2014-04-20 13:15:31 +02:00
[](StringView name, const Context& context) -> String
2013-10-01 19:47:37 +02:00
{ return Server::instance().session(); }
}, {
"client",
2014-04-20 13:15:31 +02:00
[](StringView name, const Context& context) -> String
{ return context.name(); }
2013-10-01 19:47:37 +02:00
}, {
"cursor_line",
2014-04-20 13:15:31 +02:00
[](StringView name, const Context& context)
{ return to_string(context.selections().main().cursor().line + 1); }
2013-10-01 19:47:37 +02:00
}, {
"cursor_column",
2014-04-20 13:15:31 +02:00
[](StringView name, const Context& context)
{ return to_string(context.selections().main().cursor().column + 1); }
2013-12-11 14:46:33 +01:00
}, {
"cursor_char_column",
2014-04-20 13:15:31 +02:00
[](StringView name, const Context& context)
{ auto coord = context.selections().main().cursor();
2013-12-11 14:46:33 +01:00
return to_string(context.buffer()[coord.line].char_count_to(coord.column) + 1); }
2013-10-01 19:47:37 +02:00
}, {
"selection_desc",
2014-04-20 13:15:31 +02:00
[](StringView name, const Context& context)
{ auto& sel = context.selections().main();
auto beg = sel.min();
return to_string(beg.line + 1) + "." + to_string(beg.column + 1) + "+" +
to_string((int)context.buffer().distance(beg, sel.max())+1); }
}, {
"selections_desc",
[](StringView name, const Context& context)
{ return join(transformed(context.selections(), [&](const Selection& sel) {
auto beg = sel.min();
return to_string(beg.line + 1) + "." + to_string(beg.column + 1) + "+" +
to_string((int)context.buffer().distance(beg, sel.max())+1);
}), ':'); }
2013-10-01 19:47:37 +02:00
}, {
"window_width",
2014-04-20 13:15:31 +02:00
[](StringView name, const Context& context)
2013-10-01 19:47:37 +02:00
{ return to_string(context.window().dimensions().column); }
}, {
"window_height",
2014-04-20 13:15:31 +02:00
[](StringView name, const Context& context)
2013-10-01 19:47:37 +02:00
{ return to_string(context.window().dimensions().line); }
} };
2013-10-01 19:47:37 +02:00
ShellManager& shell_manager = ShellManager::instance();
for (auto& env_var : env_vars)
shell_manager.register_env_var(env_var.name, env_var.func);
}
void register_registers()
{
using StringList = std::vector<String>;
2014-03-22 22:00:24 +01:00
static const struct {
char name;
StringList (*func)(const Context&);
} dyn_regs[] = {
{ '%', [](const Context& context) { return StringList{{context.buffer().display_name()}}; } },
{ '.', [](const Context& context) { return context.selections_content(); } },
{ '#', [](const Context& context) {
StringList res;
2014-07-14 20:00:54 +02:00
for (size_t i = 1; i < context.selections().size()+1; ++i)
res.push_back(to_string((int)i));
return res;
} }
};
RegisterManager& register_manager = RegisterManager::instance();
for (auto& dyn_reg : dyn_regs)
register_manager.register_dynamic_register(dyn_reg.name, dyn_reg.func);
for (size_t i = 0; i < 10; ++i)
{
2013-01-04 18:39:13 +01:00
register_manager.register_dynamic_register('0'+i,
[i](const Context& context) {
std::vector<String> result;
for (auto& sel : context.selections())
2013-01-04 18:39:13 +01:00
result.emplace_back(i < sel.captures().size() ? sel.captures()[i] : "");
return result;
});
}
}
void register_options()
{
OptionsRegistry& reg = GlobalScope::instance().option_registry();
reg.declare_option("tabstop", "size of a tab character", 8);
reg.declare_option("indentwidth", "indentation width", 4);
reg.declare_option("scrolloff",
"number of lines and columns to keep visible main cursor when scrolling",
CharCoord{0,0});
reg.declare_option("eolformat", "end of line format: 'crlf' or 'lf'", "lf"_str);
reg.declare_option("BOM", "insert a byte order mark when writing buffer",
"no"_str);
reg.declare_option("complete_prefix",
"complete up to common prefix in tab completion",
true);
reg.declare_option("incsearch",
"incrementaly apply search/select/split regex",
true);
reg.declare_option("autoinfo",
"automatically display contextual help",
1);
reg.declare_option("autoshowcompl",
"automatically display possible completions for prompts",
true);
reg.declare_option("aligntab",
"use tab characters when possible for alignement",
false);
reg.declare_option("ignored_files",
"patterns to ignore when completing filenames",
Regex{R"(^(\..*|.*\.(o|so|a))$)"});
reg.declare_option("disabled_hooks",
"patterns to disable hooks whose group is matched",
Regex{});
reg.declare_option("filetype", "buffer filetype", ""_str);
reg.declare_option("path", "path to consider when trying to find a file",
std::vector<String>({ "./", "/usr/include" }));
reg.declare_option("completers", "insert mode completers to execute.",
std::vector<InsertCompleterDesc>({
InsertCompleterDesc{ InsertCompleterDesc::Filename },
InsertCompleterDesc{ InsertCompleterDesc::Word, "all"_str }
}), OptionFlags::None);
reg.declare_option("autoreload",
"autoreload buffer when a filesystem modification is detected",
Ask);
reg.declare_option("ui_options",
"options passed to UI as a string map",
UserInterface::Options());
}
2014-11-14 23:40:51 +01:00
void create_local_client(StringView init_command)
2012-10-17 17:49:34 +02:00
{
class LocalNCursesUI : public NCursesUI
{
~LocalNCursesUI()
{
if (not ClientManager::instance().empty() and fork())
{
2013-04-03 18:51:40 +02:00
this->NCursesUI::~NCursesUI();
puts("detached from terminal\n");
exit(0);
}
}
};
if (not isatty(1))
throw runtime_error("stdout is not a tty");
if (not isatty(0))
{
// move stdin to another fd, and restore tty as stdin
int fd = dup(0);
int tty = open("/dev/tty", O_RDONLY);
dup2(tty, 0);
close(tty);
create_fifo_buffer("*stdin*", fd);
}
UserInterface* ui = new LocalNCursesUI{};
2013-09-12 23:47:23 +02:00
static Client* client = ClientManager::instance().create_client(
std::unique_ptr<UserInterface>{ui}, get_env_vars(), init_command);
2013-04-15 18:50:45 +02:00
signal(SIGHUP, [](int) {
if (client)
ClientManager::instance().remove_client(*client);
client = nullptr;
});
2012-10-17 17:49:34 +02:00
}
void signal_handler(int signal)
2013-01-23 13:46:18 +01:00
{
2013-04-12 01:28:22 +02:00
NCursesUI::abort();
const char* text = nullptr;
switch (signal)
{
case SIGSEGV: text = "SIGSEGV"; break;
case SIGFPE: text = "SIGFPE"; break;
case SIGQUIT: text = "SIGQUIT"; break;
case SIGTERM: text = "SIGTERM"; break;
}
if (signal != SIGTERM)
on_assert_failed(text);
2014-01-27 20:53:17 +01:00
if (Server::has_instance())
Server::instance().close_session();
if (BufferManager::has_instance())
BufferManager::instance().backup_modified_buffers();
if (signal == SIGTERM)
exit(-1);
else
abort();
2013-01-23 13:46:18 +01:00
}
int run_client(StringView session, StringView init_command)
{
try
{
EventManager event_manager;
2014-11-05 14:57:12 +01:00
RemoteClient client{session, make_unique<NCursesUI>(),
get_env_vars(), init_command};
while (true)
event_manager.handle_next_events(EventMode::Normal);
}
catch (peer_disconnected&)
{
fputs("disconnected from server\n", stderr);
return -1;
}
catch (connection_failed& e)
{
fputs(e.what(), stderr);
return -1;
}
return 0;
}
int run_server(StringView session, StringView init_command,
2015-01-06 14:40:56 +01:00
bool ignore_kakrc, bool daemon, ArrayView<StringView> files)
{
static bool terminate = false;
if (daemon)
{
if (session.empty())
{
fputs("-d needs a session name to be specified with -s\n", stderr);
return -1;
}
if (pid_t child = fork())
{
printf("Kakoune forked to background, for session '%s'\n"
"send SIGTERM to process %d for closing the session\n",
(const char*)session.zstr(), child);
exit(0);
}
signal(SIGTERM, [](int) { terminate = true; });
}
StringRegistry string_registry;
EventManager event_manager;
GlobalScope global_scope;
ShellManager shell_manager;
CommandManager command_manager;
BufferManager buffer_manager;
RegisterManager register_manager;
HighlighterRegistry highlighter_registry;
DefinedHighlighters defined_highlighters;
FaceRegistry face_registry;
ClientManager client_manager;
run_unit_tests();
register_options();
register_env_vars();
register_registers();
register_commands();
register_highlighters();
write_debug("*** This is the debug buffer, where debug info will be written ***");
Server server(session.empty() ? to_string(getpid()) : String{session});
if (not ignore_kakrc) try
{
Context initialisation_context;
command_manager.execute("source " + runtime_directory() + "/kakrc",
initialisation_context);
}
catch (Kakoune::runtime_error& error)
{
write_debug("error while parsing kakrc:\n "_str + error.what());
}
catch (Kakoune::client_removed&)
{
2013-10-26 20:23:00 +02:00
write_debug("error while parsing kakrc: asked to quit");
}
2012-10-16 17:15:09 +02:00
{
Context empty_context;
global_scope.hooks().run_hook("KakBegin", "", empty_context);
}
2013-04-19 13:45:44 +02:00
if (not files.empty()) try
{
// create buffers in reverse order so that the first given buffer
// is the most recently created one.
for (auto& file : reversed(files))
{
if (not create_buffer_from_file(file))
new Buffer(file, Buffer::Flags::New | Buffer::Flags::File);
}
}
catch (Kakoune::runtime_error& error)
{
write_debug("error while opening command line files: "_str + error.what());
}
else
new Buffer("*scratch*", Buffer::Flags::None);
if (not daemon)
create_local_client(init_command);
while (not terminate and (not client_manager.empty() or daemon))
{
client_manager.redraw_clients();
event_manager.handle_next_events(EventMode::Normal);
client_manager.handle_pending_inputs();
client_manager.clear_mode_trashes();
buffer_manager.clear_buffer_trash();
}
2013-04-19 13:45:44 +02:00
{
Context empty_context;
global_scope.hooks().run_hook("KakEnd", "", empty_context);
}
return 0;
}
2015-01-06 14:40:56 +01:00
int run_filter(StringView keystr, ArrayView<StringView> files, bool quiet)
{
2014-10-27 18:54:20 +01:00
StringRegistry string_registry;
GlobalScope global_scope;
2014-10-26 21:21:01 +01:00
ShellManager shell_manager;
BufferManager buffer_manager;
RegisterManager register_manager;
register_options();
register_env_vars();
register_registers();
2014-08-17 16:19:04 +02:00
try
{
2014-08-17 16:19:04 +02:00
auto keys = parse_keys(keystr);
2014-08-17 16:19:04 +02:00
auto apply_keys_to_buffer = [&](Buffer& buffer)
{
try
{
InputHandler input_handler{
{ buffer, {{0,0}, buffer.back_coord()} },
Context::Flags::Transient
};
2014-08-17 16:19:04 +02:00
for (auto& key : keys)
input_handler.handle_key(key);
}
catch (Kakoune::runtime_error& err)
{
if (not quiet)
fprintf(stderr, "error while applying keys to buffer '%s': %s\n",
buffer.display_name().c_str(), err.what());
2014-08-17 16:19:04 +02:00
}
};
2014-08-17 16:19:04 +02:00
for (auto& file : files)
{
Buffer* buffer = create_buffer_from_file(file);
write_buffer_to_file(*buffer, file + ".kak-bak");
2014-08-17 16:19:04 +02:00
apply_keys_to_buffer(*buffer);
write_buffer_to_file(*buffer, file);
2014-08-17 16:19:04 +02:00
buffer_manager.delete_buffer(*buffer);
}
if (not isatty(0))
{
Buffer* buffer = create_buffer_from_data(read_fd(0), "*stdin*",
Buffer::Flags::None);
apply_keys_to_buffer(*buffer);
write_buffer_to_fd(*buffer, 1);
buffer_manager.delete_buffer(*buffer);
}
}
2014-08-17 16:19:04 +02:00
catch (Kakoune::runtime_error& err)
{
2014-08-17 16:19:04 +02:00
fprintf(stderr, "error: %s\n", err.what());
}
buffer_manager.clear_buffer_trash();
return 0;
}
int run_pipe(StringView session)
{
char buf[512];
String command;
while (ssize_t count = read(0, buf, 512))
{
if (count < 0)
{
fprintf(stderr, "error while reading stdin\n");
return -1;
}
command += String{buf, buf + count};
}
try
{
send_command(session, command);
}
catch (connection_failed& e)
{
fputs(e.what(), stderr);
return -1;
}
return 0;
}
int main(int argc, char* argv[])
{
setlocale(LC_ALL, "");
signal(SIGSEGV, signal_handler);
signal(SIGFPE, signal_handler);
signal(SIGQUIT, signal_handler);
signal(SIGTERM, signal_handler);
std::vector<String> params;
for (size_t i = 1; i < argc; ++i)
params.push_back(argv[i]);
const ParameterDesc param_desc{
SwitchMap{ { "c", { true, "connect to given session" } },
{ "e", { true, "execute argument on initialisation" } },
{ "n", { false, "do not source kakrc files on startup" } },
{ "s", { true, "set session name" } },
{ "d", { false, "run as a headless session (requires -s)" } },
{ "p", { true, "just send stdin as commands to the given session" } },
{ "f", { true, "act as a filter, executing given keys on given files" } },
{ "q", { false, "in filter mode, be quiet about errors applying keys" } } }
};
try
{
ParametersParser parser(params, param_desc);
if (parser.has_option("p"))
{
for (auto opt : { "c", "n", "s", "d", "e" })
{
if (parser.has_option(opt))
{
fprintf(stderr, "error: -%s makes not sense with -p\n", opt);
return -1;
}
}
return run_pipe(parser.option_value("p"));
}
else if (parser.has_option("f"))
{
std::vector<StringView> files;
for (size_t i = 0; i < parser.positional_count(); ++i)
files.emplace_back(parser[i]);
return run_filter(parser.option_value("f"), files,
parser.has_option("q"));
}
String init_command;
if (parser.has_option("e"))
init_command = parser.option_value("e");
if (parser.has_option("c"))
{
for (auto opt : { "n", "s", "d" })
{
if (parser.has_option(opt))
{
fprintf(stderr, "error: -%s makes not sense with -c\n", opt);
return -1;
}
}
return run_client(parser.option_value("c"), init_command);
}
else
{
std::vector<StringView> files;
for (size_t i = 0; i < parser.positional_count(); ++i)
files.emplace_back(parser[i]);
StringView session;
if (parser.has_option("s"))
session = parser.option_value("s");
return run_server(session, init_command,
parser.has_option("n"),
parser.has_option("d"),
files);
}
2011-09-02 18:51:20 +02:00
}
catch (Kakoune::parameter_error& error)
{
printf("Error: %s\n"
"Valid switches:\n"
"%s",
error.what(),
generate_switches_doc(param_desc.switches).c_str());
return -1;
}
2011-09-09 21:24:18 +02:00
catch (Kakoune::exception& error)
{
on_assert_failed(("uncaught exception:\n"_str + error.what()).c_str());
2013-02-22 18:45:59 +01:00
return -1;
}
catch (std::exception& error)
{
on_assert_failed(("uncaught exception:\n"_str + error.what()).c_str());
return -1;
}
2013-02-22 18:45:59 +01:00
catch (...)
{
on_assert_failed("uncaught exception");
2011-09-09 21:24:18 +02:00
return -1;
}
2011-09-02 18:51:20 +02:00
return 0;
}