diff options
Diffstat (limited to 'src/term/terminal.zig')
| -rw-r--r-- | src/term/terminal.zig | 208 |
1 files changed, 47 insertions, 161 deletions
diff --git a/src/term/terminal.zig b/src/term/terminal.zig index 02ae4b3c..2fe84d0e 100644 --- a/src/term/terminal.zig +++ b/src/term/terminal.zig @@ -419,85 +419,6 @@ fn asGhostRgb(rgb: [3]u8) GColor.RGB { return .{ .r = rgb[0], .g = rgb[1], .b = rgb[2] }; } -pub const PendingCommand = struct { - bytes: []u8 = &.{}, - wait: enum { none, spawn, input } = .none, -}; - -pub fn armShellSpawn(pane: *Pane) void { - std.debug.assert(pane.pending_command.bytes.len == 0); - pane.pending_command.wait = .spawn; -} - -/// Remembers a line pardes types into this terminal as the command it -/// started, for Kill: it runs from the shell's next C mark to its D. -/// ponytail: of several lines queued for a shell not up yet, only the last -/// is remembered, as the first of them. -pub fn noteCommand(pane: *Pane, line: []const u8) void { - const state = pane.terminal orelse return; - const word = std.mem.trim(u8, line, " \t")[0 .. std.mem.indexOfAny(u8, std.mem.trim(u8, line, " \t"), " \t") orelse std.mem.trim(u8, line, " \t").len]; - var sent: @typeInfo(@FieldType(Pane, "sent_command")).optional.child = .{ .seq = state.stream.handler.started +% 1 }; - sent.len = @intCast(@min(word.len, sent.word.len)); - @memcpy(sent.word[0..sent.len], word[0..sent.len]); - pane.sent_command = sent; -} - -/// Whether the command pardes last typed here is running now. -pub fn commandRunning(pane: *const Pane) bool { - const state = pane.terminal orelse return false; - const sent = pane.sent_command orelse return false; - const marks = &state.stream.handler; - return marks.phase == .running and marks.started == sent.seq; -} - -pub fn queuePendingCommand(pane: *Pane, command: []const u8) !bool { - if (pane.pending_command.wait == .none) return false; - const old_len = pane.pending_command.bytes.len; - const new_len = try std.math.add(usize, old_len, try std.math.add(usize, command.len, 1)); - const bytes = if (old_len == 0) - try pane.gpa.alloc(u8, new_len) - else - try pane.gpa.realloc(pane.pending_command.bytes, new_len); - @memcpy(bytes[old_len..][0..command.len], command); - bytes[new_len - 1] = '\r'; - pane.pending_command.bytes = bytes; - pane.greet = false; - return true; -} - -pub fn shellSpawned(p: *Pardes, id: usize, prompt_marks: bool) void { - const pane = p.panes[id] orelse return; - if (!pane.isTerminal() or pane.pending_command.wait != .spawn) return; - if (prompt_marks) { - pane.pending_command.wait = .input; - releasePendingCommand(p, id, pane, false); - } else { - pane.greet = false; - releasePendingCommand(p, id, pane, true); - } -} - -pub fn releasePendingCommandIfReady(p: *Pardes, id: usize, pane: *Pane) void { - if (pane.pending_command.wait == .input) - releasePendingCommand(p, id, pane, pardes.tape.value(.prompt, promptInputReady, .{pane})); -} - -fn releasePendingCommand(p: *Pardes, id: usize, pane: *Pane, ready: bool) void { - if (!ready) return; - const bytes = pane.pending_command.bytes; - pane.pending_command = .{}; - if (bytes.len > 0) { - p.emitWrite(id, bytes); - pane.gpa.free(bytes); - } -} - -pub fn deinitPendingCommand(pane: *Pane) void { - if (pane.pending_command.bytes.len > 0) - pane.gpa.free(pane.pending_command.bytes); - pane.pending_command = .{}; -} - /// Where a kitty client puts its temporary files: `$TMPDIR`, else /tmp /// (which ghostty accepts whatever this says). The environment block lives /// as long as the process and pardes never edits it (ChildEnv.exportVar). @@ -898,66 +819,64 @@ pub fn feed(state: *State, bytes: []const u8, track: []const i32, rows: []i32, e return .{ .rows = rows[0..track.len], .erased = erased[0..track.len], .cleared = cleared, .alive = alive != null, .failed = failed }; } -/// Whether a new terminal's greeting may be typed now: only at the shell's -/// first prompt (pardes's own marks: no command started; a prompt drawn -/// again for a resize is the same first prompt), with nothing -/// typed at it and no program on the alternate screen. Any later moment is `.never`, for good: something has run or -/// been typed first, and an `ls` then would go into it. A shell pardes -/// cannot mark has no first prompt to find, and is never greeted. -pub fn greeting(pane: *const Pane) enum { wait, now, never } { - if (pane.fs.unmarked) return .never; - // Text typed into the edit buffer that stands in for the prompt row. - if (pane.ovl) |o| if (o.text.len > 0) return .never; - const state = pane.terminal orelse return .wait; - const marks = &state.stream.handler; - // (Not `declined`: bash's first prompt comes after a D of its own.) - if (marks.started > 0) return .never; - // At a prompt's input (ghostty's semantic marks, pardes's or the - // shell's own), before any command pardes's marks saw run. - if (!promptInputReady(pane)) return .wait; - return if (promptInputEmpty(pane)) .now else .never; -} - -/// At a prompt's input: on the alternate screen too, where a program killed -/// there (htop, `sig KILL`) left the emulator and the shell then drew its -/// prompt, marks and all. A full-screen program draws no prompt marks. -pub fn promptInputReady(pane: *const Pane) bool { - const state = pane.terminal orelse return false; - return state.vt.screens.active.cursor.semantic_content == .input; +/// Where the shell is in its command cycle (`Term.Prompt`); all zero +/// without an emulator. +pub fn prompt(state: ?*State) Term.Prompt { + const s = state orelse return .{}; + const marks = &s.stream.handler; + const cursor = &s.vt.screens.active.cursor; + // At a prompt's input: on the alternate screen too, where a program + // killed there (htop, `sig KILL`) left the emulator and the shell then + // drew its prompt, marks and all. A full-screen program draws no + // prompt marks. + const ready = cursor.semantic_content == .input; + // Nothing typed on its line: no input left of the cursor and none + // under it (text typed and then Ctrl-A'd starts at the cursor). + // Nothing further right counts: that is where fish draws a right + // prompt, and fish suggests nothing on an empty line. + const empty = ready and empty: { + const row = cursor.page_pin.cells(.all); + for (row[0..@min(cursor.x + 1, row.len)]) |cell| + if (cell.semantic_content == .input and !cell.isEmpty()) break :empty false; + break :empty true; + }; + return .{ + .phase = switch (marks.phase) { + .none => .none, + .prompt => .prompt, + .input => .input, + .running => .running, + }, + .started = marks.started, + .prompts = marks.prompts, + .declined = marks.declined, + .continuation = marks.continuation, + .finished = if (marks.finished) |f| .{ .seq = f.seq, .status = f.status } else null, + .input_ready = ready, + .input_empty = empty, + .at_prompt = s.vt.cursorIsAtPrompt(), + }; } -pub const CommandOutput = struct { - /// Owned by the caller. - text: [:0]const u8, - /// Whether `text` starts where the command did. It does not when that - /// start is not there to read: cut off by `max_rows`, scrolled out of - /// the history or erased from it by ED 3 (ghostty flags the pin - /// `garbage`; an erased end leaves no text at all), erased under it - /// while it ran (`MarkedHandler.lost`), or never pinned (a C or D that - /// came on the alternate screen). - whole: bool, -}; - /// What the newest finished command printed: the screen text between its /// C and D marks, read from at most `max_rows` rows above its end, so a /// command that printed the whole history costs no more than its tail. /// The shell exited in the middle of a command (its `exit 3`): no end mark /// will come, so the command's output ends where the cursor is. -pub fn endOutputHere(pane: *Pane) void { - const state = pane.terminal orelse return; +pub fn endOutputHere(state: *State) void { const marks = &state.stream.handler; if (marks.phase == .running and marks.out_end == null) marks.pinCursor(&marks.out_end, true); } -pub fn commandOutput(pane: *Pane, gpa: std.mem.Allocator, max_rows: usize) !CommandOutput { +pub fn commandOutput(state: ?*State, gpa: std.mem.Allocator, max_rows: usize) !Term.CommandOutput { // Unless there is text to read, whether the nothing it printed is the // whole of it. const whole = printed: { - const state = pane.terminal orelse break :printed true; - const marks = &state.stream.handler; + const s = state orelse break :printed true; + const marks = &s.stream.handler; const start = marks.out_start orelse break :printed false; const end = marks.out_end orelse break :printed false; - const screen = state.vt.screens.get(.primary) orelse break :printed false; + const screen = s.vt.screens.get(.primary) orelse break :printed false; if (end.garbage) break :printed false; var whole = !marks.lost and !start.garbage; // Nothing printed: the whole of it. @@ -982,19 +901,6 @@ pub fn commandOutput(pane: *Pane, gpa: std.mem.Allocator, max_rows: usize) !Comm return .{ .text = try gpa.dupeSentinel(u8, "", 0), .whole = whole }; } -/// At a prompt with nothing typed on its line: no input left of the -/// cursor and none under it (text typed and then Ctrl-A'd starts at the -/// cursor). Nothing further right counts: that is where fish draws a -/// right prompt, and fish suggests nothing on an empty line. -pub fn promptInputEmpty(pane: *const Pane) bool { - if (!promptInputReady(pane)) return false; - const cursor = &pane.terminal.?.vt.screens.active.cursor; - const row = cursor.page_pin.cells(.all); - for (row[0..@min(cursor.x + 1, row.len)]) |cell| - if (cell.semantic_content == .input and !cell.isEmpty()) return false; - return true; -} - /// One key for its program, as the program's keyboard protocol and modes /// ask for it, written to `out`. pub fn key(state: *State, k: Key, out: *std.Io.Writer) !void { @@ -2008,26 +1914,6 @@ fn ghostColor(p: *Pardes, color: ghostty_vt.Style.Color, is_bg: bool) pardes.Col }; } -/// executing at a prompt with typed text below it: pad the output area -/// with newlines so the command's output doesn't overwrite the buffer -pub fn padOutputBelowEdits(p: *Pardes, id: usize) void { - // Nothing to pad away from: with no emulator there is no prompt and no - // child whose output could land on top of the edit buffer. - const pane = p.panes[id] orelse return; - const o = pane.ovl orelse return; - if (!pane.isTerminal()) return; - const state = pane.terminal orelse return; - if (!state.vt.cursorIsAtPrompt()) return; - // the buffer's LAST surface row: its lines may outnumber the shell - // rows it covers, and it is the bottom one output must clear - const max_row = o.row + @as(i32, @intCast(modal.lineCount(o.text))) - 1; - const goff: i32 = @intCast(state.vt.screens.active.pages.scrollbar().offset); - const cursor_abs = pane.surfRow(goff + @as(i32, @intCast(state.vt.screens.active.cursor.y))); - const pad = std.math.clamp(max_row - cursor_abs, 0, @as(i32, pane.rows)); - var i: i32 = 0; - while (i < pad) : (i += 1) p.emitWrite(id, "\r"); -} - pub fn pushUndo(p: *Pardes, pane: *Pane) error{OutOfMemory}!void { return pane.body.remember(p.gpa, pane.ovl); } @@ -2202,7 +2088,7 @@ test "document construction allocates only the pane and has inert terminal defau try std.testing.expectEqual(@as(usize, @sizeOf(Pane)), failing.allocated_bytes); try std.testing.expectEqual(Term.Grid{}, grid(pane.terminal)); try std.testing.expectEqual(Term.Modes{}, modes(pane.terminal)); - try std.testing.expect(!promptInputReady(pane)); + try std.testing.expectEqual(Term.Prompt{}, prompt(pane.terminal)); pane.scrollBy(100); pane.followOutput(); pane.resizeGrid(80, 24); @@ -2865,9 +2751,9 @@ test "a finished command's output erased by a later ED 3 is not called whole, an const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 6 }); defer p.deinit(); const pane = p.panes[0].?; - const prompt = "\x1b]133;A;cl=line;aid=pardes\x07$ \x1b]133;B;aid=pardes\x07"; - p.update(.{ .output = .{ .pane = 0, .bytes = prompt ++ "\r\n\x1b]133;C;aid=pardes\x07printed\r\n\x1b]133;D;0;aid=pardes\x07" ++ prompt } }); - const before = try commandOutput(pane, gpa, 100); + const marked = "\x1b]133;A;cl=line;aid=pardes\x07$ \x1b]133;B;aid=pardes\x07"; + p.update(.{ .output = .{ .pane = 0, .bytes = marked ++ "\r\n\x1b]133;C;aid=pardes\x07printed\r\n\x1b]133;D;0;aid=pardes\x07" ++ marked } }); + const before = try commandOutput(pane.terminal, gpa, 100); defer gpa.free(before.text); try std.testing.expect(before.whole); try std.testing.expect(std.mem.startsWith(u8, before.text, "printed")); @@ -2876,7 +2762,7 @@ test "a finished command's output erased by a later ED 3 is not called whole, an // where another program's text would be read as its output. p.update(.{ .output = .{ .pane = 0, .bytes = &lineBreaks(20) } }); p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[3J" } }); - const after = try commandOutput(pane, gpa, 100); + const after = try commandOutput(pane.terminal, gpa, 100); defer gpa.free(after.text); try std.testing.expect(!after.whole); try std.testing.expectEqualStrings("", after.text); |
