/* vi:set ts=8 sts=4 sw=4 noet: * * VIM - Vi IMproved by Bram Moolenaar * * Do ":help uganda" in Vim to read copying and usage conditions. * Do ":help credits" in Vim to see a list of people who contributed. * See README.txt for an overview of the Vim source code. */ /* * Terminal window support, see ":help :terminal". * * There are three parts: * 1. Generic code for all systems. * Uses libvterm for the terminal emulator. * 2. The MS-Windows implementation. * Uses winpty. * 3. The Unix-like implementation. * Uses pseudo-tty's (pty's). * * For each terminal one VTerm is constructed. This uses libvterm. A copy of * this library is in the libvterm directory. * * When a terminal window is opened, a job is started that will be connected to * the terminal emulator. * * If the terminal window has keyboard focus, typed keys are converted to the * terminal encoding and writing to the job over a channel. * * If the job produces output, it is written to the terminal emulator. The * terminal emulator invokes callbacks when its screen content changes. The * line range is stored in tl_dirty_row_start and tl_dirty_row_end. Once in a * while, if the terminal window is visible, the screen contents is drawn. * * When the job ends the text is put in a buffer. Redrawing then happens from * that buffer, attributes come from the scrollback buffer tl_scrollback. * When the buffer is changed it is turned into a normal buffer, the attributes * in tl_scrollback are no longer used. */ #include "vim.h" #if defined(FEAT_TERMINAL) || defined(PROTO) #ifndef MIN # define MIN(x,y) ((x) < (y) ? (x) : (y)) #endif #ifndef MAX # define MAX(x,y) ((x) > (y) ? (x) : (y)) #endif #include "libvterm/include/vterm.h" // This is VTermScreenCell without the characters, thus much smaller. typedef struct { VTermScreenCellAttrs attrs; char width; VTermColor fg; VTermColor bg; } cellattr_T; typedef struct sb_line_S { int sb_cols; // can differ per line cellattr_T *sb_cells; // allocated cellattr_T sb_fill_attr; // for short line char_u *sb_text; // for tl_scrollback_postponed } sb_line_T; #ifdef MSWIN # ifndef HPCON # define HPCON VOID* # endif # ifndef EXTENDED_STARTUPINFO_PRESENT # define EXTENDED_STARTUPINFO_PRESENT 0x00080000 # endif # ifndef PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE # define PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE 0x00020016 # endif typedef struct _DYN_STARTUPINFOEXW { STARTUPINFOW StartupInfo; LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList; } DYN_STARTUPINFOEXW, *PDYN_STARTUPINFOEXW; #endif // typedef term_T in structs.h struct terminal_S { term_T *tl_next; VTerm *tl_vterm; job_T *tl_job; buf_T *tl_buffer; #if defined(FEAT_GUI) int tl_system; // when non-zero used for :!cmd output int tl_toprow; // row with first line of system terminal #endif // Set when setting the size of a vterm, reset after redrawing. int tl_vterm_size_changed; int tl_normal_mode; // TRUE: Terminal-Normal mode int tl_channel_closing; int tl_channel_closed; int tl_channel_recently_closed; // still need to handle tl_finish int tl_finish; #define TL_FINISH_UNSET NUL #define TL_FINISH_CLOSE 'c' // ++close or :terminal without argument #define TL_FINISH_NOCLOSE 'n' // ++noclose #define TL_FINISH_OPEN 'o' // ++open char_u *tl_opencmd; char_u *tl_eof_chars; char_u *tl_api; // prefix for terminal API function char_u *tl_arg0_cmd; // To format the status bar #ifdef MSWIN void *tl_winpty_config; void *tl_winpty; HPCON tl_conpty; DYN_STARTUPINFOEXW tl_siex; // Structure that always needs to be hold FILE *tl_out_fd; #endif #if defined(FEAT_SESSION) char_u *tl_command; #endif char_u *tl_kill; // last known vterm size int tl_rows; int tl_cols; char_u *tl_title; // NULL or allocated char_u *tl_status_text; // NULL or allocated // Range of screen rows to update. Zero based. int tl_dirty_row_start; // MAX_ROW if nothing dirty int tl_dirty_row_end; // row below last one to update int tl_dirty_snapshot; // text updated after making snapshot #ifdef FEAT_TIMERS int tl_timer_set; proftime_T tl_timer_due; #endif int tl_postponed_scroll; // to be scrolled up garray_T tl_scrollback; int tl_scrollback_scrolled; garray_T tl_scrollback_postponed; char_u *tl_highlight_name; // replaces "Terminal"; allocated cellattr_T tl_default_color; linenr_T tl_top_diff_rows; // rows of top diff file or zero linenr_T tl_bot_diff_rows; // rows of bottom diff file VTermPos tl_cursor_pos; int tl_cursor_visible; int tl_cursor_blink; int tl_cursor_shape; // 1: block, 2: underline, 3: bar char_u *tl_cursor_color; // NULL or allocated long_u *tl_palette; // array of 16 colors specified by term_start, can // be NULL int tl_using_altscreen; garray_T tl_osc_buf; // incomplete OSC string }; #define TMODE_ONCE 1 // CTRL-\ CTRL-N used #define TMODE_LOOP 2 // CTRL-W N used /* * List of all active terminals. */ static term_T *first_term = NULL; // Terminal active in terminal_loop(). static term_T *in_terminal_loop = NULL; #ifdef MSWIN static BOOL has_winpty = FALSE; static BOOL has_conpty = FALSE; #endif #define MAX_ROW 999999 // used for tl_dirty_row_end to update all rows #define KEY_BUF_LEN 200 #define FOR_ALL_TERMS(term) \ for ((term) = first_term; (term) != NULL; (term) = (term)->tl_next) /* * Functions with separate implementation for MS-Windows and Unix-like systems. */ static int term_and_job_init(term_T *term, typval_T *argvar, char **argv, jobopt_T *opt, jobopt_T *orig_opt); static int create_pty_only(term_T *term, jobopt_T *opt); static void term_report_winsize(term_T *term, int rows, int cols); static void term_free_vterm(term_T *term); #ifdef FEAT_GUI static void update_system_term(term_T *term); #endif static void handle_postponed_scrollback(term_T *term); // The character that we know (or assume) that the terminal expects for the // backspace key. static int term_backspace_char = BS; // Store the last set and the desired cursor properties, so that we only update // them when needed. Doing it unnecessary may result in flicker. static char_u *last_set_cursor_color = NULL; static char_u *desired_cursor_color = NULL; static int last_set_cursor_shape = -1; static int desired_cursor_shape = -1; static int last_set_cursor_blink = -1; static int desired_cursor_blink = -1; /////////////////////////////////////// // 1. Generic code for all systems. static int cursor_color_equal(char_u *lhs_color, char_u *rhs_color) { if (lhs_color != NULL && rhs_color != NULL) return STRCMP(lhs_color, rhs_color) == 0; return lhs_color == NULL && rhs_color == NULL; } static void cursor_color_copy(char_u **to_color, char_u *from_color) { // Avoid a free & alloc if the value is already right. if (cursor_color_equal(*to_color, from_color)) return; vim_free(*to_color); *to_color = (from_color == NULL) ? NULL : vim_strsave(from_color); } static char_u * cursor_color_get(char_u *color) { return (color == NULL) ? (char_u *)"" : color; } /* * Parse 'termwinsize' and set "rows" and "cols" for the terminal size in the * current window. * Sets "rows" and/or "cols" to zero when it should follow the window size. * Return TRUE if the size is the minimum size: "24*80". */ static int parse_termwinsize(win_T *wp, int *rows, int *cols) { int minsize = FALSE; *rows = 0; *cols = 0; if (*wp->w_p_tws == NUL) return FALSE; char_u *p = vim_strchr(wp->w_p_tws, 'x'); // Syntax of value was already checked when it's set. if (p == NULL) { minsize = TRUE; p = vim_strchr(wp->w_p_tws, '*'); } *rows = atoi((char *)wp->w_p_tws); *cols = atoi((char *)p + 1); return minsize; } /* * Determine the terminal size from 'termwinsize' and the current window. */ static void set_term_and_win_size(term_T *term, jobopt_T *opt) { int rows, cols; int minsize; #ifdef FEAT_GUI if (term->tl_system) { // Use the whole screen for the system command. However, it will start // at the command line and scroll up as needed, using tl_toprow. term->tl_rows = Rows; term->tl_cols = Columns; return; } #endif term->tl_rows = curwin->w_height; term->tl_cols = curwin->w_width; minsize = parse_termwinsize(curwin, &rows, &cols); if (minsize) { if (term->tl_rows < rows) term->tl_rows = rows; if (term->tl_cols < cols) term->tl_cols = cols; } if ((opt->jo_set2 & JO2_TERM_ROWS)) term->tl_rows = opt->jo_term_rows; else if (rows != 0) term->tl_rows = rows; if ((opt->jo_set2 & JO2_TERM_COLS)) term->tl_cols = opt->jo_term_cols; else if (cols != 0) term->tl_cols = cols; if (!opt->jo_hidden) { if (term->tl_rows != curwin->w_height) win_setheight_win(term->tl_rows, curwin); if (term->tl_cols != curwin->w_width) win_setwidth_win(term->tl_cols, curwin); // Set 'winsize' now to avoid a resize at the next redraw. if (!minsize && *curwin->w_p_tws != NUL) { char_u buf[100]; vim_snprintf((char *)buf, 100, "%dx%d", term->tl_rows, term->tl_cols); set_option_value_give_err((char_u *)"termwinsize", 0L, buf, OPT_LOCAL); } } } /* * Initialize job options for a terminal job. * Caller may overrule some of them. */ void init_job_options(jobopt_T *opt) { clear_job_options(opt); opt->jo_mode = CH_MODE_RAW; opt->jo_out_mode = CH_MODE_RAW; opt->jo_err_mode = CH_MODE_RAW; opt->jo_set = JO_MODE | JO_OUT_MODE | JO_ERR_MODE; } /* * Set job options mandatory for a terminal job. */ static void setup_job_options(jobopt_T *opt, int rows, int cols) { #ifndef MSWIN // Win32: Redirecting the job output won't work, thus always connect stdout // here. if (!(opt->jo_set & JO_OUT_IO)) #endif { // Connect stdout to the terminal. opt->jo_io[PART_OUT] = JIO_BUFFER; opt->jo_io_buf[PART_OUT] = curbuf->b_fnum; opt->jo_modifiable[PART_OUT] = 0; opt->jo_set |= JO_OUT_IO + JO_OUT_BUF + JO_OUT_MODIFIABLE; } #ifndef MSWIN // Win32: Redirecting the job output won't work, thus always connect stderr // here. if (!(opt->jo_set & JO_ERR_IO)) #endif { // Connect stderr to the terminal. opt->jo_io[PART_ERR] = JIO_BUFFER; opt->jo_io_buf[PART_ERR] = curbuf->b_fnum; opt->jo_modifiable[PART_ERR] = 0; opt->jo_set |= JO_ERR_IO + JO_ERR_BUF + JO_ERR_MODIFIABLE; } opt->jo_pty = TRUE; if ((opt->jo_set2 & JO2_TERM_ROWS) == 0) opt->jo_term_rows = rows; if ((opt->jo_set2 & JO2_TERM_COLS) == 0) opt->jo_term_cols = cols; } /* * Flush messages on channels. */ static void term_flush_messages(void) { mch_check_messages(); parse_queued_messages(); } /* * Close a terminal buffer (and its window). Used when creating the terminal * fails. */ static void term_close_buffer(buf_T *buf, buf_T *old_curbuf) { free_terminal(buf); if (old_curbuf != NULL) { --curbuf->b_nwindows; curbuf = old_curbuf; curwin->w_buffer = curbuf; ++curbuf->b_nwindows; } CHECK_CURBUF; // Wiping out the buffer will also close the window and call // free_terminal(). do_buffer(DOBUF_WIPE, DOBUF_FIRST, FORWARD, buf->b_fnum, TRUE); } /* * Start a terminal window and return its buffer. * Use either "argvar" or "argv", the other must be NULL. * When "flags" has TERM_START_NOJOB only create the buffer, b_term and open * the window. * Returns NULL when failed. */ buf_T * term_start( typval_T *argvar, char **argv, jobopt_T *opt, int flags) { exarg_T split_ea; win_T *old_curwin = curwin; term_T *term; buf_T *old_curbuf = NULL; int res; buf_T *newbuf; int vertical = opt->jo_vertical || (cmdmod.cmod_split & WSP_VERT); jobopt_T orig_opt; // only partly filled if (check_restricted() || check_secure()) return NULL; if (cmdwin_type != 0) { emsg(_(e_cannot_open_terminal_from_command_line_window)); return NULL; } if ((opt->jo_set & (JO_IN_IO + JO_OUT_IO + JO_ERR_IO)) == (JO_IN_IO + JO_OUT_IO + JO_ERR_IO) || (!(opt->jo_set & JO_OUT_IO) && (opt->jo_set & JO_OUT_BUF)) || (!(opt->jo_set & JO_ERR_IO) && (opt->jo_set & JO_ERR_BUF)) || (argvar != NULL && argvar->v_type == VAR_LIST && argvar->vval.v_list != NULL && argvar->vval.v_list->lv_first == &range_list_item)) { emsg(_(e_invalid_argument)); return NULL; } term = ALLOC_CLEAR_ONE(term_T); if (term == NULL) return NULL; term->tl_dirty_row_end = MAX_ROW; term->tl_cursor_visible = TRUE; term->tl_cursor_shape = VTERM_PROP_CURSORSHAPE_BLOCK; term->tl_finish = opt->jo_term_finish; #ifdef FEAT_GUI term->tl_system = (flags & TERM_START_SYSTEM); #endif ga_init2(&term->tl_scrollback, sizeof(sb_line_T), 300); ga_init2(&term->tl_scrollback_postponed, sizeof(sb_line_T), 300); ga_init2(&term->tl_osc_buf, sizeof(char), 300); setpcmark(); CLEAR_FIELD(split_ea); if (opt->jo_curwin) { // Create a new buffer in the current window. if (!can_abandon(curbuf, flags & TERM_START_FORCEIT)) { no_write_message(); vim_free(term); return NULL; } if (do_ecmd(0, NULL, NULL, &split_ea, ECMD_ONE, (buf_hide(curwin->w_buffer) ? ECMD_HIDE : 0) + ((flags & TERM_START_FORCEIT) ? ECMD_FORCEIT : 0), curwin) == FAIL) { vim_free(term); return NULL; } } else if (opt->jo_hidden || (flags & TERM_START_SYSTEM)) { buf_T *buf; // Create a new buffer without a window. Make it the current buffer for // a moment to be able to do the initializations. buf = buflist_new((char_u *)"", NULL, (linenr_T)0, BLN_NEW | BLN_LISTED); if (buf == NULL || ml_open(buf) == FAIL) { vim_free(term); return NULL; } old_curbuf = curbuf; --curbuf->b_nwindows; curbuf = buf; curwin->w_buffer = buf; ++curbuf->b_nwindows; } else { // Open a new window or tab. split_ea.cmdidx = CMD_new; split_ea.cmd = (char_u *)"new"; split_ea.arg = (char_u *)""; if (opt->jo_term_rows > 0 && !vertical) { split_ea.line2 = opt->jo_term_rows; split_ea.addr_count = 1; } if (opt->jo_term_cols > 0 && vertical) { split_ea.line2 = opt->jo_term_cols; split_ea.addr_count = 1; } if (vertical) cmdmod.cmod_split |= WSP_VERT; ex_splitview(&split_ea); if (curwin == old_curwin) { // split failed vim_free(term); return NULL; } } term->tl_buffer = curbuf; curbuf->b_term = term; if (!opt->jo_hidden) { // Only one size was taken care of with :new, do the other one. With // "curwin" both need to be done. if (opt->jo_term_rows > 0 && (opt->jo_curwin || vertical)) win_setheight(opt->jo_term_rows); if (opt->jo_term_cols > 0 && (opt->jo_curwin || !vertical)) win_setwidth(opt->jo_term_cols); } // Link the new terminal in the list of active terminals. term->tl_next = first_term; first_term = term; apply_autocmds(EVENT_BUFFILEPRE, NULL, NULL, FALSE, curbuf); if (opt->jo_term_name != NULL) { vim_free(curbuf->b_ffname); curbuf->b_ffname = vim_strsave(opt->jo_term_name); } else if (argv != NULL) { vim_free(curbuf->b_ffname); curbuf->b_ffname = vim_strsave((char_u *)"!system"); } else { int i; size_t len; char_u *cmd, *p; if (argvar->v_type == VAR_STRING) { cmd = argvar->vval.v_string; if (cmd == NULL) cmd = (char_u *)""; else if (STRCMP(cmd, "NONE") == 0) cmd = (char_u *)"pty"; } else if (argvar->v_type != VAR_LIST || argvar->vval.v_list == NULL || argvar->vval.v_list->lv_len == 0 || (cmd = tv_get_string_chk( &argvar->vval.v_list->lv_first->li_tv)) == NULL) cmd = (char_u*)""; len = STRLEN(cmd) + 10; p = alloc(len); for (i = 0; p != NULL; ++i) { // Prepend a ! to the command name to avoid the buffer name equals // the executable, otherwise ":w!" would overwrite it. if (i == 0) vim_snprintf((char *)p, len, "!%s", cmd); else vim_snprintf((char *)p, len, "!%s (%d)", cmd, i); if (buflist_findname(p) == NULL) { vim_free(curbuf->b_ffname); curbuf->b_ffname = p; break; } } } vim_free(curbuf->b_sfname); curbuf->b_sfname = vim_strsave(curbuf->b_ffname); curbuf->b_fname = curbuf->b_ffname; apply_autocmds(EVENT_BUFFILEPOST, NULL, NULL, FALSE, curbuf); if (opt->jo_term_opencmd != NULL) term->tl_opencmd = vim_strsave(opt->jo_term_opencmd); if (opt->jo_eof_chars != NULL) term->tl_eof_chars = vim_strsave(opt->jo_eof_chars); set_string_option_direct((char_u *)"buftype", -1, (char_u *)"terminal", OPT_FREE|OPT_LOCAL, 0); // Avoid that 'buftype' is reset when this buffer is entered. curbuf->b_p_initialized = TRUE; // Mark the buffer as not modifiable. It can only be made modifiable after // the job finished. curbuf->b_p_ma = FALSE; set_term_and_win_size(term, opt); #ifdef MSWIN mch_memmove(orig_opt.jo_io, opt->jo_io, sizeof(orig_opt.jo_io)); #endif setup_job_options(opt, term->tl_rows, term->tl_cols); if (flags & TERM_START_NOJOB) return curbuf; #if defined(FEAT_SESSION) // Remember the command for the session file. if (opt->jo_term_norestore || argv != NULL) term->tl_command = vim_strsave((char_u *)"NONE"); else if (argvar->v_type == VAR_STRING) { char_u *cmd = argvar->vval.v_string; if (cmd != NULL && STRCMP(cmd, p_sh) != 0) term->tl_command = vim_strsave(cmd); } else if (argvar->v_type == VAR_LIST && argvar->vval.v_list != NULL && argvar->vval.v_list->lv_len > 0) { garray_T ga; listitem_T *item; ga_init2(&ga, 1, 100); FOR_ALL_LIST_ITEMS(argvar->vval.v_list, item) { char_u *s = tv_get_string_chk(&item->li_tv); char_u *p; if (s == NULL) break; p = vim_strsave_fnameescape(s, VSE_NONE); if (p == NULL) break; ga_concat(&ga, p); vim_free(p); ga_append(&ga, ' '); } if (item == NULL) { ga_append(&ga, NUL); term->tl_command = ga.ga_data; } else ga_clear(&ga); } #endif if (opt->jo_term_kill != NULL) { char_u *p = skiptowhite(opt->jo_term_kill); term->tl_kill = vim_strnsave(opt->jo_term_kill, p - opt->jo_term_kill); } if (opt->jo_term_api != NULL) { char_u *p = skiptowhite(opt->jo_term_api); term->tl_api = vim_strnsave(opt->jo_term_api, p - opt->jo_term_api); } else term->tl_api = vim_strsave((char_u *)"Tapi_"); if (opt->jo_set2 & JO2_TERM_HIGHLIGHT) term->tl_highlight_name = vim_strsave(opt->jo_term_highlight); #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) // Save the user-defined palette, it is only used in GUI (or 'tgc' is on). if (opt->jo_set2 & JO2_ANSI_COLORS) { term->tl_palette = ALLOC_MULT(long_u, 16); if (term->tl_palette == NULL) { vim_free(term); return NULL; } memcpy(term->tl_palette, opt->jo_ansi_colors, sizeof(long_u) * 16); } #endif // System dependent: setup the vterm and maybe start the job in it. if (argv == NULL && argvar->v_type == VAR_STRING && argvar->vval.v_string != NULL && STRCMP(argvar->vval.v_string, "NONE") == 0) res = create_pty_only(term, opt); else res = term_and_job_init(term, argvar, argv, opt, &orig_opt); newbuf = curbuf; if (res == OK) { // Get and remember the size we ended up with. Update the pty. vterm_get_size(term->tl_vterm, &term->tl_rows, &term->tl_cols); term_report_winsize(term, term->tl_rows, term->tl_cols); #ifdef FEAT_GUI if (term->tl_system) { // display first line below typed command term->tl_toprow = msg_row + 1; term->tl_dirty_row_end = 0; } #endif // Make sure we don't get stuck on sending keys to the job, it leads to // a deadlock if the job is waiting for Vim to read. channel_set_nonblock(term->tl_job->jv_channel, PART_IN); if (old_curbuf != NULL) { --curbuf->b_nwindows; curbuf = old_curbuf; curwin->w_buffer = curbuf; ++curbuf->b_nwindows; } else if (vgetc_busy #ifdef FEAT_TIMERS || timer_busy #endif || input_busy) { char_u ignore[4]; // When waiting for input need to return and possibly end up in // terminal_loop() instead. ignore[0] = K_SPECIAL; ignore[1] = KS_EXTRA; ignore[2] = KE_IGNORE; ignore[3] = NUL; ins_typebuf(ignore, REMAP_NONE, 0, TRUE, FALSE); typebuf_was_filled = TRUE; } } else { term_close_buffer(curbuf, old_curbuf); return NULL; } apply_autocmds(EVENT_TERMINALOPEN, NULL, NULL, FALSE, newbuf); if (!opt->jo_hidden && !(flags & TERM_START_SYSTEM)) apply_autocmds(EVENT_TERMINALWINOPEN, NULL, NULL, FALSE, newbuf); return newbuf; } /* * ":terminal": open a terminal window and execute a job in it. */ void ex_terminal(exarg_T *eap) { typval_T argvar[2]; jobopt_T opt; int opt_shell = FALSE; char_u *cmd; char_u *tofree = NULL; init_job_options(&opt); cmd = eap->arg; while (*cmd == '+' && *(cmd + 1) == '+') { char_u *p, *ep; cmd += 2; p = skiptowhite(cmd); ep = vim_strchr(cmd, '='); if (ep != NULL) { if (ep < p) p = ep; else ep = NULL; } # define OPTARG_HAS(name) ((int)(p - cmd) == sizeof(name) - 1 \ && STRNICMP(cmd, name, sizeof(name) - 1) == 0) if (OPTARG_HAS("close")) opt.jo_term_finish = 'c'; else if (OPTARG_HAS("noclose")) opt.jo_term_finish = 'n'; else if (OPTARG_HAS("open")) opt.jo_term_finish = 'o'; else if (OPTARG_HAS("curwin")) opt.jo_curwin = 1; else if (OPTARG_HAS("hidden")) opt.jo_hidden = 1; else if (OPTARG_HAS("norestore")) opt.jo_term_norestore = 1; else if (OPTARG_HAS("shell")) opt_shell = TRUE; else if (OPTARG_HAS("kill") && ep != NULL) { opt.jo_set2 |= JO2_TERM_KILL; opt.jo_term_kill = ep + 1; p = skiptowhite(cmd); } else if (OPTARG_HAS("api")) { opt.jo_set2 |= JO2_TERM_API; if (ep != NULL) { opt.jo_term_api = ep + 1; p = skiptowhite(cmd); } else opt.jo_term_api = NULL; } else if (OPTARG_HAS("rows") && ep != NULL && isdigit(ep[1])) { opt.jo_set2 |= JO2_TERM_ROWS; opt.jo_term_rows = atoi((char *)ep + 1); p = skiptowhite(cmd); } else if (OPTARG_HAS("cols") && ep != NULL && isdigit(ep[1])) { opt.jo_set2 |= JO2_TERM_COLS; opt.jo_term_cols = atoi((char *)ep + 1); p = skiptowhite(cmd); } else if (OPTARG_HAS("eof") && ep != NULL) { char_u *buf = NULL; char_u *keys; vim_free(opt.jo_eof_chars); p = skiptowhite(cmd); *p = NUL; keys = replace_termcodes(ep + 1, &buf, REPTERM_FROM_PART | REPTERM_DO_LT | REPTERM_SPECIAL, NULL); opt.jo_set2 |= JO2_EOF_CHARS; opt.jo_eof_chars = vim_strsave(keys); vim_free(buf); *p = ' '; } #ifdef MSWIN else if ((int)(p - cmd) == 4 && STRNICMP(cmd, "type", 4) == 0 && ep != NULL) { int tty_type = NUL; p = skiptowhite(cmd); if (STRNICMP(ep + 1, "winpty", p - (ep + 1)) == 0) tty_type = 'w'; else if (STRNICMP(ep + 1, "conpty", p - (ep + 1)) == 0) tty_type = 'c'; else { semsg(e_invalid_value_for_argument_str, "type"); goto theend; } opt.jo_set2 |= JO2_TTY_TYPE; opt.jo_tty_type = tty_type; } #endif else { if (*p) *p = NUL; semsg(_(e_invalid_attribute_str), cmd); goto theend; } # undef OPTARG_HAS cmd = skipwhite(p); } if (*cmd == NUL) { // Make a copy of 'shell', an autocommand may change the option. tofree = cmd = vim_strsave(p_sh); // default to close when the shell exits if (opt.jo_term_finish == NUL) opt.jo_term_finish = TL_FINISH_CLOSE; } if (eap->addr_count > 0) { // Write lines from current buffer to the job. opt.jo_set |= JO_IN_IO | JO_IN_BUF | JO_IN_TOP | JO_IN_BOT; opt.jo_io[PART_IN] = JIO_BUFFER; opt.jo_io_buf[PART_IN] = curbuf->b_fnum; opt.jo_in_top = eap->line1; opt.jo_in_bot = eap->line2; } if (opt_shell && tofree == NULL) { #ifdef UNIX char **argv = NULL; char_u *tofree1 = NULL; char_u *tofree2 = NULL; // :term ++shell command if (unix_build_argv(cmd, &argv, &tofree1, &tofree2) == OK) term_start(NULL, argv, &opt, eap->forceit ? TERM_START_FORCEIT : 0); vim_free(argv); vim_free(tofree1); vim_free(tofree2); goto theend; #else # ifdef MSWIN long_u cmdlen = STRLEN(p_sh) + STRLEN(p_shcf) + STRLEN(cmd) + 10; char_u *newcmd; newcmd = alloc(cmdlen); if (newcmd == NULL) goto theend; tofree = newcmd; vim_snprintf((char *)newcmd, cmdlen, "%s %s %s", p_sh, p_shcf, cmd); cmd = newcmd; # else emsg(_(e_sorry_plusplusshell_not_supported_on_this_system)); goto theend; # endif #endif } argvar[0].v_type = VAR_STRING; argvar[0].vval.v_string = cmd; argvar[1].v_type = VAR_UNKNOWN; term_start(argvar, NULL, &opt, eap->forceit ? TERM_START_FORCEIT : 0); theend: vim_free(tofree); vim_free(opt.jo_eof_chars); } #if defined(FEAT_SESSION) || defined(PROTO) /* * Write a :terminal command to the session file to restore the terminal in * window "wp". * Return FAIL if writing fails. */ int term_write_session(FILE *fd, win_T *wp, hashtab_T *terminal_bufs) { const int bufnr = wp->w_buffer->b_fnum; term_T *term = wp->w_buffer->b_term; if (terminal_bufs != NULL && wp->w_buffer->b_nwindows > 1) { // There are multiple views into this terminal buffer. We don't want to // create the terminal multiple times. If it's the first time, create, // otherwise link to the first buffer. char id_as_str[NUMBUFLEN]; hashitem_T *entry; vim_snprintf(id_as_str, sizeof(id_as_str), "%d", bufnr); entry = hash_find(terminal_bufs, (char_u *)id_as_str); if (!HASHITEM_EMPTY(entry)) { // we've already opened this terminal buffer if (fprintf(fd, "execute 'buffer ' . s:term_buf_%d", bufnr) < 0) return FAIL; return put_eol(fd); } } // Create the terminal and run the command. This is not without // risk, but let's assume the user only creates a session when this // will be OK. if (fprintf(fd, "terminal ++curwin ++cols=%d ++rows=%d ", term->tl_cols, term->tl_rows) < 0) return FAIL; #ifdef MSWIN if (fprintf(fd, "++type=%s ", term->tl_job->jv_tty_type) < 0) return FAIL; #endif if (term->tl_command != NULL && fputs((char *)term->tl_command, fd) < 0) return FAIL; if (put_eol(fd) != OK) return FAIL; if (fprintf(fd, "let s:term_buf_%d = bufnr()", bufnr) < 0) return FAIL; if (terminal_bufs != NULL && wp->w_buffer->b_nwindows > 1) { char *hash_key = alloc(NUMBUFLEN); vim_snprintf(hash_key, NUMBUFLEN, "%d", bufnr); hash_add(terminal_bufs, (char_u *)hash_key, "terminal session"); } return put_eol(fd); } /* * Return TRUE if "buf" has a terminal that should be restored. */ int term_should_restore(buf_T *buf) { term_T *term = buf->b_term; return term != NULL && (term->tl_command == NULL || STRCMP(term->tl_command, "NONE") != 0); } #endif /* * Free the scrollback buffer for "term". */ static void free_scrollback(term_T *term) { int i; for (i = 0; i < term->tl_scrollback.ga_len; ++i) vim_free(((sb_line_T *)term->tl_scrollback.ga_data + i)->sb_cells); ga_clear(&term->tl_scrollback); for (i = 0; i < term->tl_scrollback_postponed.ga_len; ++i) vim_free(((sb_line_T *)term->tl_scrollback_postponed.ga_data + i)->sb_cells); ga_clear(&term->tl_scrollback_postponed); } // Terminals that need to be freed soon. static term_T *terminals_to_free = NULL; /* * Free a terminal and everything it refers to. * Kills the job if there is one. * Called when wiping out a buffer. * The actual terminal structure is freed later in free_unused_terminals(), * because callbacks may wipe out a buffer while the terminal is still * referenced. */ void free_terminal(buf_T *buf) { term_T *term = buf->b_term; term_T *tp; if (term == NULL) return; // Unlink the terminal form the list of terminals. if (first_term == term) first_term = term->tl_next; else for (tp = first_term; tp->tl_next != NULL; tp = tp->tl_next) if (tp->tl_next == term) { tp->tl_next = term->tl_next; break; } if (term->tl_job != NULL) { if (term->tl_job->jv_status != JOB_ENDED && term->tl_job->jv_status != JOB_FINISHED && term->tl_job->jv_status != JOB_FAILED) job_stop(term->tl_job, NULL, "kill"); job_unref(term->tl_job); } term->tl_next = terminals_to_free; terminals_to_free = term; buf->b_term = NULL; if (in_terminal_loop == term) in_terminal_loop = NULL; } void free_unused_terminals(void) { while (terminals_to_free != NULL) { term_T *term = terminals_to_free; terminals_to_free = term->tl_next; free_scrollback(term); ga_clear(&term->tl_osc_buf); term_free_vterm(term); vim_free(term->tl_api); vim_free(term->tl_title); #ifdef FEAT_SESSION vim_free(term->tl_command); #endif vim_free(term->tl_kill); vim_free(term->tl_status_text); vim_free(term->tl_opencmd); vim_free(term->tl_eof_chars); vim_free(term->tl_arg0_cmd); #ifdef MSWIN if (term->tl_out_fd != NULL) fclose(term->tl_out_fd); #endif vim_free(term->tl_highlight_name); vim_free(term->tl_cursor_color); vim_free(term->tl_palette); vim_free(term); } } /* * Get the part that is connected to the tty. Normally this is PART_IN, but * when writing buffer lines to the job it can be another. This makes it * possible to do "1,5term vim -". */ static ch_part_T get_tty_part(term_T *term UNUSED) { #ifdef UNIX ch_part_T parts[3] = {PART_IN, PART_OUT, PART_ERR}; int i; for (i = 0; i < 3; ++i) { int fd = term->tl_job->jv_channel->ch_part[parts[i]].ch_fd; if (mch_isatty(fd)) return parts[i]; } #endif return PART_IN; } /* * Read any vterm output and send it on the channel. */ static void term_forward_output(term_T *term) { VTerm *vterm = term->tl_vterm; char buf[KEY_BUF_LEN]; size_t curlen = vterm_output_read(vterm, buf, KEY_BUF_LEN); if (curlen > 0) channel_send(term->tl_job->jv_channel, get_tty_part(term), (char_u *)buf, (int)curlen, NULL); } /* * Write job output "msg[len]" to the vterm. */ static void term_write_job_output(term_T *term, char_u *msg_arg, size_t len_arg) { char_u *msg = msg_arg; size_t len = len_arg; VTerm *vterm = term->tl_vterm; size_t prevlen = vterm_output_get_buffer_current(vterm); size_t limit = term->tl_buffer->b_p_twsl * term->tl_cols * 3; // Limit the length to 'termwinscroll' * cols * 3 bytes. Keep the text at // the end. if (len > limit) { char_u *p = msg + len - limit; p -= (*mb_head_off)(msg, p); len -= p - msg; msg = p; } vterm_input_write(vterm, (char *)msg, len); // flush vterm buffer when vterm responded to control sequence if (prevlen != vterm_output_get_buffer_current(vterm)) term_forward_output(term); // this invokes the damage callbacks vterm_screen_flush_damage(vterm_obtain_screen(vterm)); } static void update_cursor(term_T *term, int redraw) { if (term->tl_normal_mode) return; #ifdef FEAT_GUI if (term->tl_system) windgoto(term->tl_cursor_pos.row + term->tl_toprow, term->tl_cursor_pos.col); else #endif setcursor(); if (redraw) { aco_save_T aco; if (term->tl_buffer == curbuf && term->tl_cursor_visible) cursor_on(); out_flush(); #ifdef FEAT_GUI if (gui.in_use) { gui_update_cursor(FALSE, FALSE); gui_mch_flush(); } #endif // Make sure an invoked autocmd doesn't delete the buffer (and the // terminal) under our fingers. ++term->tl_buffer->b_locked; // save and restore curwin and curbuf, in case the autocmd changes them aucmd_prepbuf(&aco, curbuf); apply_autocmds(EVENT_TEXTCHANGEDT, NULL, NULL, FALSE, term->tl_buffer); aucmd_restbuf(&aco); --term->tl_buffer->b_locked; } } /* * Invoked when "msg" output from a job was received. Write it to the terminal * of "buffer". */ void write_to_term(buf_T *buffer, char_u *msg, channel_T *channel) { size_t len = STRLEN(msg); term_T *term = buffer->b_term; #ifdef MSWIN // Win32: Cannot redirect output of the job, intercept it here and write to // the file. if (term->tl_out_fd != NULL) { ch_log(channel, "Writing %d bytes to output file", (int)len); fwrite(msg, len, 1, term->tl_out_fd); return; } #endif if (term->tl_vterm == NULL) { ch_log(channel, "NOT writing %d bytes to terminal", (int)len); return; } ch_log(channel, "writing %d bytes to terminal", (int)len); cursor_off(); term_write_job_output(term, msg, len); #ifdef FEAT_GUI if (term->tl_system) { // show system output, scrolling up the screen as needed update_system_term(term); update_cursor(term, TRUE); } else #endif // In Terminal-Normal mode we are displaying the buffer, not the terminal // contents, thus no screen update is needed. if (!term->tl_normal_mode) { // Don't use update_screen() when editing the command line, it gets // cleared. // TODO: only update once in a while. ch_log(term->tl_job->jv_channel, "updating screen"); if (buffer == curbuf && (State & MODE_CMDLINE) == 0) { update_screen(UPD_VALID_NO_UPDATE); // update_screen() can be slow, check the terminal wasn't closed // already if (buffer == curbuf && curbuf->b_term != NULL) update_cursor(curbuf->b_term, TRUE); } else redraw_after_callback(TRUE, FALSE); } } /* * Send a mouse position and click to the vterm */ static int term_send_mouse(VTerm *vterm, int button, int pressed) { VTermModifier mod = VTERM_MOD_NONE; int row = mouse_row - W_WINROW(curwin); int col = mouse_col - curwin->w_wincol; #ifdef FEAT_PROP_POPUP if (popup_is_popup(curwin)) { row -= popup_top_extra(curwin); col -= popup_left_extra(curwin); } #endif vterm_mouse_move(vterm, row, col, mod); if (button != 0) vterm_mouse_button(vterm, button, pressed, mod); return TRUE; } static int enter_mouse_col = -1; static int enter_mouse_row = -1; /* * Handle a mouse click, drag or release. * Return TRUE when a mouse event is sent to the terminal. */ static int term_mouse_click(VTerm *vterm, int key) { #if defined(FEAT_CLIPBOARD) // For modeless selection mouse drag and release events are ignored, unless // they are preceded with a mouse down event static int ignore_drag_release = TRUE; VTermMouseState mouse_state; vterm_state_get_mousestate(vterm_obtain_state(vterm), &mouse_state); if (mouse_state.flags == 0) { // Terminal is not using the mouse, use modeless selection. switch (key) { case K_LEFTDRAG: case K_LEFTRELEASE: case K_RIGHTDRAG: case K_RIGHTRELEASE: // Ignore drag and release events when the button-down wasn't // seen before. if (ignore_drag_release) { int save_mouse_col, save_mouse_row; if (enter_mouse_col < 0) break; // mouse click in the window gave us focus, handle that // click now save_mouse_col = mouse_col; save_mouse_row = mouse_row; mouse_col = enter_mouse_col; mouse_row = enter_mouse_row; clip_modeless(MOUSE_LEFT, TRUE, FALSE); mouse_col = save_mouse_col; mouse_row = save_mouse_row; } // FALLTHROUGH case K_LEFTMOUSE: case K_RIGHTMOUSE: if (key == K_LEFTRELEASE || key == K_RIGHTRELEASE) ignore_drag_release = TRUE; else ignore_drag_release = FALSE; // Should we call mouse_has() here? if (clip_star.available) { int button, is_click, is_drag; button = get_mouse_button(KEY2TERMCAP1(key), &is_click, &is_drag); if (mouse_model_popup() && button == MOUSE_LEFT && (mod_mask & MOD_MASK_SHIFT)) { // Translate shift-left to right button. button = MOUSE_RIGHT; mod_mask &= ~MOD_MASK_SHIFT; } clip_modeless(button, is_click, is_drag); } break; case K_MIDDLEMOUSE: if (clip_star.available) insert_reg('*', TRUE); break; } enter_mouse_col = -1; return FALSE; } #endif enter_mouse_col = -1; switch (key) { case K_LEFTMOUSE: case K_LEFTMOUSE_NM: term_send_mouse(vterm, 1, 1); break; case K_LEFTDRAG: term_send_mouse(vterm, 1, 1); break; case K_LEFTRELEASE: case K_LEFTRELEASE_NM: term_send_mouse(vterm, 1, 0); break; case K_MOUSEMOVE: term_send_mouse(vterm, 0, 0); break; case K_MIDDLEMOUSE: term_send_mouse(vterm, 2, 1); break; case K_MIDDLEDRAG: term_send_mouse(vterm, 2, 1); break; case K_MIDDLERELEASE: term_send_mouse(vterm, 2, 0); break; case K_RIGHTMOUSE: term_send_mouse(vterm, 3, 1); break; case K_RIGHTDRAG: term_send_mouse(vterm, 3, 1); break; case K_RIGHTRELEASE: term_send_mouse(vterm, 3, 0); break; } return TRUE; } /* * Convert typed key "c" with modifiers "modmask" into bytes to send to the * job. * Return the number of bytes in "buf". */ static int term_convert_key(term_T *term, int c, int modmask, char *buf) { VTerm *vterm = term->tl_vterm; VTermKey key = VTERM_KEY_NONE; VTermModifier mod = VTERM_MOD_NONE; int other = FALSE; switch (c) { // don't use VTERM_KEY_ENTER, it may do an unwanted conversion // don't use VTERM_KEY_BACKSPACE, it always // becomes 0x7f DEL case K_BS: c = term_backspace_char; break; case ESC: key = VTERM_KEY_ESCAPE; break; case K_DEL: key = VTERM_KEY_DEL; break; case K_DOWN: key = VTERM_KEY_DOWN; break; case K_S_DOWN: mod = VTERM_MOD_SHIFT; key = VTERM_KEY_DOWN; break; case K_END: key = VTERM_KEY_END; break; case K_S_END: mod = VTERM_MOD_SHIFT; key = VTERM_KEY_END; break; case K_C_END: mod = VTERM_MOD_CTRL; key = VTERM_KEY_END; break; case K_F10: key = VTERM_KEY_FUNCTION(10); break; case K_F11: key = VTERM_KEY_FUNCTION(11); break; case K_F12: key = VTERM_KEY_FUNCTION(12); break; case K_F1: key = VTERM_KEY_FUNCTION(1); break; case K_F2: key = VTERM_KEY_FUNCTION(2); break; case K_F3: key = VTERM_KEY_FUNCTION(3); break; case K_F4: key = VTERM_KEY_FUNCTION(4); break; case K_F5: key = VTERM_KEY_FUNCTION(5); break; case K_F6: key = VTERM_KEY_FUNCTION(6); break; case K_F7: key = VTERM_KEY_FUNCTION(7); break; case K_F8: key = VTERM_KEY_FUNCTION(8); break; case K_F9: key = VTERM_KEY_FUNCTION(9); break; case K_HOME: key = VTERM_KEY_HOME; break; case K_S_HOME: mod = VTERM_MOD_SHIFT; key = VTERM_KEY_HOME; break; case K_C_HOME: mod = VTERM_MOD_CTRL; key = VTERM_KEY_HOME; break; case K_INS: key = VTERM_KEY_INS; break; case K_K0: key = VTERM_KEY_KP_0; break; case K_K1: key = VTERM_KEY_KP_1; break; case K_K2: key = VTERM_KEY_KP_2; break; case K_K3: key = VTERM_KEY_KP_3; break; case K_K4: key = VTERM_KEY_KP_4; break; case K_K5: key = VTERM_KEY_KP_5; break; case K_K6: key = VTERM_KEY_KP_6; break; case K_K7: key = VTERM_KEY_KP_7; break; case K_K8: key = VTERM_KEY_KP_8; break; case K_K9: key = VTERM_KEY_KP_9; break; case K_KDEL: key = VTERM_KEY_DEL; break; // TODO case K_KDIVIDE: key = VTERM_KEY_KP_DIVIDE; break; case K_KEND: key = VTERM_KEY_KP_1; break; // TODO case K_KENTER: key = VTERM_KEY_KP_ENTER; break; case K_KHOME: key = VTERM_KEY_KP_7; break; // TODO case K_KINS: key = VTERM_KEY_KP_0; break; // TODO case K_KMINUS: key = VTERM_KEY_KP_MINUS; break; case K_KMULTIPLY: key = VTERM_KEY_KP_MULT; break; case K_KPAGEDOWN: key = VTERM_KEY_KP_3; break; // TODO case K_KPAGEUP: key = VTERM_KEY_KP_9; break; // TODO case K_KPLUS: key = VTERM_KEY_KP_PLUS; break; case K_KPOINT: key = VTERM_KEY_KP_PERIOD; break; case K_LEFT: key = VTERM_KEY_LEFT; break; case K_S_LEFT: mod = VTERM_MOD_SHIFT; key = VTERM_KEY_LEFT; break; case K_C_LEFT: mod = VTERM_MOD_CTRL; key = VTERM_KEY_LEFT; break; case K_PAGEDOWN: key = VTERM_KEY_PAGEDOWN; break; case K_PAGEUP: key = VTERM_KEY_PAGEUP; break; case K_RIGHT: key = VTERM_KEY_RIGHT; break; case K_S_RIGHT: mod = VTERM_MOD_SHIFT; key = VTERM_KEY_RIGHT; break; case K_C_RIGHT: mod = VTERM_MOD_CTRL; key = VTERM_KEY_RIGHT; break; case K_UP: key = VTERM_KEY_UP; break; case K_S_UP: mod = VTERM_MOD_SHIFT; key = VTERM_KEY_UP; break; case TAB: key = VTERM_KEY_TAB; break; case K_S_TAB: mod = VTERM_MOD_SHIFT; key = VTERM_KEY_TAB; break; case K_MOUSEUP: other = term_send_mouse(vterm, 5, 1); break; case K_MOUSEDOWN: other = term_send_mouse(vterm, 4, 1); break; case K_MOUSELEFT: other = term_send_mouse(vterm, 7, 1); break; case K_MOUSERIGHT: other = term_send_mouse(vterm, 6, 1); break; case K_LEFTMOUSE: case K_LEFTMOUSE_NM: case K_LEFTDRAG: case K_LEFTRELEASE: case K_LEFTRELEASE_NM: case K_MOUSEMOVE: case K_MIDDLEMOUSE: case K_MIDDLEDRAG: case K_MIDDLERELEASE: case K_RIGHTMOUSE: case K_RIGHTDRAG: case K_RIGHTRELEASE: if (!term_mouse_click(vterm, c)) return 0; other = TRUE; break; case K_X1MOUSE: /* TODO */ return 0; case K_X1DRAG: /* TODO */ return 0; case K_X1RELEASE: /* TODO */ return 0; case K_X2MOUSE: /* TODO */ return 0; case K_X2DRAG: /* TODO */ return 0; case K_X2RELEASE: /* TODO */ return 0; case K_IGNORE: return 0; case K_NOP: return 0; case K_UNDO: return 0; case K_HELP: return 0; case K_XF1: key = VTERM_KEY_FUNCTION(1); break; case K_XF2: key = VTERM_KEY_FUNCTION(2); break; case K_XF3: key = VTERM_KEY_FUNCTION(3); break; case K_XF4: key = VTERM_KEY_FUNCTION(4); break; case K_SELECT: return 0; #ifdef FEAT_GUI case K_VER_SCROLLBAR: return 0; case K_HOR_SCROLLBAR: return 0; #endif #ifdef FEAT_GUI_TABLINE case K_TABLINE: return 0; case K_TABMENU: return 0; #endif #ifdef FEAT_NETBEANS_INTG case K_F21: key = VTERM_KEY_FUNCTION(21); break; #endif #ifdef FEAT_DND case K_DROP: return 0; #endif case K_CURSORHOLD: return 0; case K_PS: vterm_keyboard_start_paste(vterm); other = TRUE; break; case K_PE: vterm_keyboard_end_paste(vterm); other = TRUE; break; } // add modifiers for the typed key if (modmask & MOD_MASK_SHIFT) mod |= VTERM_MOD_SHIFT; if (modmask & MOD_MASK_CTRL) mod |= VTERM_MOD_CTRL; if (modmask & (MOD_MASK_ALT | MOD_MASK_META)) mod |= VTERM_MOD_ALT; // Ctrl-Shift-i may have the key "I" instead of "i", but for the kitty // keyboard protocol should use "i". Applies to all ascii letters. if (ASCII_ISUPPER(c) && vterm_is_kitty_keyboard(vterm) && mod == (VTERM_MOD_CTRL | VTERM_MOD_SHIFT)) c = TOLOWER_ASC(c); /* * Convert special keys to vterm keys: * - Write keys to vterm: vterm_keyboard_key() * - Write output to channel. */ if (key != VTERM_KEY_NONE) // Special key, let vterm convert it. vterm_keyboard_key(vterm, key, mod); else if (!other) // Normal character, let vterm convert it. vterm_keyboard_unichar(vterm, c, mod); // Read back the converted escape sequence. return (int)vterm_output_read(vterm, buf, KEY_BUF_LEN); } /* * Return TRUE if the job for "term" is still running. * If "check_job_status" is TRUE update the job status. * NOTE: "term" may be freed by callbacks. */ static int term_job_running_check(term_T *term, int check_job_status) { // Also consider the job finished when the channel is closed, to avoid a // race condition when updating the title. if (term == NULL || term->tl_job == NULL || !channel_is_open(term->tl_job->jv_channel)) return FALSE; job_T *job = term->tl_job; // Careful: Checking the job status may invoke callbacks, which close // the buffer and terminate "term". However, "job" will not be freed // yet. if (check_job_status) job_status(job); return (job->jv_status == JOB_STARTED || (job->jv_channel != NULL && job->jv_channel->ch_keep_open)); } /* * Return TRUE if the job for "term" is still running. */ int term_job_running(term_T *term) { return term_job_running_check(term, FALSE); } /* * Return TRUE if the job for "term" is still running, ignoring the job was * "NONE". */ int term_job_running_not_none(term_T *term) { return term_job_running(term) && !term_none_open(term); } /* * Return TRUE if "term" has an active channel and used ":term NONE". */ int term_none_open(term_T *term) { // Also consider the job finished when the channel is closed, to avoid a // race condition when updating the title. return term != NULL && term->tl_job != NULL && channel_is_open(term->tl_job->jv_channel) && term->tl_job->jv_channel->ch_keep_open; } // // Used to confirm whether we would like to kill a terminal. // Return OK when the user confirms to kill it. // Return FAIL if the user selects otherwise. // int term_confirm_stop(buf_T *buf) { char_u buff[DIALOG_MSG_SIZE]; int ret; dialog_msg(buff, _("Kill job in \"%s\"?"), buf_get_fname(buf)); ret = vim_dialog_yesno(VIM_QUESTION, NULL, buff, 1); if (ret == VIM_YES) return OK; else return FAIL; } /* * Used when exiting: kill the job in "buf" if so desired. * Return OK when the job finished. * Return FAIL when the job is still running. */ int term_try_stop_job(buf_T *buf) { int count; char *how = (char *)buf->b_term->tl_kill; #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) if ((how == NULL || *how == NUL) && (p_confirm || (cmdmod.cmod_flags & CMOD_CONFIRM))) { if (term_confirm_stop(buf) == OK) how = "kill"; else return FAIL; } #endif if (how == NULL || *how == NUL) return FAIL; job_stop(buf->b_term->tl_job, NULL, how); // wait for up to a second for the job to die for (count = 0; count < 100; ++count) { job_T *job; // buffer, terminal and job may be cleaned up while waiting if (!buf_valid(buf) || buf->b_term == NULL || buf->b_term->tl_job == NULL) return OK; job = buf->b_term->tl_job; // Call job_status() to update jv_status. It may cause the job to be // cleaned up but it won't be freed. job_status(job); if (job->jv_status >= JOB_ENDED) return OK; ui_delay(10L, TRUE); term_flush_messages(); } return FAIL; } /* * Add the last line of the scrollback buffer to the buffer in the window. */ static void add_scrollback_line_to_buffer(term_T *term, char_u *text, int len) { buf_T *buf = term->tl_buffer; int empty = (buf->b_ml.ml_flags & ML_EMPTY); linenr_T lnum = buf->b_ml.ml_line_count; #ifdef MSWIN if (!enc_utf8 && enc_codepage > 0) { WCHAR *ret = NULL; int length = 0; MultiByteToWideChar_alloc(CP_UTF8, 0, (char*)text, len + 1, &ret, &length); if (ret != NULL) { WideCharToMultiByte_alloc(enc_codepage, 0, ret, length, (char **)&text, &len, 0, 0); vim_free(ret); ml_append_buf(term->tl_buffer, lnum, text, len, FALSE); vim_free(text); } } else #endif ml_append_buf(term->tl_buffer, lnum, text, len + 1, FALSE); if (empty) { // Delete the empty line that was in the empty buffer. curbuf = buf; ml_delete(1); curbuf = curwin->w_buffer; } } static void cell2cellattr(const VTermScreenCell *cell, cellattr_T *attr) { attr->width = cell->width; attr->attrs = cell->attrs; attr->fg = cell->fg; attr->bg = cell->bg; } static int equal_celattr(cellattr_T *a, cellattr_T *b) { // We only compare the RGB colors, ignoring the ANSI index and type. // Thus black set explicitly is equal the background black. return a->fg.red == b->fg.red && a->fg.green == b->fg.green && a->fg.blue == b->fg.blue && a->bg.red == b->bg.red && a->bg.green == b->bg.green && a->bg.blue == b->bg.blue; } /* * Add an empty scrollback line to "term". When "lnum" is not zero, add the * line at this position. Otherwise at the end. */ static int add_empty_scrollback(term_T *term, cellattr_T *fill_attr, int lnum) { if (ga_grow(&term->tl_scrollback, 1) == FAIL) return FALSE; sb_line_T *line = (sb_line_T *)term->tl_scrollback.ga_data + term->tl_scrollback.ga_len; if (lnum > 0) { int i; for (i = 0; i < term->tl_scrollback.ga_len - lnum; ++i) { *line = *(line - 1); --line; } } line->sb_cols = 0; line->sb_cells = NULL; line->sb_fill_attr = *fill_attr; ++term->tl_scrollback.ga_len; return OK; } /* * Remove the terminal contents from the scrollback and the buffer. * Used before adding a new scrollback line or updating the buffer for lines * displayed in the terminal. */ static void cleanup_scrollback(term_T *term) { sb_line_T *line; garray_T *gap; curbuf = term->tl_buffer; gap = &term->tl_scrollback; while (curbuf->b_ml.ml_line_count > term->tl_scrollback_scrolled && gap->ga_len > 0) { ml_delete(curbuf->b_ml.ml_line_count); line = (sb_line_T *)gap->ga_data + gap->ga_len - 1; vim_free(line->sb_cells); --gap->ga_len; } curbuf = curwin->w_buffer; if (curbuf == term->tl_buffer) check_cursor(); } /* * Add the current lines of the terminal to scrollback and to the buffer. */ static void update_snapshot(term_T *term) { VTermScreen *screen; int len; int lines_skipped = 0; VTermPos pos; VTermScreenCell cell; cellattr_T fill_attr, new_fill_attr; cellattr_T *p; ch_log(term->tl_job == NULL ? NULL : term->tl_job->jv_channel, "Adding terminal window snapshot to buffer"); // First remove the lines that were appended before, they might be // outdated. cleanup_scrollback(term); screen = vterm_obtain_screen(term->tl_vterm); fill_attr = new_fill_attr = term->tl_default_color; for (pos.row = 0; pos.row < term->tl_rows; ++pos.row) { len = 0; for (pos.col = 0; pos.col < term->tl_cols; ++pos.col) if (vterm_screen_get_cell(screen, pos, &cell) != 0 && cell.chars[0] != NUL) { len = pos.col + 1; new_fill_attr = term->tl_default_color; } else // Assume the last attr is the filler attr. cell2cellattr(&cell, &new_fill_attr); if (len == 0 && equal_celattr(&new_fill_attr, &fill_attr)) ++lines_skipped; else { while (lines_skipped > 0) { // Line was skipped, add an empty line. --lines_skipped; if (add_empty_scrollback(term, &fill_attr, 0) == OK) add_scrollback_line_to_buffer(term, (char_u *)"", 0); } if (len == 0) p = NULL; else p = ALLOC_MULT(cellattr_T, len); if ((p != NULL || len == 0) && ga_grow(&term->tl_scrollback, 1) == OK) { garray_T ga; int width; sb_line_T *line = (sb_line_T *)term->tl_scrollback.ga_data + term->tl_scrollback.ga_len; ga_init2(&ga, 1, 100); for (pos.col = 0; pos.col < len; pos.col += width) { if (vterm_screen_get_cell(screen, pos, &cell) == 0) { width = 1; CLEAR_POINTER(p + pos.col); if (ga_grow(&ga, 1) == OK) ga.ga_len += utf_char2bytes(' ', (char_u *)ga.ga_data + ga.ga_len); } else { width = cell.width; cell2cellattr(&cell, &p[pos.col]); if (width == 2) // second cell of double-width character has the // same attributes. p[pos.col + 1] = p[pos.col]; // Each character can be up to 6 bytes. if (ga_grow(&ga, VTERM_MAX_CHARS_PER_CELL * 6) == OK) { int i; int c; for (i = 0; (c = cell.chars[i]) > 0 || i == 0; ++i) ga.ga_len += utf_char2bytes(c == NUL ? ' ' : c, (char_u *)ga.ga_data + ga.ga_len); } } } line->sb_cols = len; line->sb_cells = p; line->sb_fill_attr = new_fill_attr; fill_attr = new_fill_attr; ++term->tl_scrollback.ga_len; if (ga_grow(&ga, 1) == FAIL) add_scrollback_line_to_buffer(term, (char_u *)"", 0); else { *((char_u *)ga.ga_data + ga.ga_len) = NUL; add_scrollback_line_to_buffer(term, ga.ga_data, ga.ga_len); } ga_clear(&ga); } else vim_free(p); } } // Add trailing empty lines. for (pos.row = term->tl_scrollback.ga_len; pos.row < term->tl_scrollback_scrolled + term->tl_cursor_pos.row; ++pos.row) { if (add_empty_scrollback(term, &fill_attr, 0) == OK) add_scrollback_line_to_buffer(term, (char_u *)"", 0); } term->tl_dirty_snapshot = FALSE; #ifdef FEAT_TIMERS term->tl_timer_set = FALSE; #endif } /* * Loop over all windows in the current tab, and also curwin, which is not * encountered when using a terminal in a popup window. * Return TRUE if "*wp" was set to the next window. */ static int for_all_windows_and_curwin(win_T **wp, int *did_curwin) { if (*wp == NULL) *wp = firstwin; else if ((*wp)->w_next != NULL) *wp = (*wp)->w_next; else if (!*did_curwin) *wp = curwin; else return FALSE; if (*wp == curwin) *did_curwin = TRUE; return TRUE; } /* * If needed, add the current lines of the terminal to scrollback and to the * buffer. Called after the job has ended and when switching to * Terminal-Normal mode. * When "redraw" is TRUE redraw the windows that show the terminal. */ static void may_move_terminal_to_buffer(term_T *term, int redraw) { if (term->tl_vterm == NULL) return; // Update the snapshot only if something changes or the buffer does not // have all the lines. if (term->tl_dirty_snapshot || term->tl_buffer->b_ml.ml_line_count <= term->tl_scrollback_scrolled) update_snapshot(term); // Obtain the current background color. vterm_state_get_default_colors(vterm_obtain_state(term->tl_vterm), &term->tl_default_color.fg, &term->tl_default_color.bg); if (redraw) { win_T *wp = NULL; int did_curwin = FALSE; while (for_all_windows_and_curwin(&wp, &did_curwin)) { if (wp->w_buffer == term->tl_buffer) { wp->w_cursor.lnum = term->tl_buffer->b_ml.ml_line_count; wp->w_cursor.col = 0; wp->w_valid = 0; if (wp->w_cursor.lnum >= wp->w_height) { linenr_T min_topline = wp->w_cursor.lnum - wp->w_height + 1; if (wp->w_topline < min_topline) wp->w_topline = min_topline; } redraw_win_later(wp, UPD_NOT_VALID); } } } } #if defined(FEAT_TIMERS) || defined(PROTO) /* * Check if any terminal timer expired. If so, copy text from the terminal to * the buffer. * Return the time until the next timer will expire. */ int term_check_timers(int next_due_arg, proftime_T *now) { term_T *term; int next_due = next_due_arg; FOR_ALL_TERMS(term) { if (term->tl_timer_set && !term->tl_normal_mode) { long this_due = proftime_time_left(&term->tl_timer_due, now); if (this_due <= 1) { term->tl_timer_set = FALSE; may_move_terminal_to_buffer(term, FALSE); } else if (next_due == -1 || next_due > this_due) next_due = this_due; } } return next_due; } #endif /* * When "normal_mode" is TRUE set the terminal to Terminal-Normal mode, * otherwise end it. */ static void set_terminal_mode(term_T *term, int normal_mode) { term->tl_normal_mode = normal_mode; may_trigger_modechanged(); if (!normal_mode) handle_postponed_scrollback(term); VIM_CLEAR(term->tl_status_text); if (term->tl_buffer == curbuf) maketitle(); } /* * Called after the job is finished and Terminal mode is not active: * Move the vterm contents into the scrollback buffer and free the vterm. */ static void cleanup_vterm(term_T *term) { set_terminal_mode(term, FALSE); if (term->tl_finish != TL_FINISH_CLOSE) may_move_terminal_to_buffer(term, TRUE); term_free_vterm(term); } /* * Switch from Terminal-Job mode to Terminal-Normal mode. * Suspends updating the terminal window. */ static void term_enter_normal_mode(void) { term_T *term = curbuf->b_term; set_terminal_mode(term, TRUE); // Append the current terminal contents to the buffer. may_move_terminal_to_buffer(term, TRUE); // Move the window cursor to the position of the cursor in the // terminal. curwin->w_cursor.lnum = term->tl_scrollback_scrolled + term->tl_cursor_pos.row + 1; check_cursor(); if (coladvance(term->tl_cursor_pos.col) == FAIL) coladvance(MAXCOL); curwin->w_set_curswant = TRUE; // Display the same lines as in the terminal. curwin->w_topline = term->tl_scrollback_scrolled + 1; } /* * Returns TRUE if the current window contains a terminal and we are in * Terminal-Normal mode. */ int term_in_normal_mode(void) { term_T *term = curbuf->b_term; return term != NULL && term->tl_normal_mode; } /* * Switch from Terminal-Normal mode to Terminal-Job mode. * Restores updating the terminal window. */ void term_enter_job_mode(void) { term_T *term = curbuf->b_term; set_terminal_mode(term, FALSE); if (term->tl_channel_closed) cleanup_vterm(term); redraw_buf_and_status_later(curbuf, UPD_NOT_VALID); #ifdef FEAT_PROP_POPUP if (WIN_IS_POPUP(curwin)) redraw_later(UPD_NOT_VALID); #endif } /* * When "modify_other_keys" is set then vgetc() should not reduce a key with * modifiers into a basic key. However, we may only find out after calling * vgetc(). Therefore vgetorpeek() will call check_no_reduce_keys() to update * "no_reduce_keys" before using it. */ typedef enum { NRKS_NONE, // initial value NRKS_CHECK, // modify_other_keys was off before calling vgetc() NRKS_SET, // no_reduce_keys was incremented in term_vgetc() or // check_no_reduce_keys(), must be decremented. } reduce_key_state_T; static reduce_key_state_T no_reduce_key_state = NRKS_NONE; /* * Return TRUE if the term is using modifyOtherKeys level 2 or the kitty * keyboard protocol. */ static int vterm_using_key_protocol(void) { return curbuf->b_term != NULL && curbuf->b_term->tl_vterm != NULL && (vterm_is_modify_other_keys(curbuf->b_term->tl_vterm) || vterm_is_kitty_keyboard(curbuf->b_term->tl_vterm)); } void check_no_reduce_keys(void) { if (no_reduce_key_state != NRKS_CHECK || no_reduce_keys >= 1 || curbuf->b_term == NULL || curbuf->b_term->tl_vterm == NULL) return; if (vterm_using_key_protocol()) { // "modify_other_keys" or kitty keyboard protocol was enabled while // waiting. no_reduce_key_state = NRKS_SET; ++no_reduce_keys; } } /* * Get a key from the user with terminal mode mappings. * Note: while waiting a terminal may be closed and freed if the channel is * closed and ++close was used. This may even happen before we get here. */ static int term_vgetc(void) { int c; int save_State = State; State = MODE_TERMINAL; got_int = FALSE; #ifdef MSWIN ctrl_break_was_pressed = FALSE; #endif if (vterm_using_key_protocol()) { ++no_reduce_keys; no_reduce_key_state = NRKS_SET; } else { no_reduce_key_state = NRKS_CHECK; } c = vgetc(); got_int = FALSE; State = save_State; if (no_reduce_key_state == NRKS_SET) --no_reduce_keys; no_reduce_key_state = NRKS_NONE; return c; } static int mouse_was_outside = FALSE; /* * Send key "c" with modifiers "modmask" to terminal. * Return FAIL when the key needs to be handled in Normal mode. * Return OK when the key was dropped or sent to the terminal. */ int send_keys_to_term(term_T *term, int c, int modmask, int typed) { char msg[KEY_BUF_LEN]; size_t len; int dragging_outside = FALSE; // Catch keys that need to be handled as in Normal mode. switch (c) { case NUL: case K_ZERO: if (typed) stuffcharReadbuff(c); return FAIL; case K_TABLINE: stuffcharReadbuff(c); return FAIL; case K_IGNORE: case K_CANCEL: // used for :normal when running out of chars return FAIL; case K_LEFTDRAG: case K_MIDDLEDRAG: case K_RIGHTDRAG: case K_X1DRAG: case K_X2DRAG: dragging_outside = mouse_was_outside; // FALLTHROUGH case K_LEFTMOUSE: case K_LEFTMOUSE_NM: case K_LEFTRELEASE: case K_LEFTRELEASE_NM: case K_MOUSEMOVE: case K_MIDDLEMOUSE: case K_MIDDLERELEASE: case K_RIGHTMOUSE: case K_RIGHTRELEASE: case K_X1MOUSE: case K_X1RELEASE: case K_X2MOUSE: case K_X2RELEASE: case K_MOUSEUP: case K_MOUSEDOWN: case K_MOUSELEFT: case K_MOUSERIGHT: { int row = mouse_row; int col = mouse_col; #ifdef FEAT_PROP_POPUP if (popup_is_popup(curwin)) { row -= popup_top_extra(curwin); col -= popup_left_extra(curwin); } #endif if (row < W_WINROW(curwin) || row >= (W_WINROW(curwin) + curwin->w_height) || col < curwin->w_wincol || col >= W_ENDCOL(curwin) || dragging_outside) { // click or scroll outside the current window or on status // line or vertical separator if (typed) { stuffcharReadbuff(c); mouse_was_outside = TRUE; } return FAIL; } } break; case K_COMMAND: case K_SCRIPT_COMMAND: return do_cmdkey_command(c, 0); } if (typed) mouse_was_outside = FALSE; // Convert the typed key to a sequence of bytes for the job. len = term_convert_key(term, c, modmask, msg); if (len > 0) // TODO: if FAIL is returned, stop? channel_send(term->tl_job->jv_channel, get_tty_part(term), (char_u *)msg, (int)len, NULL); return OK; } static void position_cursor(win_T *wp, VTermPos *pos) { wp->w_wrow = MIN(pos->row, MAX(0, wp->w_height - 1)); wp->w_wcol = MIN(pos->col, MAX(0, wp->w_width - 1)); #ifdef FEAT_PROP_POPUP if (popup_is_popup(wp)) { wp->w_wrow += popup_top_extra(wp); wp->w_wcol += popup_left_extra(wp); wp->w_flags |= WFLAG_WCOL_OFF_ADDED | WFLAG_WROW_OFF_ADDED; } else wp->w_flags &= ~(WFLAG_WCOL_OFF_ADDED | WFLAG_WROW_OFF_ADDED); #endif wp->w_valid |= (VALID_WCOL|VALID_WROW); } /* * Handle CTRL-W "": send register contents to the job. */ static void term_paste_register(int prev_c UNUSED) { int c; list_T *l; listitem_T *item; long reglen = 0; int type; if (add_to_showcmd(prev_c)) if (add_to_showcmd('"')) out_flush(); c = term_vgetc(); clear_showcmd(); if (!term_use_loop()) // job finished while waiting for a character return; // CTRL-W "= prompt for expression to evaluate. if (c == '=' && get_expr_register() != '=') return; if (!term_use_loop()) // job finished while waiting for a character return; l = (list_T *)get_reg_contents(c, GREG_LIST); if (l == NULL) return; type = get_reg_type(c, ®len); FOR_ALL_LIST_ITEMS(l, item) { char_u *s = tv_get_string(&item->li_tv); #ifdef MSWIN char_u *tmp = s; if (!enc_utf8 && enc_codepage > 0) { WCHAR *ret = NULL; int length = 0; MultiByteToWideChar_alloc(enc_codepage, 0, (char *)s, (int)STRLEN(s), &ret, &length); if (ret != NULL) { WideCharToMultiByte_alloc(CP_UTF8, 0, ret, length, (char **)&s, &length, 0, 0); vim_free(ret); } } #endif channel_send(curbuf->b_term->tl_job->jv_channel, PART_IN, s, (int)STRLEN(s), NULL); #ifdef MSWIN if (tmp != s) vim_free(s); #endif if (item->li_next != NULL || type == MLINE) channel_send(curbuf->b_term->tl_job->jv_channel, PART_IN, (char_u *)"\r", 1, NULL); } list_free(l); } /* * Return TRUE when waiting for a character in the terminal, the cursor of the * terminal should be displayed. */ int terminal_is_active(void) { return in_terminal_loop != NULL; } /* * Return the highlight group ID for the terminal and the window. */ static int term_get_highlight_id(term_T *term, win_T *wp) { char_u *name; if (wp != NULL && *wp->w_p_wcr != NUL) name = wp->w_p_wcr; else if (term->tl_highlight_name != NULL) name = term->tl_highlight_name; else name = (char_u*)"Terminal"; return syn_name2id(name); } #if defined(FEAT_GUI) || defined(PROTO) cursorentry_T * term_get_cursor_shape(guicolor_T *fg, guicolor_T *bg) { term_T *term = in_terminal_loop; static cursorentry_T entry; int id; guicolor_T term_fg = INVALCOLOR; guicolor_T term_bg = INVALCOLOR; CLEAR_FIELD(entry); entry.shape = entry.mshape = term->tl_cursor_shape == VTERM_PROP_CURSORSHAPE_UNDERLINE ? SHAPE_HOR : term->tl_cursor_shape == VTERM_PROP_CURSORSHAPE_BAR_LEFT ? SHAPE_VER : SHAPE_BLOCK; entry.percentage = 20; if (term->tl_cursor_blink) { entry.blinkwait = 700; entry.blinkon = 400; entry.blinkoff = 250; } // The highlight group overrules the defaults. id = term_get_highlight_id(term, curwin); if (id != 0) syn_id2colors(id, &term_fg, &term_bg); if (term_bg != INVALCOLOR) *fg = term_bg; else *fg = gui.back_pixel; if (term->tl_cursor_color == NULL) { if (term_fg != INVALCOLOR) *bg = term_fg; else *bg = gui.norm_pixel; } else *bg = color_name2handle(term->tl_cursor_color); entry.name = "n"; entry.used_for = SHAPE_CURSOR; return &entry; } #endif static void may_output_cursor_props(void) { if (!cursor_color_equal(last_set_cursor_color, desired_cursor_color) || last_set_cursor_shape != desired_cursor_shape || last_set_cursor_blink != desired_cursor_blink) { cursor_color_copy(&last_set_cursor_color, desired_cursor_color); last_set_cursor_shape = desired_cursor_shape; last_set_cursor_blink = desired_cursor_blink; term_cursor_color(cursor_color_get(desired_cursor_color)); if (desired_cursor_shape == -1 || desired_cursor_blink == -1) // this will restore the initial cursor style, if possible ui_cursor_shape_forced(TRUE); else term_cursor_shape(desired_cursor_shape, desired_cursor_blink); } } /* * Set the cursor color and shape, if not last set to these. */ static void may_set_cursor_props(term_T *term) { #ifdef FEAT_GUI // For the GUI the cursor properties are obtained with // term_get_cursor_shape(). if (gui.in_use) return; #endif if (in_terminal_loop == term) { cursor_color_copy(&desired_cursor_color, term->tl_cursor_color); desired_cursor_shape = term->tl_cursor_shape; desired_cursor_blink = term->tl_cursor_blink; may_output_cursor_props(); } } /* * Reset the desired cursor properties and restore them when needed. */ static void prepare_restore_cursor_props(void) { #ifdef FEAT_GUI if (gui.in_use) return; #endif cursor_color_copy(&desired_cursor_color, NULL); desired_cursor_shape = -1; desired_cursor_blink = -1; may_output_cursor_props(); } /* * Returns TRUE if the current window contains a terminal and we are sending * keys to the job. * If "check_job_status" is TRUE update the job status. */ static int term_use_loop_check(int check_job_status) { term_T *term = curbuf->b_term; return term != NULL && !term->tl_normal_mode && term->tl_vterm != NULL && term_job_running_check(term, check_job_status); } /* * Returns TRUE if the current window contains a terminal and we are sending * keys to the job. */ int term_use_loop(void) { return term_use_loop_check(FALSE); } /* * Called when entering a window with the mouse. If this is a terminal window * we may want to change state. */ void term_win_entered(void) { term_T *term = curbuf->b_term; if (term == NULL) return; if (term_use_loop_check(TRUE)) { reset_VIsual_and_resel(); if (State & MODE_INSERT) stop_insert_mode = TRUE; } mouse_was_outside = FALSE; enter_mouse_col = mouse_col; enter_mouse_row = mouse_row; } void term_focus_change(int in_focus) { term_T *term = curbuf->b_term; if (term == NULL || term->tl_vterm == NULL) return; VTermState *state = vterm_obtain_state(term->tl_vterm); if (in_focus) vterm_state_focus_in(state); else vterm_state_focus_out(state); term_forward_output(term); } /* * vgetc() may not include CTRL in the key when modify_other_keys is set. * Return the Ctrl-key value in that case. */ static int raw_c_to_ctrl(int c) { if ((mod_mask & MOD_MASK_CTRL) && ((c >= '`' && c <= 0x7f) || (c >= '@' && c <= '_'))) return c & 0x1f; return c; } /* * When modify_other_keys is set then do the reverse of raw_c_to_ctrl(). * Also when the Kitty keyboard protocol is used. * May set "mod_mask". */ static int ctrl_to_raw_c(int c) { if (c < 0x20 && vterm_using_key_protocol()) { mod_mask |= MOD_MASK_CTRL; return c + '@'; } return c; } /* * Wait for input and send it to the job. * When "blocking" is TRUE wait for a character to be typed. Otherwise return * when there is no more typahead. * Return when the start of a CTRL-W command is typed or anything else that * should be handled as a Normal mode command. * Returns OK if a typed character is to be handled in Normal mode, FAIL if * the terminal was closed. */ int terminal_loop(int blocking) { int c; int raw_c; int termwinkey = 0; int ret; #ifdef UNIX int tty_fd = curbuf->b_term->tl_job->jv_channel ->ch_part[get_tty_part(curbuf->b_term)].ch_fd; #endif int restore_cursor = FALSE; // Remember the terminal we are sending keys to. However, the terminal // might be closed while waiting for a character, e.g. typing "exit" in a // shell and ++close was used. Therefore use curbuf->b_term instead of a // stored reference. in_terminal_loop = curbuf->b_term; if (*curwin->w_p_twk != NUL) { termwinkey = string_to_key(curwin->w_p_twk, TRUE); if (termwinkey == Ctrl_W) termwinkey = 0; } position_cursor(curwin, &curbuf->b_term->tl_cursor_pos); may_set_cursor_props(curbuf->b_term); while (blocking || vpeekc_nomap() != NUL) { #ifdef FEAT_GUI if (curbuf->b_term != NULL && !curbuf->b_term->tl_system) #endif // TODO: skip screen update when handling a sequence of keys. // Repeat redrawing in case a message is received while redrawing. while (must_redraw != 0) if (update_screen(0) == FAIL) break; if (!term_use_loop_check(TRUE) || in_terminal_loop != curbuf->b_term) // job finished while redrawing break; update_cursor(curbuf->b_term, FALSE); restore_cursor = TRUE; raw_c = term_vgetc(); if (!term_use_loop_check(TRUE) || in_terminal_loop != curbuf->b_term) { // Job finished while waiting for a character. Push back the // received character. if (raw_c != K_IGNORE) vungetc(raw_c); break; } if (raw_c == K_IGNORE) continue; c = raw_c_to_ctrl(raw_c); #ifdef UNIX /* * The shell or another program may change the tty settings. Getting * them for every typed character is a bit of overhead, but it's needed * for the first character typed, e.g. when Vim starts in a shell. */ if (mch_isatty(tty_fd)) { ttyinfo_T info; // Get the current backspace character of the pty. if (get_tty_info(tty_fd, &info) == OK) term_backspace_char = info.backspace; } #endif #ifdef MSWIN // On Windows winpty handles CTRL-C, don't send a CTRL_C_EVENT. // Use CTRL-BREAK to kill the job. if (ctrl_break_was_pressed) mch_signal_job(curbuf->b_term->tl_job, (char_u *)"kill"); #endif // Was either CTRL-W (termwinkey) or CTRL-\ pressed? // Not in a system terminal. if ((c == (termwinkey == 0 ? Ctrl_W : termwinkey) || c == Ctrl_BSL) #ifdef FEAT_GUI && !curbuf->b_term->tl_system #endif ) { int prev_c = c; int prev_raw_c = raw_c; int prev_mod_mask = mod_mask; if (add_to_showcmd(c)) out_flush(); raw_c = term_vgetc(); c = raw_c_to_ctrl(raw_c); clear_showcmd(); if (!term_use_loop_check(TRUE) || in_terminal_loop != curbuf->b_term) // job finished while waiting for a character break; if (prev_c == Ctrl_BSL) { if (c == Ctrl_N) { // CTRL-\ CTRL-N : go to Terminal-Normal mode. term_enter_normal_mode(); ret = FAIL; goto theend; } // Send both keys to the terminal, first one here, second one // below. send_keys_to_term(curbuf->b_term, prev_raw_c, prev_mod_mask, TRUE); } else if (c == Ctrl_C) { // "CTRL-W CTRL-C" or 'termwinkey' CTRL-C: end the job mch_signal_job(curbuf->b_term->tl_job, (char_u *)"kill"); } else if (c == '.') { // "CTRL-W .": send CTRL-W to the job // "'termwinkey' .": send 'termwinkey' to the job raw_c = ctrl_to_raw_c(termwinkey == 0 ? Ctrl_W : termwinkey); } else if (c == Ctrl_BSL) { // "CTRL-W CTRL-\": send CTRL-\ to the job raw_c = ctrl_to_raw_c(Ctrl_BSL); } else if (c == 'N') { // CTRL-W N : go to Terminal-Normal mode. term_enter_normal_mode(); ret = FAIL; goto theend; } else if (c == '"') { term_paste_register(prev_c); continue; } else if (termwinkey == 0 || c != termwinkey) { // space for CTRL-W, modifier, multi-byte char and NUL char_u buf[1 + 3 + MB_MAXBYTES + 1]; // Put the command into the typeahead buffer, when using the // stuff buffer KeyStuffed is set and 'langmap' won't be used. buf[0] = Ctrl_W; buf[special_to_buf(c, mod_mask, FALSE, buf + 1) + 1] = NUL; ins_typebuf(buf, REMAP_NONE, 0, TRUE, FALSE); ret = OK; goto theend; } } # ifdef MSWIN if (!enc_utf8 && has_mbyte && raw_c >= 0x80) { WCHAR wc; char_u mb[3]; mb[0] = (unsigned)raw_c >> 8; mb[1] = raw_c; if (MultiByteToWideChar(GetACP(), 0, (char*)mb, 2, &wc, 1) > 0) raw_c = wc; } # endif if (send_keys_to_term(curbuf->b_term, raw_c, mod_mask, TRUE) != OK) { if (raw_c == K_MOUSEMOVE) // We are sure to come back here, don't reset the cursor color // and shape to avoid flickering. restore_cursor = FALSE; ret = OK; goto theend; } } ret = FAIL; theend: in_terminal_loop = NULL; if (restore_cursor) prepare_restore_cursor_props(); // Move a snapshot of the screen contents to the buffer, so that completion // works in other buffers. if (curbuf->b_term != NULL && !curbuf->b_term->tl_normal_mode) may_move_terminal_to_buffer(curbuf->b_term, FALSE); return ret; } static void may_toggle_cursor(term_T *term) { if (in_terminal_loop != term) return; if (term->tl_cursor_visible) cursor_on(); else cursor_off(); } /* * Reverse engineer the RGB value into a cterm color index. * First color is 1. Return 0 if no match found (default color). */ static int color2index(VTermColor *color, int fg, int *boldp) { int red = color->red; int blue = color->blue; int green = color->green; *boldp = FALSE; if (VTERM_COLOR_IS_INVALID(color)) return 0; if (VTERM_COLOR_IS_INDEXED(color)) { // Use the color as-is if possible, give up otherwise. if (color->index < t_colors) return color->index + 1; // 8-color terminals can actually display twice as many colors by // setting the high-intensity/bold bit. else if (t_colors == 8 && fg && color->index < 16) { *boldp = TRUE; return (color->index & 7) + 1; } return 0; } if (t_colors >= 256) { if (red == blue && red == green) { // 24-color greyscale plus white and black static int cutoff[23] = { 0x0D, 0x17, 0x21, 0x2B, 0x35, 0x3F, 0x49, 0x53, 0x5D, 0x67, 0x71, 0x7B, 0x85, 0x8F, 0x99, 0xA3, 0xAD, 0xB7, 0xC1, 0xCB, 0xD5, 0xDF, 0xE9}; int i; if (red < 5) return 17; // 00/00/00 if (red > 245) // ff/ff/ff return 232; for (i = 0; i < 23; ++i) if (red < cutoff[i]) return i + 233; return 256; } { static int cutoff[5] = {0x2F, 0x73, 0x9B, 0xC3, 0xEB}; int ri, gi, bi; // 216-color cube for (ri = 0; ri < 5; ++ri) if (red < cutoff[ri]) break; for (gi = 0; gi < 5; ++gi) if (green < cutoff[gi]) break; for (bi = 0; bi < 5; ++bi) if (blue < cutoff[bi]) break; return 17 + ri * 36 + gi * 6 + bi; } } return 0; } /* * Convert Vterm attributes to highlight flags. */ static int vtermAttr2hl(VTermScreenCellAttrs *cellattrs) { int attr = 0; if (cellattrs->bold) attr |= HL_BOLD; if (cellattrs->underline) attr |= HL_UNDERLINE; if (cellattrs->italic) attr |= HL_ITALIC; if (cellattrs->strike) attr |= HL_STRIKETHROUGH; if (cellattrs->reverse) attr |= HL_INVERSE; return attr; } /* * Store Vterm attributes in "cell" from highlight flags. */ static void hl2vtermAttr(int attr, cellattr_T *cell) { CLEAR_FIELD(cell->attrs); if (attr & HL_BOLD) cell->attrs.bold = 1; if (attr & HL_UNDERLINE) cell->attrs.underline = 1; if (attr & HL_ITALIC) cell->attrs.italic = 1; if (attr & HL_STRIKETHROUGH) cell->attrs.strike = 1; if (attr & HL_INVERSE) cell->attrs.reverse = 1; } /* * Convert the attributes of a vterm cell into an attribute index. */ static int cell2attr( term_T *term, win_T *wp, VTermScreenCellAttrs *cellattrs, VTermColor *cellfg, VTermColor *cellbg) { int attr = vtermAttr2hl(cellattrs); VTermColor *fg = cellfg; VTermColor *bg = cellbg; int is_default_fg = VTERM_COLOR_IS_DEFAULT_FG(fg); int is_default_bg = VTERM_COLOR_IS_DEFAULT_BG(bg); if (is_default_fg || is_default_bg) { if (wp != NULL && *wp->w_p_wcr != NUL) { if (is_default_fg) fg = &wp->w_term_wincolor.fg; if (is_default_bg) bg = &wp->w_term_wincolor.bg; } else { if (is_default_fg) fg = &term->tl_default_color.fg; if (is_default_bg) bg = &term->tl_default_color.bg; } } #ifdef FEAT_GUI if (gui.in_use) { guicolor_T guifg = gui_mch_get_rgb_color(fg->red, fg->green, fg->blue); guicolor_T guibg = gui_mch_get_rgb_color(bg->red, bg->green, bg->blue); return get_gui_attr_idx(attr, guifg, guibg); } else #endif #ifdef FEAT_TERMGUICOLORS if (p_tgc) { guicolor_T tgcfg = VTERM_COLOR_IS_INVALID(fg) ? INVALCOLOR : gui_get_rgb_color_cmn(fg->red, fg->green, fg->blue); guicolor_T tgcbg = VTERM_COLOR_IS_INVALID(bg) ? INVALCOLOR : gui_get_rgb_color_cmn(bg->red, bg->green, bg->blue); return get_tgc_attr_idx(attr, tgcfg, tgcbg); } else #endif { int bold = MAYBE; int ctermfg = color2index(fg, TRUE, &bold); int ctermbg = color2index(bg, FALSE, &bold); // with 8 colors set the bold attribute to get a bright foreground if (bold == TRUE) attr |= HL_BOLD; return get_cterm_attr_idx(attr, ctermfg, ctermbg); } return 0; } static void set_dirty_snapshot(term_T *term) { term->tl_dirty_snapshot = TRUE; #ifdef FEAT_TIMERS if (!term->tl_normal_mode) { // Update the snapshot after 100 msec of not getting updates. profile_setlimit(100L, &term->tl_timer_due); term->tl_timer_set = TRUE; } #endif } static int handle_damage(VTermRect rect, void *user) { term_T *term = (term_T *)user; term->tl_dirty_row_start = MIN(term->tl_dirty_row_start, rect.start_row); term->tl_dirty_row_end = MAX(term->tl_dirty_row_end, rect.end_row); set_dirty_snapshot(term); redraw_buf_later(term->tl_buffer, UPD_SOME_VALID); return 1; } static void term_scroll_up(term_T *term, int start_row, int count) { win_T *wp = NULL; int did_curwin = FALSE; VTermColor fg, bg; VTermScreenCellAttrs attr; int clear_attr; CLEAR_FIELD(attr); while (for_all_windows_and_curwin(&wp, &did_curwin)) { if (wp->w_buffer == term->tl_buffer) { // Set the color to clear lines with. vterm_state_get_default_colors(vterm_obtain_state(term->tl_vterm), &fg, &bg); clear_attr = cell2attr(term, wp, &attr, &fg, &bg); win_del_lines(wp, start_row, count, FALSE, FALSE, clear_attr); } } } static int handle_moverect(VTermRect dest, VTermRect src, void *user) { term_T *term = (term_T *)user; int count = src.start_row - dest.start_row; // Scrolling up is done much more efficiently by deleting lines instead of // redrawing the text. But avoid doing this multiple times, postpone until // the redraw happens. if (dest.start_col == src.start_col && dest.end_col == src.end_col && dest.start_row < src.start_row) { if (dest.start_row == 0) term->tl_postponed_scroll += count; else term_scroll_up(term, dest.start_row, count); } term->tl_dirty_row_start = MIN(term->tl_dirty_row_start, dest.start_row); term->tl_dirty_row_end = MIN(term->tl_dirty_row_end, dest.end_row); set_dirty_snapshot(term); // Note sure if the scrolling will work correctly, let's do a complete // redraw later. redraw_buf_later(term->tl_buffer, UPD_NOT_VALID); return 1; } static int handle_movecursor( VTermPos pos, VTermPos oldpos UNUSED, int visible, void *user) { term_T *term = (term_T *)user; win_T *wp = NULL; int did_curwin = FALSE; term->tl_cursor_pos = pos; term->tl_cursor_visible = visible; while (for_all_windows_and_curwin(&wp, &did_curwin)) { if (wp->w_buffer == term->tl_buffer) position_cursor(wp, &pos); } if (term->tl_buffer == curbuf && !term->tl_normal_mode) update_cursor(term, term->tl_cursor_visible); return 1; } static int handle_settermprop( VTermProp prop, VTermValue *value, void *user) { term_T *term = (term_T *)user; char_u *strval = NULL; switch (prop) { case VTERM_PROP_TITLE: if (disable_vterm_title_for_testing) break; strval = vim_strnsave((char_u *)value->string.str, value->string.len); if (strval == NULL) break; vim_free(term->tl_title); // a blank title isn't useful, make it empty, so that "running" is // displayed if (*skipwhite(strval) == NUL) term->tl_title = NULL; // Same as blank else if (term->tl_arg0_cmd != NULL && STRNCMP(term->tl_arg0_cmd, strval, (int)STRLEN(term->tl_arg0_cmd)) == 0) term->tl_title = NULL; // Empty corrupted data of winpty else if (STRNCMP(" - ", strval, 4) == 0) term->tl_title = NULL; #ifdef MSWIN else if (!enc_utf8 && enc_codepage > 0) { WCHAR *ret = NULL; int length = 0; MultiByteToWideChar_alloc(CP_UTF8, 0, (char*)value->string.str, (int)value->string.len, &ret, &length); if (ret != NULL) { WideCharToMultiByte_alloc(enc_codepage, 0, ret, length, (char**)&term->tl_title, &length, 0, 0); vim_free(ret); } } #endif else { term->tl_title = strval; strval = NULL; } VIM_CLEAR(term->tl_status_text); if (term == curbuf->b_term) { maketitle(); curwin->w_redr_status = TRUE; } break; case VTERM_PROP_CURSORVISIBLE: term->tl_cursor_visible = value->boolean; may_toggle_cursor(term); out_flush(); break; case VTERM_PROP_CURSORBLINK: term->tl_cursor_blink = value->boolean; may_set_cursor_props(term); break; case VTERM_PROP_CURSORSHAPE: term->tl_cursor_shape = value->number; may_set_cursor_props(term); break; case VTERM_PROP_CURSORCOLOR: strval = vim_strnsave((char_u *)value->string.str, value->string.len); if (strval == NULL) break; cursor_color_copy(&term->tl_cursor_color, strval); may_set_cursor_props(term); break; case VTERM_PROP_ALTSCREEN: // TODO: do anything else? term->tl_using_altscreen = value->boolean; break; default: break; } vim_free(strval); // Always return 1, otherwise vterm doesn't store the value internally. return 1; } /* * The job running in the terminal resized the terminal. */ static int handle_resize(int rows, int cols, void *user) { term_T *term = (term_T *)user; win_T *wp; term->tl_rows = rows; term->tl_cols = cols; if (term->tl_vterm_size_changed) // Size was set by vterm_set_size(), don't set the window size. term->tl_vterm_size_changed = FALSE; else { FOR_ALL_WINDOWS(wp) { if (wp->w_buffer == term->tl_buffer) { win_setheight_win(rows, wp); win_setwidth_win(cols, wp); } } redraw_buf_later(term->tl_buffer, UPD_NOT_VALID); } return 1; } /* * If the number of lines that are stored goes over 'termscrollback' then * delete the first 10%. * "gap" points to tl_scrollback or tl_scrollback_postponed. * "update_buffer" is TRUE when the buffer should be updated. */ static void limit_scrollback(term_T *term, garray_T *gap, int update_buffer) { if (gap->ga_len < term->tl_buffer->b_p_twsl) return; int todo = term->tl_buffer->b_p_twsl / 10; int i; curbuf = term->tl_buffer; for (i = 0; i < todo; ++i) { vim_free(((sb_line_T *)gap->ga_data + i)->sb_cells); if (update_buffer) ml_delete(1); } curbuf = curwin->w_buffer; gap->ga_len -= todo; mch_memmove(gap->ga_data, (sb_line_T *)gap->ga_data + todo, sizeof(sb_line_T) * gap->ga_len); if (update_buffer) term->tl_scrollback_scrolled -= todo; } /* * Handle a line that is pushed off the top of the screen. */ static int handle_pushline(int cols, const VTermScreenCell *cells, void *user) { term_T *term = (term_T *)user; garray_T *gap; int update_buffer; if (term->tl_normal_mode) { // In Terminal-Normal mode the user interacts with the buffer, thus we // must not change it. Postpone adding the scrollback lines. gap = &term->tl_scrollback_postponed; update_buffer = FALSE; } else { // First remove the lines that were appended before, the pushed line // goes above it. cleanup_scrollback(term); gap = &term->tl_scrollback; update_buffer = TRUE; } limit_scrollback(term, gap, update_buffer); if (ga_grow(gap, 1) == FAIL) return 0; cellattr_T *p = NULL; int len = 0; int i; int c; int col; int text_len; char_u *text; sb_line_T *line; garray_T ga; cellattr_T fill_attr = term->tl_default_color; // do not store empty cells at the end for (i = 0; i < cols; ++i) if (cells[i].chars[0] != 0) len = i + 1; else cell2cellattr(&cells[i], &fill_attr); ga_init2(&ga, 1, 100); if (len > 0) p = ALLOC_MULT(cellattr_T, len); if (p != NULL) { for (col = 0; col < len; col += cells[col].width) { if (ga_grow(&ga, MB_MAXBYTES) == FAIL) { ga.ga_len = 0; break; } for (i = 0; (c = cells[col].chars[i]) > 0 || i == 0; ++i) ga.ga_len += utf_char2bytes(c == NUL ? ' ' : c, (char_u *)ga.ga_data + ga.ga_len); cell2cellattr(&cells[col], &p[col]); } } if (ga_grow(&ga, 1) == FAIL) { if (update_buffer) text = (char_u *)""; else text = vim_strsave((char_u *)""); text_len = 0; } else { text = ga.ga_data; text_len = ga.ga_len; *(text + text_len) = NUL; } if (update_buffer) add_scrollback_line_to_buffer(term, text, text_len); line = (sb_line_T *)gap->ga_data + gap->ga_len; line->sb_cols = len; line->sb_cells = p; line->sb_fill_attr = fill_attr; if (update_buffer) { line->sb_text = NULL; ++term->tl_scrollback_scrolled; ga_clear(&ga); // free the text } else { line->sb_text = text; ga_init(&ga); // text is kept in tl_scrollback_postponed } ++gap->ga_len; return 0; // ignored } /* * Called when leaving Terminal-Normal mode: deal with any scrollback that was * received and stored in tl_scrollback_postponed. */ static void handle_postponed_scrollback(term_T *term) { int i; if (term->tl_scrollback_postponed.ga_len == 0) return; ch_log(NULL, "Moving postponed scrollback to scrollback"); // First remove the lines that were appended before, the pushed lines go // above it. cleanup_scrollback(term); for (i = 0; i < term->tl_scrollback_postponed.ga_len; ++i) { char_u *text; sb_line_T *pp_line; sb_line_T *line; if (ga_grow(&term->tl_scrollback, 1) == FAIL) break; pp_line = (sb_line_T *)term->tl_scrollback_postponed.ga_data + i; text = pp_line->sb_text; if (text == NULL) text = (char_u *)""; add_scrollback_line_to_buffer(term, text, (int)STRLEN(text)); vim_free(pp_line->sb_text); line = (sb_line_T *)term->tl_scrollback.ga_data + term->tl_scrollback.ga_len; line->sb_cols = pp_line->sb_cols; line->sb_cells = pp_line->sb_cells; line->sb_fill_attr = pp_line->sb_fill_attr; line->sb_text = NULL; ++term->tl_scrollback_scrolled; ++term->tl_scrollback.ga_len; } ga_clear(&term->tl_scrollback_postponed); limit_scrollback(term, &term->tl_scrollback, TRUE); } /* * Called when the terminal wants to ring the system bell. */ static int handle_bell(void *user UNUSED) { vim_beep(BO_TERM); return 0; } static VTermScreenCallbacks screen_callbacks = { handle_damage, // damage handle_moverect, // moverect handle_movecursor, // movecursor handle_settermprop, // settermprop handle_bell, // bell handle_resize, // resize handle_pushline, // sb_pushline NULL, // sb_popline NULL // sb_clear }; /* * Do the work after the channel of a terminal was closed. * Must be called only when updating_screen is FALSE. * Returns TRUE when a buffer was closed (list of terminals may have changed). */ static int term_after_channel_closed(term_T *term) { // Unless in Terminal-Normal mode: clear the vterm. if (!term->tl_normal_mode) { int fnum = term->tl_buffer->b_fnum; cleanup_vterm(term); if (term->tl_finish == TL_FINISH_CLOSE) { aco_save_T aco; int do_set_w_closing = term->tl_buffer->b_nwindows == 0; #ifdef FEAT_PROP_POPUP win_T *pwin = NULL; // If this was a terminal in a popup window, go back to the // previous window. if (popup_is_popup(curwin) && curbuf == term->tl_buffer) { pwin = curwin; if (win_valid(prevwin)) win_enter(prevwin, FALSE); } else #endif // If this is the last normal window: exit Vim. if (term->tl_buffer->b_nwindows > 0 && only_one_window()) { exarg_T ea; CLEAR_FIELD(ea); ex_quit(&ea); return TRUE; } // ++close or term_finish == "close" ch_log(NULL, "terminal job finished, closing window"); aucmd_prepbuf(&aco, term->tl_buffer); if (curbuf == term->tl_buffer) { // Avoid closing the window if we temporarily use it. if (is_aucmd_win(curwin)) do_set_w_closing = TRUE; if (do_set_w_closing) curwin->w_closing = TRUE; do_bufdel(DOBUF_WIPE, (char_u *)"", 1, fnum, fnum, FALSE); if (do_set_w_closing) curwin->w_closing = FALSE; aucmd_restbuf(&aco); } #ifdef FEAT_PROP_POPUP if (pwin != NULL) popup_close_with_retval(pwin, 0); #endif return TRUE; } if (term->tl_finish == TL_FINISH_OPEN && term->tl_buffer->b_nwindows == 0) { char *cmd = term->tl_opencmd == NULL ? "botright sbuf %d" : (char *)term->tl_opencmd; size_t len = strlen(cmd) + 50; char *buf = alloc(len); if (buf != NULL) { ch_log(NULL, "terminal job finished, opening window"); vim_snprintf(buf, len, cmd, fnum); do_cmdline_cmd((char_u *)buf); vim_free(buf); } } else ch_log(NULL, "terminal job finished"); } redraw_buf_and_status_later(term->tl_buffer, UPD_NOT_VALID); return FALSE; } #if defined(FEAT_PROP_POPUP) || defined(PROTO) /* * If the current window is a terminal in a popup window and the job has * finished, close the popup window and to back to the previous window. * Otherwise return FAIL. */ int may_close_term_popup(void) { if (!popup_is_popup(curwin) || curbuf->b_term == NULL || term_job_running_not_none(curbuf->b_term)) return FAIL; win_T *pwin = curwin; if (win_valid(prevwin)) win_enter(prevwin, FALSE); popup_close_with_retval(pwin, 0); return OK; } #endif /* * Called when a channel is going to be closed, before invoking the close * callback. */ void term_channel_closing(channel_T *ch) { term_T *term; for (term = first_term; term != NULL; term = term->tl_next) if (term->tl_job == ch->ch_job && !term->tl_channel_closed) term->tl_channel_closing = TRUE; } /* * Called when a channel has been closed. * If this was a channel for a terminal window then finish it up. */ void term_channel_closed(channel_T *ch) { term_T *term; term_T *next_term; int did_one = FALSE; for (term = first_term; term != NULL; term = next_term) { next_term = term->tl_next; if (term->tl_job == ch->ch_job && !term->tl_channel_closed) { term->tl_channel_closed = TRUE; did_one = TRUE; VIM_CLEAR(term->tl_title); VIM_CLEAR(term->tl_status_text); #ifdef MSWIN if (term->tl_out_fd != NULL) { fclose(term->tl_out_fd); term->tl_out_fd = NULL; } #endif if (updating_screen) { // Cannot open or close windows now. Can happen when // 'lazyredraw' is set. term->tl_channel_recently_closed = TRUE; continue; } if (term_after_channel_closed(term)) next_term = first_term; } } if (did_one) { redraw_statuslines(); // Need to break out of vgetc(). ins_char_typebuf(K_IGNORE, 0); typebuf_was_filled = TRUE; term = curbuf->b_term; if (term != NULL) { if (term->tl_job == ch->ch_job) maketitle(); update_cursor(term, term->tl_cursor_visible); } } } /* * To be called after resetting updating_screen: handle any terminal where the * channel was closed. */ void term_check_channel_closed_recently(void) { term_T *term; term_T *next_term; for (term = first_term; term != NULL; term = next_term) { next_term = term->tl_next; if (term->tl_channel_recently_closed) { term->tl_channel_recently_closed = FALSE; if (term_after_channel_closed(term)) // start over, the list may have changed next_term = first_term; } } } /* * Fill one screen line from a line of the terminal. * Advances "pos" to past the last column. */ static void term_line2screenline( term_T *term, win_T *wp, VTermScreen *screen, VTermPos *pos, int max_col) { int off = screen_get_current_line_off(); for (pos->col = 0; pos->col < max_col; ) { VTermScreenCell cell; int c; if (vterm_screen_get_cell(screen, *pos, &cell) == 0) CLEAR_FIELD(cell); c = cell.chars[0]; if (c == NUL) { ScreenLines[off] = ' '; if (enc_utf8) ScreenLinesUC[off] = NUL; } else { if (enc_utf8) { int i; // composing chars for (i = 0; i < Screen_mco && i + 1 < VTERM_MAX_CHARS_PER_CELL; ++i) { ScreenLinesC[i][off] = cell.chars[i + 1]; if (cell.chars[i + 1] == 0) break; } if (c >= 0x80 || (Screen_mco > 0 && ScreenLinesC[0][off] != 0)) { ScreenLines[off] = ' '; ScreenLinesUC[off] = c; } else { ScreenLines[off] = c; ScreenLinesUC[off] = NUL; } } #ifdef MSWIN else if (has_mbyte && c >= 0x80) { char_u mb[MB_MAXBYTES+1]; WCHAR wc = c; if (WideCharToMultiByte(GetACP(), 0, &wc, 1, (char*)mb, 2, 0, 0) > 1) { ScreenLines[off] = mb[0]; ScreenLines[off + 1] = mb[1]; cell.width = mb_ptr2cells(mb); } else ScreenLines[off] = c; } #endif else // This will only store the lower byte of "c". ScreenLines[off] = c; } ScreenAttrs[off] = cell2attr(term, wp, &cell.attrs, &cell.fg, &cell.bg); ++pos->col; ++off; if (cell.width == 2) { // don't set the second byte to NUL for a DBCS encoding, it // has been set above if (enc_utf8) { ScreenLinesUC[off] = NUL; ScreenLines[off] = NUL; } else if (!has_mbyte) { // Can't show a double-width character with a single-byte // 'encoding', just use a space. ScreenLines[off] = ' '; ScreenAttrs[off] = ScreenAttrs[off - 1]; } ++pos->col; ++off; } } } #if defined(FEAT_GUI) static void update_system_term(term_T *term) { VTermPos pos; VTermScreen *screen; if (term->tl_vterm == NULL) return; screen = vterm_obtain_screen(term->tl_vterm); // Scroll up to make more room for terminal lines if needed. while (term->tl_toprow > 0 && (Rows - term->tl_toprow) < term->tl_dirty_row_end) { int save_p_more = p_more; p_more = FALSE; msg_row = Rows - 1; msg_puts("\n"); p_more = save_p_more; --term->tl_toprow; } for (pos.row = term->tl_dirty_row_start; pos.row < term->tl_dirty_row_end && pos.row < Rows; ++pos.row) { if (pos.row < term->tl_rows) { int max_col = MIN(Columns, term->tl_cols); term_line2screenline(term, NULL, screen, &pos, max_col); } else pos.col = 0; screen_line(curwin, term->tl_toprow + pos.row, 0, pos.col, Columns, 0); } term->tl_dirty_row_start = MAX_ROW; term->tl_dirty_row_end = 0; } #endif /* * Return TRUE if window "wp" is to be redrawn with term_update_window(). * Returns FALSE when there is no terminal running in this window or it is in * Terminal-Normal mode. */ int term_do_update_window(win_T *wp) { term_T *term = wp->w_buffer->b_term; return term != NULL && term->tl_vterm != NULL && !term->tl_normal_mode; } /* * Called to update a window that contains an active terminal. */ void term_update_window(win_T *wp) { term_T *term = wp->w_buffer->b_term; VTerm *vterm; VTermScreen *screen; VTermState *state; VTermPos pos; int rows, cols; int newrows, newcols; int minsize; win_T *twp; vterm = term->tl_vterm; screen = vterm_obtain_screen(vterm); state = vterm_obtain_state(vterm); // We use UPD_NOT_VALID on a resize or scroll, redraw everything then. // With UPD_SOME_VALID only redraw what was marked dirty. if (wp->w_redr_type > UPD_SOME_VALID) { term->tl_dirty_row_start = 0; term->tl_dirty_row_end = MAX_ROW; if (term->tl_postponed_scroll > 0 && term->tl_postponed_scroll < term->tl_rows / 3) // Scrolling is usually faster than redrawing, when there are only // a few lines to scroll. term_scroll_up(term, 0, term->tl_postponed_scroll); term->tl_postponed_scroll = 0; } /* * If the window was resized a redraw will be triggered and we get here. * Adjust the size of the vterm unless 'termwinsize' specifies a fixed size. */ minsize = parse_termwinsize(wp, &rows, &cols); newrows = 99999; newcols = 99999; for (twp = firstwin; ; twp = twp->w_next) { // Always use curwin, it may be a popup window. win_T *wwp = twp == NULL ? curwin : twp; // When more than one window shows the same terminal, use the // smallest size. if (wwp->w_buffer == term->tl_buffer) { newrows = MIN(newrows, wwp->w_height); newcols = MIN(newcols, wwp->w_width); } if (twp == NULL) break; } if (newrows == 99999 || newcols == 99999) return; // safety exit newrows = rows == 0 ? newrows : minsize ? MAX(rows, newrows) : rows; newcols = cols == 0 ? newcols : minsize ? MAX(cols, newcols) : cols; // If no cell is visible there is no point in resizing. Also, vterm can't // handle a zero height. if (newrows == 0 || newcols == 0) return; if (term->tl_rows != newrows || term->tl_cols != newcols) { term->tl_vterm_size_changed = TRUE; vterm_set_size(vterm, newrows, newcols); ch_log(term->tl_job->jv_channel, "Resizing terminal to %d lines", newrows); term_report_winsize(term, newrows, newcols); // Updating the terminal size will cause the snapshot to be cleared. // When not in terminal_loop() we need to restore it. if (term != in_terminal_loop) may_move_terminal_to_buffer(term, FALSE); } // The cursor may have been moved when resizing. vterm_state_get_cursorpos(state, &pos); position_cursor(wp, &pos); for (pos.row = term->tl_dirty_row_start; pos.row < term->tl_dirty_row_end && pos.row < wp->w_height; ++pos.row) { if (pos.row < term->tl_rows) { int max_col = MIN(wp->w_width, term->tl_cols); term_line2screenline(term, wp, screen, &pos, max_col); } else pos.col = 0; screen_line(wp, wp->w_winrow + pos.row #ifdef FEAT_MENU + winbar_height(wp) #endif , wp->w_wincol, pos.col, wp->w_width, #ifdef FEAT_PROP_POPUP popup_is_popup(wp) ? SLF_POPUP : #endif 0); } } /* * Called after updating all windows: may reset dirty rows. */ void term_did_update_window(win_T *wp) { term_T *term = wp->w_buffer->b_term; if (term == NULL || term->tl_vterm == NULL || term->tl_normal_mode || wp->w_redr_type != 0) return; term->tl_dirty_row_start = MAX_ROW; term->tl_dirty_row_end = 0; } /* * Return TRUE if "wp" is a terminal window where the job has finished. */ int term_is_finished(buf_T *buf) { return buf->b_term != NULL && buf->b_term->tl_vterm == NULL; } /* * Return TRUE if "wp" is a terminal window where the job has finished or we * are in Terminal-Normal mode, thus we show the buffer contents. */ int term_show_buffer(buf_T *buf) { term_T *term = buf->b_term; return term != NULL && (term->tl_vterm == NULL || term->tl_normal_mode); } /* * The current buffer is going to be changed. If there is terminal * highlighting remove it now. */ void term_change_in_curbuf(void) { term_T *term = curbuf->b_term; if (!term_is_finished(curbuf) || term->tl_scrollback.ga_len <= 0) return; free_scrollback(term); redraw_buf_later(term->tl_buffer, UPD_NOT_VALID); // The buffer is now like a normal buffer, it cannot be easily // abandoned when changed. set_string_option_direct((char_u *)"buftype", -1, (char_u *)"", OPT_FREE|OPT_LOCAL, 0); } /* * Get the screen attribute for a position in the buffer. * Use a negative "col" to get the filler background color. */ int term_get_attr(win_T *wp, linenr_T lnum, int col) { buf_T *buf = wp->w_buffer; term_T *term = buf->b_term; sb_line_T *line; cellattr_T *cellattr; if (lnum > term->tl_scrollback.ga_len) cellattr = &term->tl_default_color; else { line = (sb_line_T *)term->tl_scrollback.ga_data + lnum - 1; if (col < 0 || col >= line->sb_cols) cellattr = &line->sb_fill_attr; else cellattr = line->sb_cells + col; } return cell2attr(term, wp, &cellattr->attrs, &cellattr->fg, &cellattr->bg); } /* * Convert a cterm color number 0 - 255 to RGB. * This is compatible with xterm. */ static void cterm_color2vterm(int nr, VTermColor *rgb) { cterm_color2rgb(nr, &rgb->red, &rgb->green, &rgb->blue, &rgb->index); if (rgb->index == 0) rgb->type = VTERM_COLOR_RGB; else { rgb->type = VTERM_COLOR_INDEXED; --rgb->index; } } /* * Initialize vterm color from the synID. * Returns TRUE if color is set to "fg" and "bg". * Otherwise returns FALSE. */ static int get_vterm_color_from_synid(int id, VTermColor *fg, VTermColor *bg) { #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) // Use the actual color for the GUI and when 'termguicolors' is set. if (0 # ifdef FEAT_GUI || gui.in_use # endif # ifdef FEAT_TERMGUICOLORS || p_tgc # ifdef FEAT_VTP // Finally get INVALCOLOR on this execution path || (!p_tgc && t_colors >= 256) # endif # endif ) { guicolor_T fg_rgb = INVALCOLOR; guicolor_T bg_rgb = INVALCOLOR; if (id > 0) syn_id2colors(id, &fg_rgb, &bg_rgb); if (fg_rgb != INVALCOLOR) { long_u rgb = GUI_MCH_GET_RGB(fg_rgb); fg->red = (unsigned)(rgb >> 16); fg->green = (unsigned)(rgb >> 8) & 255; fg->blue = (unsigned)rgb & 255; fg->type = VTERM_COLOR_RGB | VTERM_COLOR_DEFAULT_FG; } else fg->type = VTERM_COLOR_INVALID | VTERM_COLOR_DEFAULT_FG; if (bg_rgb != INVALCOLOR) { long_u rgb = GUI_MCH_GET_RGB(bg_rgb); bg->red = (unsigned)(rgb >> 16); bg->green = (unsigned)(rgb >> 8) & 255; bg->blue = (unsigned)rgb & 255; bg->type = VTERM_COLOR_RGB | VTERM_COLOR_DEFAULT_BG; } else bg->type = VTERM_COLOR_INVALID | VTERM_COLOR_DEFAULT_BG; return TRUE; } else #endif if (t_colors >= 16) { int cterm_fg = -1; int cterm_bg = -1; if (id > 0) syn_id2cterm_bg(id, &cterm_fg, &cterm_bg); if (cterm_fg >= 0) { cterm_color2vterm(cterm_fg, fg); fg->type |= VTERM_COLOR_DEFAULT_FG; } else fg->type = VTERM_COLOR_INVALID | VTERM_COLOR_DEFAULT_FG; if (cterm_bg >= 0) { cterm_color2vterm(cterm_bg, bg); bg->type |= VTERM_COLOR_DEFAULT_BG; } else bg->type = VTERM_COLOR_INVALID | VTERM_COLOR_DEFAULT_BG; return TRUE; } return FALSE; } void term_reset_wincolor(win_T *wp) { wp->w_term_wincolor.fg.type = VTERM_COLOR_INVALID | VTERM_COLOR_DEFAULT_FG; wp->w_term_wincolor.bg.type = VTERM_COLOR_INVALID | VTERM_COLOR_DEFAULT_BG; } /* * Cache the color of 'wincolor'. */ void term_update_wincolor(win_T *wp) { int id = 0; if (*wp->w_p_wcr != NUL) id = syn_name2id(wp->w_p_wcr); if (id == 0 || !get_vterm_color_from_synid(id, &wp->w_term_wincolor.fg, &wp->w_term_wincolor.bg)) term_reset_wincolor(wp); } /* * Called when option 'termguicolors' was set, * or when any highlight is changed. */ void term_update_wincolor_all(void) { win_T *wp = NULL; int did_curwin = FALSE; while (for_all_windows_and_curwin(&wp, &did_curwin)) term_update_wincolor(wp); } /* * Initialize term->tl_default_color from the environment. */ static void init_default_colors(term_T *term) { VTermColor *fg, *bg; int fgval, bgval; int id; CLEAR_FIELD(term->tl_default_color.attrs); term->tl_default_color.width = 1; fg = &term->tl_default_color.fg; bg = &term->tl_default_color.bg; // Vterm uses a default black background. Set it to white when // 'background' is "light". if (*p_bg == 'l') { fgval = 0; bgval = 255; } else { fgval = 255; bgval = 0; } fg->red = fg->green = fg->blue = fgval; bg->red = bg->green = bg->blue = bgval; fg->type = VTERM_COLOR_RGB | VTERM_COLOR_DEFAULT_FG; bg->type = VTERM_COLOR_RGB | VTERM_COLOR_DEFAULT_BG; // The highlight group overrules the defaults. id = term_get_highlight_id(term, NULL); if (!get_vterm_color_from_synid(id, fg, bg)) { #if defined(MSWIN) && (!defined(FEAT_GUI_MSWIN) || defined(VIMDLL)) int tmp; #endif // In an MS-Windows console we know the normal colors. if (cterm_normal_fg_color > 0) { cterm_color2vterm(cterm_normal_fg_color - 1, fg); # if defined(MSWIN) && (!defined(FEAT_GUI_MSWIN) || defined(VIMDLL)) # ifdef VIMDLL if (!gui.in_use) # endif { tmp = fg->red; fg->red = fg->blue; fg->blue = tmp; } # endif } # ifdef FEAT_TERMRESPONSE else term_get_fg_color(&fg->red, &fg->green, &fg->blue); # endif if (cterm_normal_bg_color > 0) { cterm_color2vterm(cterm_normal_bg_color - 1, bg); # if defined(MSWIN) && (!defined(FEAT_GUI_MSWIN) || defined(VIMDLL)) # ifdef VIMDLL if (!gui.in_use) # endif { tmp = fg->red; fg->red = fg->blue; fg->blue = tmp; } # endif } # ifdef FEAT_TERMRESPONSE else term_get_bg_color(&bg->red, &bg->green, &bg->blue); # endif } } #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) /* * Return TRUE if the user-defined palette (either g:terminal_ansi_colors or the * "ansi_colors" argument in term_start()) shall be applied. */ static int term_use_palette(void) { if (0 #ifdef FEAT_GUI || gui.in_use #endif #ifdef FEAT_TERMGUICOLORS || p_tgc #endif ) return TRUE; return FALSE; } /* * Set the 16 ANSI colors from array of RGB values */ static void set_vterm_palette(VTerm *vterm, long_u *rgb) { int index = 0; VTermState *state = vterm_obtain_state(vterm); for (; index < 16; index++) { VTermColor color; color.type = VTERM_COLOR_RGB; color.red = (unsigned)(rgb[index] >> 16); color.green = (unsigned)(rgb[index] >> 8) & 255; color.blue = (unsigned)rgb[index] & 255; color.index = 0; vterm_state_set_palette_color(state, index, &color); } } /* * Set the ANSI color palette from a list of colors */ static int set_ansi_colors_list(VTerm *vterm, list_T *list) { int n = 0; long_u rgb[16]; listitem_T *li; for (li = list->lv_first; li != NULL && n < 16; li = li->li_next, n++) { char_u *color_name; guicolor_T guicolor; color_name = tv_get_string_chk(&li->li_tv); if (color_name == NULL) return FAIL; guicolor = GUI_GET_COLOR(color_name); if (guicolor == INVALCOLOR) return FAIL; rgb[n] = GUI_MCH_GET_RGB(guicolor); } if (n != 16 || li != NULL) return FAIL; set_vterm_palette(vterm, rgb); return OK; } /* * Initialize the ANSI color palette from g:terminal_ansi_colors[0:15] */ static void init_vterm_ansi_colors(VTerm *vterm) { dictitem_T *var = find_var((char_u *)"g:terminal_ansi_colors", NULL, TRUE); if (var == NULL) return; if (var->di_tv.v_type != VAR_LIST || var->di_tv.vval.v_list == NULL || var->di_tv.vval.v_list->lv_first == &range_list_item || set_ansi_colors_list(vterm, var->di_tv.vval.v_list) == FAIL) semsg(_(e_invalid_argument_str), "g:terminal_ansi_colors"); } #endif /* * Handles a "drop" command from the job in the terminal. * "item" is the file name, "item->li_next" may have options. */ static void handle_drop_command(listitem_T *item) { char_u *fname = tv_get_string(&item->li_tv); listitem_T *opt_item = item->li_next; int bufnr; win_T *wp; tabpage_T *tp; exarg_T ea; char_u *tofree = NULL; bufnr = buflist_add(fname, BLN_LISTED | BLN_NOOPT); FOR_ALL_TAB_WINDOWS(tp, wp) { if (wp->w_buffer->b_fnum == bufnr) { // buffer is in a window already, go there goto_tabpage_win(tp, wp); return; } } CLEAR_FIELD(ea); if (opt_item != NULL && opt_item->li_tv.v_type == VAR_DICT && opt_item->li_tv.vval.v_dict != NULL) { dict_T *dict = opt_item->li_tv.vval.v_dict; char_u *p; p = dict_get_string(dict, "ff", FALSE); if (p == NULL) p = dict_get_string(dict, "fileformat", FALSE); if (p != NULL) { if (check_ff_value(p) == FAIL) ch_log(NULL, "Invalid ff argument to drop: %s", p); else ea.force_ff = *p; } p = dict_get_string(dict, "enc", FALSE); if (p == NULL) p = dict_get_string(dict, "encoding", FALSE); if (p != NULL) { ea.cmd = alloc(STRLEN(p) + 12); if (ea.cmd != NULL) { sprintf((char *)ea.cmd, "sbuf ++enc=%s", p); ea.force_enc = 11; tofree = ea.cmd; } } p = dict_get_string(dict, "bad", FALSE); if (p != NULL) get_bad_opt(p, &ea); if (dict_has_key(dict, "bin")) ea.force_bin = FORCE_BIN; if (dict_has_key(dict, "binary")) ea.force_bin = FORCE_BIN; if (dict_has_key(dict, "nobin")) ea.force_bin = FORCE_NOBIN; if (dict_has_key(dict, "nobinary")) ea.force_bin = FORCE_NOBIN; } // open in new window, like ":split fname" if (ea.cmd == NULL) ea.cmd = (char_u *)"split"; ea.arg = fname; ea.cmdidx = CMD_split; ex_splitview(&ea); vim_free(tofree); } /* * Return TRUE if "func" starts with "pat" and "pat" isn't empty. */ static int is_permitted_term_api(char_u *func, char_u *pat) { return pat != NULL && *pat != NUL && STRNICMP(func, pat, STRLEN(pat)) == 0; } /* * Handles a function call from the job running in a terminal. * "item" is the function name, "item->li_next" has the arguments. */ static void handle_call_command(term_T *term, channel_T *channel, listitem_T *item) { char_u *func; typval_T argvars[2]; typval_T rettv; funcexe_T funcexe; if (item->li_next == NULL) { ch_log(channel, "Missing function arguments for call"); return; } func = tv_get_string(&item->li_tv); if (!is_permitted_term_api(func, term->tl_api)) { ch_log(channel, "Unpermitted function: %s", func); return; } argvars[0].v_type = VAR_NUMBER; argvars[0].vval.v_number = term->tl_buffer->b_fnum; argvars[1] = item->li_next->li_tv; CLEAR_FIELD(funcexe); funcexe.fe_firstline = 1L; funcexe.fe_lastline = 1L; funcexe.fe_evaluate = TRUE; if (call_func(func, -1, &rettv, 2, argvars, &funcexe) == OK) { clear_tv(&rettv); ch_log(channel, "Function %s called", func); } else ch_log(channel, "Calling function %s failed", func); } /* * URL decoding (also know as Percent-encoding). * * Note this function currently is only used for decoding shell's * OSC 7 escape sequence which we can assume all bytes are valid * UTF-8 bytes. Thus we don't need to deal with invalid UTF-8 * encoding bytes like 0xfe, 0xff. */ static size_t url_decode(const char *src, const size_t len, char_u *dst) { size_t i = 0, j = 0; while (i < len) { if (src[i] == '%' && i + 2 < len) { dst[j] = hexhex2nr((char_u *)&src[i + 1]); j++; i += 3; } else { dst[j] = src[i]; i++; j++; } } dst[j] = '\0'; return j; } /* * Sync terminal buffer's cwd with shell's pwd with the help of OSC 7. * * The OSC 7 sequence has the format of * "\033]7;file://HOSTNAME/CURRENT/DIR\033\\" * and what VTerm provides via VTermStringFragment is * "file://HOSTNAME/CURRENT/DIR" */ static void sync_shell_dir(garray_T *gap) { int offset = 7; // len of "file://" is 7 char *pos = (char *)gap->ga_data + offset; char_u *new_dir; // remove HOSTNAME to get PWD while (offset < (int)gap->ga_len && *pos != '/' ) { ++offset; ++pos; } if (offset >= (int)gap->ga_len) { semsg(_(e_failed_to_extract_pwd_from_str_check_your_shell_config), gap->ga_data); return; } new_dir = alloc(gap->ga_len - offset + 1); url_decode(pos, gap->ga_len-offset, new_dir); changedir_func(new_dir, TRUE, CDSCOPE_WINDOW); vim_free(new_dir); } /* * Called by libvterm when it cannot recognize an OSC sequence. * We recognize a terminal API command. */ static int parse_osc(int command, VTermStringFragment frag, void *user) { term_T *term = (term_T *)user; js_read_T reader; typval_T tv; channel_T *channel = term->tl_job == NULL ? NULL : term->tl_job->jv_channel; garray_T *gap = &term->tl_osc_buf; // We recognize only OSC 5 1 ; {command} and OSC 7 ; {command} if (command != 51 && (command != 7 || !p_asd)) return 0; // Concatenate what was received until the final piece is found. if (ga_grow(gap, (int)frag.len + 1) == FAIL) { ga_clear(gap); return 1; } mch_memmove((char *)gap->ga_data + gap->ga_len, frag.str, frag.len); gap->ga_len += (int)frag.len; if (!frag.final) return 1; ((char *)gap->ga_data)[gap->ga_len] = 0; if (command == 7) { sync_shell_dir(gap); ga_clear(gap); return 1; } reader.js_buf = gap->ga_data; reader.js_fill = NULL; reader.js_used = 0; if (json_decode(&reader, &tv, 0) == OK && tv.v_type == VAR_LIST && tv.vval.v_list != NULL) { listitem_T *item = tv.vval.v_list->lv_first; if (item == NULL) ch_log(channel, "Missing command"); else { char_u *cmd = tv_get_string(&item->li_tv); // Make sure an invoked command doesn't delete the buffer (and the // terminal) under our fingers. ++term->tl_buffer->b_locked; item = item->li_next; if (item == NULL) ch_log(channel, "Missing argument for %s", cmd); else if (STRCMP(cmd, "drop") == 0) handle_drop_command(item); else if (STRCMP(cmd, "call") == 0) handle_call_command(term, channel, item); else ch_log(channel, "Invalid command received: %s", cmd); --term->tl_buffer->b_locked; } } else ch_log(channel, "Invalid JSON received"); ga_clear(gap); clear_tv(&tv); return 1; } /* * Called by libvterm when it cannot recognize a CSI sequence. * We recognize the window position report. */ static int parse_csi( const char *leader UNUSED, const long args[], int argcount, const char *intermed UNUSED, char command, void *user) { term_T *term = (term_T *)user; char buf[100]; int len; int x = 0; int y = 0; win_T *wp; // We recognize only CSI 13 t if (command != 't' || argcount != 1 || args[0] != 13) return 0; // not handled // When getting the window position is not possible or it fails it results // in zero/zero. #if defined(FEAT_GUI) \ || (defined(HAVE_TGETENT) && defined(FEAT_TERMRESPONSE)) \ || defined(MSWIN) (void)ui_get_winpos(&x, &y, (varnumber_T)100); #endif FOR_ALL_WINDOWS(wp) if (wp->w_buffer == term->tl_buffer) break; if (wp != NULL) { #ifdef FEAT_GUI if (gui.in_use) { x += wp->w_wincol * gui.char_width; y += W_WINROW(wp) * gui.char_height; } else #endif { // We roughly estimate the position of the terminal window inside // the Vim window by assuming a 10 x 7 character cell. x += wp->w_wincol * 7; y += W_WINROW(wp) * 10; } } len = vim_snprintf(buf, 100, "\x1b[3;%d;%dt", x, y); channel_send(term->tl_job->jv_channel, get_tty_part(term), (char_u *)buf, len, NULL); return 1; } static VTermStateFallbacks state_fallbacks = { NULL, // control parse_csi, // csi parse_osc, // osc NULL, // dcs NULL, // apc NULL, // pm NULL // sos }; /* * Use Vim's allocation functions for vterm so profiling works. */ static void * vterm_malloc(size_t size, void *data UNUSED) { // make sure that the length is not zero return alloc_clear(size == 0 ? 1L : size); } static void vterm_memfree(void *ptr, void *data UNUSED) { vim_free(ptr); } static VTermAllocatorFunctions vterm_allocator = { &vterm_malloc, &vterm_memfree }; /* * Create a new vterm and initialize it. * Return FAIL when out of memory. */ static int create_vterm(term_T *term, int rows, int cols) { VTerm *vterm; VTermScreen *screen; VTermState *state; VTermValue value; vterm = vterm_new_with_allocator(rows, cols, &vterm_allocator, NULL); term->tl_vterm = vterm; if (vterm == NULL) return FAIL; // Allocate screen and state here, so we can bail out if that fails. state = vterm_obtain_state(vterm); screen = vterm_obtain_screen(vterm); if (state == NULL || screen == NULL) { vterm_free(vterm); return FAIL; } vterm_screen_set_callbacks(screen, &screen_callbacks, term); // TODO: depends on 'encoding'. vterm_set_utf8(vterm, 1); init_default_colors(term); vterm_state_set_default_colors( state, &term->tl_default_color.fg, &term->tl_default_color.bg); if (t_colors < 16) // Less than 16 colors: assume that bold means using a bright color for // the foreground color. vterm_state_set_bold_highbright(vterm_obtain_state(vterm), 1); // Required to initialize most things. vterm_screen_reset(screen, 1 /* hard */); // Allow using alternate screen. vterm_screen_enable_altscreen(screen, 1); // For unix do not use a blinking cursor. In an xterm this causes the // cursor to blink if it's blinking in the xterm. // For Windows we respect the system wide setting. #ifdef MSWIN if (GetCaretBlinkTime() == INFINITE) value.boolean = 0; else value.boolean = 1; #else value.boolean = 0; #endif vterm_state_set_termprop(state, VTERM_PROP_CURSORBLINK, &value); vterm_state_set_unrecognised_fallbacks(state, &state_fallbacks, term); return OK; } /* * Reset the terminal palette to its default value. */ static void term_reset_palette(VTerm *vterm) { VTermState *state = vterm_obtain_state(vterm); int index; for (index = 0; index < 16; index++) { VTermColor color; color.type = VTERM_COLOR_INDEXED; ansi_color2rgb(index, &color.red, &color.green, &color.blue, &color.index); // The first valid index starts at 1. color.index -= 1; vterm_state_set_palette_color(state, index, &color); } } static void term_update_palette(term_T *term) { #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) if (term_use_palette() && (term->tl_palette != NULL || find_var((char_u *)"g:terminal_ansi_colors", NULL, TRUE) != NULL)) { if (term->tl_palette != NULL) set_vterm_palette(term->tl_vterm, term->tl_palette); else init_vterm_ansi_colors(term->tl_vterm); } else #endif term_reset_palette(term->tl_vterm); } /* * Called when option 'termguicolors' is changed. */ void term_update_palette_all(void) { term_T *term; FOR_ALL_TERMS(term) { if (term->tl_vterm == NULL) continue; term_update_palette(term); } } /* * Called when option 'background' or 'termguicolors' was set, * or when any highlight is changed. */ void term_update_colors_all(void) { term_T *term; FOR_ALL_TERMS(term) { if (term->tl_vterm == NULL) continue; init_default_colors(term); vterm_state_set_default_colors( vterm_obtain_state(term->tl_vterm), &term->tl_default_color.fg, &term->tl_default_color.bg); } } /* * Return the text to show for the buffer name and status. */ char_u * term_get_status_text(term_T *term) { if (term->tl_status_text != NULL) return term->tl_status_text; char_u *txt; size_t len; char_u *fname; if (term->tl_normal_mode) { if (term_job_running(term)) txt = (char_u *)_("Terminal"); else txt = (char_u *)_("Terminal-finished"); } else if (term->tl_title != NULL) txt = term->tl_title; else if (term_none_open(term)) txt = (char_u *)_("active"); else if (term_job_running(term)) txt = (char_u *)_("running"); else txt = (char_u *)_("finished"); fname = buf_get_fname(term->tl_buffer); len = 9 + STRLEN(fname) + STRLEN(txt); term->tl_status_text = alloc(len); if (term->tl_status_text != NULL) vim_snprintf((char *)term->tl_status_text, len, "%s [%s]", fname, txt); return term->tl_status_text; } /* * Clear the cached value of the status text. */ void term_clear_status_text(term_T *term) { VIM_CLEAR(term->tl_status_text); } /* * Mark references in jobs of terminals. */ int set_ref_in_term(int copyID) { int abort = FALSE; term_T *term; typval_T tv; for (term = first_term; !abort && term != NULL; term = term->tl_next) if (term->tl_job != NULL) { tv.v_type = VAR_JOB; tv.vval.v_job = term->tl_job; abort = abort || set_ref_in_item(&tv, copyID, NULL, NULL); } return abort; } /* * Get the buffer from the first argument in "argvars". * Returns NULL when the buffer is not for a terminal window and logs a message * with "where". */ static buf_T * term_get_buf(typval_T *argvars, char *where) { buf_T *buf; ++emsg_off; buf = tv_get_buf(&argvars[0], FALSE); --emsg_off; if (buf == NULL || buf->b_term == NULL) { (void)tv_get_number(&argvars[0]); // issue errmsg if type error ch_log(NULL, "%s: invalid buffer argument", where); return NULL; } return buf; } static void clear_cell(VTermScreenCell *cell) { CLEAR_FIELD(*cell); cell->fg.type = VTERM_COLOR_INVALID | VTERM_COLOR_DEFAULT_FG; cell->bg.type = VTERM_COLOR_INVALID | VTERM_COLOR_DEFAULT_BG; } static void dump_term_color(FILE *fd, VTermColor *color) { int index; if (VTERM_COLOR_IS_INDEXED(color)) index = color->index + 1; else if (color->type == 0) // use RGB values index = 255; else // default color index = 0; fprintf(fd, "%02x%02x%02x%d", (int)color->red, (int)color->green, (int)color->blue, index); } /* * "term_dumpwrite(buf, filename, options)" function * * Each screen cell in full is: * |{characters}+{attributes}#{fg-color}{color-idx}#{bg-color}{color-idx} * {characters} is a space for an empty cell * For a double-width character "+" is changed to "*" and the next cell is * skipped. * {attributes} is the decimal value of HL_BOLD + HL_UNDERLINE, etc. * when "&" use the same as the previous cell. * {fg-color} is hex RGB, when "&" use the same as the previous cell. * {bg-color} is hex RGB, when "&" use the same as the previous cell. * {color-idx} is a number from 0 to 255 * * Screen cell with same width, attributes and color as the previous one: * |{characters} * * To use the color of the previous cell, use "&" instead of {color}-{idx}. * * Repeating the previous screen cell: * @{count} */ void f_term_dumpwrite(typval_T *argvars, typval_T *rettv UNUSED) { buf_T *buf; term_T *term; char_u *fname; int max_height = 0; int max_width = 0; stat_T st; FILE *fd; VTermPos pos; VTermScreen *screen; VTermScreenCell prev_cell; VTermState *state; VTermPos cursor_pos; if (check_restricted() || check_secure()) return; if (in_vim9script() && (check_for_buffer_arg(argvars, 0) == FAIL || check_for_string_arg(argvars, 1) == FAIL || check_for_opt_dict_arg(argvars, 2) == FAIL)) return; buf = term_get_buf(argvars, "term_dumpwrite()"); if (buf == NULL) return; term = buf->b_term; if (term->tl_vterm == NULL) { emsg(_(e_job_already_finished)); return; } if (argvars[2].v_type != VAR_UNKNOWN) { dict_T *d; if (check_for_dict_arg(argvars, 2) == FAIL) return; d = argvars[2].vval.v_dict; if (d != NULL) { max_height = dict_get_number(d, "rows"); max_width = dict_get_number(d, "columns"); } } fname = tv_get_string_chk(&argvars[1]); if (fname == NULL) return; if (mch_stat((char *)fname, &st) >= 0) { semsg(_(e_file_exists_str), fname); return; } if (*fname == NUL || (fd = mch_fopen((char *)fname, WRITEBIN)) == NULL) { semsg(_(e_cant_create_file_str), *fname == NUL ? (char_u *)_("") : fname); return; } clear_cell(&prev_cell); screen = vterm_obtain_screen(term->tl_vterm); state = vterm_obtain_state(term->tl_vterm); vterm_state_get_cursorpos(state, &cursor_pos); for (pos.row = 0; (max_height == 0 || pos.row < max_height) && pos.row < term->tl_rows; ++pos.row) { int repeat = 0; for (pos.col = 0; (max_width == 0 || pos.col < max_width) && pos.col < term->tl_cols; ++pos.col) { VTermScreenCell cell; int same_attr; int same_chars = TRUE; int i; int is_cursor_pos = (pos.col == cursor_pos.col && pos.row == cursor_pos.row); if (vterm_screen_get_cell(screen, pos, &cell) == 0) clear_cell(&cell); for (i = 0; i < VTERM_MAX_CHARS_PER_CELL; ++i) { int c = cell.chars[i]; int pc = prev_cell.chars[i]; int should_break = c == NUL || pc == NUL; // For the first character NUL is the same as space. if (i == 0) { c = (c == NUL) ? ' ' : c; pc = (pc == NUL) ? ' ' : pc; } if (c != pc) same_chars = FALSE; if (should_break) break; } same_attr = vtermAttr2hl(&cell.attrs) == vtermAttr2hl(&prev_cell.attrs) && vterm_color_is_equal(&cell.fg, &prev_cell.fg) && vterm_color_is_equal(&cell.bg, &prev_cell.bg); if (same_chars && cell.width == prev_cell.width && same_attr && !is_cursor_pos) { ++repeat; } else { if (repeat > 0) { fprintf(fd, "@%d", repeat); repeat = 0; } fputs(is_cursor_pos ? ">" : "|", fd); if (cell.chars[0] == NUL) fputs(" ", fd); else { char_u charbuf[10]; int len; for (i = 0; i < VTERM_MAX_CHARS_PER_CELL && cell.chars[i] != NUL; ++i) { len = utf_char2bytes(cell.chars[i], charbuf); fwrite(charbuf, len, 1, fd); } } // When only the characters differ we don't write anything, the // following "|", "@" or NL will indicate using the same // attributes. if (cell.width != prev_cell.width || !same_attr) { if (cell.width == 2) fputs("*", fd); else fputs("+", fd); if (same_attr) { fputs("&", fd); } else { fprintf(fd, "%d", vtermAttr2hl(&cell.attrs)); if (vterm_color_is_equal(&cell.fg, &prev_cell.fg)) fputs("&", fd); else { fputs("#", fd); dump_term_color(fd, &cell.fg); } if (vterm_color_is_equal(&cell.bg, &prev_cell.bg)) fputs("&", fd); else { fputs("#", fd); dump_term_color(fd, &cell.bg); } } } prev_cell = cell; } if (cell.width == 2) ++pos.col; } if (repeat > 0) fprintf(fd, "@%d", repeat); fputs("\n", fd); } fclose(fd); } /* * Called when a dump is corrupted. Put a breakpoint here when debugging. */ static void dump_is_corrupt(garray_T *gap) { ga_concat(gap, (char_u *)"CORRUPT"); } static void append_cell(garray_T *gap, cellattr_T *cell) { if (ga_grow(gap, 1) == FAIL) return; *(((cellattr_T *)gap->ga_data) + gap->ga_len) = *cell; ++gap->ga_len; } static void clear_cellattr(cellattr_T *cell) { CLEAR_FIELD(*cell); cell->fg.type = VTERM_COLOR_DEFAULT_FG; cell->bg.type = VTERM_COLOR_DEFAULT_BG; } /* * Read the dump file from "fd" and append lines to the current buffer. * Return the cell width of the longest line. */ static int read_dump_file(FILE *fd, VTermPos *cursor_pos) { int c; garray_T ga_text; garray_T ga_cell; char_u *prev_char = NULL; int attr = 0; cellattr_T cell; cellattr_T empty_cell; term_T *term = curbuf->b_term; int max_cells = 0; int start_row = term->tl_scrollback.ga_len; ga_init2(&ga_text, 1, 90); ga_init2(&ga_cell, sizeof(cellattr_T), 90); clear_cellattr(&cell); clear_cellattr(&empty_cell); cursor_pos->row = -1; cursor_pos->col = -1; c = fgetc(fd); for (;;) { if (c == EOF) break; if (c == '\r') { // DOS line endings? Ignore. c = fgetc(fd); } else if (c == '\n') { // End of a line: append it to the buffer. if (ga_text.ga_data == NULL) dump_is_corrupt(&ga_text); if (ga_grow(&term->tl_scrollback, 1) == OK) { sb_line_T *line = (sb_line_T *)term->tl_scrollback.ga_data + term->tl_scrollback.ga_len; if (max_cells < ga_cell.ga_len) max_cells = ga_cell.ga_len; line->sb_cols = ga_cell.ga_len; line->sb_cells = ga_cell.ga_data; line->sb_fill_attr = term->tl_default_color; ++term->tl_scrollback.ga_len; ga_init(&ga_cell); ga_append(&ga_text, NUL); ml_append(curbuf->b_ml.ml_line_count, ga_text.ga_data, ga_text.ga_len, FALSE); } else ga_clear(&ga_cell); ga_text.ga_len = 0; c = fgetc(fd); } else if (c == '|' || c == '>') { int prev_len = ga_text.ga_len; if (c == '>') { if (cursor_pos->row != -1) dump_is_corrupt(&ga_text); // duplicate cursor cursor_pos->row = term->tl_scrollback.ga_len - start_row; cursor_pos->col = ga_cell.ga_len; } // normal character(s) followed by "+", "*", "|", "@" or NL c = fgetc(fd); if (c != EOF) ga_append(&ga_text, c); for (;;) { c = fgetc(fd); if (c == '+' || c == '*' || c == '|' || c == '>' || c == '@' || c == EOF || c == '\n') break; ga_append(&ga_text, c); } // save the character for repeating it vim_free(prev_char); if (ga_text.ga_data != NULL) prev_char = vim_strnsave(((char_u *)ga_text.ga_data) + prev_len, ga_text.ga_len - prev_len); if (c == '@' || c == '|' || c == '>' || c == '\n') { // use all attributes from previous cell } else if (c == '+' || c == '*') { int is_bg; cell.width = c == '+' ? 1 : 2; c = fgetc(fd); if (c == '&') { // use same attr as previous cell c = fgetc(fd); } else if (isdigit(c)) { // get the decimal attribute attr = 0; while (isdigit(c)) { attr = attr * 10 + (c - '0'); c = fgetc(fd); } hl2vtermAttr(attr, &cell); // is_bg == 0: fg, is_bg == 1: bg for (is_bg = 0; is_bg <= 1; ++is_bg) { if (c == '&') { // use same color as previous cell c = fgetc(fd); } else if (c == '#') { int red, green, blue, index = 0, type; c = fgetc(fd); red = hex2nr(c); c = fgetc(fd); red = (red << 4) + hex2nr(c); c = fgetc(fd); green = hex2nr(c); c = fgetc(fd); green = (green << 4) + hex2nr(c); c = fgetc(fd); blue = hex2nr(c); c = fgetc(fd); blue = (blue << 4) + hex2nr(c); c = fgetc(fd); if (!isdigit(c)) dump_is_corrupt(&ga_text); while (isdigit(c)) { index = index * 10 + (c - '0'); c = fgetc(fd); } if (index == 0 || index == 255) { type = VTERM_COLOR_RGB; if (index == 0) { if (is_bg) type |= VTERM_COLOR_DEFAULT_BG; else type |= VTERM_COLOR_DEFAULT_FG; } } else { type = VTERM_COLOR_INDEXED; index -= 1; } if (is_bg) { cell.bg.type = type; cell.bg.red = red; cell.bg.green = green; cell.bg.blue = blue; cell.bg.index = index; } else { cell.fg.type = type; cell.fg.red = red; cell.fg.green = green; cell.fg.blue = blue; cell.fg.index = index; } } else dump_is_corrupt(&ga_text); } } else dump_is_corrupt(&ga_text); } else dump_is_corrupt(&ga_text); append_cell(&ga_cell, &cell); if (cell.width == 2) append_cell(&ga_cell, &empty_cell); } else if (c == '@') { if (prev_char == NULL) dump_is_corrupt(&ga_text); else { int count = 0; // repeat previous character, get the count for (;;) { c = fgetc(fd); if (!isdigit(c)) break; count = count * 10 + (c - '0'); } while (count-- > 0) { ga_concat(&ga_text, prev_char); append_cell(&ga_cell, &cell); } } } else { dump_is_corrupt(&ga_text); c = fgetc(fd); } } if (ga_text.ga_len > 0) { // trailing characters after last NL dump_is_corrupt(&ga_text); ga_append(&ga_text, NUL); ml_append(curbuf->b_ml.ml_line_count, ga_text.ga_data, ga_text.ga_len, FALSE); } ga_clear(&ga_text); ga_clear(&ga_cell); vim_free(prev_char); return max_cells; } /* * Return an allocated string with at least "text_width" "=" characters and * "fname" inserted in the middle. */ static char_u * get_separator(int text_width, char_u *fname) { int width = MAX(text_width, curwin->w_width); char_u *textline; int fname_size; char_u *p = fname; int i; size_t off; textline = alloc(width + (int)STRLEN(fname) + 1); if (textline == NULL) return NULL; fname_size = vim_strsize(fname); if (fname_size < width - 8) { // enough room, don't use the full window width width = MAX(text_width, fname_size + 8); } else if (fname_size > width - 8) { // full name doesn't fit, use only the tail p = gettail(fname); fname_size = vim_strsize(p); } // skip characters until the name fits while (fname_size > width - 8) { p += (*mb_ptr2len)(p); fname_size = vim_strsize(p); } for (i = 0; i < (width - fname_size) / 2 - 1; ++i) textline[i] = '='; textline[i++] = ' '; STRCPY(textline + i, p); off = STRLEN(textline); textline[off] = ' '; for (i = 1; i < (width - fname_size) / 2; ++i) textline[off + i] = '='; textline[off + i] = NUL; return textline; } /* * Common for "term_dumpdiff()" and "term_dumpload()". */ static void term_load_dump(typval_T *argvars, typval_T *rettv, int do_diff) { jobopt_T opt; buf_T *buf = NULL; char_u buf1[NUMBUFLEN]; char_u buf2[NUMBUFLEN]; char_u *fname1; char_u *fname2 = NULL; char_u *fname_tofree = NULL; FILE *fd1; FILE *fd2 = NULL; char_u *textline = NULL; // First open the files. If this fails bail out. fname1 = tv_get_string_buf_chk(&argvars[0], buf1); if (do_diff) fname2 = tv_get_string_buf_chk(&argvars[1], buf2); if (fname1 == NULL || (do_diff && fname2 == NULL)) { emsg(_(e_invalid_argument)); return; } fd1 = mch_fopen((char *)fname1, READBIN); if (fd1 == NULL) { semsg(_(e_cant_read_file_str), fname1); return; } if (do_diff) { fd2 = mch_fopen((char *)fname2, READBIN); if (fd2 == NULL) { fclose(fd1); semsg(_(e_cant_read_file_str), fname2); return; } } init_job_options(&opt); if (argvars[do_diff ? 2 : 1].v_type != VAR_UNKNOWN && get_job_options(&argvars[do_diff ? 2 : 1], &opt, 0, JO2_TERM_NAME + JO2_TERM_COLS + JO2_TERM_ROWS + JO2_VERTICAL + JO2_CURWIN + JO2_NORESTORE) == FAIL) goto theend; if (opt.jo_term_name == NULL) { size_t len = STRLEN(fname1) + 12; fname_tofree = alloc(len); if (fname_tofree != NULL) { vim_snprintf((char *)fname_tofree, len, "dump diff %s", fname1); opt.jo_term_name = fname_tofree; } } if (opt.jo_bufnr_buf != NULL) { win_T *wp = buf_jump_open_win(opt.jo_bufnr_buf); // With "bufnr" argument: enter the window with this buffer and make it // empty. if (wp == NULL) semsg(_(e_invalid_argument_str), "bufnr"); else { buf = curbuf; while (!(curbuf->b_ml.ml_flags & ML_EMPTY)) ml_delete((linenr_T)1); free_scrollback(curbuf->b_term); redraw_later(UPD_NOT_VALID); } } else // Create a new terminal window. buf = term_start(&argvars[0], NULL, &opt, TERM_START_NOJOB); if (buf != NULL && buf->b_term != NULL) { int i; linenr_T bot_lnum; linenr_T lnum; term_T *term = buf->b_term; int width; int width2; VTermPos cursor_pos1; VTermPos cursor_pos2; init_default_colors(term); rettv->vval.v_number = buf->b_fnum; // read the files, fill the buffer with the diff width = read_dump_file(fd1, &cursor_pos1); // position the cursor if (cursor_pos1.row >= 0) { curwin->w_cursor.lnum = cursor_pos1.row + 1; coladvance(cursor_pos1.col); } // Delete the empty line that was in the empty buffer. ml_delete(1); // For term_dumpload() we are done here. if (!do_diff) goto theend; term->tl_top_diff_rows = curbuf->b_ml.ml_line_count; textline = get_separator(width, fname1); if (textline == NULL) goto theend; if (add_empty_scrollback(term, &term->tl_default_color, 0) == OK) ml_append(curbuf->b_ml.ml_line_count, textline, 0, FALSE); vim_free(textline); textline = get_separator(width, fname2); if (textline == NULL) goto theend; if (add_empty_scrollback(term, &term->tl_default_color, 0) == OK) ml_append(curbuf->b_ml.ml_line_count, textline, 0, FALSE); textline[width] = NUL; bot_lnum = curbuf->b_ml.ml_line_count; width2 = read_dump_file(fd2, &cursor_pos2); if (width2 > width) { vim_free(textline); textline = alloc(width2 + 1); if (textline == NULL) goto theend; width = width2; textline[width] = NUL; } term->tl_bot_diff_rows = curbuf->b_ml.ml_line_count - bot_lnum; for (lnum = 1; lnum <= term->tl_top_diff_rows; ++lnum) { if (lnum + bot_lnum > curbuf->b_ml.ml_line_count) { // bottom part has fewer rows, fill with "-" for (i = 0; i < width; ++i) textline[i] = '-'; } else { char_u *line1; char_u *line2; char_u *p1; char_u *p2; int col; sb_line_T *sb_line = (sb_line_T *)term->tl_scrollback.ga_data; cellattr_T *cellattr1 = (sb_line + lnum - 1)->sb_cells; cellattr_T *cellattr2 = (sb_line + lnum + bot_lnum - 1) ->sb_cells; // Make a copy, getting the second line will invalidate it. line1 = vim_strsave(ml_get(lnum)); if (line1 == NULL) break; p1 = line1; line2 = ml_get(lnum + bot_lnum); p2 = line2; for (col = 0; col < width && *p1 != NUL && *p2 != NUL; ++col) { int len1 = utfc_ptr2len(p1); int len2 = utfc_ptr2len(p2); textline[col] = ' '; if (len1 != len2 || STRNCMP(p1, p2, len1) != 0) // text differs textline[col] = 'X'; else if (lnum == cursor_pos1.row + 1 && col == cursor_pos1.col && (cursor_pos1.row != cursor_pos2.row || cursor_pos1.col != cursor_pos2.col)) // cursor in first but not in second textline[col] = '>'; else if (lnum == cursor_pos2.row + 1 && col == cursor_pos2.col && (cursor_pos1.row != cursor_pos2.row || cursor_pos1.col != cursor_pos2.col)) // cursor in second but not in first textline[col] = '<'; else if (cellattr1 != NULL && cellattr2 != NULL) { if ((cellattr1 + col)->width != (cellattr2 + col)->width) textline[col] = 'w'; else if (!vterm_color_is_equal(&(cellattr1 + col)->fg, &(cellattr2 + col)->fg)) textline[col] = 'f'; else if (!vterm_color_is_equal(&(cellattr1 + col)->bg, &(cellattr2 + col)->bg)) textline[col] = 'b'; else if (vtermAttr2hl(&(cellattr1 + col)->attrs) != vtermAttr2hl(&((cellattr2 + col)->attrs))) textline[col] = 'a'; } p1 += len1; p2 += len2; // TODO: handle different width } while (col < width) { if (*p1 == NUL && *p2 == NUL) textline[col] = '?'; else if (*p1 == NUL) { textline[col] = '+'; p2 += utfc_ptr2len(p2); } else { textline[col] = '-'; p1 += utfc_ptr2len(p1); } ++col; } vim_free(line1); } if (add_empty_scrollback(term, &term->tl_default_color, term->tl_top_diff_rows) == OK) ml_append(term->tl_top_diff_rows + lnum, textline, 0, FALSE); ++bot_lnum; } while (lnum + bot_lnum <= curbuf->b_ml.ml_line_count) { // bottom part has more rows, fill with "+" for (i = 0; i < width; ++i) textline[i] = '+'; if (add_empty_scrollback(term, &term->tl_default_color, term->tl_top_diff_rows) == OK) ml_append(term->tl_top_diff_rows + lnum, textline, 0, FALSE); ++lnum; ++bot_lnum; } term->tl_cols = width; // looks better without wrapping curwin->w_p_wrap = 0; } theend: vim_free(textline); vim_free(fname_tofree); fclose(fd1); if (fd2 != NULL) fclose(fd2); } /* * If the current buffer shows the output of term_dumpdiff(), swap the top and * bottom files. * Return FAIL when this is not possible. */ int term_swap_diff(void) { term_T *term = curbuf->b_term; linenr_T line_count; linenr_T top_rows; linenr_T bot_rows; linenr_T bot_start; linenr_T lnum; char_u *p; sb_line_T *sb_line; if (term == NULL || !term_is_finished(curbuf) || term->tl_top_diff_rows == 0 || term->tl_scrollback.ga_len == 0) return FAIL; line_count = curbuf->b_ml.ml_line_count; top_rows = term->tl_top_diff_rows; bot_rows = term->tl_bot_diff_rows; bot_start = line_count - bot_rows; sb_line = (sb_line_T *)term->tl_scrollback.ga_data; // move lines from top to above the bottom part for (lnum = 1; lnum <= top_rows; ++lnum) { p = vim_strsave(ml_get(1)); if (p == NULL) return OK; ml_append(bot_start, p, 0, FALSE); ml_delete(1); vim_free(p); } // move lines from bottom to the top for (lnum = 1; lnum <= bot_rows; ++lnum) { p = vim_strsave(ml_get(bot_start + lnum)); if (p == NULL) return OK; ml_delete(bot_start + lnum); ml_append(lnum - 1, p, 0, FALSE); vim_free(p); } // move top title to bottom p = vim_strsave(ml_get(bot_rows + 1)); if (p == NULL) return OK; ml_append(line_count - top_rows - 1, p, 0, FALSE); ml_delete(bot_rows + 1); vim_free(p); // move bottom title to top p = vim_strsave(ml_get(line_count - top_rows)); if (p == NULL) return OK; ml_delete(line_count - top_rows); ml_append(bot_rows, p, 0, FALSE); vim_free(p); if (top_rows == bot_rows) { // rows counts are equal, can swap cell properties for (lnum = 0; lnum < top_rows; ++lnum) { sb_line_T temp; temp = *(sb_line + lnum); *(sb_line + lnum) = *(sb_line + bot_start + lnum); *(sb_line + bot_start + lnum) = temp; } } else { size_t size = sizeof(sb_line_T) * term->tl_scrollback.ga_len; sb_line_T *temp = alloc(size); // need to copy cell properties into temp memory if (temp != NULL) { mch_memmove(temp, term->tl_scrollback.ga_data, size); mch_memmove(term->tl_scrollback.ga_data, temp + bot_start, sizeof(sb_line_T) * bot_rows); mch_memmove((sb_line_T *)term->tl_scrollback.ga_data + bot_rows, temp + top_rows, sizeof(sb_line_T) * (line_count - top_rows - bot_rows)); mch_memmove((sb_line_T *)term->tl_scrollback.ga_data + line_count - top_rows, temp, sizeof(sb_line_T) * top_rows); vim_free(temp); } } term->tl_top_diff_rows = bot_rows; term->tl_bot_diff_rows = top_rows; update_screen(UPD_NOT_VALID); return OK; } /* * "term_dumpdiff(filename, filename, options)" function */ void f_term_dumpdiff(typval_T *argvars, typval_T *rettv) { if (in_vim9script() && (check_for_string_arg(argvars, 0) == FAIL || check_for_string_arg(argvars, 1) == FAIL || check_for_opt_dict_arg(argvars, 2) == FAIL)) return; term_load_dump(argvars, rettv, TRUE); } /* * "term_dumpload(filename, options)" function */ void f_term_dumpload(typval_T *argvars, typval_T *rettv) { if (in_vim9script() && (check_for_string_arg(argvars, 0) == FAIL || check_for_opt_dict_arg(argvars, 1) == FAIL)) return; term_load_dump(argvars, rettv, FALSE); } /* * "term_getaltscreen(buf)" function */ void f_term_getaltscreen(typval_T *argvars, typval_T *rettv) { buf_T *buf; if (in_vim9script() && check_for_buffer_arg(argvars, 0) == FAIL) return; buf = term_get_buf(argvars, "term_getaltscreen()"); if (buf == NULL) return; rettv->vval.v_number = buf->b_term->tl_using_altscreen; } /* * "term_getattr(attr, name)" function */ void f_term_getattr(typval_T *argvars, typval_T *rettv) { int attr; size_t i; char_u *name; static struct { char *name; int attr; } attrs[] = { {"bold", HL_BOLD}, {"italic", HL_ITALIC}, {"underline", HL_UNDERLINE}, {"strike", HL_STRIKETHROUGH}, {"reverse", HL_INVERSE}, }; if (in_vim9script() && (check_for_number_arg(argvars, 0) == FAIL || check_for_string_arg(argvars, 1) == FAIL)) return; attr = tv_get_number(&argvars[0]); name = tv_get_string_chk(&argvars[1]); if (name == NULL) return; if (attr > HL_ALL) attr = syn_attr2attr(attr); for (i = 0; i < ARRAY_LENGTH(attrs); ++i) if (STRCMP(name, attrs[i].name) == 0) { rettv->vval.v_number = (attr & attrs[i].attr) != 0 ? 1 : 0; break; } } /* * "term_getcursor(buf)" function */ void f_term_getcursor(typval_T *argvars, typval_T *rettv) { buf_T *buf; term_T *term; list_T *l; dict_T *d; if (rettv_list_alloc(rettv) == FAIL) return; if (in_vim9script() && check_for_buffer_arg(argvars, 0) == FAIL) return; buf = term_get_buf(argvars, "term_getcursor()"); if (buf == NULL) return; term = buf->b_term; l = rettv->vval.v_list; list_append_number(l, term->tl_cursor_pos.row + 1); list_append_number(l, term->tl_cursor_pos.col + 1); d = dict_alloc(); if (d == NULL) return; dict_add_number(d, "visible", term->tl_cursor_visible); dict_add_number(d, "blink", blink_state_is_inverted() ? !term->tl_cursor_blink : term->tl_cursor_blink); dict_add_number(d, "shape", term->tl_cursor_shape); dict_add_string(d, "color", cursor_color_get(term->tl_cursor_color)); list_append_dict(l, d); } /* * "term_getjob(buf)" function */ void f_term_getjob(typval_T *argvars, typval_T *rettv) { buf_T *buf; if (in_vim9script() && check_for_buffer_arg(argvars, 0) == FAIL) return; buf = term_get_buf(argvars, "term_getjob()"); if (buf == NULL) { rettv->v_type = VAR_SPECIAL; rettv->vval.v_number = VVAL_NULL; return; } rettv->v_type = VAR_JOB; rettv->vval.v_job = buf->b_term->tl_job; if (rettv->vval.v_job != NULL) ++rettv->vval.v_job->jv_refcount; } static int get_row_number(typval_T *tv, term_T *term) { if (tv->v_type == VAR_STRING && tv->vval.v_string != NULL && STRCMP(tv->vval.v_string, ".") == 0) return term->tl_cursor_pos.row; return (int)tv_get_number(tv) - 1; } /* * "term_getline(buf, row)" function */ void f_term_getline(typval_T *argvars, typval_T *rettv) { buf_T *buf; term_T *term; int row; rettv->v_type = VAR_STRING; if (in_vim9script() && (check_for_buffer_arg(argvars, 0) == FAIL || check_for_lnum_arg(argvars, 1) == FAIL)) return; buf = term_get_buf(argvars, "term_getline()"); if (buf == NULL) return; term = buf->b_term; row = get_row_number(&argvars[1], term); if (term->tl_vterm == NULL) { linenr_T lnum = row + term->tl_scrollback_scrolled + 1; // vterm is finished, get the text from the buffer if (lnum > 0 && lnum <= buf->b_ml.ml_line_count) rettv->vval.v_string = vim_strsave(ml_get_buf(buf, lnum, FALSE)); } else { VTermScreen *screen = vterm_obtain_screen(term->tl_vterm); VTermRect rect; int len; char_u *p; if (row < 0 || row >= term->tl_rows) return; len = term->tl_cols * MB_MAXBYTES + 1; p = alloc(len); if (p == NULL) return; rettv->vval.v_string = p; rect.start_col = 0; rect.end_col = term->tl_cols; rect.start_row = row; rect.end_row = row + 1; p[vterm_screen_get_text(screen, (char *)p, len, rect)] = NUL; } } /* * "term_getscrolled(buf)" function */ void f_term_getscrolled(typval_T *argvars, typval_T *rettv) { buf_T *buf; if (in_vim9script() && check_for_buffer_arg(argvars, 0) == FAIL) return; buf = term_get_buf(argvars, "term_getscrolled()"); if (buf == NULL) return; rettv->vval.v_number = buf->b_term->tl_scrollback_scrolled; } /* * "term_getsize(buf)" function */ void f_term_getsize(typval_T *argvars, typval_T *rettv) { buf_T *buf; list_T *l; if (rettv_list_alloc(rettv) == FAIL) return; if (in_vim9script() && check_for_buffer_arg(argvars, 0) == FAIL) return; buf = term_get_buf(argvars, "term_getsize()"); if (buf == NULL) return; l = rettv->vval.v_list; list_append_number(l, buf->b_term->tl_rows); list_append_number(l, buf->b_term->tl_cols); } /* * "term_setsize(buf, rows, cols)" function */ void f_term_setsize(typval_T *argvars UNUSED, typval_T *rettv UNUSED) { buf_T *buf; term_T *term; varnumber_T rows, cols; if (in_vim9script() && (check_for_buffer_arg(argvars, 0) == FAIL || check_for_number_arg(argvars, 1) == FAIL || check_for_number_arg(argvars, 2) == FAIL)) return; buf = term_get_buf(argvars, "term_setsize()"); if (buf == NULL) { emsg(_(e_not_terminal_buffer)); return; } if (buf->b_term->tl_vterm == NULL) return; term = buf->b_term; rows = tv_get_number(&argvars[1]); rows = rows <= 0 ? term->tl_rows : rows; cols = tv_get_number(&argvars[2]); cols = cols <= 0 ? term->tl_cols : cols; vterm_set_size(term->tl_vterm, rows, cols); // handle_resize() will resize the windows // Get and remember the size we ended up with. Update the pty. vterm_get_size(term->tl_vterm, &term->tl_rows, &term->tl_cols); term_report_winsize(term, term->tl_rows, term->tl_cols); } /* * "term_getstatus(buf)" function */ void f_term_getstatus(typval_T *argvars, typval_T *rettv) { buf_T *buf; term_T *term; char_u val[100]; rettv->v_type = VAR_STRING; if (in_vim9script() && check_for_buffer_arg(argvars, 0) == FAIL) return; buf = term_get_buf(argvars, "term_getstatus()"); if (buf == NULL) return; term = buf->b_term; if (term_job_running(term)) STRCPY(val, "running"); else STRCPY(val, "finished"); if (term->tl_normal_mode) STRCAT(val, ",normal"); rettv->vval.v_string = vim_strsave(val); } /* * "term_gettitle(buf)" function */ void f_term_gettitle(typval_T *argvars, typval_T *rettv) { buf_T *buf; rettv->v_type = VAR_STRING; if (in_vim9script() && check_for_buffer_arg(argvars, 0) == FAIL) return; buf = term_get_buf(argvars, "term_gettitle()"); if (buf == NULL) return; if (buf->b_term->tl_title != NULL) rettv->vval.v_string = vim_strsave(buf->b_term->tl_title); } /* * "term_gettty(buf)" function */ void f_term_gettty(typval_T *argvars, typval_T *rettv) { buf_T *buf; char_u *p = NULL; int num = 0; if (in_vim9script() && (check_for_buffer_arg(argvars, 0) == FAIL || check_for_opt_bool_arg(argvars, 1) == FAIL)) return; rettv->v_type = VAR_STRING; buf = term_get_buf(argvars, "term_gettty()"); if (buf == NULL) return; if (argvars[1].v_type != VAR_UNKNOWN) num = tv_get_bool(&argvars[1]); switch (num) { case 0: if (buf->b_term->tl_job != NULL) p = buf->b_term->tl_job->jv_tty_out; break; case 1: if (buf->b_term->tl_job != NULL) p = buf->b_term->tl_job->jv_tty_in; break; default: semsg(_(e_invalid_argument_str), tv_get_string(&argvars[1])); return; } if (p != NULL) rettv->vval.v_string = vim_strsave(p); } /* * "term_list()" function */ void f_term_list(typval_T *argvars UNUSED, typval_T *rettv) { term_T *tp; list_T *l; if (rettv_list_alloc(rettv) == FAIL || first_term == NULL) return; l = rettv->vval.v_list; FOR_ALL_TERMS(tp) if (tp->tl_buffer != NULL) if (list_append_number(l, (varnumber_T)tp->tl_buffer->b_fnum) == FAIL) return; } /* * "term_scrape(buf, row)" function */ void f_term_scrape(typval_T *argvars, typval_T *rettv) { buf_T *buf; VTermScreen *screen = NULL; VTermPos pos; list_T *l; term_T *term; char_u *p; sb_line_T *line; if (rettv_list_alloc(rettv) == FAIL) return; if (in_vim9script() && (check_for_buffer_arg(argvars, 0) == FAIL || check_for_lnum_arg(argvars, 1) == FAIL)) return; buf = term_get_buf(argvars, "term_scrape()"); if (buf == NULL) return; term = buf->b_term; l = rettv->vval.v_list; pos.row = get_row_number(&argvars[1], term); if (term->tl_vterm != NULL) { screen = vterm_obtain_screen(term->tl_vterm); if (screen == NULL) // can't really happen return; p = NULL; line = NULL; } else { linenr_T lnum = pos.row + term->tl_scrollback_scrolled; if (lnum < 0 || lnum >= term->tl_scrollback.ga_len) return; p = ml_get_buf(buf, lnum + 1, FALSE); line = (sb_line_T *)term->tl_scrollback.ga_data + lnum; } for (pos.col = 0; pos.col < term->tl_cols; ) { dict_T *dcell; int width; VTermScreenCellAttrs attrs; VTermColor fg, bg; char_u rgb[8]; char_u mbs[MB_MAXBYTES * VTERM_MAX_CHARS_PER_CELL + 1]; int off = 0; int i; if (screen == NULL) { cellattr_T *cellattr; int len; // vterm has finished, get the cell from scrollback if (pos.col >= line->sb_cols) break; cellattr = line->sb_cells + pos.col; width = cellattr->width; attrs = cellattr->attrs; fg = cellattr->fg; bg = cellattr->bg; len = mb_ptr2len(p); mch_memmove(mbs, p, len); mbs[len] = NUL; p += len; } else { VTermScreenCell cell; if (vterm_screen_get_cell(screen, pos, &cell) == 0) break; for (i = 0; i < VTERM_MAX_CHARS_PER_CELL; ++i) { if (cell.chars[i] == 0) break; off += (*utf_char2bytes)((int)cell.chars[i], mbs + off); } mbs[off] = NUL; width = cell.width; attrs = cell.attrs; fg = cell.fg; bg = cell.bg; } dcell = dict_alloc(); if (dcell == NULL) break; list_append_dict(l, dcell); dict_add_string(dcell, "chars", mbs); vim_snprintf((char *)rgb, 8, "#%02x%02x%02x", fg.red, fg.green, fg.blue); dict_add_string(dcell, "fg", rgb); vim_snprintf((char *)rgb, 8, "#%02x%02x%02x", bg.red, bg.green, bg.blue); dict_add_string(dcell, "bg", rgb); dict_add_number(dcell, "attr", cell2attr(term, NULL, &attrs, &fg, &bg)); dict_add_number(dcell, "width", width); ++pos.col; if (width == 2) ++pos.col; } } /* * "term_sendkeys(buf, keys)" function */ void f_term_sendkeys(typval_T *argvars, typval_T *rettv UNUSED) { buf_T *buf; char_u *msg; term_T *term; if (in_vim9script() && (check_for_buffer_arg(argvars, 0) == FAIL || check_for_string_arg(argvars, 1) == FAIL)) return; buf = term_get_buf(argvars, "term_sendkeys()"); if (buf == NULL) return; msg = tv_get_string_chk(&argvars[1]); if (msg == NULL) return; term = buf->b_term; if (term->tl_vterm == NULL) return; while (*msg != NUL) { int c; if (*msg == K_SPECIAL && msg[1] != NUL && msg[2] != NUL) { c = TO_SPECIAL(msg[1], msg[2]); msg += 3; } else { c = PTR2CHAR(msg); msg += MB_CPTR2LEN(msg); } send_keys_to_term(term, c, 0, FALSE); } } #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) || defined(PROTO) /* * "term_getansicolors(buf)" function */ void f_term_getansicolors(typval_T *argvars, typval_T *rettv) { buf_T *buf; term_T *term; VTermState *state; VTermColor color; char_u hexbuf[10]; int index; list_T *list; if (rettv_list_alloc(rettv) == FAIL) return; if (in_vim9script() && check_for_buffer_arg(argvars, 0) == FAIL) return; buf = term_get_buf(argvars, "term_getansicolors()"); if (buf == NULL) return; term = buf->b_term; if (term->tl_vterm == NULL) return; list = rettv->vval.v_list; state = vterm_obtain_state(term->tl_vterm); for (index = 0; index < 16; index++) { vterm_state_get_palette_color(state, index, &color); sprintf((char *)hexbuf, "#%02x%02x%02x", color.red, color.green, color.blue); if (list_append_string(list, hexbuf, 7) == FAIL) return; } } /* * "term_setansicolors(buf, list)" function */ void f_term_setansicolors(typval_T *argvars, typval_T *rettv UNUSED) { buf_T *buf; term_T *term; listitem_T *li; int n = 0; if (in_vim9script() && (check_for_buffer_arg(argvars, 0) == FAIL || check_for_list_arg(argvars, 1) == FAIL)) return; buf = term_get_buf(argvars, "term_setansicolors()"); if (buf == NULL) return; term = buf->b_term; if (term->tl_vterm == NULL) return; if (check_for_nonnull_list_arg(argvars, 1) == FAIL) return; if (argvars[1].vval.v_list->lv_first == &range_list_item || argvars[1].vval.v_list->lv_len != 16) { emsg(_(e_invalid_argument)); return; } if (term->tl_palette == NULL) term->tl_palette = ALLOC_MULT(long_u, 16); if (term->tl_palette == NULL) return; FOR_ALL_LIST_ITEMS(argvars[1].vval.v_list, li) { char_u *color_name; guicolor_T guicolor; color_name = tv_get_string_chk(&li->li_tv); if (color_name == NULL) return; guicolor = GUI_GET_COLOR(color_name); if (guicolor == INVALCOLOR) { semsg(_(e_cannot_allocate_color_str), color_name); return; } term->tl_palette[n++] = GUI_MCH_GET_RGB(guicolor); } term_update_palette(term); } #endif /* * "term_setapi(buf, api)" function */ void f_term_setapi(typval_T *argvars, typval_T *rettv UNUSED) { buf_T *buf; term_T *term; char_u *api; if (in_vim9script() && (check_for_buffer_arg(argvars, 0) == FAIL || check_for_string_arg(argvars, 1) == FAIL)) return; buf = term_get_buf(argvars, "term_setapi()"); if (buf == NULL) return; term = buf->b_term; vim_free(term->tl_api); api = tv_get_string_chk(&argvars[1]); if (api != NULL) term->tl_api = vim_strsave(api); else term->tl_api = NULL; } /* * "term_setrestore(buf, command)" function */ void f_term_setrestore(typval_T *argvars UNUSED, typval_T *rettv UNUSED) { #if defined(FEAT_SESSION) buf_T *buf; term_T *term; char_u *cmd; if (in_vim9script() && (check_for_buffer_arg(argvars, 0) == FAIL || check_for_string_arg(argvars, 1) == FAIL)) return; buf = term_get_buf(argvars, "term_setrestore()"); if (buf == NULL) return; term = buf->b_term; vim_free(term->tl_command); cmd = tv_get_string_chk(&argvars[1]); if (cmd != NULL) term->tl_command = vim_strsave(cmd); else term->tl_command = NULL; #endif } /* * "term_setkill(buf, how)" function */ void f_term_setkill(typval_T *argvars UNUSED, typval_T *rettv UNUSED) { buf_T *buf; term_T *term; char_u *how; if (in_vim9script() && (check_for_buffer_arg(argvars, 0) == FAIL || check_for_string_arg(argvars, 1) == FAIL)) return; buf = term_get_buf(argvars, "term_setkill()"); if (buf == NULL) return; term = buf->b_term; vim_free(term->tl_kill); how = tv_get_string_chk(&argvars[1]); if (how != NULL) term->tl_kill = vim_strsave(how); else term->tl_kill = NULL; } /* * "term_start(command, options)" function */ void f_term_start(typval_T *argvars, typval_T *rettv) { jobopt_T opt; buf_T *buf; if (in_vim9script() && (check_for_string_or_list_arg(argvars, 0) == FAIL || check_for_opt_dict_arg(argvars, 1) == FAIL)) return; init_job_options(&opt); if (argvars[1].v_type != VAR_UNKNOWN && get_job_options(&argvars[1], &opt, JO_TIMEOUT_ALL + JO_STOPONEXIT + JO_CALLBACK + JO_OUT_CALLBACK + JO_ERR_CALLBACK + JO_EXIT_CB + JO_CLOSE_CALLBACK + JO_OUT_IO, JO2_TERM_NAME + JO2_TERM_FINISH + JO2_HIDDEN + JO2_TERM_OPENCMD + JO2_TERM_COLS + JO2_TERM_ROWS + JO2_VERTICAL + JO2_CURWIN + JO2_CWD + JO2_ENV + JO2_EOF_CHARS + JO2_NORESTORE + JO2_TERM_KILL + JO2_TERM_HIGHLIGHT + JO2_ANSI_COLORS + JO2_TTY_TYPE + JO2_TERM_API) == FAIL) return; buf = term_start(&argvars[0], NULL, &opt, 0); if (buf != NULL && buf->b_term != NULL) rettv->vval.v_number = buf->b_fnum; } /* * "term_wait" function */ void f_term_wait(typval_T *argvars, typval_T *rettv UNUSED) { buf_T *buf; if (in_vim9script() && (check_for_buffer_arg(argvars, 0) == FAIL || check_for_opt_number_arg(argvars, 1) == FAIL)) return; buf = term_get_buf(argvars, "term_wait()"); if (buf == NULL) return; if (buf->b_term->tl_job == NULL) { ch_log(NULL, "term_wait(): no job to wait for"); return; } if (buf->b_term->tl_job->jv_channel == NULL) // channel is closed, nothing to do return; // Get the job status, this will detect a job that finished. if (!buf->b_term->tl_job->jv_channel->ch_keep_open && STRCMP(job_status(buf->b_term->tl_job), "dead") == 0) { // The job is dead, keep reading channel I/O until the channel is // closed. buf->b_term may become NULL if the terminal was closed while // waiting. ch_log(NULL, "term_wait(): waiting for channel to close"); while (buf->b_term != NULL && !buf->b_term->tl_channel_closed) { term_flush_messages(); ui_delay(10L, FALSE); if (!buf_valid(buf)) // If the terminal is closed when the channel is closed the // buffer disappears. break; if (buf->b_term == NULL || buf->b_term->tl_channel_closing) // came here from a close callback, only wait one time break; } term_flush_messages(); } else { long wait = 10L; term_flush_messages(); // Wait for some time for any channel I/O. if (argvars[1].v_type != VAR_UNKNOWN) wait = tv_get_number(&argvars[1]); ui_delay(wait, TRUE); // Flushing messages on channels is hopefully sufficient. // TODO: is there a better way? term_flush_messages(); } } /* * Called when a channel has sent all the lines to a terminal. * Send a CTRL-D to mark the end of the text. */ void term_send_eof(channel_T *ch) { term_T *term; FOR_ALL_TERMS(term) if (term->tl_job == ch->ch_job) { if (term->tl_eof_chars != NULL) { channel_send(ch, PART_IN, term->tl_eof_chars, (int)STRLEN(term->tl_eof_chars), NULL); channel_send(ch, PART_IN, (char_u *)"\r", 1, NULL); } # ifdef MSWIN else // Default: CTRL-D channel_send(ch, PART_IN, (char_u *)"\004\r", 2, NULL); # endif } } #if defined(FEAT_GUI) || defined(PROTO) job_T * term_getjob(term_T *term) { return term != NULL ? term->tl_job : NULL; } #endif # if defined(MSWIN) || defined(PROTO) /////////////////////////////////////// // 2. MS-Windows implementation. #ifdef PROTO typedef int COORD; typedef int DWORD; typedef int HANDLE; typedef int *DWORD_PTR; typedef int HPCON; typedef int HRESULT; typedef int LPPROC_THREAD_ATTRIBUTE_LIST; typedef int SIZE_T; typedef int PSIZE_T; typedef int PVOID; typedef int BOOL; # define WINAPI #endif HRESULT (WINAPI *pCreatePseudoConsole)(COORD, HANDLE, HANDLE, DWORD, HPCON*); HRESULT (WINAPI *pResizePseudoConsole)(HPCON, COORD); HRESULT (WINAPI *pClosePseudoConsole)(HPCON); BOOL (WINAPI *pInitializeProcThreadAttributeList)(LPPROC_THREAD_ATTRIBUTE_LIST, DWORD, DWORD, PSIZE_T); BOOL (WINAPI *pUpdateProcThreadAttribute)(LPPROC_THREAD_ATTRIBUTE_LIST, DWORD, DWORD_PTR, PVOID, SIZE_T, PVOID, PSIZE_T); void (WINAPI *pDeleteProcThreadAttributeList)(LPPROC_THREAD_ATTRIBUTE_LIST); static int dyn_conpty_init(int verbose) { static HMODULE hKerneldll = NULL; int i; static struct { char *name; FARPROC *ptr; } conpty_entry[] = { {"CreatePseudoConsole", (FARPROC*)&pCreatePseudoConsole}, {"ResizePseudoConsole", (FARPROC*)&pResizePseudoConsole}, {"ClosePseudoConsole", (FARPROC*)&pClosePseudoConsole}, {"InitializeProcThreadAttributeList", (FARPROC*)&pInitializeProcThreadAttributeList}, {"UpdateProcThreadAttribute", (FARPROC*)&pUpdateProcThreadAttribute}, {"DeleteProcThreadAttributeList", (FARPROC*)&pDeleteProcThreadAttributeList}, {NULL, NULL} }; if (!has_conpty_working()) { if (verbose) emsg(_(e_conpty_is_not_available)); return FAIL; } // No need to initialize twice. if (hKerneldll) return OK; hKerneldll = vimLoadLib("kernel32.dll"); for (i = 0; conpty_entry[i].name != NULL && conpty_entry[i].ptr != NULL; ++i) { if ((*conpty_entry[i].ptr = (FARPROC)GetProcAddress(hKerneldll, conpty_entry[i].name)) == NULL) { if (verbose) semsg(_(e_could_not_load_library_function_str), conpty_entry[i].name); hKerneldll = NULL; return FAIL; } } return OK; } static int conpty_term_and_job_init( term_T *term, typval_T *argvar, char **argv UNUSED, jobopt_T *opt, jobopt_T *orig_opt) { WCHAR *cmd_wchar = NULL; WCHAR *cmd_wchar_copy = NULL; WCHAR *cwd_wchar = NULL; WCHAR *env_wchar = NULL; channel_T *channel = NULL; job_T *job = NULL; HANDLE jo = NULL; garray_T ga_cmd, ga_env; char_u *cmd = NULL; HRESULT hr; COORD consize; SIZE_T breq; PROCESS_INFORMATION proc_info; HANDLE i_theirs = NULL; HANDLE o_theirs = NULL; HANDLE i_ours = NULL; HANDLE o_ours = NULL; ga_init2(&ga_cmd, sizeof(char*), 20); ga_init2(&ga_env, sizeof(char*), 20); if (argvar->v_type == VAR_STRING) { cmd = argvar->vval.v_string; } else if (argvar->v_type == VAR_LIST) { if (win32_build_cmd(argvar->vval.v_list, &ga_cmd) == FAIL) goto failed; cmd = ga_cmd.ga_data; } if (cmd == NULL || *cmd == NUL) { emsg(_(e_invalid_argument)); goto failed; } term->tl_arg0_cmd = vim_strsave(cmd); cmd_wchar = enc_to_utf16(cmd, NULL); if (cmd_wchar != NULL) { // Request by CreateProcessW breq = wcslen(cmd_wchar) + 1 + 1; // Addition of NUL by API cmd_wchar_copy = ALLOC_MULT(WCHAR, breq); wcsncpy(cmd_wchar_copy, cmd_wchar, breq - 1); } ga_clear(&ga_cmd); if (cmd_wchar == NULL) goto failed; if (opt->jo_cwd != NULL) cwd_wchar = enc_to_utf16(opt->jo_cwd, NULL); win32_build_env(opt->jo_env, &ga_env, TRUE); env_wchar = ga_env.ga_data; if (!CreatePipe(&i_theirs, &i_ours, NULL, 0)) goto failed; if (!CreatePipe(&o_ours, &o_theirs, NULL, 0)) goto failed; consize.X = term->tl_cols; consize.Y = term->tl_rows; hr = pCreatePseudoConsole(consize, i_theirs, o_theirs, 0, &term->tl_conpty); if (FAILED(hr)) goto failed; term->tl_siex.StartupInfo.cb = sizeof(term->tl_siex); // Set up pipe inheritance safely: Vista or later. pInitializeProcThreadAttributeList(NULL, 1, 0, &breq); term->tl_siex.lpAttributeList = alloc(breq); if (!term->tl_siex.lpAttributeList) goto failed; if (!pInitializeProcThreadAttributeList(term->tl_siex.lpAttributeList, 1, 0, &breq)) goto failed; if (!pUpdateProcThreadAttribute( term->tl_siex.lpAttributeList, 0, PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE, term->tl_conpty, sizeof(HPCON), NULL, NULL)) goto failed; channel = add_channel(); if (channel == NULL) goto failed; job = job_alloc(); if (job == NULL) goto failed; if (argvar->v_type == VAR_STRING) { int argc; build_argv_from_string(cmd, &job->jv_argv, &argc); } else { int argc; build_argv_from_list(argvar->vval.v_list, &job->jv_argv, &argc); } if (opt->jo_set & JO_IN_BUF) job->jv_in_buf = buflist_findnr(opt->jo_io_buf[PART_IN]); if (!CreateProcessW(NULL, cmd_wchar_copy, NULL, NULL, FALSE, EXTENDED_STARTUPINFO_PRESENT | CREATE_UNICODE_ENVIRONMENT | CREATE_SUSPENDED | CREATE_DEFAULT_ERROR_MODE, env_wchar, cwd_wchar, &term->tl_siex.StartupInfo, &proc_info)) goto failed; CloseHandle(i_theirs); CloseHandle(o_theirs); channel_set_pipes(channel, (sock_T)i_ours, (sock_T)o_ours, (sock_T)o_ours); // Write lines with CR instead of NL. channel->ch_write_text_mode = TRUE; // Use to explicitly delete anonymous pipe handle. channel->ch_anonymous_pipe = TRUE; jo = CreateJobObject(NULL, NULL); if (jo == NULL) goto failed; if (!AssignProcessToJobObject(jo, proc_info.hProcess)) { // Failed, switch the way to terminate process with TerminateProcess. CloseHandle(jo); jo = NULL; } ResumeThread(proc_info.hThread); CloseHandle(proc_info.hThread); vim_free(cmd_wchar); vim_free(cmd_wchar_copy); vim_free(cwd_wchar); vim_free(env_wchar); if (create_vterm(term, term->tl_rows, term->tl_cols) == FAIL) goto failed; #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) if (term_use_palette()) { if (term->tl_palette != NULL) set_vterm_palette(term->tl_vterm, term->tl_palette); else init_vterm_ansi_colors(term->tl_vterm); } #endif channel_set_job(channel, job, opt); job_set_options(job, opt); job->jv_channel = channel; job->jv_proc_info = proc_info; job->jv_job_object = jo; job->jv_status = JOB_STARTED; job->jv_tty_type = vim_strsave((char_u *)"conpty"); ++job->jv_refcount; term->tl_job = job; // Redirecting stdout and stderr doesn't work at the job level. Instead // open the file here and handle it in. opt->jo_io was changed in // setup_job_options(), use the original flags here. if (orig_opt->jo_io[PART_OUT] == JIO_FILE) { char_u *fname = opt->jo_io_name[PART_OUT]; ch_log(channel, "Opening output file %s", fname); term->tl_out_fd = mch_fopen((char *)fname, WRITEBIN); if (term->tl_out_fd == NULL) semsg(_(e_cant_open_file_str), fname); } return OK; failed: ga_clear(&ga_cmd); ga_clear(&ga_env); vim_free(cmd_wchar); vim_free(cmd_wchar_copy); vim_free(cwd_wchar); if (channel != NULL) channel_clear(channel); if (job != NULL) { job->jv_channel = NULL; job_cleanup(job); } term->tl_job = NULL; if (jo != NULL) CloseHandle(jo); if (term->tl_siex.lpAttributeList != NULL) { pDeleteProcThreadAttributeList(term->tl_siex.lpAttributeList); vim_free(term->tl_siex.lpAttributeList); } term->tl_siex.lpAttributeList = NULL; if (o_theirs != NULL) CloseHandle(o_theirs); if (o_ours != NULL) CloseHandle(o_ours); if (i_ours != NULL) CloseHandle(i_ours); if (i_theirs != NULL) CloseHandle(i_theirs); if (term->tl_conpty != NULL) pClosePseudoConsole(term->tl_conpty); term->tl_conpty = NULL; return FAIL; } static void conpty_term_report_winsize(term_T *term, int rows, int cols) { COORD consize; consize.X = cols; consize.Y = rows; pResizePseudoConsole(term->tl_conpty, consize); } static void term_free_conpty(term_T *term) { if (term->tl_siex.lpAttributeList != NULL) { pDeleteProcThreadAttributeList(term->tl_siex.lpAttributeList); vim_free(term->tl_siex.lpAttributeList); } term->tl_siex.lpAttributeList = NULL; if (term->tl_conpty != NULL) pClosePseudoConsole(term->tl_conpty); term->tl_conpty = NULL; } int use_conpty(void) { return has_conpty; } # ifndef PROTO #define WINPTY_SPAWN_FLAG_AUTO_SHUTDOWN 1ul #define WINPTY_SPAWN_FLAG_EXIT_AFTER_SHUTDOWN 2ull #define WINPTY_MOUSE_MODE_FORCE 2 void* (*winpty_config_new)(UINT64, void*); void* (*winpty_open)(void*, void*); void* (*winpty_spawn_config_new)(UINT64, void*, LPCWSTR, void*, void*, void*); BOOL (*winpty_spawn)(void*, void*, HANDLE*, HANDLE*, DWORD*, void*); void (*winpty_config_set_mouse_mode)(void*, int); void (*winpty_config_set_initial_size)(void*, int, int); LPCWSTR (*winpty_conin_name)(void*); LPCWSTR (*winpty_conout_name)(void*); LPCWSTR (*winpty_conerr_name)(void*); void (*winpty_free)(void*); void (*winpty_config_free)(void*); void (*winpty_spawn_config_free)(void*); void (*winpty_error_free)(void*); LPCWSTR (*winpty_error_msg)(void*); BOOL (*winpty_set_size)(void*, int, int, void*); HANDLE (*winpty_agent_process)(void*); #define WINPTY_DLL "winpty.dll" static HINSTANCE hWinPtyDLL = NULL; # endif static int dyn_winpty_init(int verbose) { int i; static struct { char *name; FARPROC *ptr; } winpty_entry[] = { {"winpty_conerr_name", (FARPROC*)&winpty_conerr_name}, {"winpty_config_free", (FARPROC*)&winpty_config_free}, {"winpty_config_new", (FARPROC*)&winpty_config_new}, {"winpty_config_set_mouse_mode", (FARPROC*)&winpty_config_set_mouse_mode}, {"winpty_config_set_initial_size", (FARPROC*)&winpty_config_set_initial_size}, {"winpty_conin_name", (FARPROC*)&winpty_conin_name}, {"winpty_conout_name", (FARPROC*)&winpty_conout_name}, {"winpty_error_free", (FARPROC*)&winpty_error_free}, {"winpty_free", (FARPROC*)&winpty_free}, {"winpty_open", (FARPROC*)&winpty_open}, {"winpty_spawn", (FARPROC*)&winpty_spawn}, {"winpty_spawn_config_free", (FARPROC*)&winpty_spawn_config_free}, {"winpty_spawn_config_new", (FARPROC*)&winpty_spawn_config_new}, {"winpty_error_msg", (FARPROC*)&winpty_error_msg}, {"winpty_set_size", (FARPROC*)&winpty_set_size}, {"winpty_agent_process", (FARPROC*)&winpty_agent_process}, {NULL, NULL} }; // No need to initialize twice. if (hWinPtyDLL) return OK; // Load winpty.dll, prefer using the 'winptydll' option, fall back to just // winpty.dll. if (*p_winptydll != NUL) hWinPtyDLL = vimLoadLib((char *)p_winptydll); if (!hWinPtyDLL) hWinPtyDLL = vimLoadLib(WINPTY_DLL); if (!hWinPtyDLL) { if (verbose) semsg(_(e_could_not_load_library_str_str), (*p_winptydll != NUL ? p_winptydll : (char_u *)WINPTY_DLL), GetWin32Error()); return FAIL; } for (i = 0; winpty_entry[i].name != NULL && winpty_entry[i].ptr != NULL; ++i) { if ((*winpty_entry[i].ptr = (FARPROC)GetProcAddress(hWinPtyDLL, winpty_entry[i].name)) == NULL) { if (verbose) semsg(_(e_could_not_load_library_function_str), winpty_entry[i].name); hWinPtyDLL = NULL; return FAIL; } } return OK; } static int winpty_term_and_job_init( term_T *term, typval_T *argvar, char **argv UNUSED, jobopt_T *opt, jobopt_T *orig_opt) { WCHAR *cmd_wchar = NULL; WCHAR *cwd_wchar = NULL; WCHAR *env_wchar = NULL; channel_T *channel = NULL; job_T *job = NULL; DWORD error; HANDLE jo = NULL; HANDLE child_process_handle; HANDLE child_thread_handle; void *winpty_err = NULL; void *spawn_config = NULL; garray_T ga_cmd, ga_env; char_u *cmd = NULL; ga_init2(&ga_cmd, sizeof(char*), 20); ga_init2(&ga_env, sizeof(char*), 20); if (argvar->v_type == VAR_STRING) { cmd = argvar->vval.v_string; } else if (argvar->v_type == VAR_LIST) { if (win32_build_cmd(argvar->vval.v_list, &ga_cmd) == FAIL) goto failed; cmd = ga_cmd.ga_data; } if (cmd == NULL || *cmd == NUL) { emsg(_(e_invalid_argument)); goto failed; } term->tl_arg0_cmd = vim_strsave(cmd); cmd_wchar = enc_to_utf16(cmd, NULL); ga_clear(&ga_cmd); if (cmd_wchar == NULL) goto failed; if (opt->jo_cwd != NULL) cwd_wchar = enc_to_utf16(opt->jo_cwd, NULL); win32_build_env(opt->jo_env, &ga_env, TRUE); env_wchar = ga_env.ga_data; term->tl_winpty_config = winpty_config_new(0, &winpty_err); if (term->tl_winpty_config == NULL) goto failed; winpty_config_set_mouse_mode(term->tl_winpty_config, WINPTY_MOUSE_MODE_FORCE); winpty_config_set_initial_size(term->tl_winpty_config, term->tl_cols, term->tl_rows); term->tl_winpty = winpty_open(term->tl_winpty_config, &winpty_err); if (term->tl_winpty == NULL) goto failed; spawn_config = winpty_spawn_config_new( WINPTY_SPAWN_FLAG_AUTO_SHUTDOWN | WINPTY_SPAWN_FLAG_EXIT_AFTER_SHUTDOWN, NULL, cmd_wchar, cwd_wchar, env_wchar, &winpty_err); if (spawn_config == NULL) goto failed; channel = add_channel(); if (channel == NULL) goto failed; job = job_alloc(); if (job == NULL) goto failed; if (argvar->v_type == VAR_STRING) { int argc; build_argv_from_string(cmd, &job->jv_argv, &argc); } else { int argc; build_argv_from_list(argvar->vval.v_list, &job->jv_argv, &argc); } if (opt->jo_set & JO_IN_BUF) job->jv_in_buf = buflist_findnr(opt->jo_io_buf[PART_IN]); if (!winpty_spawn(term->tl_winpty, spawn_config, &child_process_handle, &child_thread_handle, &error, &winpty_err)) goto failed; channel_set_pipes(channel, (sock_T)CreateFileW( winpty_conin_name(term->tl_winpty), GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL), (sock_T)CreateFileW( winpty_conout_name(term->tl_winpty), GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL), (sock_T)CreateFileW( winpty_conerr_name(term->tl_winpty), GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)); // Write lines with CR instead of NL. channel->ch_write_text_mode = TRUE; jo = CreateJobObject(NULL, NULL); if (jo == NULL) goto failed; if (!AssignProcessToJobObject(jo, child_process_handle)) { // Failed, switch the way to terminate process with TerminateProcess. CloseHandle(jo); jo = NULL; } winpty_spawn_config_free(spawn_config); vim_free(cmd_wchar); vim_free(cwd_wchar); vim_free(env_wchar); if (create_vterm(term, term->tl_rows, term->tl_cols) == FAIL) goto failed; #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) if (term_use_palette()) { if (term->tl_palette != NULL) set_vterm_palette(term->tl_vterm, term->tl_palette); else init_vterm_ansi_colors(term->tl_vterm); } #endif channel_set_job(channel, job, opt); job_set_options(job, opt); job->jv_channel = channel; job->jv_proc_info.hProcess = child_process_handle; job->jv_proc_info.dwProcessId = GetProcessId(child_process_handle); job->jv_job_object = jo; job->jv_status = JOB_STARTED; job->jv_tty_in = utf16_to_enc( (short_u *)winpty_conin_name(term->tl_winpty), NULL); job->jv_tty_out = utf16_to_enc( (short_u *)winpty_conout_name(term->tl_winpty), NULL); job->jv_tty_type = vim_strsave((char_u *)"winpty"); ++job->jv_refcount; term->tl_job = job; // Redirecting stdout and stderr doesn't work at the job level. Instead // open the file here and handle it in. opt->jo_io was changed in // setup_job_options(), use the original flags here. if (orig_opt->jo_io[PART_OUT] == JIO_FILE) { char_u *fname = opt->jo_io_name[PART_OUT]; ch_log(channel, "Opening output file %s", fname); term->tl_out_fd = mch_fopen((char *)fname, WRITEBIN); if (term->tl_out_fd == NULL) semsg(_(e_cant_open_file_str), fname); } return OK; failed: ga_clear(&ga_cmd); ga_clear(&ga_env); vim_free(cmd_wchar); vim_free(cwd_wchar); if (spawn_config != NULL) winpty_spawn_config_free(spawn_config); if (channel != NULL) channel_clear(channel); if (job != NULL) { job->jv_channel = NULL; job_cleanup(job); } term->tl_job = NULL; if (jo != NULL) CloseHandle(jo); if (term->tl_winpty != NULL) winpty_free(term->tl_winpty); term->tl_winpty = NULL; if (term->tl_winpty_config != NULL) winpty_config_free(term->tl_winpty_config); term->tl_winpty_config = NULL; if (winpty_err != NULL) { char *msg = (char *)utf16_to_enc( (short_u *)winpty_error_msg(winpty_err), NULL); emsg(msg); winpty_error_free(winpty_err); } return FAIL; } /* * Create a new terminal of "rows" by "cols" cells. * Store a reference in "term". * Return OK or FAIL. */ static int term_and_job_init( term_T *term, typval_T *argvar, char **argv, jobopt_T *opt, jobopt_T *orig_opt) { int use_winpty = FALSE; int use_conpty = FALSE; int tty_type = *p_twt; has_winpty = dyn_winpty_init(FALSE) != FAIL ? TRUE : FALSE; has_conpty = dyn_conpty_init(FALSE) != FAIL ? TRUE : FALSE; if (!has_winpty && !has_conpty) // If neither is available give the errors for winpty, since when // conpty is not available it can't be installed either. return dyn_winpty_init(TRUE); if (opt->jo_tty_type != NUL) tty_type = opt->jo_tty_type; if (tty_type == NUL) { if (has_conpty && (is_conpty_stable() || !has_winpty)) use_conpty = TRUE; else if (has_winpty) use_winpty = TRUE; // else: error } else if (tty_type == 'w') // winpty { if (has_winpty) use_winpty = TRUE; } else if (tty_type == 'c') // conpty { if (has_conpty) use_conpty = TRUE; else return dyn_conpty_init(TRUE); } if (use_conpty) return conpty_term_and_job_init(term, argvar, argv, opt, orig_opt); if (use_winpty) return winpty_term_and_job_init(term, argvar, argv, opt, orig_opt); // error return dyn_winpty_init(TRUE); } static int create_pty_only(term_T *term, jobopt_T *options) { HANDLE hPipeIn = INVALID_HANDLE_VALUE; HANDLE hPipeOut = INVALID_HANDLE_VALUE; char in_name[80], out_name[80]; channel_T *channel = NULL; if (create_vterm(term, term->tl_rows, term->tl_cols) == FAIL) return FAIL; vim_snprintf(in_name, sizeof(in_name), "\\\\.\\pipe\\vim-%d-in-%d", GetCurrentProcessId(), curbuf->b_fnum); hPipeIn = CreateNamedPipe(in_name, PIPE_ACCESS_OUTBOUND, PIPE_TYPE_MESSAGE | PIPE_NOWAIT, PIPE_UNLIMITED_INSTANCES, 0, 0, NMPWAIT_NOWAIT, NULL); if (hPipeIn == INVALID_HANDLE_VALUE) goto failed; vim_snprintf(out_name, sizeof(out_name), "\\\\.\\pipe\\vim-%d-out-%d", GetCurrentProcessId(), curbuf->b_fnum); hPipeOut = CreateNamedPipe(out_name, PIPE_ACCESS_INBOUND, PIPE_TYPE_MESSAGE | PIPE_NOWAIT, PIPE_UNLIMITED_INSTANCES, 0, 0, 0, NULL); if (hPipeOut == INVALID_HANDLE_VALUE) goto failed; ConnectNamedPipe(hPipeIn, NULL); ConnectNamedPipe(hPipeOut, NULL); term->tl_job = job_alloc(); if (term->tl_job == NULL) goto failed; ++term->tl_job->jv_refcount; // behave like the job is already finished term->tl_job->jv_status = JOB_FINISHED; channel = add_channel(); if (channel == NULL) goto failed; term->tl_job->jv_channel = channel; channel->ch_keep_open = TRUE; channel->ch_named_pipe = TRUE; channel_set_pipes(channel, (sock_T)hPipeIn, (sock_T)hPipeOut, (sock_T)hPipeOut); channel_set_job(channel, term->tl_job, options); term->tl_job->jv_tty_in = vim_strsave((char_u*)in_name); term->tl_job->jv_tty_out = vim_strsave((char_u*)out_name); return OK; failed: if (hPipeIn != NULL) CloseHandle(hPipeIn); if (hPipeOut != NULL) CloseHandle(hPipeOut); return FAIL; } /* * Free the terminal emulator part of "term". */ static void term_free_vterm(term_T *term) { term_free_conpty(term); if (term->tl_winpty != NULL) winpty_free(term->tl_winpty); term->tl_winpty = NULL; if (term->tl_winpty_config != NULL) winpty_config_free(term->tl_winpty_config); term->tl_winpty_config = NULL; if (term->tl_vterm != NULL) vterm_free(term->tl_vterm); term->tl_vterm = NULL; } /* * Report the size to the terminal. */ static void term_report_winsize(term_T *term, int rows, int cols) { if (term->tl_conpty) conpty_term_report_winsize(term, rows, cols); if (term->tl_winpty) winpty_set_size(term->tl_winpty, cols, rows, NULL); } int terminal_enabled(void) { return dyn_winpty_init(FALSE) == OK || dyn_conpty_init(FALSE) == OK; } # else /////////////////////////////////////// // 3. Unix-like implementation. /* * Create a new terminal of "rows" by "cols" cells. * Start job for "cmd". * Store the pointers in "term". * When "argv" is not NULL then "argvar" is not used. * Return OK or FAIL. */ static int term_and_job_init( term_T *term, typval_T *argvar, char **argv, jobopt_T *opt, jobopt_T *orig_opt UNUSED) { term->tl_arg0_cmd = NULL; if (create_vterm(term, term->tl_rows, term->tl_cols) == FAIL) return FAIL; #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) if (term_use_palette()) { if (term->tl_palette != NULL) set_vterm_palette(term->tl_vterm, term->tl_palette); else init_vterm_ansi_colors(term->tl_vterm); } #endif // This may change a string in "argvar". term->tl_job = job_start(argvar, argv, opt, &term->tl_job); if (term->tl_job != NULL) ++term->tl_job->jv_refcount; return term->tl_job != NULL && term->tl_job->jv_channel != NULL && term->tl_job->jv_status != JOB_FAILED ? OK : FAIL; } static int create_pty_only(term_T *term, jobopt_T *opt) { if (create_vterm(term, term->tl_rows, term->tl_cols) == FAIL) return FAIL; term->tl_job = job_alloc(); if (term->tl_job == NULL) return FAIL; ++term->tl_job->jv_refcount; // behave like the job is already finished term->tl_job->jv_status = JOB_FINISHED; return mch_create_pty_channel(term->tl_job, opt); } /* * Free the terminal emulator part of "term". */ static void term_free_vterm(term_T *term) { if (term->tl_vterm != NULL) vterm_free(term->tl_vterm); term->tl_vterm = NULL; } /* * Report the size to the terminal. */ static void term_report_winsize(term_T *term, int rows, int cols) { // Use an ioctl() to report the new window size to the job. if (term->tl_job == NULL || term->tl_job->jv_channel == NULL) return; int fd = -1; int part; for (part = PART_OUT; part < PART_COUNT; ++part) { fd = term->tl_job->jv_channel->ch_part[part].ch_fd; if (mch_isatty(fd)) break; } if (part < PART_COUNT && mch_report_winsize(fd, rows, cols) == OK) mch_signal_job(term->tl_job, (char_u *)"winch"); } # endif #endif // FEAT_TERMINAL