#include "assert.hh" #include "backtrace.hh" #include "buffer.hh" #include "buffer_manager.hh" #include "buffer_utils.hh" #include "client_manager.hh" #include "command_manager.hh" #include "commands.hh" #include "context.hh" #include "event_manager.hh" #include "face_registry.hh" #include "file.hh" #include "highlighters.hh" #include "insert_completer.hh" #include "json_ui.hh" #include "ncurses_ui.hh" #include "option_types.hh" #include "parameters_parser.hh" #include "ranges.hh" #include "regex.hh" #include "register_manager.hh" #include "remote.hh" #include "scope.hh" #include "shared_string.hh" #include "shell_manager.hh" #include "string.hh" #include "unit_tests.hh" #include "window.hh" #include #include #include #include #include #include namespace Kakoune { extern const char* version; struct { unsigned int version; const char* notes; } constexpr version_notes[] = { { 20180904, "» Big breaking refactoring of various Kakoune features,\n" " configuration might need to be updated see `:doc changelog` for details\n" "» define-command -allow-override switch has been renamed -override\n" }, { 20180413, "» ModeChange hook has been introduced and is expected to replace\n" " the various ${MODE}Begin/${MODE}End hooks, consider those deprecated.\n" "» '*' Does not strip whitespaces anymore, use built-in '_' to strip them\n" "» 'l' on eol will go to next line, 'h' on first char will go to previous\n" "» selections merging behaviour is now a bit more complex again\n" "» 'x' will only jump to next line if full line is already selected\n" "» WORD text object moved to instead of W for consistency\n" "» rotate main selection moved to ), rotate content to , ( for backward\n" "» faces are now scoped, set-face command takes an additional scope parameter\n" "» key is gone, use instead\n" } }; void show_startup_info(Client* local_client, int last_version) { String info; for (auto note : version_notes) { if (not note.version) info += format("• Development version\n{}\n", note.notes); else if (note.version > last_version) { const auto year = note.version / 10000; const auto month = (note.version / 100) % 100; const auto day = note.version % 100; info += format("• Kakoune v{}.{}{}.{}{}\n{}\n", year, month < 10 ? "0" : "", month, day < 10 ? "0" : "", day, note.notes); } } if (not info.empty()) { info += "See the `:doc options startup-info` to control this message\n"; local_client->info_show(format("Kakoune {}", version), info, {}, InfoStyle::Prompt); } } struct startup_error : runtime_error { using runtime_error::runtime_error; }; inline void write_stdout(StringView str) { try { write(1, str); } catch (runtime_error&) {} } inline void write_stderr(StringView str) { try { write(2, str); } catch (runtime_error&) {} } String runtime_directory() { char relpath[PATH_MAX+1]; format_to(relpath, "{}../share/kak", split_path(get_kak_binary_path()).first); struct stat st; if (stat(relpath, &st) == 0 and S_ISDIR(st.st_mode)) return real_path(relpath); return "/usr/share/kak"; } String config_directory() { StringView config_home = getenv("XDG_CONFIG_HOME"); if (config_home.empty()) return format("{}/.config/kak", homedir()); return format("{}/kak", config_home); } static const EnvVarDesc builtin_env_vars[] = { { "bufname", false, [](StringView name, const Context& context, Quoting quoting) -> String { return context.buffer().display_name(); } }, { "buffile", false, [](StringView name, const Context& context, Quoting quoting) -> String { return context.buffer().name(); } }, { "buflist", false, [](StringView name, const Context& context, Quoting quoting) { return join(BufferManager::instance() | transform(&Buffer::display_name) | transform(quoter(quoting)), ' ', false); } }, { "buf_line_count", false, [](StringView name, const Context& context, Quoting quoting) -> String { return to_string(context.buffer().line_count()); } }, { "timestamp", false, [](StringView name, const Context& context, Quoting quoting) -> String { return to_string(context.buffer().timestamp()); } }, { "history_id", false, [](StringView name, const Context& context, Quoting quoting) -> String { return to_string((size_t)context.buffer().current_history_id()); } }, { "selection", false, [](StringView name, const Context& context, Quoting quoting) { const Selection& sel = context.selections().main(); return content(context.buffer(), sel); } }, { "selections", false, [](StringView name, const Context& context, Quoting quoting) { return join(context.selections_content() | transform(quoter(quoting)), ' ', false); } }, { "runtime", false, [](StringView name, const Context& context, Quoting quoting) { return runtime_directory(); } }, { "config", false, [](StringView name, const Context& context, Quoting quoting) { return config_directory(); } }, { "version", false, [](StringView name, const Context& context, Quoting quoting) -> String { return version; } }, { "opt_", true, [](StringView name, const Context& context, Quoting quoting) { return context.options()[name.substr(4_byte)].get_as_string(quoting); } }, { "main_reg_", true, [](StringView name, const Context& context, Quoting quoting) { return context.main_sel_register_value(name.substr(9_byte)).str(); } }, { "reg_", true, [](StringView name, const Context& context, Quoting quoting) { return join(RegisterManager::instance()[name.substr(4_byte)].get(context) | transform(quoter(quoting)), ' ', false); } }, { "client_env_", true, [](StringView name, const Context& context, Quoting quoting) { return context.client().get_env_var(name.substr(11_byte)).str(); } }, { "session", false, [](StringView name, const Context& context, Quoting quoting) -> String { return Server::instance().session(); } }, { "client", false, [](StringView name, const Context& context, Quoting quoting) -> String { return context.name(); } }, { "client_pid", false, [](StringView name, const Context& context, Quoting quoting) -> String { return to_string(context.client().pid()); } }, { "client_list", false, [](StringView name, const Context& context, Quoting quoting) -> String { return join(ClientManager::instance() | transform([](const std::unique_ptr& c) -> const String& { return c->context().name(); }), ' ', false); } }, { "modified", false, [](StringView name, const Context& context, Quoting quoting) -> String { return context.buffer().is_modified() ? "true" : "false"; } }, { "cursor_line", false, [](StringView name, const Context& context, Quoting quoting) -> String { return to_string(context.selections().main().cursor().line + 1); } }, { "cursor_column", false, [](StringView name, const Context& context, Quoting quoting) -> String { return to_string(context.selections().main().cursor().column + 1); } }, { "cursor_char_value", false, [](StringView name, const Context& context, Quoting quoting) -> String { auto coord = context.selections().main().cursor(); auto& buffer = context.buffer(); return to_string((size_t)utf8::codepoint(buffer.iterator_at(coord), buffer.end())); } }, { "cursor_char_column", false, [](StringView name, const Context& context, Quoting quoting) -> String { auto coord = context.selections().main().cursor(); return to_string(context.buffer()[coord.line].char_count_to(coord.column) + 1); } }, { "cursor_byte_offset", false, [](StringView name, const Context& context, Quoting quoting) -> String { auto cursor = context.selections().main().cursor(); return to_string(context.buffer().distance({0,0}, cursor)); } }, { "selection_desc", false, [](StringView name, const Context& context, Quoting quoting) { return selection_to_string(context.selections().main()); } }, { "selections_desc", false, [](StringView name, const Context& context, Quoting quoting) { return selection_list_to_string(context.selections()); } }, { "window_width", false, [](StringView name, const Context& context, Quoting quoting) -> String { return to_string(context.window().dimensions().column); } }, { "window_height", false, [](StringView name, const Context& context, Quoting quoting) -> String { return to_string(context.window().dimensions().line); } }, { "user_modes", false, [](StringView name, const Context& context, Quoting quoting) -> String { return join(context.keymaps().user_modes(), ' ', false); } } }; void register_registers() { RegisterManager& register_manager = RegisterManager::instance(); for (auto c : "abcdefghijklmnopqrstuvwxyz/\"|^@:") register_manager.add_register(c, std::make_unique()); using StringList = Vector; register_manager.add_register('%', make_dyn_reg( [](const Context& context) { return StringList{{context.buffer().display_name()}}; })); register_manager.add_register('.', make_dyn_reg( [](const Context& context) { auto content = context.selections_content(); return StringList{content.begin(), content.end()}; })); register_manager.add_register('#', make_dyn_reg( [](const Context& context) { const size_t count = context.selections().size(); StringList res; res.reserve(count); for (size_t i = 1; i < count+1; ++i) res.push_back(to_string((int)i)); return res; })); for (size_t i = 0; i < 10; ++i) { register_manager.add_register('0'+i, make_dyn_reg( [i](const Context& context) { StringList result; for (auto& sel : context.selections()) result.emplace_back(i < sel.captures().size() ? sel.captures()[i] : ""); return result; }, [i](Context& context, ConstArrayView values) { if (values.empty()) return; auto& sels = context.selections(); for (size_t sel_index = 0; sel_index < sels.size(); ++sel_index) { auto& sel = sels[sel_index]; if (sel.captures().size() < i+1) sel.captures().resize(i+1); sel.captures()[i] = values[std::min(sel_index, values.size()-1)]; } })); } register_manager.add_register('_', std::make_unique()); } static void check_tabstop(const int& val) { if (val < 1) throw runtime_error{"tabstop should be strictly positive"}; } static void check_indentwidth(const int& val) { if (val < 0) throw runtime_error{"indentwidth should be positive or zero"}; } static void check_scrolloff(const DisplayCoord& so) { if (so.line < 0 or so.column < 0) throw runtime_error{"scroll offset must be positive or zero"}; } static void check_timeout(const int& timeout) { if (timeout < 50) throw runtime_error{"the minimum acceptable timeout is 50 milliseconds"}; } static void check_extra_word_chars(const Vector& extra_chars) { if (any_of(extra_chars, is_blank)) throw runtime_error{"blanks are not accepted for extra completion characters"}; } static void check_matching_pairs(const Vector& pairs) { if ((pairs.size() % 2) != 0) throw runtime_error{"matching pairs should have a pair number of element"}; if (not all_of(pairs, is_punctuation)) throw runtime_error{"matching pairs can only be punctuation"}; } 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", {0,0}); reg.declare_option("eolformat", "end of line format", EolFormat::Lf); reg.declare_option("BOM", "byte order mark to use when writing buffer", ByteOrderMark::None); reg.declare_option("incsearch", "incrementally apply search/select/split regex", true); reg.declare_option("autoinfo", "automatically display contextual help", AutoInfo::Command | AutoInfo::OnKey); reg.declare_option("auto_complete", "automatically display possible completions", AutoComplete::Insert | AutoComplete::Prompt); reg.declare_option("aligntab", "use tab characters when possible for alignment", 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", Vector({ "./", "%/", "/usr/include" })); reg.declare_option("completers", "insert mode completers to execute.", InsertCompleterDescList({ InsertCompleterDesc{ InsertCompleterDesc::Filename, {} }, InsertCompleterDesc{ InsertCompleterDesc::Word, "all"_str } }), OptionFlags::None); reg.declare_option("static_words", "list of words to always consider for insert word completion", Vector{}); reg.declare_option("autoreload", "autoreload buffer when a filesystem modification is detected", Autoreload::Ask); reg.declare_option( "idle_timeout", "timeout, in milliseconds, before idle hooks are triggered", 50); reg.declare_option( "fs_check_timeout", "timeout, in milliseconds, between file system buffer modification checks", 500); reg.declare_option("ui_options", "space separated list of = options that are " "passed to and interpreted by the user interface\n" "\n" "The ncurses ui supports the following options:\n" " : :\n" " ncurses_assistant clippy|cat|dilbert|none|off\n" " ncurses_status_on_top bool\n" " ncurses_set_title bool\n" " ncurses_enable_mouse bool\n" " ncurses_change_colors bool\n" " ncurses_wheel_up_button int\n" " ncurses_wheel_down_button int\n" " ncurses_shift_function_key int\n", UserInterface::Options{}); reg.declare_option("modelinefmt", "format string used to generate the modeline", "%val{bufname} %val{cursor_line}:%val{cursor_char_column} {{context_info}} {{mode_info}} - %val{client}@[%val{session}]"_str); reg.declare_option("debug", "various debug flags", DebugFlags::None); reg.declare_option("readonly", "prevent buffers from being modified", false); reg.declare_option, check_extra_word_chars>( "extra_word_chars", "Additional characters to be considered as words for insert completion", {}); reg.declare_option, check_matching_pairs>( "matching_pairs", "set of pair of characters to be considered as matching pairs", { '(', ')', '{', '}', '[', ']', '<', '>' }); reg.declare_option("startup_info_version", "version up to which startup info changes should be hidden", 0); } static Client* local_client = nullptr; static int local_client_exit = 0; static UserInterface* local_ui = nullptr; static bool convert_to_client_pending = false; enum class UIType { NCurses, Json, Dummy, }; UIType parse_ui_type(StringView ui_name) { if (ui_name == "ncurses") return UIType::NCurses; if (ui_name == "json") return UIType::Json; if (ui_name == "dummy") return UIType::Dummy; throw parameter_error(format("error: unknown ui type: '{}'", ui_name)); } std::unique_ptr make_ui(UIType ui_type) { struct DummyUI : UserInterface { DummyUI() { set_signal_handler(SIGINT, SIG_DFL); } bool is_ok() const override { return true; } void menu_show(ConstArrayView, DisplayCoord, Face, Face, MenuStyle) override {} void menu_select(int) override {} void menu_hide() override {} void info_show(StringView, StringView, DisplayCoord, Face, InfoStyle) override {} void info_hide() override {} void draw(const DisplayBuffer&, const Face&, const Face&) override {} void draw_status(const DisplayLine&, const DisplayLine&, const Face&) override {} DisplayCoord dimensions() override { return {24,80}; } void set_cursor(CursorMode, DisplayCoord) override {} void refresh(bool) override {} void set_on_key(OnKeyCallback) override {} void set_ui_options(const Options&) override {} }; switch (ui_type) { case UIType::NCurses: return std::make_unique(); case UIType::Json: return std::make_unique(); case UIType::Dummy: return std::make_unique(); } throw logic_error{}; } pid_t fork_server_to_background() { if (pid_t pid = fork()) return pid; if (fork()) // double fork to orphan the server exit(0); write_stderr(format("Kakoune forked server to background ({}), for session '{}'\n", getpid(), Server::instance().session())); return 0; } std::unique_ptr create_local_ui(UIType ui_type) { if (ui_type != UIType::NCurses) return make_ui(ui_type); struct LocalUI : NCursesUI { LocalUI() { kak_assert(not local_ui); local_ui = this; m_old_sigtstp = set_signal_handler(SIGTSTP, [](int) { if (ClientManager::instance().count() == 1 and *ClientManager::instance().begin() == local_client) { // Suspend normally if we are the only client auto current = set_signal_handler(SIGTSTP, static_cast(local_ui)->m_old_sigtstp); sigset_t unblock_sigtstp, old_mask; sigemptyset(&unblock_sigtstp); sigaddset(&unblock_sigtstp, SIGTSTP); sigprocmask(SIG_UNBLOCK, &unblock_sigtstp, &old_mask); raise(SIGTSTP); set_signal_handler(SIGTSTP, current); sigprocmask(SIG_SETMASK, &old_mask, nullptr); } else convert_to_client_pending = true; }); } ~LocalUI() override { set_signal_handler(SIGTSTP, m_old_sigtstp); local_client = nullptr; local_ui = nullptr; if (not convert_to_client_pending and not ClientManager::instance().empty()) { if (fork_server_to_background()) { this->NCursesUI::~NCursesUI(); exit(local_client_exit); } } } private: using SigHandler = void (*)(int); SigHandler m_old_sigtstp; }; if (not isatty(1)) throw startup_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, Buffer::Flags::None); } return std::make_unique(); } int run_client(StringView session, StringView name, StringView client_init, Optional init_coord, UIType ui_type, bool suspend) { try { EventManager event_manager; RemoteClient client{session, name, make_ui(ui_type), getpid(), get_env_vars(), client_init, std::move(init_coord)}; if (suspend) raise(SIGTSTP); while (not client.exit_status() and client.is_ui_ok()) event_manager.handle_next_events(EventMode::Normal); return client.exit_status().value_or(-1); } catch (disconnected& e) { write_stderr(format("{}\ndisconnecting\n", e.what())); return -1; } } struct convert_to_client_mode { String session; String client_name; String buffer_name; String selections; }; enum class ServerFlags { None = 0, IgnoreKakrc = 1 << 0, Daemon = 1 << 1, ReadOnly = 1 << 2, StartupInfo = 1 << 3, }; constexpr bool with_bit_ops(Meta::Type) { return true; } int run_server(StringView session, StringView server_init, StringView client_init, Optional init_coord, ServerFlags flags, UIType ui_type, DebugFlags debug_flags, ConstArrayView files) { static bool terminate = false; if (flags & ServerFlags::Daemon) { if (session.empty()) { write_stderr("-d needs a session name to be specified with -s\n"); return -1; } if (pid_t child = fork()) { write_stderr(format("Kakoune forked to background, for session '{}'\n" "send SIGTERM to process {} for closing the session\n", session, child)); exit(0); } set_signal_handler(SIGTERM, [](int) { terminate = true; }); } EventManager event_manager; Server server{session.empty() ? to_string(getpid()) : session.str()}; StringRegistry string_registry; GlobalScope global_scope; ShellManager shell_manager{builtin_env_vars}; CommandManager command_manager; RegisterManager register_manager; HighlighterRegistry highlighter_registry; DefinedHighlighters defined_highlighters; ClientManager client_manager; BufferManager buffer_manager; register_options(); register_registers(); register_commands(); register_highlighters(); global_scope.options()["debug"].set(debug_flags); UnitTest::run_all_tests(); write_to_debug_buffer("*** This is the debug buffer, where debug info will be written ***"); GlobalScope::instance().options().get_local_option("readonly").set(flags & ServerFlags::ReadOnly); bool startup_error = false; if (not (flags & ServerFlags::IgnoreKakrc)) try { Context init_context{Context::EmptyContextFlag{}}; command_manager.execute(format("source {}/kakrc", runtime_directory()), init_context); } catch (runtime_error& error) { startup_error = true; write_to_debug_buffer(format("error while parsing kakrc:\n" " {}", error.what())); } if (not server_init.empty()) try { Context init_context{Context::EmptyContextFlag{}}; command_manager.execute(server_init, init_context); } catch (runtime_error& error) { startup_error = true; write_to_debug_buffer(format("error while running server init commands:\n" " {}", error.what())); } { Context empty_context{Context::EmptyContextFlag{}}; global_scope.hooks().run_hook("KakBegin", session, empty_context); } 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 : files | reverse()) { try { Buffer *buffer = open_or_create_file_buffer(file); if (flags & ServerFlags::ReadOnly) buffer->flags() |= Buffer::Flags::ReadOnly; } catch (runtime_error& error) { startup_error = true; write_to_debug_buffer(format("error while opening file '{}':\n" " {}", file, error.what())); } } } catch (runtime_error& error) { write_to_debug_buffer(format("error while opening command line files: {}", error.what())); } try { if (not (flags & ServerFlags::Daemon)) { local_client = client_manager.create_client( create_local_ui(ui_type), getpid(), {}, get_env_vars(), client_init, std::move(init_coord), [](int status) { local_client_exit = status; }); if (startup_error and local_client) local_client->print_status({ "error during startup, see *debug* buffer for details", local_client->context().faces()["Error"] }); if (flags & ServerFlags::StartupInfo and local_client) show_startup_info(local_client, global_scope.options()["startup_info_version"].get()); } while (not terminate and (not client_manager.empty() or server.negotiating() or (flags & ServerFlags::Daemon))) { client_manager.redraw_clients(); // Loop so that eventual inputs happening during the processing are handled as // well, avoiding unneeded redraws. bool allow_blocking = not client_manager.has_pending_inputs(); while (event_manager.handle_next_events(EventMode::Normal, nullptr, allow_blocking)) { client_manager.process_pending_inputs(); allow_blocking = false; } client_manager.process_pending_inputs(); client_manager.clear_client_trash(); client_manager.clear_window_trash(); buffer_manager.clear_buffer_trash(); if (local_client and not contains(client_manager, local_client)) local_client = nullptr; else if (local_client and not local_client->is_ui_ok()) { ClientManager::instance().remove_client(*local_client, false, -1); local_client = nullptr; if (not client_manager.empty() and fork_server_to_background()) return 0; } else if (convert_to_client_pending) { kak_assert(local_client); const String client_name = local_client->context().name(); const String buffer_name = local_client->context().buffer().name(); const String selections = selection_list_to_string(local_client->context().selections()); ClientManager::instance().remove_client(*local_client, true, 0); client_manager.clear_client_trash(); convert_to_client_pending = false; if (fork_server_to_background()) { String session = server.session(); server.close_session(false); throw convert_to_client_mode{ std::move(session), std::move(client_name), std::move(buffer_name), std::move(selections) }; } } } } catch (const kill_session& kill) { local_client_exit = kill.exit_status; } { Context empty_context{Context::EmptyContextFlag{}}; global_scope.hooks().run_hook("KakEnd", "", empty_context); } return local_client_exit; } int run_filter(StringView keystr, ConstArrayView files, bool quiet, StringView suffix_backup) { StringRegistry string_registry; GlobalScope global_scope; EventManager event_manager; ShellManager shell_manager{builtin_env_vars}; RegisterManager register_manager; BufferManager buffer_manager; register_options(); register_registers(); try { auto keys = parse_keys(keystr); auto apply_to_buffer = [&](Buffer& buffer) { try { InputHandler input_handler{ { buffer, Selection{{0,0}, buffer.back_coord()} }, Context::Flags::Draft }; for (auto& key : keys) input_handler.handle_key(key); } catch (runtime_error& err) { if (not quiet) write_stderr(format("error while applying keys to buffer '{}': {}\n", buffer.display_name(), err.what())); } }; for (auto& file : files) { Buffer* buffer = open_file_buffer(file, Buffer::Flags::NoHooks); if (not suffix_backup.empty()) write_buffer_to_file(*buffer, buffer->name() + suffix_backup); apply_to_buffer(*buffer); write_buffer_to_file(*buffer, buffer->name()); buffer_manager.delete_buffer(*buffer); } if (not isatty(0)) { Buffer& buffer = *buffer_manager.create_buffer( "*stdin*", Buffer::Flags::NoHooks, read_fd(0), InvalidTime); apply_to_buffer(buffer); write_buffer_to_fd(buffer, 1); buffer_manager.delete_buffer(buffer); } } catch (runtime_error& err) { write_stderr(format("error: {}\n", err.what())); } buffer_manager.clear_buffer_trash(); return 0; } int run_pipe(StringView session) { try { send_command(session, read_fd(0)); } catch (disconnected& e) { write_stderr(format("{}\ndisconnecting\n", e.what())); return -1; } return 0; } void signal_handler(int signal) { 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; case SIGPIPE: text = "SIGPIPE"; break; } if (signal != SIGTERM) { auto msg = format("Received {}, exiting.\nPid: {}\nCallstack:\n{}", text, getpid(), Backtrace{}.desc()); write_stderr(msg); notify_fatal_error(msg); } if (Server::has_instance()) Server::instance().close_session(); if (BufferManager::has_instance()) BufferManager::instance().backup_modified_buffers(); if (signal == SIGTERM) exit(-1); else abort(); } } int main(int argc, char* argv[]) { using namespace Kakoune; setlocale(LC_ALL, ""); set_signal_handler(SIGSEGV, signal_handler); set_signal_handler(SIGFPE, signal_handler); set_signal_handler(SIGQUIT, signal_handler); set_signal_handler(SIGTERM, signal_handler); set_signal_handler(SIGPIPE, SIG_IGN); set_signal_handler(SIGINT, [](int){}); set_signal_handler(SIGCHLD, [](int){}); const ParameterDesc param_desc{ SwitchMap{ { "c", { true, "connect to given session" } }, { "e", { true, "execute argument on client initialisation" } }, { "E", { true, "execute argument on server 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, "filter: for each file, select the entire buffer and execute the given keys" } }, { "i", { true, "backup the files on which a filter is applied using the given suffix" } }, { "q", { false, "in filter mode, be quiet about errors applying keys" } }, { "ui", { true, "set the type of user interface to use (ncurses, dummy, or json)" } }, { "l", { false, "list existing sessions" } }, { "clear", { false, "clear dead sessions" } }, { "debug", { true, "initial debug option value" } }, { "version", { false, "display kakoune version and exit" } }, { "ro", { false, "readonly mode" } }, { "help", { false, "display a help message and quit" } } } }; try { auto show_usage = [&]() { write_stdout(format("Usage: {} [options] [file]... [+[:]|+:]\n\n" "Options:\n" "{}\n" "Prefixing a positional argument with a plus (`+`) sign will place the\n" "cursor at a given set of coordinates, or the end of the buffer if the plus\n" "sign is followed only by a colon (`:`)\n", argv[0], generate_switches_doc(param_desc.switches))); return 0; }; const auto params = ArrayView{argv+1, argv + argc} | transform([](auto* s) { return String{s}; }) | gather>(); if (contains(params, "--help"_sv)) return show_usage(); ParametersParser parser{params, param_desc}; const bool show_help_message = (bool)parser.get_switch("help"); if (show_help_message) return show_usage(); if (parser.get_switch("version")) { write_stdout(format("Kakoune {}\n", Kakoune::version)); return 0; } const bool list_sessions = (bool)parser.get_switch("l"); const bool clear_sessions = (bool)parser.get_switch("clear"); if (list_sessions or clear_sessions) { const String username = get_user_name(); const StringView tmp_dir = tmpdir(); for (auto& session : list_files(format("{}/kakoune/{}/", tmp_dir, username))) { const bool valid = check_session(session); if (list_sessions) write_stdout(format("{}{}\n", session, valid ? "" : " (dead)")); if (not valid and clear_sessions) { char socket_file[128]; format_to(socket_file, "{}/kakoune/{}/{}", tmp_dir, username, session); unlink(socket_file); } } return 0; } if (auto session = parser.get_switch("p")) { for (auto opt : { "c", "n", "s", "d", "e", "E", "ro" }) { if (parser.get_switch(opt)) { write_stderr(format("error: -{} is incompatible with -p\n", opt)); return -1; } } return run_pipe(*session); } auto client_init = parser.get_switch("e").value_or(StringView{}); auto server_init = parser.get_switch("E").value_or(StringView{}); const UIType ui_type = parse_ui_type(parser.get_switch("ui").value_or("ncurses")); if (auto keys = parser.get_switch("f")) { if (parser.get_switch("ro")) { write_stderr("error: -ro is incompatible with -f\n"); return -1; } Vector files; for (size_t i = 0; i < parser.positional_count(); ++i) files.emplace_back(parser[i]); return run_filter(*keys, files, (bool)parser.get_switch("q"), parser.get_switch("i").value_or(StringView{})); } Vector files; Optional init_coord; for (auto& name : parser) { if (not name.empty() and name[0_byte] == '+') { if (name == "+" or name == "+:") { client_init = client_init + "; exec gj"; continue; } auto colon = find(name, ':'); if (auto line = str_to_int_ifp({name.begin()+1, colon})) { init_coord = BufferCoord{ *line - 1, colon != name.end() ? str_to_int_ifp({colon+1, name.end()}).value_or(1) - 1 : 0 }; continue; } } files.emplace_back(name); } if (auto server_session = parser.get_switch("c")) { for (auto opt : { "n", "s", "d", "E", "ro" }) { if (parser.get_switch(opt)) { write_stderr(format("error: -{} is incompatible with -c\n", opt)); return -1; } } String new_files; for (auto name : files) new_files += format("edit '{}';", escape(real_path(name), "'", '\\')); return run_client(*server_session, {}, new_files + client_init, init_coord, ui_type, false); } else { StringView session = parser.get_switch("s").value_or(StringView{}); try { auto flags = (parser.get_switch("n") ? ServerFlags::IgnoreKakrc : ServerFlags::None) | (parser.get_switch("d") ? ServerFlags::Daemon : ServerFlags::None) | (parser.get_switch("ro") ? ServerFlags::ReadOnly : ServerFlags::None) | (argc == 1 and isatty(0) ? ServerFlags::StartupInfo : ServerFlags::None); auto debug_flags = option_from_string(Meta::Type{}, parser.get_switch("debug").value_or("")); return run_server(session, server_init, client_init, init_coord, flags, ui_type, debug_flags, files); } catch (convert_to_client_mode& convert) { return run_client(convert.session, convert.client_name, format("try %^buffer '{}'; select '{}'^; echo converted to client only mode", escape(convert.buffer_name, "'^", '\\'), convert.selections), {}, ui_type, true); } } } catch (parameter_error& error) { write_stderr(format("Error while parsing parameters: {}\n" "Valid switches:\n" "{}", error.what(), generate_switches_doc(param_desc.switches))); return -1; } catch (startup_error& error) { write_stderr(format("Could not start kakoune: {}\n", error.what())); return -1; } catch (Kakoune::exception& error) { write_stderr(format("uncaught exception ({}):\n{}\n", typeid(error).name(), error.what())); return -1; } catch (std::exception& error) { write_stderr(format("uncaught exception ({}):\n{}\n", typeid(error).name(), error.what())); return -1; } catch (...) { write_stderr("uncaught exception"); return -1; } return 0; }