Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-05 15:50:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibVT/Terminal.cpp

1654 lines
51 KiB
C++
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
* Copyright (c) 2021, Daniel Bertalan <dani@danielbertalan.dev>
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 09:38:21 +01:00
*/
Everywhere: Hook up remaining debug macros to Debug.h.
2021-01-24 15:28:26 +01:00
#include <AK/Debug.h>
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
#include <AK/Queue.h>
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
#include <AK/StringBuilder.h>
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
#include <AK/StringView.h>
LibVT: Keep track of the 'true' line endings
2021-06-19 18:17:18 +04:30
#include <AK/TemporaryChange.h>
LibVT+Kernel: Create `Color` class Previously, we converted colors to their RGB values immediately when they were set. This meant that their semantic meaning was lost, we could not tell a precise RGB value apart from a named/indexed color. The new way of storing colors will allow us to retain this information, so we can change a color scheme on the fly, and previously emitted text will also be affected.
2021-05-27 19:19:30 +02:00
#include <LibVT/Color.h>
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
#include <LibVT/Terminal.h>
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 22:58:51 +03:00
#ifdef KERNEL
Kernel: Move TTY-related code to a new subdirectory under Devices The TTY subsystem is represented with unix devices, so it should be under the Devices directory like the Audio, Storage, GPU and HID subsystems.
2023-07-08 14:18:32 +03:00
# include <Kernel/Devices/TTY/VirtualConsole.h>
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 22:58:51 +03:00
#endif
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
namespace VT {
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 22:58:51 +03:00
#ifndef KERNEL
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
Terminal::Terminal(TerminalClient& client)
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 22:58:51 +03:00
#else
Terminal::Terminal(Kernel::VirtualConsole& client)
#endif
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
: m_client(client)
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
, m_parser(*this)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
}
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 22:58:51 +03:00
#ifndef KERNEL
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
void Terminal::clear()
{
LibVT: Fix `ECH` not clearing lines The `num` parameter should be treated as an offset from the cursor position, not from the beginning of the line. The previous behavior caused fragments of previous lines to be visible when moving the entire buffer in vim (e.g. with `gg` and `G`). The debug messages I used while fixing it are also included in this commit. These will help diagnose further issues if they arise.
2021-06-05 07:23:01 +02:00
dbgln_if(TERMINAL_DEBUG, "Clear the entire screen");
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
for (size_t i = 0; i < rows(); ++i)
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
active_buffer()[i]->clear();
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
set_cursor(0, 0);
}
LibVT+Kernel: Support clearing the scrollback buffer As per the `xterm ctlseqs` documentation, `\e3J` should clear the scrollback buffer, and leave the visible lines unchanged. This commit fixes a FIXME.
2021-06-05 09:29:49 +02:00
void Terminal::clear_history()
Terminal+LibVT: Add "clear including history" action (Ctrl+Shift+K) :^) Sometimes you just want to get rid of all your scrollback history in the terminal, and now there's a way to do that.
2020-07-05 23:34:02 +02:00
{
LibVT+Kernel: Support clearing the scrollback buffer As per the `xterm ctlseqs` documentation, `\e3J` should clear the scrollback buffer, and leave the visible lines unchanged. This commit fixes a FIXME.
2021-06-05 09:29:49 +02:00
dbgln_if(TERMINAL_DEBUG, "Clear history");
Kernel+LibVT: Fix selection with scrollback wrap-around If lines are removed from the tail of the scrollback buffer, the previous line indices will refer to different lines; therefore we need to offset them.
2021-06-05 16:46:33 +02:00
auto previous_history_size = m_history.size();
Terminal+LibVT: Add "clear including history" action (Ctrl+Shift+K) :^) Sometimes you just want to get rid of all your scrollback history in the terminal, and now there's a way to do that.
2020-07-05 23:34:02 +02:00
m_history.clear();
LibVT: Let Terminal keep history in a circular buffer This makes Terminal::scroll_up() O(1) instead of O(n) in the size of the history. (It's still O(n) in the size of visible lines.) Reduces time to run `disasm /bin/id` with the default terminal window size from 530ms to 409ms (min-of-5) on my system.
2020-09-09 19:06:57 -04:00
m_history_start = 0;
Kernel+LibVT: Fix selection with scrollback wrap-around If lines are removed from the tail of the scrollback buffer, the previous line indices will refer to different lines; therefore we need to offset them.
2021-06-05 16:46:33 +02:00
m_client.terminal_history_changed(-previous_history_size);
Terminal+LibVT: Add "clear including history" action (Ctrl+Shift+K) :^) Sometimes you just want to get rid of all your scrollback history in the terminal, and now there's a way to do that.
2020-07-05 23:34:02 +02:00
}
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 22:58:51 +03:00
#endif
Terminal+LibVT: Add "clear including history" action (Ctrl+Shift+K) :^) Sometimes you just want to get rid of all your scrollback history in the terminal, and now there's a way to do that.
2020-07-05 23:34:02 +02:00
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
void Terminal::alter_ansi_mode(bool should_set, Parameters params)
{
for (auto mode : params) {
switch (mode) {
// FIXME: implement *something* for this
default:
dbgln("Terminal::alter_ansi_mode: Unimplemented mode {} (should_set={})", mode, should_set);
break;
}
}
}
void Terminal::alter_private_mode(bool should_set, Parameters params)
LibVT: fix SM/RM not respecting private markers Since we now store intermediate characters separately, the intermediates should be checked for the presence of the '?' DEC private marker, not the first parameter.
2021-05-15 14:58:24 +02:00
{
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
for (auto mode : params) {
switch (mode) {
LibVT: Implement support for Cursor Keys Mode (DECCKM)
2021-09-30 11:44:20 +02:00
case 1:
// Cursor Keys Mode (DECCKM)
dbgln_if(TERMINAL_DEBUG, "Setting cursor keys mode (should_set={})", should_set);
m_cursor_keys_mode = should_set ? CursorKeysMode::Application : CursorKeysMode::Cursor;
break;
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
case 3: {
// 80/132-column mode (DECCOLM)
unsigned new_columns = should_set ? 132 : 80;
dbgln_if(TERMINAL_DEBUG, "Setting {}-column mode", new_columns);
set_size(new_columns, rows());
clear();
break;
}
case 12:
if (should_set) {
// Start blinking cursor
LibVT+Kernel: Separate the caret shapes and its steadiness Currently CursorStyle enum handles both the styles and the steadiness or blinking of the terminal caret, which doubles the amount of its entries. This commit changes CursorStyle to CursorShape and moves the blinking option to a seperate boolean value.
2022-05-12 22:52:14 +02:00
m_client.set_cursor_blinking(true);
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
} else {
// Stop blinking cursor
LibVT+Kernel: Separate the caret shapes and its steadiness Currently CursorStyle enum handles both the styles and the steadiness or blinking of the terminal caret, which doubles the amount of its entries. This commit changes CursorStyle to CursorShape and moves the blinking option to a seperate boolean value.
2022-05-12 22:52:14 +02:00
m_client.set_cursor_blinking(false);
LibVT: fix SM/RM not respecting private markers Since we now store intermediate characters separately, the intermediates should be checked for the presence of the '?' DEC private marker, not the first parameter.
2021-05-15 14:58:24 +02:00
}
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
break;
case 25:
if (should_set) {
// Show cursor
LibVT+Kernel: Separate the caret shapes and its steadiness Currently CursorStyle enum handles both the styles and the steadiness or blinking of the terminal caret, which doubles the amount of its entries. This commit changes CursorStyle to CursorShape and moves the blinking option to a seperate boolean value.
2022-05-12 22:52:14 +02:00
m_cursor_shape = m_saved_cursor_shape;
m_client.set_cursor_shape(m_cursor_shape);
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
} else {
// Hide cursor
LibVT+Kernel: Separate the caret shapes and its steadiness Currently CursorStyle enum handles both the styles and the steadiness or blinking of the terminal caret, which doubles the amount of its entries. This commit changes CursorStyle to CursorShape and moves the blinking option to a seperate boolean value.
2022-05-12 22:52:14 +02:00
m_saved_cursor_shape = m_cursor_shape;
m_cursor_shape = VT::CursorShape::None;
m_client.set_cursor_shape(VT::CursorShape::None);
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
}
break;
case 1047:
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
#ifndef KERNEL
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
if (should_set) {
dbgln_if(TERMINAL_DEBUG, "Switching to Alternate Screen Buffer");
m_use_alternate_screen_buffer = true;
clear();
LibVT: Reset scrollbar after switching to/from the alternate buffer We did not call the history change callback after switching to the alternate screen buffer, which caused the scrollbar to not change its maximum value. If we already had lines in the scrollback buffer, this meant that we could drag the scrollbar, which then tried to access non-existent lines from the scrollback. Fixes #8581
2021-07-09 17:36:23 +02:00
m_client.terminal_history_changed(-m_history.size());
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
} else {
dbgln_if(TERMINAL_DEBUG, "Switching to Normal Screen Buffer");
m_use_alternate_screen_buffer = false;
LibVT: Reset scrollbar after switching to/from the alternate buffer We did not call the history change callback after switching to the alternate screen buffer, which caused the scrollbar to not change its maximum value. If we already had lines in the scrollback buffer, this meant that we could drag the scrollbar, which then tried to access non-existent lines from the scrollback. Fixes #8581
2021-07-09 17:36:23 +02:00
m_client.terminal_history_changed(m_history.size());
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
}
m_need_full_flush = true;
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
#else
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
dbgln("Alternate Screen Buffer is not supported");
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
#endif
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
break;
case 1048:
if (should_set)
SCOSC();
else
SCORC();
break;
case 1049:
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
#ifndef KERNEL
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
if (should_set) {
dbgln_if(TERMINAL_DEBUG, "Switching to Alternate Screen Buffer and saving state");
m_normal_saved_state = m_current_state;
m_use_alternate_screen_buffer = true;
clear();
LibVT: Reset scrollbar after switching to/from the alternate buffer We did not call the history change callback after switching to the alternate screen buffer, which caused the scrollbar to not change its maximum value. If we already had lines in the scrollback buffer, this meant that we could drag the scrollbar, which then tried to access non-existent lines from the scrollback. Fixes #8581
2021-07-09 17:36:23 +02:00
m_client.terminal_history_changed(-m_history.size());
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
} else {
dbgln_if(TERMINAL_DEBUG, "Switching to Normal Screen Buffer and restoring state");
m_current_state = m_normal_saved_state;
m_use_alternate_screen_buffer = false;
set_cursor(cursor_row(), cursor_column());
LibVT: Reset scrollbar after switching to/from the alternate buffer We did not call the history change callback after switching to the alternate screen buffer, which caused the scrollbar to not change its maximum value. If we already had lines in the scrollback buffer, this meant that we could drag the scrollbar, which then tried to access non-existent lines from the scrollback. Fixes #8581
2021-07-09 17:36:23 +02:00
m_client.terminal_history_changed(m_history.size());
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
}
m_need_full_flush = true;
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
#else
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
dbgln("Alternate Screen Buffer is not supported");
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
#endif
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
break;
case 2004:
dbgln_if(TERMINAL_DEBUG, "Setting bracketed mode enabled={}", should_set);
m_needs_bracketed_paste = should_set;
break;
default:
dbgln("Terminal::alter_private_mode: Unimplemented private mode {} (should_set={})", mode, should_set);
break;
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
}
}
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
void Terminal::RM(Parameters params)
{
alter_ansi_mode(false, params);
}
void Terminal::DECRST(Parameters params)
LibVT: Replace escape$h_l with SM (Set Mode) / RM (Reset Mode)
2020-01-26 14:21:54 +00:00
{
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
alter_private_mode(false, params);
LibVT: Replace escape$h_l with SM (Set Mode) / RM (Reset Mode)
2020-01-26 14:21:54 +00:00
}
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
void Terminal::SM(Parameters params)
LibVT: Replace escape$h_l with SM (Set Mode) / RM (Reset Mode)
2020-01-26 14:21:54 +00:00
{
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
alter_ansi_mode(true, params);
}
void Terminal::DECSET(Parameters params)
{
alter_private_mode(true, params);
LibVT: Replace escape$h_l with SM (Set Mode) / RM (Reset Mode)
2020-01-26 14:21:54 +00:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::SGR(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
if (params.is_empty()) {
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
m_current_state.attribute.reset();
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
return;
}
LibVT+Kernel: Create `Color` class Previously, we converted colors to their RGB values immediately when they were set. This meant that their semantic meaning was lost, we could not tell a precise RGB value apart from a named/indexed color. The new way of storing colors will allow us to retain this information, so we can change a color scheme on the fly, and previously emitted text will also be affected.
2021-05-27 19:19:30 +02:00
auto parse_color = [&]() -> Optional<Color> {
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
if (params.size() < 2) {
dbgln("Color code has no type");
return {};
}
LibVT+Kernel: Create `Color` class Previously, we converted colors to their RGB values immediately when they were set. This meant that their semantic meaning was lost, we could not tell a precise RGB value apart from a named/indexed color. The new way of storing colors will allow us to retain this information, so we can change a color scheme on the fly, and previously emitted text will also be affected.
2021-05-27 19:19:30 +02:00
u32 rgb = 0;
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
switch (params[1]) {
LibVT: Support RGB colors (\x1b[38;2;<r>;<g>;<b>m)
2020-05-10 12:11:03 +04:30
case 5: // 8-bit
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
if (params.size() < 3) {
dbgln("8-bit color code has too few parameters");
return {};
}
LibVT+Kernel: Create `Color` class Previously, we converted colors to their RGB values immediately when they were set. This meant that their semantic meaning was lost, we could not tell a precise RGB value apart from a named/indexed color. The new way of storing colors will allow us to retain this information, so we can change a color scheme on the fly, and previously emitted text will also be affected.
2021-05-27 19:19:30 +02:00
if (params[2] > 255) {
dbgln("8-bit color code has out-of-bounds value");
return {};
}
return Color::indexed(params[2]);
LibVT: Support RGB colors (\x1b[38;2;<r>;<g>;<b>m)
2020-05-10 12:11:03 +04:30
case 2: // 24-bit
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
if (params.size() < 5) {
dbgln("24-bit color code has too few parameters");
return {};
}
LibVT: Support RGB colors (\x1b[38;2;<r>;<g>;<b>m)
2020-05-10 12:11:03 +04:30
for (size_t i = 0; i < 3; ++i) {
LibVT+Kernel: Create `Color` class Previously, we converted colors to their RGB values immediately when they were set. This meant that their semantic meaning was lost, we could not tell a precise RGB value apart from a named/indexed color. The new way of storing colors will allow us to retain this information, so we can change a color scheme on the fly, and previously emitted text will also be affected.
2021-05-27 19:19:30 +02:00
rgb <<= 8;
rgb |= params[i + 2];
LibVT: Support RGB colors (\x1b[38;2;<r>;<g>;<b>m)
2020-05-10 12:11:03 +04:30
}
LibVT+Kernel: Create `Color` class Previously, we converted colors to their RGB values immediately when they were set. This meant that their semantic meaning was lost, we could not tell a precise RGB value apart from a named/indexed color. The new way of storing colors will allow us to retain this information, so we can change a color scheme on the fly, and previously emitted text will also be affected.
2021-05-27 19:19:30 +02:00
return Color::rgb(rgb);
LibVT: Support RGB colors (\x1b[38;2;<r>;<g>;<b>m)
2020-05-10 12:11:03 +04:30
default:
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
dbgln("Unknown color type {}", params[1]);
return {};
LibVT: Support RGB colors (\x1b[38;2;<r>;<g>;<b>m)
2020-05-10 12:11:03 +04:30
}
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
};
LibVT: Support RGB colors (\x1b[38;2;<r>;<g>;<b>m)
2020-05-10 12:11:03 +04:30
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
if (params[0] == 38) {
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
m_current_state.attribute.foreground_color = parse_color().value_or(m_current_state.attribute.foreground_color);
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
} else if (params[0] == 48) {
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
m_current_state.attribute.background_color = parse_color().value_or(m_current_state.attribute.background_color);
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
} else {
// A single escape sequence may set multiple parameters.
for (auto param : params) {
switch (param) {
case 0:
// Reset
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
m_current_state.attribute.reset();
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
break;
case 1:
LibVT/Kernel: Make VT::Attribute::Flags enum class, use AK EnumBits Noticed the TODO in `Attribute.h` and realized we have as solution to this problem already. :^)
2022-03-17 23:14:50 -07:00
m_current_state.attribute.flags |= Attribute::Flags::Bold;
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
break;
case 3:
LibVT/Kernel: Make VT::Attribute::Flags enum class, use AK EnumBits Noticed the TODO in `Attribute.h` and realized we have as solution to this problem already. :^)
2022-03-17 23:14:50 -07:00
m_current_state.attribute.flags |= Attribute::Flags::Italic;
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
break;
case 4:
LibVT/Kernel: Make VT::Attribute::Flags enum class, use AK EnumBits Noticed the TODO in `Attribute.h` and realized we have as solution to this problem already. :^)
2022-03-17 23:14:50 -07:00
m_current_state.attribute.flags |= Attribute::Flags::Underline;
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
break;
case 5:
LibVT/Kernel: Make VT::Attribute::Flags enum class, use AK EnumBits Noticed the TODO in `Attribute.h` and realized we have as solution to this problem already. :^)
2022-03-17 23:14:50 -07:00
m_current_state.attribute.flags |= Attribute::Flags::Blink;
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
break;
case 7:
LibVT/Kernel: Make VT::Attribute::Flags enum class, use AK EnumBits Noticed the TODO in `Attribute.h` and realized we have as solution to this problem already. :^)
2022-03-17 23:14:50 -07:00
m_current_state.attribute.flags |= Attribute::Flags::Negative;
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
break;
case 22:
LibVT/Kernel: Make VT::Attribute::Flags enum class, use AK EnumBits Noticed the TODO in `Attribute.h` and realized we have as solution to this problem already. :^)
2022-03-17 23:14:50 -07:00
m_current_state.attribute.flags &= ~Attribute::Flags::Bold;
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
break;
case 23:
LibVT/Kernel: Make VT::Attribute::Flags enum class, use AK EnumBits Noticed the TODO in `Attribute.h` and realized we have as solution to this problem already. :^)
2022-03-17 23:14:50 -07:00
m_current_state.attribute.flags &= ~Attribute::Flags::Italic;
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
break;
case 24:
LibVT/Kernel: Make VT::Attribute::Flags enum class, use AK EnumBits Noticed the TODO in `Attribute.h` and realized we have as solution to this problem already. :^)
2022-03-17 23:14:50 -07:00
m_current_state.attribute.flags &= ~Attribute::Flags::Underline;
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
break;
case 25:
LibVT/Kernel: Make VT::Attribute::Flags enum class, use AK EnumBits Noticed the TODO in `Attribute.h` and realized we have as solution to this problem already. :^)
2022-03-17 23:14:50 -07:00
m_current_state.attribute.flags &= ~Attribute::Flags::Blink;
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
break;
case 27:
LibVT/Kernel: Make VT::Attribute::Flags enum class, use AK EnumBits Noticed the TODO in `Attribute.h` and realized we have as solution to this problem already. :^)
2022-03-17 23:14:50 -07:00
m_current_state.attribute.flags &= ~Attribute::Flags::Negative;
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
break;
case 30:
case 31:
case 32:
case 33:
case 34:
case 35:
case 36:
case 37:
// Foreground color
LibVT: Implement bright color support Previously, we only used bright colors when the bold attribute was set. We now have the option to set it via escape sequences. We also needed to make the bold text behavior optional, as some color schemes do weird things with it. For example, Solarized uses it for various shades of gray, so bold green would turn into a light shade of gray. The following new escape sequences are supported: - `CSI 90;m` to `CSI 97;m`: set bright foreground color - `CSI 100;m` to `CSI 107;m`: set bright background color
2021-06-03 17:26:25 +02:00
m_current_state.attribute.foreground_color = Color::named(static_cast<Color::ANSIColor>(param - 30));
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
break;
case 39:
// reset foreground
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
m_current_state.attribute.foreground_color = Attribute::default_foreground_color;
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
break;
case 40:
case 41:
case 42:
case 43:
case 44:
case 45:
case 46:
case 47:
// Background color
LibVT: Implement bright color support Previously, we only used bright colors when the bold attribute was set. We now have the option to set it via escape sequences. We also needed to make the bold text behavior optional, as some color schemes do weird things with it. For example, Solarized uses it for various shades of gray, so bold green would turn into a light shade of gray. The following new escape sequences are supported: - `CSI 90;m` to `CSI 97;m`: set bright foreground color - `CSI 100;m` to `CSI 107;m`: set bright background color
2021-06-03 17:26:25 +02:00
m_current_state.attribute.background_color = Color::named(static_cast<Color::ANSIColor>(param - 40));
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
break;
case 49:
// reset background
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
m_current_state.attribute.background_color = Attribute::default_background_color;
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
break;
LibVT: Implement bright color support Previously, we only used bright colors when the bold attribute was set. We now have the option to set it via escape sequences. We also needed to make the bold text behavior optional, as some color schemes do weird things with it. For example, Solarized uses it for various shades of gray, so bold green would turn into a light shade of gray. The following new escape sequences are supported: - `CSI 90;m` to `CSI 97;m`: set bright foreground color - `CSI 100;m` to `CSI 107;m`: set bright background color
2021-06-03 17:26:25 +02:00
case 90:
case 91:
case 92:
case 93:
case 94:
case 95:
case 96:
case 97:
// Bright foreground color
m_current_state.attribute.foreground_color = Color::named(static_cast<Color::ANSIColor>(8 + param - 90));
break;
case 100:
case 101:
case 102:
case 103:
case 104:
case 105:
case 106:
case 107:
// Bright background color
m_current_state.attribute.background_color = Color::named(static_cast<Color::ANSIColor>(8 + param - 100));
break;
LibVT: Correct color handling VT100's documentation says that more than one SGR (Set Graphics Rendition) parameters may be included in a single escape sequence. However, we treated those with more than 3 parameters as color sequences, so this behavior was not replicated.
2021-05-17 16:33:47 +02:00
default:
dbgln("FIXME: SGR: p: {}", param);
LibVT: Support RGB colors (\x1b[38;2;<r>;<g>;<b>m)
2020-05-10 12:11:03 +04:30
}
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
}
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::SCOSC()
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
dbgln_if(TERMINAL_DEBUG, "Save cursor position");
m_saved_cursor_position = m_current_state.cursor;
}
void Terminal::SCORC()
{
dbgln_if(TERMINAL_DEBUG, "Restore cursor position");
m_current_state.cursor = m_saved_cursor_position;
set_cursor(cursor_row(), cursor_column());
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
void Terminal::DECSC()
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
dbgln_if(TERMINAL_DEBUG, "Save cursor (and other state)");
if (m_use_alternate_screen_buffer) {
m_alternate_saved_state = m_current_state;
} else {
m_normal_saved_state = m_current_state;
}
}
void Terminal::DECRC()
{
dbgln_if(TERMINAL_DEBUG, "Restore cursor (and other state)");
if (m_use_alternate_screen_buffer) {
m_current_state = m_alternate_saved_state;
} else {
m_current_state = m_normal_saved_state;
}
set_cursor(cursor_row(), cursor_column());
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::XTERM_WM(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
if (params.size() < 1)
return;
LibVT: Add title stack support This feature allows applications to reset the window title once they exited. It is used by `vim` if `set title` is enabled.
2021-05-24 10:40:00 +02:00
switch (params[0]) {
case 22: {
LibVT: Remove Vector<Kernel::KString> title stack When using the kernel console, there's no such concept of title at all. Also, this makes vim to crash the kernel due to dereferencing a null pointer, so let's remove this as this is clearly not needed when using the kernel virtual console.
2022-07-14 05:53:13 +03:00
#ifndef KERNEL
LibVT: Add title stack support This feature allows applications to reset the window title once they exited. It is used by `vim` if `set title` is enabled.
2021-05-24 10:40:00 +02:00
if (params.size() > 1 && params[1] == 1) {
dbgln("FIXME: we don't support icon titles");
return;
}
dbgln_if(TERMINAL_DEBUG, "Title stack push: {}", m_current_window_title);
LibVT: Use NNOP<KString> to store window titles in the Kernel This will allow us to eventually propagate allocation failure.
2022-02-15 22:46:49 +02:00
(void)m_title_stack.try_append(move(m_current_window_title));
#endif
LibVT: Add title stack support This feature allows applications to reset the window title once they exited. It is used by `vim` if `set title` is enabled.
2021-05-24 10:40:00 +02:00
break;
}
case 23: {
LibVT: Remove Vector<Kernel::KString> title stack When using the kernel console, there's no such concept of title at all. Also, this makes vim to crash the kernel due to dereferencing a null pointer, so let's remove this as this is clearly not needed when using the kernel virtual console.
2022-07-14 05:53:13 +03:00
#ifndef KERNEL
LibVT: Add title stack support This feature allows applications to reset the window title once they exited. It is used by `vim` if `set title` is enabled.
2021-05-24 10:40:00 +02:00
if (params.size() > 1 && params[1] == 1)
return;
if (m_title_stack.is_empty()) {
dbgln("Shenanigans: Tried to pop from empty title stack");
return;
}
m_current_window_title = m_title_stack.take_last();
dbgln_if(TERMINAL_DEBUG, "Title stack pop: {}", m_current_window_title);
m_client.set_window_title(m_current_window_title);
LibVT: Use NNOP<KString> to store window titles in the Kernel This will allow us to eventually propagate allocation failure.
2022-02-15 22:46:49 +02:00
#endif
LibVT: Add title stack support This feature allows applications to reset the window title once they exited. It is used by `vim` if `set title` is enabled.
2021-05-24 10:40:00 +02:00
break;
}
default:
dbgln("FIXME: XTERM_WM: Ps: {} (param count: {})", params[0], params.size());
}
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::DECSTBM(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
unsigned top = 1;
unsigned bottom = m_rows;
LibVT: Fix issues running `nano` This commit fixes 3 correctness issues with the ANSI escape sequence handling logic: 1. Default parameters were not handled correctly: the specification says that 0-valued CSI escape sequence parameters should take their default values. 2. We did not call `scroll_{up, down}` when encountering RI/IND commands that reached the scroll margins. This caused nano to only scroll the first line.
2021-05-23 15:57:21 +02:00
if (params.size() >= 1 && params[0] != 0)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
top = params[0];
LibVT: Fix issues running `nano` This commit fixes 3 correctness issues with the ANSI escape sequence handling logic: 1. Default parameters were not handled correctly: the specification says that 0-valued CSI escape sequence parameters should take their default values. 2. We did not call `scroll_{up, down}` when encountering RI/IND commands that reached the scroll margins. This caused nano to only scroll the first line.
2021-05-23 15:57:21 +02:00
if (params.size() >= 2 && params[1] != 0)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
bottom = params[1];
if ((bottom - top) < 2 || bottom > m_rows) {
LibVT: Convert dbgprintf() => dbgln() and remove some debug code
2021-01-16 22:52:54 +01:00
dbgln("Error: DECSTBM: scrolling region invalid: {}-{}", top, bottom);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
return;
}
LibVT: Ignore DECSTBM with invalid values (#8559) Co-authored-by: pancake <pancake@nopcode.org>
2021-07-08 20:11:55 +02:00
if (top >= bottom) {
return;
}
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
m_scroll_region_top = top - 1;
m_scroll_region_bottom = bottom - 1;
set_cursor(0, 0);
LibVT: Fix issues running `nano` This commit fixes 3 correctness issues with the ANSI escape sequence handling logic: 1. Default parameters were not handled correctly: the specification says that 0-valued CSI escape sequence parameters should take their default values. 2. We did not call `scroll_{up, down}` when encountering RI/IND commands that reached the scroll margins. This caused nano to only scroll the first line.
2021-05-23 15:57:21 +02:00
dbgln_if(TERMINAL_DEBUG, "Set scrolling region: {}-{}", m_scroll_region_top, m_scroll_region_bottom);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::CUP(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT: Rename escape$H to CUP (Cursor Position)
2020-01-26 13:42:00 +00:00
// CUP – Cursor Position
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
unsigned row = 1;
unsigned col = 1;
LibVT: Fix issues running `nano` This commit fixes 3 correctness issues with the ANSI escape sequence handling logic: 1. Default parameters were not handled correctly: the specification says that 0-valued CSI escape sequence parameters should take their default values. 2. We did not call `scroll_{up, down}` when encountering RI/IND commands that reached the scroll margins. This caused nano to only scroll the first line.
2021-05-23 15:57:21 +02:00
if (params.size() >= 1 && params[0] != 0)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
row = params[0];
LibVT: Fix issues running `nano` This commit fixes 3 correctness issues with the ANSI escape sequence handling logic: 1. Default parameters were not handled correctly: the specification says that 0-valued CSI escape sequence parameters should take their default values. 2. We did not call `scroll_{up, down}` when encountering RI/IND commands that reached the scroll margins. This caused nano to only scroll the first line.
2021-05-23 15:57:21 +02:00
if (params.size() >= 2 && params[1] != 0)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
col = params[1];
set_cursor(row - 1, col - 1);
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::HVP(Parameters params)
LibVT: Support HVP (Horizontal and Vertical Position) (final 'f')
2020-01-25 19:49:42 +01:00
{
unsigned row = 1;
unsigned col = 1;
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
if (params.size() >= 1 && params[0] != 0)
LibVT: Support HVP (Horizontal and Vertical Position) (final 'f')
2020-01-25 19:49:42 +01:00
row = params[0];
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
if (params.size() >= 2 && params[1] != 0)
LibVT: Support HVP (Horizontal and Vertical Position) (final 'f')
2020-01-25 19:49:42 +01:00
col = params[1];
set_cursor(row - 1, col - 1);
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::CUU(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
unsigned num = 1;
if (params.size() >= 1 && params[0] != 0)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
num = params[0];
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
int new_row = cursor_row() - num;
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
if (new_row < 0)
new_row = 0;
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
set_cursor(new_row, cursor_column());
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::CUD(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
unsigned num = 1;
if (params.size() >= 1 && params[0] != 0)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
num = params[0];
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
unsigned new_row = cursor_row() + num;
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
if (new_row >= m_rows)
new_row = m_rows - 1;
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
set_cursor(new_row, cursor_column());
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::CUF(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
unsigned num = 1;
if (params.size() >= 1 && params[0] != 0)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
num = params[0];
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
unsigned new_column = cursor_column() + num;
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
if (new_column >= m_columns)
new_column = m_columns - 1;
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
set_cursor(cursor_row(), new_column);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::CUB(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
unsigned num = 1;
if (params.size() >= 1 && params[0] != 0)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
num = params[0];
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
int new_column = (int)cursor_column() - num;
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
if (new_column < 0)
new_column = 0;
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
set_cursor(cursor_row(), new_column);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Add missing cursor movement escape sequences This commit adds support for the following ANSI escape sequences: - `CNL` - Cursor Next Line - `CPL` - Cursor Previous Line - `VPR` - Line Position Relative - `HPA` - Character Position Absolute - `HPR` - Character Position Relative
2021-05-29 10:48:02 +02:00
void Terminal::CNL(Parameters params)
{
unsigned num = 1;
if (params.size() >= 1 && params[0] != 0)
num = params[0];
unsigned new_row = cursor_row() + num;
if (new_row >= m_columns)
new_row = m_columns - 1;
set_cursor(new_row, 0);
}
void Terminal::CPL(Parameters params)
{
unsigned num = 1;
if (params.size() >= 1 && params[0] != 0)
num = params[0];
int new_row = (int)cursor_row() - num;
if (new_row < 0)
new_row = 0;
set_cursor(new_row, 0);
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::CHA(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
unsigned new_column = 1;
if (params.size() >= 1 && params[0] != 0)
LibVT: Add missing cursor movement escape sequences This commit adds support for the following ANSI escape sequences: - `CNL` - Cursor Next Line - `CPL` - Cursor Previous Line - `VPR` - Line Position Relative - `HPA` - Character Position Absolute - `HPR` - Character Position Relative
2021-05-29 10:48:02 +02:00
new_column = params[0];
if (new_column > m_columns)
new_column = m_columns;
set_cursor(cursor_row(), new_column - 1);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::REP(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
unsigned count = 1;
if (params.size() >= 1 && params[0] != 0)
count = params[0];
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
for (unsigned i = 0; i < count; ++i)
put_character_at(m_current_state.cursor.row, m_current_state.cursor.column++, m_last_code_point);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::VPA(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
unsigned new_row = 1;
if (params.size() >= 1 && params[0] != 0)
LibVT: Add missing cursor movement escape sequences This commit adds support for the following ANSI escape sequences: - `CNL` - Cursor Next Line - `CPL` - Cursor Previous Line - `VPR` - Line Position Relative - `HPA` - Character Position Absolute - `HPR` - Character Position Relative
2021-05-29 10:48:02 +02:00
new_row = params[0];
if (new_row > m_rows)
new_row = m_rows;
set_cursor(new_row - 1, cursor_column());
}
void Terminal::VPR(Parameters params)
{
unsigned num = 1;
if (params.size() >= 1 && params[0] != 0)
num = params[0];
int new_row = cursor_row() + num;
if (new_row >= m_rows)
new_row = m_rows - 1;
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
set_cursor(new_row, cursor_column());
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Add missing cursor movement escape sequences This commit adds support for the following ANSI escape sequences: - `CNL` - Cursor Next Line - `CPL` - Cursor Previous Line - `VPR` - Line Position Relative - `HPA` - Character Position Absolute - `HPR` - Character Position Relative
2021-05-29 10:48:02 +02:00
void Terminal::HPA(Parameters params)
{
unsigned new_column = 1;
if (params.size() >= 1 && params[0] != 0)
new_column = params[0];
if (new_column > m_columns)
new_column = m_columns;
set_cursor(cursor_row(), new_column - 1);
}
void Terminal::HPR(Parameters params)
{
unsigned num = 1;
if (params.size() >= 1 && params[0] != 0)
num = params[0];
unsigned new_column = cursor_column() + num;
if (new_column >= m_columns)
new_column = m_columns - 1;
set_cursor(cursor_row(), new_column);
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::ECH(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
// Erase characters (without moving cursor)
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
unsigned num = 1;
if (params.size() >= 1 && params[0] != 0)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
num = params[0];
LibVT: Fix `ECH` not clearing lines The `num` parameter should be treated as an offset from the cursor position, not from the beginning of the line. The previous behavior caused fragments of previous lines to be visible when moving the entire buffer in vim (e.g. with `gg` and `G`). The debug messages I used while fixing it are also included in this commit. These will help diagnose further issues if they arise.
2021-06-05 07:23:01 +02:00
// Clear num characters from the right of the cursor.
auto clear_end = min<unsigned>(m_columns, cursor_column() + num - 1);
dbgln_if(TERMINAL_DEBUG, "Erase characters {}-{} on line {}", cursor_column(), clear_end, cursor_row());
Kernel+LibVT: Add function for deleting a range of characters Previously, this was done by telling the client to put a space at each character in the range. This was inefficient, because a large number of function calls took place and incorrect, as the ANSI standard dictates that character attributes should be cleared as well. The newly added `clear_in_line` function solves this issue. It performs just one bounds check when it's called and can be implemented as a pretty tight loop.
2021-06-05 11:12:00 +02:00
clear_in_line(cursor_row(), cursor_column(), clear_end);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::EL(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
unsigned mode = 0;
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
if (params.size() >= 1)
mode = params[0];
switch (mode) {
case 0:
LibVT: Fix `ECH` not clearing lines The `num` parameter should be treated as an offset from the cursor position, not from the beginning of the line. The previous behavior caused fragments of previous lines to be visible when moving the entire buffer in vim (e.g. with `gg` and `G`). The debug messages I used while fixing it are also included in this commit. These will help diagnose further issues if they arise.
2021-06-05 07:23:01 +02:00
dbgln_if(TERMINAL_DEBUG, "Clear line {} from cursor column ({}) to the end", cursor_row(), cursor_column());
Kernel+LibVT: Add function for deleting a range of characters Previously, this was done by telling the client to put a space at each character in the range. This was inefficient, because a large number of function calls took place and incorrect, as the ANSI standard dictates that character attributes should be cleared as well. The newly added `clear_in_line` function solves this issue. It performs just one bounds check when it's called and can be implemented as a pretty tight loop.
2021-06-05 11:12:00 +02:00
clear_in_line(cursor_row(), cursor_column(), m_columns - 1);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
break;
case 1:
LibVT: Fix `ECH` not clearing lines The `num` parameter should be treated as an offset from the cursor position, not from the beginning of the line. The previous behavior caused fragments of previous lines to be visible when moving the entire buffer in vim (e.g. with `gg` and `G`). The debug messages I used while fixing it are also included in this commit. These will help diagnose further issues if they arise.
2021-06-05 07:23:01 +02:00
dbgln_if(TERMINAL_DEBUG, "Clear line {} from the start to cursor column ({})", cursor_row(), cursor_column());
Kernel+LibVT: Add function for deleting a range of characters Previously, this was done by telling the client to put a space at each character in the range. This was inefficient, because a large number of function calls took place and incorrect, as the ANSI standard dictates that character attributes should be cleared as well. The newly added `clear_in_line` function solves this issue. It performs just one bounds check when it's called and can be implemented as a pretty tight loop.
2021-06-05 11:12:00 +02:00
clear_in_line(cursor_row(), 0, cursor_column());
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
break;
case 2:
LibVT: Fix `ECH` not clearing lines The `num` parameter should be treated as an offset from the cursor position, not from the beginning of the line. The previous behavior caused fragments of previous lines to be visible when moving the entire buffer in vim (e.g. with `gg` and `G`). The debug messages I used while fixing it are also included in this commit. These will help diagnose further issues if they arise.
2021-06-05 07:23:01 +02:00
dbgln_if(TERMINAL_DEBUG, "Clear line {} completely", cursor_row());
Kernel+LibVT: Add function for deleting a range of characters Previously, this was done by telling the client to put a space at each character in the range. This was inefficient, because a large number of function calls took place and incorrect, as the ANSI standard dictates that character attributes should be cleared as well. The newly added `clear_in_line` function solves this issue. It performs just one bounds check when it's called and can be implemented as a pretty tight loop.
2021-06-05 11:12:00 +02:00
clear_in_line(cursor_row(), 0, m_columns - 1);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
break;
default:
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
unimplemented_csi_sequence(params, {}, 'K');
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
break;
}
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::ED(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
unsigned mode = 0;
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
if (params.size() >= 1)
mode = params[0];
switch (mode) {
case 0:
LibVT: Fix `ECH` not clearing lines The `num` parameter should be treated as an offset from the cursor position, not from the beginning of the line. The previous behavior caused fragments of previous lines to be visible when moving the entire buffer in vim (e.g. with `gg` and `G`). The debug messages I used while fixing it are also included in this commit. These will help diagnose further issues if they arise.
2021-06-05 07:23:01 +02:00
dbgln_if(TERMINAL_DEBUG, "Clear from cursor ({},{}) to end of screen", cursor_row(), cursor_column());
Kernel+LibVT: Add function for deleting a range of characters Previously, this was done by telling the client to put a space at each character in the range. This was inefficient, because a large number of function calls took place and incorrect, as the ANSI standard dictates that character attributes should be cleared as well. The newly added `clear_in_line` function solves this issue. It performs just one bounds check when it's called and can be implemented as a pretty tight loop.
2021-06-05 11:12:00 +02:00
clear_in_line(cursor_row(), cursor_column(), m_columns - 1);
for (int row = cursor_row() + 1; row < m_rows; ++row)
clear_in_line(row, 0, m_columns - 1);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
break;
case 1:
LibVT: Fix `ECH` not clearing lines The `num` parameter should be treated as an offset from the cursor position, not from the beginning of the line. The previous behavior caused fragments of previous lines to be visible when moving the entire buffer in vim (e.g. with `gg` and `G`). The debug messages I used while fixing it are also included in this commit. These will help diagnose further issues if they arise.
2021-06-05 07:23:01 +02:00
dbgln_if(TERMINAL_DEBUG, "Clear from beginning of screen to cursor ({},{})", cursor_row(), cursor_column());
Kernel+LibVT: Add function for deleting a range of characters Previously, this was done by telling the client to put a space at each character in the range. This was inefficient, because a large number of function calls took place and incorrect, as the ANSI standard dictates that character attributes should be cleared as well. The newly added `clear_in_line` function solves this issue. It performs just one bounds check when it's called and can be implemented as a pretty tight loop.
2021-06-05 11:12:00 +02:00
clear_in_line(cursor_row(), 0, cursor_column());
for (int row = cursor_row() - 1; row >= 0; --row)
clear_in_line(row, 0, m_columns - 1);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
break;
case 2:
clear();
break;
case 3:
LibVT+Kernel: Support clearing the scrollback buffer As per the `xterm ctlseqs` documentation, `\e3J` should clear the scrollback buffer, and leave the visible lines unchanged. This commit fixes a FIXME.
2021-06-05 09:29:49 +02:00
clear_history();
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
break;
default:
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
unimplemented_csi_sequence(params, {}, 'J');
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
break;
}
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::SU(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT: Fix issues running `nano` This commit fixes 3 correctness issues with the ANSI escape sequence handling logic: 1. Default parameters were not handled correctly: the specification says that 0-valued CSI escape sequence parameters should take their default values. 2. We did not call `scroll_{up, down}` when encountering RI/IND commands that reached the scroll margins. This caused nano to only scroll the first line.
2021-05-23 15:57:21 +02:00
unsigned count = 1;
if (params.size() >= 1 && params[0] != 0)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
count = params[0];
LibVT+Kernel: Clean up scroll API This commit cleans up some of the `#ifdef`-ed code smell in `Terminal`, by extending the scroll APIs to take a range of lines as a parameter. This makes it possible to use the same code for `IL`/`DL` as for scrolling. Note that the current scrolling implementation is very naive, and does many insertions/deletions in the middle of arrays, whereas swaps should be enough. This optimization will come in a later commit. The `linefeed` override was removed from `VirtualConsole`. Previously, it exhibited incorrect behavior by moving to column 0. Now that we use the method defined in `Terminal`, code which relied on this behavior stopped working. We go instead go through the TTY layer which handles the various output flags. Passing the input character-by-character seems a bit excessive, so a fix for it will come in another PR.
2021-06-02 15:36:31 +02:00
scroll_up(count);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::SD(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT: Fix issues running `nano` This commit fixes 3 correctness issues with the ANSI escape sequence handling logic: 1. Default parameters were not handled correctly: the specification says that 0-valued CSI escape sequence parameters should take their default values. 2. We did not call `scroll_{up, down}` when encountering RI/IND commands that reached the scroll margins. This caused nano to only scroll the first line.
2021-05-23 15:57:21 +02:00
unsigned count = 1;
if (params.size() >= 1 && params[0] != 0)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
count = params[0];
LibVT+Kernel: Clean up scroll API This commit cleans up some of the `#ifdef`-ed code smell in `Terminal`, by extending the scroll APIs to take a range of lines as a parameter. This makes it possible to use the same code for `IL`/`DL` as for scrolling. Note that the current scrolling implementation is very naive, and does many insertions/deletions in the middle of arrays, whereas swaps should be enough. This optimization will come in a later commit. The `linefeed` override was removed from `VirtualConsole`. Previously, it exhibited incorrect behavior by moving to column 0. Now that we use the method defined in `Terminal`, code which relied on this behavior stopped working. We go instead go through the TTY layer which handles the various output flags. Passing the input character-by-character seems a bit excessive, so a fix for it will come in another PR.
2021-06-02 15:36:31 +02:00
scroll_down(count);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT+Kernel: Add support for setting cursor styles This commit introduces support for 3 new escape sequences: 1. Stop blinking cursor mode 2. `DECTCEM` mode (enable/disable cursor) 3. `DECSCUSR` (set cursor style) `TerminalWidget` now supports the following cursor types: block, underline and vertical bar. Each of these can blink or be steady. `VirtualConsole` ignores these (just as we were doing before).
2021-05-24 09:36:41 +02:00
void Terminal::DECSCUSR(Parameters params)
{
unsigned style = 1;
if (params.size() >= 1 && params[0] != 0)
style = params[0];
switch (style) {
case 1:
LibVT+Kernel: Separate the caret shapes and its steadiness Currently CursorStyle enum handles both the styles and the steadiness or blinking of the terminal caret, which doubles the amount of its entries. This commit changes CursorStyle to CursorShape and moves the blinking option to a seperate boolean value.
2022-05-12 22:52:14 +02:00
m_client.set_cursor_shape(VT::CursorShape::Block);
m_client.set_cursor_blinking(true);
LibVT+Kernel: Add support for setting cursor styles This commit introduces support for 3 new escape sequences: 1. Stop blinking cursor mode 2. `DECTCEM` mode (enable/disable cursor) 3. `DECSCUSR` (set cursor style) `TerminalWidget` now supports the following cursor types: block, underline and vertical bar. Each of these can blink or be steady. `VirtualConsole` ignores these (just as we were doing before).
2021-05-24 09:36:41 +02:00
break;
case 2:
LibVT+Kernel: Separate the caret shapes and its steadiness Currently CursorStyle enum handles both the styles and the steadiness or blinking of the terminal caret, which doubles the amount of its entries. This commit changes CursorStyle to CursorShape and moves the blinking option to a seperate boolean value.
2022-05-12 22:52:14 +02:00
m_client.set_cursor_shape(VT::CursorShape::Block);
m_client.set_cursor_blinking(false);
LibVT+Kernel: Add support for setting cursor styles This commit introduces support for 3 new escape sequences: 1. Stop blinking cursor mode 2. `DECTCEM` mode (enable/disable cursor) 3. `DECSCUSR` (set cursor style) `TerminalWidget` now supports the following cursor types: block, underline and vertical bar. Each of these can blink or be steady. `VirtualConsole` ignores these (just as we were doing before).
2021-05-24 09:36:41 +02:00
break;
case 3:
LibVT+Kernel: Separate the caret shapes and its steadiness Currently CursorStyle enum handles both the styles and the steadiness or blinking of the terminal caret, which doubles the amount of its entries. This commit changes CursorStyle to CursorShape and moves the blinking option to a seperate boolean value.
2022-05-12 22:52:14 +02:00
m_client.set_cursor_shape(VT::CursorShape::Underline);
m_client.set_cursor_blinking(true);
LibVT+Kernel: Add support for setting cursor styles This commit introduces support for 3 new escape sequences: 1. Stop blinking cursor mode 2. `DECTCEM` mode (enable/disable cursor) 3. `DECSCUSR` (set cursor style) `TerminalWidget` now supports the following cursor types: block, underline and vertical bar. Each of these can blink or be steady. `VirtualConsole` ignores these (just as we were doing before).
2021-05-24 09:36:41 +02:00
break;
case 4:
LibVT+Kernel: Separate the caret shapes and its steadiness Currently CursorStyle enum handles both the styles and the steadiness or blinking of the terminal caret, which doubles the amount of its entries. This commit changes CursorStyle to CursorShape and moves the blinking option to a seperate boolean value.
2022-05-12 22:52:14 +02:00
m_client.set_cursor_shape(VT::CursorShape::Underline);
m_client.set_cursor_blinking(false);
LibVT+Kernel: Add support for setting cursor styles This commit introduces support for 3 new escape sequences: 1. Stop blinking cursor mode 2. `DECTCEM` mode (enable/disable cursor) 3. `DECSCUSR` (set cursor style) `TerminalWidget` now supports the following cursor types: block, underline and vertical bar. Each of these can blink or be steady. `VirtualConsole` ignores these (just as we were doing before).
2021-05-24 09:36:41 +02:00
break;
case 5:
LibVT+Kernel: Separate the caret shapes and its steadiness Currently CursorStyle enum handles both the styles and the steadiness or blinking of the terminal caret, which doubles the amount of its entries. This commit changes CursorStyle to CursorShape and moves the blinking option to a seperate boolean value.
2022-05-12 22:52:14 +02:00
m_client.set_cursor_shape(VT::CursorShape::Bar);
m_client.set_cursor_blinking(true);
LibVT+Kernel: Add support for setting cursor styles This commit introduces support for 3 new escape sequences: 1. Stop blinking cursor mode 2. `DECTCEM` mode (enable/disable cursor) 3. `DECSCUSR` (set cursor style) `TerminalWidget` now supports the following cursor types: block, underline and vertical bar. Each of these can blink or be steady. `VirtualConsole` ignores these (just as we were doing before).
2021-05-24 09:36:41 +02:00
break;
case 6:
LibVT+Kernel: Separate the caret shapes and its steadiness Currently CursorStyle enum handles both the styles and the steadiness or blinking of the terminal caret, which doubles the amount of its entries. This commit changes CursorStyle to CursorShape and moves the blinking option to a seperate boolean value.
2022-05-12 22:52:14 +02:00
m_client.set_cursor_shape(VT::CursorShape::Bar);
m_client.set_cursor_blinking(false);
LibVT+Kernel: Add support for setting cursor styles This commit introduces support for 3 new escape sequences: 1. Stop blinking cursor mode 2. `DECTCEM` mode (enable/disable cursor) 3. `DECSCUSR` (set cursor style) `TerminalWidget` now supports the following cursor types: block, underline and vertical bar. Each of these can blink or be steady. `VirtualConsole` ignores these (just as we were doing before).
2021-05-24 09:36:41 +02:00
break;
default:
dbgln("Unknown cursor style {}", style);
}
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::IL(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT+Kernel: Clean up scroll API This commit cleans up some of the `#ifdef`-ed code smell in `Terminal`, by extending the scroll APIs to take a range of lines as a parameter. This makes it possible to use the same code for `IL`/`DL` as for scrolling. Note that the current scrolling implementation is very naive, and does many insertions/deletions in the middle of arrays, whereas swaps should be enough. This optimization will come in a later commit. The `linefeed` override was removed from `VirtualConsole`. Previously, it exhibited incorrect behavior by moving to column 0. Now that we use the method defined in `Terminal`, code which relied on this behavior stopped working. We go instead go through the TTY layer which handles the various output flags. Passing the input character-by-character seems a bit excessive, so a fix for it will come in another PR.
2021-06-02 15:36:31 +02:00
size_t count = 1;
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
if (params.size() >= 1 && params[0] != 0)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
count = params[0];
LibVT+Kernel: Clean up scroll API This commit cleans up some of the `#ifdef`-ed code smell in `Terminal`, by extending the scroll APIs to take a range of lines as a parameter. This makes it possible to use the same code for `IL`/`DL` as for scrolling. Note that the current scrolling implementation is very naive, and does many insertions/deletions in the middle of arrays, whereas swaps should be enough. This optimization will come in a later commit. The `linefeed` override was removed from `VirtualConsole`. Previously, it exhibited incorrect behavior by moving to column 0. Now that we use the method defined in `Terminal`, code which relied on this behavior stopped working. We go instead go through the TTY layer which handles the various output flags. Passing the input character-by-character seems a bit excessive, so a fix for it will come in another PR.
2021-06-02 15:36:31 +02:00
if (!is_within_scroll_region(cursor_row())) {
dbgln("Shenanigans! Tried to insert line outside the scroll region");
return;
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT+Kernel: Clean up scroll API This commit cleans up some of the `#ifdef`-ed code smell in `Terminal`, by extending the scroll APIs to take a range of lines as a parameter. This makes it possible to use the same code for `IL`/`DL` as for scrolling. Note that the current scrolling implementation is very naive, and does many insertions/deletions in the middle of arrays, whereas swaps should be enough. This optimization will come in a later commit. The `linefeed` override was removed from `VirtualConsole`. Previously, it exhibited incorrect behavior by moving to column 0. Now that we use the method defined in `Terminal`, code which relied on this behavior stopped working. We go instead go through the TTY layer which handles the various output flags. Passing the input character-by-character seems a bit excessive, so a fix for it will come in another PR.
2021-06-02 15:36:31 +02:00
scroll_down(cursor_row(), m_scroll_region_bottom, count);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::DA(Parameters)
LibVT: Support the DA (Device Attributes) request (final 'c') This is used by vttest on startup to query the device for identity.
2020-01-25 19:12:08 +01:00
{
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
emit_string("\033[?1;0c"sv);
LibVT: Support the DA (Device Attributes) request (final 'c') This is used by vttest on startup to query the device for identity.
2020-01-25 19:12:08 +01:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::DL(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT+Kernel: Clean up scroll API This commit cleans up some of the `#ifdef`-ed code smell in `Terminal`, by extending the scroll APIs to take a range of lines as a parameter. This makes it possible to use the same code for `IL`/`DL` as for scrolling. Note that the current scrolling implementation is very naive, and does many insertions/deletions in the middle of arrays, whereas swaps should be enough. This optimization will come in a later commit. The `linefeed` override was removed from `VirtualConsole`. Previously, it exhibited incorrect behavior by moving to column 0. Now that we use the method defined in `Terminal`, code which relied on this behavior stopped working. We go instead go through the TTY layer which handles the various output flags. Passing the input character-by-character seems a bit excessive, so a fix for it will come in another PR.
2021-06-02 15:36:31 +02:00
size_t count = 1;
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
if (params.size() >= 1 && params[0] != 0)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
count = params[0];
LibVT+Kernel: Clean up scroll API This commit cleans up some of the `#ifdef`-ed code smell in `Terminal`, by extending the scroll APIs to take a range of lines as a parameter. This makes it possible to use the same code for `IL`/`DL` as for scrolling. Note that the current scrolling implementation is very naive, and does many insertions/deletions in the middle of arrays, whereas swaps should be enough. This optimization will come in a later commit. The `linefeed` override was removed from `VirtualConsole`. Previously, it exhibited incorrect behavior by moving to column 0. Now that we use the method defined in `Terminal`, code which relied on this behavior stopped working. We go instead go through the TTY layer which handles the various output flags. Passing the input character-by-character seems a bit excessive, so a fix for it will come in another PR.
2021-06-02 15:36:31 +02:00
if (!is_within_scroll_region(cursor_row())) {
dbgln("Shenanigans! Tried to delete line outside the scroll region");
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
return;
}
LibVT+Kernel: Clean up scroll API This commit cleans up some of the `#ifdef`-ed code smell in `Terminal`, by extending the scroll APIs to take a range of lines as a parameter. This makes it possible to use the same code for `IL`/`DL` as for scrolling. Note that the current scrolling implementation is very naive, and does many insertions/deletions in the middle of arrays, whereas swaps should be enough. This optimization will come in a later commit. The `linefeed` override was removed from `VirtualConsole`. Previously, it exhibited incorrect behavior by moving to column 0. Now that we use the method defined in `Terminal`, code which relied on this behavior stopped working. We go instead go through the TTY layer which handles the various output flags. Passing the input character-by-character seems a bit excessive, so a fix for it will come in another PR.
2021-06-02 15:36:31 +02:00
scroll_up(cursor_row(), m_scroll_region_bottom, count);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::DCH(Parameters params)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
int num = 1;
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
if (params.size() >= 1 && params[0] != 0)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
num = params[0];
Kernel+LibVT: Implement left-right scrolling This commit implements the left/right scrolling used in the `ICH`/`DCH` escape sequences for `VirtualConsole`. This brings us one step closer to VT420/xterm compatibility. We can now finally remove the last escape sequence related `ifdef`s.
2021-06-05 15:11:45 +02:00
num = min<int>(num, columns() - cursor_column());
scroll_left(cursor_row(), cursor_column(), num);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Fix newline handling Before this commit, we would jump to the first column after receiving the '\n' line feed character. This is not the correct behavior, as it should only move the cursor now. Translating the typed Return key into the correct CR LF ("\r\n") is the TTY's job, which was fixed in #7184. Fixes #6820 Fixes #6960
2021-05-17 16:25:35 +02:00
void Terminal::linefeed()
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
u16 new_row = cursor_row();
LibVT: Keep track of the 'true' line endings
2021-06-19 18:17:18 +04:30
#ifndef KERNEL
if (!m_controls_are_logically_generated)
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
active_buffer()[new_row]->set_terminated(m_column_before_carriage_return.value_or(cursor_column()));
LibVT: Keep track of the 'true' line endings
2021-06-19 18:17:18 +04:30
#endif
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
if (cursor_row() == m_scroll_region_bottom) {
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
scroll_up();
} else {
++new_row;
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
};
LibVT: Fix newline handling Before this commit, we would jump to the first column after receiving the '\n' line feed character. This is not the correct behavior, as it should only move the cursor now. Translating the typed Return key into the correct CR LF ("\r\n") is the TTY's job, which was fixed in #7184. Fixes #6820 Fixes #6960
2021-05-17 16:25:35 +02:00
// We shouldn't jump to the first column after receiving a line feed.
// The TTY will take care of generating the carriage return.
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
set_cursor(new_row, cursor_column());
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Fix newline handling Before this commit, we would jump to the first column after receiving the '\n' line feed character. This is not the correct behavior, as it should only move the cursor now. Translating the typed Return key into the correct CR LF ("\r\n") is the TTY's job, which was fixed in #7184. Fixes #6820 Fixes #6960
2021-05-17 16:25:35 +02:00
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::carriage_return()
{
LibVT+Kernel: Clean up scroll API This commit cleans up some of the `#ifdef`-ed code smell in `Terminal`, by extending the scroll APIs to take a range of lines as a parameter. This makes it possible to use the same code for `IL`/`DL` as for scrolling. Note that the current scrolling implementation is very naive, and does many insertions/deletions in the middle of arrays, whereas swaps should be enough. This optimization will come in a later commit. The `linefeed` override was removed from `VirtualConsole`. Previously, it exhibited incorrect behavior by moving to column 0. Now that we use the method defined in `Terminal`, code which relied on this behavior stopped working. We go instead go through the TTY layer which handles the various output flags. Passing the input character-by-character seems a bit excessive, so a fix for it will come in another PR.
2021-06-02 15:36:31 +02:00
dbgln_if(TERMINAL_DEBUG, "Carriage return");
LibVT: Keep track of the 'true' line endings
2021-06-19 18:17:18 +04:30
m_column_before_carriage_return = cursor_column();
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
set_cursor(cursor_row(), 0);
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
}
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
LibVT+Kernel: Clean up scroll API This commit cleans up some of the `#ifdef`-ed code smell in `Terminal`, by extending the scroll APIs to take a range of lines as a parameter. This makes it possible to use the same code for `IL`/`DL` as for scrolling. Note that the current scrolling implementation is very naive, and does many insertions/deletions in the middle of arrays, whereas swaps should be enough. This optimization will come in a later commit. The `linefeed` override was removed from `VirtualConsole`. Previously, it exhibited incorrect behavior by moving to column 0. Now that we use the method defined in `Terminal`, code which relied on this behavior stopped working. We go instead go through the TTY layer which handles the various output flags. Passing the input character-by-character seems a bit excessive, so a fix for it will come in another PR.
2021-06-02 15:36:31 +02:00
void Terminal::scroll_up(size_t count)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT+Kernel: Clean up scroll API This commit cleans up some of the `#ifdef`-ed code smell in `Terminal`, by extending the scroll APIs to take a range of lines as a parameter. This makes it possible to use the same code for `IL`/`DL` as for scrolling. Note that the current scrolling implementation is very naive, and does many insertions/deletions in the middle of arrays, whereas swaps should be enough. This optimization will come in a later commit. The `linefeed` override was removed from `VirtualConsole`. Previously, it exhibited incorrect behavior by moving to column 0. Now that we use the method defined in `Terminal`, code which relied on this behavior stopped working. We go instead go through the TTY layer which handles the various output flags. Passing the input character-by-character seems a bit excessive, so a fix for it will come in another PR.
2021-06-02 15:36:31 +02:00
scroll_up(m_scroll_region_top, m_scroll_region_bottom, count);
}
void Terminal::scroll_down(size_t count)
{
scroll_down(m_scroll_region_top, m_scroll_region_bottom, count);
}
#ifndef KERNEL
// Insert `count` blank lines at the bottom of the region. Text moves up, top lines get added to the scrollback.
void Terminal::scroll_up(u16 region_top, u16 region_bottom, size_t count)
{
VERIFY(region_top <= region_bottom);
VERIFY(region_bottom < rows());
// Only the specified region should be affected.
size_t region_size = region_bottom - region_top + 1;
count = min(count, region_size);
dbgln_if(TERMINAL_DEBUG, "Scroll up {} lines in region {}-{}", count, region_top, region_bottom);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
// NOTE: We have to invalidate the cursor first.
invalidate_cursor();
LibVT+Kernel: Clean up scroll API This commit cleans up some of the `#ifdef`-ed code smell in `Terminal`, by extending the scroll APIs to take a range of lines as a parameter. This makes it possible to use the same code for `IL`/`DL` as for scrolling. Note that the current scrolling implementation is very naive, and does many insertions/deletions in the middle of arrays, whereas swaps should be enough. This optimization will come in a later commit. The `linefeed` override was removed from `VirtualConsole`. Previously, it exhibited incorrect behavior by moving to column 0. Now that we use the method defined in `Terminal`, code which relied on this behavior stopped working. We go instead go through the TTY layer which handles the various output flags. Passing the input character-by-character seems a bit excessive, so a fix for it will come in another PR.
2021-06-02 15:36:31 +02:00
Kernel+LibVT: Fix selection with scrollback wrap-around If lines are removed from the tail of the scrollback buffer, the previous line indices will refer to different lines; therefore we need to offset them.
2021-06-05 16:46:33 +02:00
int history_delta = -count;
LibVT: Improve scrolling performance Previously, we would remove lines from the buffer, create new lines and insert them into the buffer when we scrolled. Since scrolling does not always happen at the last line, this meant `Line` objects were pointlessly moved forwards, and then immediately backwards. We now swap them in-place and clear those lines that are "inserted". As a result, performance is better and scrolling is smoother in `vim` and `nano`.
2021-06-05 08:55:33 +02:00
bool should_move_to_scrollback = !m_use_alternate_screen_buffer && max_history_size() != 0;
if (should_move_to_scrollback) {
Kernel+LibVT: Fix selection with scrollback wrap-around If lines are removed from the tail of the scrollback buffer, the previous line indices will refer to different lines; therefore we need to offset them.
2021-06-05 16:46:33 +02:00
auto remaining_lines = max_history_size() - history_size();
history_delta = (count > remaining_lines) ? remaining_lines - count : 0;
LibVT+Kernel: Clean up scroll API This commit cleans up some of the `#ifdef`-ed code smell in `Terminal`, by extending the scroll APIs to take a range of lines as a parameter. This makes it possible to use the same code for `IL`/`DL` as for scrolling. Note that the current scrolling implementation is very naive, and does many insertions/deletions in the middle of arrays, whereas swaps should be enough. This optimization will come in a later commit. The `linefeed` override was removed from `VirtualConsole`. Previously, it exhibited incorrect behavior by moving to column 0. Now that we use the method defined in `Terminal`, code which relied on this behavior stopped working. We go instead go through the TTY layer which handles the various output flags. Passing the input character-by-character seems a bit excessive, so a fix for it will come in another PR.
2021-06-02 15:36:31 +02:00
for (size_t i = 0; i < count; ++i)
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
add_line_to_history(move(active_buffer().at(region_top + i)));
LibVT: Improve scrolling performance Previously, we would remove lines from the buffer, create new lines and insert them into the buffer when we scrolled. Since scrolling does not always happen at the last line, this meant `Line` objects were pointlessly moved forwards, and then immediately backwards. We now swap them in-place and clear those lines that are "inserted". As a result, performance is better and scrolling is smoother in `vim` and `nano`.
2021-06-05 08:55:33 +02:00
}
LibVT+Kernel: Clean up scroll API This commit cleans up some of the `#ifdef`-ed code smell in `Terminal`, by extending the scroll APIs to take a range of lines as a parameter. This makes it possible to use the same code for `IL`/`DL` as for scrolling. Note that the current scrolling implementation is very naive, and does many insertions/deletions in the middle of arrays, whereas swaps should be enough. This optimization will come in a later commit. The `linefeed` override was removed from `VirtualConsole`. Previously, it exhibited incorrect behavior by moving to column 0. Now that we use the method defined in `Terminal`, code which relied on this behavior stopped working. We go instead go through the TTY layer which handles the various output flags. Passing the input character-by-character seems a bit excessive, so a fix for it will come in another PR.
2021-06-02 15:36:31 +02:00
LibVT: Improve scrolling performance Previously, we would remove lines from the buffer, create new lines and insert them into the buffer when we scrolled. Since scrolling does not always happen at the last line, this meant `Line` objects were pointlessly moved forwards, and then immediately backwards. We now swap them in-place and clear those lines that are "inserted". As a result, performance is better and scrolling is smoother in `vim` and `nano`.
2021-06-05 08:55:33 +02:00
// Move lines into their new place.
for (u16 row = region_top; row + count <= region_bottom; ++row)
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
swap(active_buffer().at(row), active_buffer().at(row + count));
LibVT: Improve scrolling performance Previously, we would remove lines from the buffer, create new lines and insert them into the buffer when we scrolled. Since scrolling does not always happen at the last line, this meant `Line` objects were pointlessly moved forwards, and then immediately backwards. We now swap them in-place and clear those lines that are "inserted". As a result, performance is better and scrolling is smoother in `vim` and `nano`.
2021-06-05 08:55:33 +02:00
// Clear 'new' lines at the bottom.
if (should_move_to_scrollback) {
// Since we moved the previous lines into history, we can't just clear them.
for (u16 row = region_bottom + 1 - count; row <= region_bottom; ++row)
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
active_buffer().at(row) = make<Line>(columns());
LibVT: Improve scrolling performance Previously, we would remove lines from the buffer, create new lines and insert them into the buffer when we scrolled. Since scrolling does not always happen at the last line, this meant `Line` objects were pointlessly moved forwards, and then immediately backwards. We now swap them in-place and clear those lines that are "inserted". As a result, performance is better and scrolling is smoother in `vim` and `nano`.
2021-06-05 08:55:33 +02:00
} else {
// The new lines haven't been moved and we don't want to leak memory.
for (u16 row = region_bottom + 1 - count; row <= region_bottom; ++row)
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
active_buffer()[row]->clear();
LibVT: Add scrollback history to VT::Terminal The default (hard-coded) history size is 500 lines. When the history is altered, the TerminalClient is notified via terminal_history_changed().
2019-08-19 19:07:52 +02:00
}
LibVT: Improve scrolling performance Previously, we would remove lines from the buffer, create new lines and insert them into the buffer when we scrolled. Since scrolling does not always happen at the last line, this meant `Line` objects were pointlessly moved forwards, and then immediately backwards. We now swap them in-place and clear those lines that are "inserted". As a result, performance is better and scrolling is smoother in `vim` and `nano`.
2021-06-05 08:55:33 +02:00
// Set dirty flag on swapped lines.
// The other lines have implicitly been set dirty by being cleared.
LibVT: Prevent `u16` underflow when resizing terminal to a height of 1 Resizing the Terminal window to its smallest size no longer crashes. Fixes #7296.
2022-11-25 22:51:42 +01:00
for (u16 row = region_top; row + count <= region_bottom; ++row)
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
active_buffer()[row]->set_dirty(true);
Kernel+LibVT: Fix selection with scrollback wrap-around If lines are removed from the tail of the scrollback buffer, the previous line indices will refer to different lines; therefore we need to offset them.
2021-06-05 16:46:33 +02:00
m_client.terminal_history_changed(history_delta);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT+Kernel: Clean up scroll API This commit cleans up some of the `#ifdef`-ed code smell in `Terminal`, by extending the scroll APIs to take a range of lines as a parameter. This makes it possible to use the same code for `IL`/`DL` as for scrolling. Note that the current scrolling implementation is very naive, and does many insertions/deletions in the middle of arrays, whereas swaps should be enough. This optimization will come in a later commit. The `linefeed` override was removed from `VirtualConsole`. Previously, it exhibited incorrect behavior by moving to column 0. Now that we use the method defined in `Terminal`, code which relied on this behavior stopped working. We go instead go through the TTY layer which handles the various output flags. Passing the input character-by-character seems a bit excessive, so a fix for it will come in another PR.
2021-06-02 15:36:31 +02:00
// Insert `count` blank lines at the top of the region. Text moves down. Does not affect the scrollback buffer.
void Terminal::scroll_down(u16 region_top, u16 region_bottom, size_t count)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT+Kernel: Clean up scroll API This commit cleans up some of the `#ifdef`-ed code smell in `Terminal`, by extending the scroll APIs to take a range of lines as a parameter. This makes it possible to use the same code for `IL`/`DL` as for scrolling. Note that the current scrolling implementation is very naive, and does many insertions/deletions in the middle of arrays, whereas swaps should be enough. This optimization will come in a later commit. The `linefeed` override was removed from `VirtualConsole`. Previously, it exhibited incorrect behavior by moving to column 0. Now that we use the method defined in `Terminal`, code which relied on this behavior stopped working. We go instead go through the TTY layer which handles the various output flags. Passing the input character-by-character seems a bit excessive, so a fix for it will come in another PR.
2021-06-02 15:36:31 +02:00
VERIFY(region_top <= region_bottom);
VERIFY(region_bottom < rows());
// Only the specified region should be affected.
size_t region_size = region_bottom - region_top + 1;
count = min(count, region_size);
dbgln_if(TERMINAL_DEBUG, "Scroll down {} lines in region {}-{}", count, region_top, region_bottom);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
// NOTE: We have to invalidate the cursor first.
invalidate_cursor();
LibVT+Kernel: Clean up scroll API This commit cleans up some of the `#ifdef`-ed code smell in `Terminal`, by extending the scroll APIs to take a range of lines as a parameter. This makes it possible to use the same code for `IL`/`DL` as for scrolling. Note that the current scrolling implementation is very naive, and does many insertions/deletions in the middle of arrays, whereas swaps should be enough. This optimization will come in a later commit. The `linefeed` override was removed from `VirtualConsole`. Previously, it exhibited incorrect behavior by moving to column 0. Now that we use the method defined in `Terminal`, code which relied on this behavior stopped working. We go instead go through the TTY layer which handles the various output flags. Passing the input character-by-character seems a bit excessive, so a fix for it will come in another PR.
2021-06-02 15:36:31 +02:00
LibVT: Improve scrolling performance Previously, we would remove lines from the buffer, create new lines and insert them into the buffer when we scrolled. Since scrolling does not always happen at the last line, this meant `Line` objects were pointlessly moved forwards, and then immediately backwards. We now swap them in-place and clear those lines that are "inserted". As a result, performance is better and scrolling is smoother in `vim` and `nano`.
2021-06-05 08:55:33 +02:00
// Move lines into their new place.
for (int row = region_bottom; row >= static_cast<int>(region_top + count); --row)
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
swap(active_buffer().at(row), active_buffer().at(row - count));
LibVT: Improve scrolling performance Previously, we would remove lines from the buffer, create new lines and insert them into the buffer when we scrolled. Since scrolling does not always happen at the last line, this meant `Line` objects were pointlessly moved forwards, and then immediately backwards. We now swap them in-place and clear those lines that are "inserted". As a result, performance is better and scrolling is smoother in `vim` and `nano`.
2021-06-05 08:55:33 +02:00
// Clear the 'new' lines at the top.
for (u16 row = region_top; row < region_top + count; ++row)
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
active_buffer()[row]->clear();
LibVT: Improve scrolling performance Previously, we would remove lines from the buffer, create new lines and insert them into the buffer when we scrolled. Since scrolling does not always happen at the last line, this meant `Line` objects were pointlessly moved forwards, and then immediately backwards. We now swap them in-place and clear those lines that are "inserted". As a result, performance is better and scrolling is smoother in `vim` and `nano`.
2021-06-05 08:55:33 +02:00
// Set dirty flag on swapped lines.
// The other lines have implicitly been set dirty by being cleared.
for (u16 row = region_top + count; row <= region_bottom; ++row)
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
active_buffer()[row]->set_dirty(true);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
Kernel+LibVT: Implement left-right scrolling This commit implements the left/right scrolling used in the `ICH`/`DCH` escape sequences for `VirtualConsole`. This brings us one step closer to VT420/xterm compatibility. We can now finally remove the last escape sequence related `ifdef`s.
2021-06-05 15:11:45 +02:00
// Insert `count` blank cells at the end of the line. Text moves left.
void Terminal::scroll_left(u16 row, u16 column, size_t count)
{
VERIFY(row < rows());
VERIFY(column < columns());
count = min<size_t>(count, columns() - column);
dbgln_if(TERMINAL_DEBUG, "Scroll left {} columns from line {} column {}", count, row, column);
auto& line = active_buffer()[row];
for (size_t i = column; i < columns() - count; ++i)
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
swap(line->cell_at(i), line->cell_at(i + count));
Kernel+LibVT: Implement left-right scrolling This commit implements the left/right scrolling used in the `ICH`/`DCH` escape sequences for `VirtualConsole`. This brings us one step closer to VT420/xterm compatibility. We can now finally remove the last escape sequence related `ifdef`s.
2021-06-05 15:11:45 +02:00
clear_in_line(row, columns() - count, columns() - 1);
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
line->set_dirty(true);
Kernel+LibVT: Implement left-right scrolling This commit implements the left/right scrolling used in the `ICH`/`DCH` escape sequences for `VirtualConsole`. This brings us one step closer to VT420/xterm compatibility. We can now finally remove the last escape sequence related `ifdef`s.
2021-06-05 15:11:45 +02:00
}
// Insert `count` blank cells after `row`. Text moves right.
void Terminal::scroll_right(u16 row, u16 column, size_t count)
{
VERIFY(row < rows());
VERIFY(column < columns());
count = min<size_t>(count, columns() - column);
dbgln_if(TERMINAL_DEBUG, "Scroll right {} columns from line {} column {}", count, row, column);
auto& line = active_buffer()[row];
for (int i = columns() - 1; i >= static_cast<int>(column + count); --i)
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
swap(line->cell_at(i), line->cell_at(i - count));
Kernel+LibVT: Implement left-right scrolling This commit implements the left/right scrolling used in the `ICH`/`DCH` escape sequences for `VirtualConsole`. This brings us one step closer to VT420/xterm compatibility. We can now finally remove the last escape sequence related `ifdef`s.
2021-06-05 15:11:45 +02:00
clear_in_line(row, column, column + count - 1);
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
line->set_dirty(true);
Kernel+LibVT: Implement left-right scrolling This commit implements the left/right scrolling used in the `ICH`/`DCH` escape sequences for `VirtualConsole`. This brings us one step closer to VT420/xterm compatibility. We can now finally remove the last escape sequence related `ifdef`s.
2021-06-05 15:11:45 +02:00
}
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 22:58:51 +03:00
void Terminal::put_character_at(unsigned row, unsigned column, u32 code_point)
{
VERIFY(row < rows());
VERIFY(column < columns());
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
auto& line = active_buffer()[row];
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
line->set_code_point(column, code_point);
line->attribute_at(column) = m_current_state.attribute;
line->attribute_at(column).flags |= Attribute::Flags::Touched;
line->set_dirty(true);
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 22:58:51 +03:00
m_last_code_point = code_point;
}
Kernel+LibVT: Add function for deleting a range of characters Previously, this was done by telling the client to put a space at each character in the range. This was inefficient, because a large number of function calls took place and incorrect, as the ANSI standard dictates that character attributes should be cleared as well. The newly added `clear_in_line` function solves this issue. It performs just one bounds check when it's called and can be implemented as a pretty tight loop.
2021-06-05 11:12:00 +02:00
void Terminal::clear_in_line(u16 row, u16 first_column, u16 last_column)
{
VERIFY(row < rows());
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
active_buffer()[row]->clear_range(first_column, last_column, m_current_state.attribute);
Kernel+LibVT: Add function for deleting a range of characters Previously, this was done by telling the client to put a space at each character in the range. This was inefficient, because a large number of function calls took place and incorrect, as the ANSI standard dictates that character attributes should be cleared as well. The newly added `clear_in_line` function solves this issue. It performs just one bounds check when it's called and can be implemented as a pretty tight loop.
2021-06-05 11:12:00 +02:00
}
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 22:58:51 +03:00
#endif
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
void Terminal::set_cursor(unsigned a_row, unsigned a_column, bool skip_debug)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
unsigned row = min(a_row, m_rows - 1u);
unsigned column = min(a_column, m_columns - 1u);
LibVT: Always clear "stomp" state when changing the cursor position This fixes a bug, where we mistakenly put a character in the next row if the cursor was told to move to the rightmost column when it was already there.
2021-12-28 13:28:21 +01:00
m_stomp = false;
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
if (row == cursor_row() && column == cursor_column())
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
return;
Everywhere: Rename ASSERT => VERIFY (...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
2021-02-23 20:42:32 +01:00
VERIFY(row < rows());
VERIFY(column < columns());
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
invalidate_cursor();
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
m_current_state.cursor.row = row;
m_current_state.cursor.column = column;
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
invalidate_cursor();
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
if (!skip_debug)
dbgln_if(TERMINAL_DEBUG, "Set cursor position: {},{}", cursor_row(), cursor_column());
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Support NEL (Next Line) I think this can just behave as if you sent a newline character ('\n').
2020-01-25 20:01:43 +01:00
void Terminal::NEL()
{
LibVT: Fix issues running `nano` This commit fixes 3 correctness issues with the ANSI escape sequence handling logic: 1. Default parameters were not handled correctly: the specification says that 0-valued CSI escape sequence parameters should take their default values. 2. We did not call `scroll_{up, down}` when encountering RI/IND commands that reached the scroll margins. This caused nano to only scroll the first line.
2021-05-23 15:57:21 +02:00
if (cursor_row() == m_scroll_region_bottom)
scroll_up();
else
set_cursor(cursor_row() + 1, 0);
LibVT: Support NEL (Next Line) I think this can just behave as if you sent a newline character ('\n').
2020-01-25 20:01:43 +01:00
}
LibVT: Support IND and RI (cursor down/up basically)
2020-01-25 20:17:50 +01:00
void Terminal::IND()
{
LibVT: Fix issues running `nano` This commit fixes 3 correctness issues with the ANSI escape sequence handling logic: 1. Default parameters were not handled correctly: the specification says that 0-valued CSI escape sequence parameters should take their default values. 2. We did not call `scroll_{up, down}` when encountering RI/IND commands that reached the scroll margins. This caused nano to only scroll the first line.
2021-05-23 15:57:21 +02:00
// Not equivalent to CUD: if we are at the bottom margin, we have to scroll up.
if (cursor_row() == m_scroll_region_bottom)
scroll_up();
else
set_cursor(cursor_row() + 1, cursor_column());
LibVT: Support IND and RI (cursor down/up basically)
2020-01-25 20:17:50 +01:00
}
void Terminal::RI()
{
LibVT: Fix issues running `nano` This commit fixes 3 correctness issues with the ANSI escape sequence handling logic: 1. Default parameters were not handled correctly: the specification says that 0-valued CSI escape sequence parameters should take their default values. 2. We did not call `scroll_{up, down}` when encountering RI/IND commands that reached the scroll margins. This caused nano to only scroll the first line.
2021-05-23 15:57:21 +02:00
// Not equivalent to CUU : if we at the top margin , we have to scroll down.
if (cursor_row() == m_scroll_region_top)
scroll_down();
else
set_cursor(cursor_row() - 1, cursor_column());
LibVT: Support IND and RI (cursor down/up basically)
2020-01-25 20:17:50 +01:00
}
LibVT: Implement `DECFI` and `DECBI` These escape sequences are the horizontal scrolling equivalents of `IND` and `RI`. Normally, they move the cursor forward or backward. But if they hit the margins (which we just treat as the first and last columns), they scroll the line. Another VT420 feature done.
2021-06-05 15:35:14 +02:00
void Terminal::DECFI()
{
if (cursor_column() == columns() - 1)
scroll_left(cursor_row(), 0, 1);
else
set_cursor(cursor_row(), cursor_column() + 1);
}
void Terminal::DECBI()
{
if (cursor_column() == 0)
scroll_right(cursor_row(), 0, 1);
else
set_cursor(cursor_row(), cursor_column() - 1);
}
LibVT: Implement `DECIC`/`DECDC` This commit adds support for these escape sequences that are used for scrolling multiple lines at once. In the current, unoptimized implementation, these just call the `scroll_left` and `scroll_right` APIs multiple times. It's a VT420 feature.
2021-06-09 21:50:44 +02:00
void Terminal::DECIC(Parameters params)
{
unsigned num = 1;
if (params.size() >= 1 && params[0] != 0)
num = params[0];
num = min<unsigned>(num, columns() - cursor_column());
for (unsigned row = cursor_row(); row <= m_scroll_region_bottom; ++row)
scroll_right(row, cursor_column(), num);
}
void Terminal::DECDC(Parameters params)
{
unsigned num = 1;
if (params.size() >= 1 && params[0] != 0)
num = params[0];
num = min<unsigned>(num, columns() - cursor_column());
for (unsigned row = cursor_row(); row <= m_scroll_region_bottom; ++row)
scroll_left(row, cursor_column(), num);
}
LibVT: Adjust some method names to align with documentation Align DECKPAM and DECKPNM method names with those from https://vt100.net/docs/vt100-ug/chapter3.html#DECKPAM
2023-12-05 04:40:57 +07:00
void Terminal::DECKPNM()
LibVT: Add stubs for DECPNM, DECPAM Still not implemented, but provides easier to grasp FIXMEs.
2021-09-30 11:43:17 +02:00
{
dbgln("FIXME: implement setting the keypad to numeric mode");
}
LibVT: Adjust some method names to align with documentation Align DECKPAM and DECKPNM method names with those from https://vt100.net/docs/vt100-ug/chapter3.html#DECKPAM
2023-12-05 04:40:57 +07:00
void Terminal::DECKPAM()
LibVT: Add stubs for DECPNM, DECPAM Still not implemented, but provides easier to grasp FIXMEs.
2021-09-30 11:43:17 +02:00
{
dbgln("FIXME: implement setting the keypad to application mode");
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::DSR(Parameters params)
LibVT: Implement Device Status Report (cursor position report)
2020-04-09 07:43:12 +04:30
{
LibVT: Respond to DSR 0 (device status) Also emit query responses in a single write() syscall instead of going character-at-a-time.
2020-05-09 10:38:57 +02:00
if (params.size() == 1 && params[0] == 5) {
// Device status
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
emit_string("\033[0n"sv); // Terminal status OK!
LibVT: Respond to DSR 0 (device status) Also emit query responses in a single write() syscall instead of going character-at-a-time.
2020-05-09 10:38:57 +02:00
} else if (params.size() == 1 && params[0] == 6) {
// Cursor position query
LibVT: Use StringBuilder's inline capacity instead of temporary Strings This let's us avoid heap allocations.
2022-02-15 21:12:30 +02:00
StringBuilder builder;
MUST(builder.try_appendff("\e[{};{}R", cursor_row() + 1, cursor_column() + 1)); // StringBuilder's inline capacity of 256 is enough to guarantee no allocations
emit_string(builder.string_view());
LibVT: Respond to DSR 0 (device status) Also emit query responses in a single write() syscall instead of going character-at-a-time.
2020-05-09 10:38:57 +02:00
} else {
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.Everything: The modifications in this commit were automatically made using the following command: find . -name '*.cpp' -exec sed -i -E 's/dbg\(\) << ("[^"{]*");/dbgln\(\1\);/' {} \;
2021-01-09 18:51:44 +01:00
dbgln("Unknown DSR");
LibVT: Respond to DSR 0 (device status) Also emit query responses in a single write() syscall instead of going character-at-a-time.
2020-05-09 10:38:57 +02:00
}
LibVT: Implement Device Status Report (cursor position report)
2020-04-09 07:43:12 +04:30
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::ICH(Parameters params)
LibVT: Implement ICH sequence.
2021-01-08 01:33:17 -05:00
{
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
unsigned num = 1;
if (params.size() >= 1 && params[0] != 0)
LibVT: Implement ICH sequence.
2021-01-08 01:33:17 -05:00
num = params[0];
Kernel+LibVT: Implement left-right scrolling This commit implements the left/right scrolling used in the `ICH`/`DCH` escape sequences for `VirtualConsole`. This brings us one step closer to VT420/xterm compatibility. We can now finally remove the last escape sequence related `ifdef`s.
2021-06-05 15:11:45 +02:00
num = min<unsigned>(num, columns() - cursor_column());
scroll_right(cursor_row(), cursor_column(), num);
LibVT: Implement ICH sequence.
2021-01-08 01:33:17 -05:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::on_input(u8 byte)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
m_parser.on_input(byte);
}
LibVT: Add incremental UTF-8 parsing to the terminal input handler Instead of relying on the GUI code to handle UTF-8, we now process and parse the incoming data into 32-bit codepoints ourselves. This means that you can now show emojis in the terminal and they will only take up one character cell each. :^)
2020-05-16 19:47:49 +02:00
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::emit_code_point(u32 code_point)
{
LibVT: Implement G0..G3 and VT100 translation table
2021-09-30 13:58:12 +02:00
auto working_set = m_working_sets[m_active_working_set_index];
code_point = m_character_set_translator.translate_code_point(working_set, code_point);
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
auto new_column = cursor_column() + 1;
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
if (new_column < columns()) {
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
put_character_at(cursor_row(), cursor_column(), code_point);
set_cursor(cursor_row(), new_column, true);
LibVT: Add incremental UTF-8 parsing to the terminal input handler Instead of relying on the GUI code to handle UTF-8, we now process and parse the incoming data into 32-bit codepoints ourselves. This means that you can now show emojis in the terminal and they will only take up one character cell each. :^)
2020-05-16 19:47:49 +02:00
return;
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
if (m_stomp) {
m_stomp = false;
LibVT: Keep track of the 'true' line endings
2021-06-19 18:17:18 +04:30
TemporaryChange change { m_controls_are_logically_generated, true };
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
carriage_return();
LibVT: Fix newline handling Before this commit, we would jump to the first column after receiving the '\n' line feed character. This is not the correct behavior, as it should only move the cursor now. Translating the typed Return key into the correct CR LF ("\r\n") is the TTY's job, which was fixed in #7184. Fixes #6820 Fixes #6960
2021-05-17 16:25:35 +02:00
linefeed();
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
put_character_at(cursor_row(), cursor_column(), code_point);
set_cursor(cursor_row(), 1);
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
} else {
// Curious: We wait once on the right-hand side
m_stomp = true;
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
put_character_at(cursor_row(), cursor_column(), code_point);
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
}
}
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::execute_control_code(u8 code)
{
LibVT: Keep track of the 'true' line endings
2021-06-19 18:17:18 +04:30
ArmedScopeGuard clear_position_before_cr {
[&] {
m_column_before_carriage_return.clear();
}
};
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
switch (code) {
case '\a':
m_client.beep();
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
return;
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
case '\b':
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
if (cursor_column()) {
set_cursor(cursor_row(), cursor_column() - 1);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
return;
}
return;
case '\t': {
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
for (unsigned i = cursor_column() + 1; i < columns(); ++i) {
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
if (m_horizontal_tabs[i]) {
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
set_cursor(cursor_row(), i);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
return;
}
}
return;
}
case '\n':
LibVT: Fix newline handling Before this commit, we would jump to the first column after receiving the '\n' line feed character. This is not the correct behavior, as it should only move the cursor now. Translating the typed Return key into the correct CR LF ("\r\n") is the TTY's job, which was fixed in #7184. Fixes #6820 Fixes #6960
2021-05-17 16:25:35 +02:00
case '\v':
case '\f':
LibVT: Keep track of the 'true' line endings
2021-06-19 18:17:18 +04:30
if (m_column_before_carriage_return == m_columns - 1)
m_column_before_carriage_return = m_columns;
LibVT: Fix newline handling Before this commit, we would jump to the first column after receiving the '\n' line feed character. This is not the correct behavior, as it should only move the cursor now. Translating the typed Return key into the correct CR LF ("\r\n") is the TTY's job, which was fixed in #7184. Fixes #6820 Fixes #6960
2021-05-17 16:25:35 +02:00
linefeed();
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
return;
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
case '\r':
carriage_return();
LibVT: Keep track of the 'true' line endings
2021-06-19 18:17:18 +04:30
clear_position_before_cr.disarm();
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
return;
default:
unimplemented_control_code(code);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
}
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::execute_escape_sequence(Intermediates intermediates, bool ignore, u8 last_byte)
{
// FIXME: Handle it somehow?
if (ignore)
dbgln("Escape sequence has its ignore flag set.");
if (intermediates.size() == 0) {
switch (last_byte) {
case 'D':
IND();
return;
case 'E':
NEL();
return;
case 'M':
RI();
return;
LibVT: Implement ST (ESC \) escape sequence Closes #7175
2021-05-16 13:14:37 +00:00
case '\\':
// ST (string terminator) -- do nothing
LibVT: Run clang-format on Terminal.cpp Some trailing whitespace is causing the CI to fail. :^)
2021-05-16 15:16:50 +01:00
return;
LibVT: Implement `DECFI` and `DECBI` These escape sequences are the horizontal scrolling equivalents of `IND` and `RI`. Normally, they move the cursor forward or backward. But if they hit the margins (which we just treat as the first and last columns), they scroll the line. Another VT420 feature done.
2021-06-05 15:35:14 +02:00
case '6':
DECBI();
return;
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
case '7':
DECSC();
return;
case '8':
DECRC();
return;
LibVT: Implement `DECFI` and `DECBI` These escape sequences are the horizontal scrolling equivalents of `IND` and `RI`. Normally, they move the cursor forward or backward. But if they hit the margins (which we just treat as the first and last columns), they scroll the line. Another VT420 feature done.
2021-06-05 15:35:14 +02:00
case '9':
DECFI();
return;
LibVT: Add stubs for DECPNM, DECPAM Still not implemented, but provides easier to grasp FIXMEs.
2021-09-30 11:43:17 +02:00
case '=':
LibVT: Adjust some method names to align with documentation Align DECKPAM and DECKPNM method names with those from https://vt100.net/docs/vt100-ug/chapter3.html#DECKPAM
2023-12-05 04:40:57 +07:00
DECKPAM();
LibVT: Add stubs for DECPNM, DECPAM Still not implemented, but provides easier to grasp FIXMEs.
2021-09-30 11:43:17 +02:00
return;
case '>':
LibVT: Adjust some method names to align with documentation Align DECKPAM and DECKPNM method names with those from https://vt100.net/docs/vt100-ug/chapter3.html#DECKPAM
2023-12-05 04:40:57 +07:00
DECKPNM();
LibVT: Add stubs for DECPNM, DECPAM Still not implemented, but provides easier to grasp FIXMEs.
2021-09-30 11:43:17 +02:00
return;
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
}
LibVT: Implement G0..G3 and VT100 translation table
2021-09-30 13:58:12 +02:00
unimplemented_escape_sequence(intermediates, last_byte);
return;
}
char intermediate = intermediates[0];
switch (intermediate) {
case '#':
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
switch (last_byte) {
case '8':
// Confidence Test - Fill screen with E's
for (size_t row = 0; row < m_rows; ++row) {
for (size_t column = 0; column < m_columns; ++column) {
put_character_at(row, column, 'E');
}
}
return;
}
LibVT: Implement G0..G3 and VT100 translation table
2021-09-30 13:58:12 +02:00
break;
case '(':
case ')':
case '*':
case '+':
// Determine G0..G3 index
size_t working_set_index = intermediate - '(';
CharacterSet new_set;
switch (last_byte) {
case 'B':
new_set = CharacterSet::Iso_8859_1;
break;
case '0':
new_set = CharacterSet::VT100;
break;
case 'U':
new_set = CharacterSet::Null;
break;
case 'K':
new_set = CharacterSet::UserDefined;
break;
default:
unimplemented_escape_sequence(intermediates, last_byte);
return;
}
dbgln_if(TERMINAL_DEBUG, "Setting G{} working set to character set {}", working_set_index, to_underlying(new_set));
VERIFY(working_set_index <= 3);
m_working_sets[working_set_index] = new_set;
return;
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
}
LibVT: Implement G0..G3 and VT100 translation table
2021-09-30 13:58:12 +02:00
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
unimplemented_escape_sequence(intermediates, last_byte);
LibVT: Add incremental UTF-8 parsing to the terminal input handler Instead of relying on the GUI code to handle UTF-8, we now process and parse the incoming data into 32-bit codepoints ourselves. This means that you can now show emojis in the terminal and they will only take up one character cell each. :^)
2020-05-16 19:47:49 +02:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::execute_csi_sequence(Parameters parameters, Intermediates intermediates, bool ignore, u8 last_byte)
LibVT: Add incremental UTF-8 parsing to the terminal input handler Instead of relying on the GUI code to handle UTF-8, we now process and parse the incoming data into 32-bit codepoints ourselves. This means that you can now show emojis in the terminal and they will only take up one character cell each. :^)
2020-05-16 19:47:49 +02:00
{
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
// FIXME: Handle it somehow?
if (ignore)
dbgln("CSI sequence has its ignore flag set.");
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
if (intermediates.is_empty()) {
switch (last_byte) {
case '@':
return ICH(parameters);
case 'A':
return CUU(parameters);
case 'B':
return CUD(parameters);
case 'C':
return CUF(parameters);
case 'D':
return CUB(parameters);
case 'E':
return CNL(parameters);
case 'F':
return CPL(parameters);
case 'G':
return CHA(parameters);
case 'H':
return CUP(parameters);
case 'J':
return ED(parameters);
case 'K':
return EL(parameters);
case 'L':
return IL(parameters);
case 'M':
return DL(parameters);
case 'P':
return DCH(parameters);
case 'S':
return SU(parameters);
case 'T':
return SD(parameters);
case 'X':
return ECH(parameters);
case '`':
return HPA(parameters);
case 'a':
return HPR(parameters);
case 'b':
return REP(parameters);
case 'c':
return DA(parameters);
case 'd':
return VPA(parameters);
case 'e':
return VPR(parameters);
case 'f':
return HVP(parameters);
case 'h':
return SM(parameters);
case 'l':
return RM(parameters);
case 'm':
return SGR(parameters);
case 'n':
return DSR(parameters);
case 'r':
return DECSTBM(parameters);
case 's':
return SCOSC();
case 't':
return XTERM_WM(parameters);
case 'u':
return SCORC();
}
} else if (intermediates.size() == 1 && intermediates[0] == '?') {
switch (last_byte) {
case 'h':
return DECSET(parameters);
case 'l':
return DECRST(parameters);
}
} else if (intermediates.size() == 1 && intermediates[0] == '\'') {
switch (last_byte) {
case '}':
return DECIC(parameters);
case '~':
return DECDC(parameters);
}
} else if (intermediates.size() == 1 && intermediates[0] == ' ') {
switch (last_byte) {
case 'q':
return DECSCUSR(parameters);
}
LibVT: Add incremental UTF-8 parsing to the terminal input handler Instead of relying on the GUI code to handle UTF-8, we now process and parse the incoming data into 32-bit codepoints ourselves. This means that you can now show emojis in the terminal and they will only take up one character cell each. :^)
2020-05-16 19:47:49 +02:00
}
LibVT: Always check intermediate bytes in CSI sequences Previously, we only checked the intermediate bytes for those escape sequences that performed different operations based on their intermediate bytes. This lead to a crash when `CSI ?1001 r` was incorrectly parsed as `CSI Pt ; Pb r` (note the missing question mark), as seen in #8559.
2021-07-09 12:08:36 +02:00
unimplemented_csi_sequence(parameters, intermediates, last_byte);
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
}
void Terminal::execute_osc_sequence(OscParameters parameters, u8 last_byte)
{
auto stringview_ify = [&](size_t param_idx) {
LibVT: Fix progress bars not getting reset
2021-05-17 16:32:11 +02:00
return StringView(parameters[param_idx]);
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
};
LibVT: Fix progress bars not getting reset
2021-05-17 16:32:11 +02:00
if (parameters.size() == 0 || parameters[0].is_empty()) {
unimplemented_osc_sequence(parameters, last_byte);
return;
}
Everywhere: Use to_number<T> instead of to_{int,uint,float,double} In a bunch of cases, this actually ends up simplifying the code as to_number will handle something such as: ``` Optional<I> opt; if constexpr (IsSigned<I>) opt = view.to_int<I>(); else opt = view.to_uint<I>(); ``` For us. The main goal here however is to have a single generic number conversion API between all of the String classes.
2023-12-23 15:59:14 +13:00
auto command_number = stringview_ify(0).to_number<unsigned>();
LibVT: Fix progress bars not getting reset
2021-05-17 16:32:11 +02:00
if (!command_number.has_value()) {
unimplemented_osc_sequence(parameters, last_byte);
return;
}
switch (command_number.value()) {
case 0:
case 1:
case 2:
LibVT: Add title stack support This feature allows applications to reset the window title once they exited. It is used by `vim` if `set title` is enabled.
2021-05-24 10:40:00 +02:00
if (parameters.size() < 2) {
LibVT: Fix progress bars not getting reset
2021-05-17 16:32:11 +02:00
dbgln("Attempted to set window title without any parameters");
LibVT: Add title stack support This feature allows applications to reset the window title once they exited. It is used by `vim` if `set title` is enabled.
2021-05-24 10:40:00 +02:00
} else {
// FIXME: the split breaks titles containing semicolons.
// Should we expose the raw OSC string from the parser? Or join by semicolon?
LibVT: Remove Vector<Kernel::KString> title stack When using the kernel console, there's no such concept of title at all. Also, this makes vim to crash the kernel due to dereferencing a null pointer, so let's remove this as this is clearly not needed when using the kernel virtual console.
2022-07-14 05:53:13 +03:00
#ifndef KERNEL
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
m_current_window_title = stringview_ify(1).to_byte_string();
LibVT: Add title stack support This feature allows applications to reset the window title once they exited. It is used by `vim` if `set title` is enabled.
2021-05-24 10:40:00 +02:00
m_client.set_window_title(m_current_window_title);
LibVT: Use NNOP<KString> to store window titles in the Kernel This will allow us to eventually propagate allocation failure.
2022-02-15 22:46:49 +02:00
#endif
LibVT: Add title stack support This feature allows applications to reset the window title once they exited. It is used by `vim` if `set title` is enabled.
2021-05-24 10:40:00 +02:00
}
LibVT: Fix progress bars not getting reset
2021-05-17 16:32:11 +02:00
break;
case 8:
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 22:58:51 +03:00
#ifndef KERNEL
LibVT: Fix progress bars not getting reset
2021-05-17 16:32:11 +02:00
if (parameters.size() < 3) {
dbgln("Attempted to set href but gave too few parameters");
} else if (parameters[1].is_empty() && parameters[2].is_empty()) {
// Clear hyperlink
LibVT: Clear the href ID by setting it to None instead of ""
2023-10-16 21:31:15 +03:30
m_current_state.attribute.href = {};
m_current_state.attribute.href_id = {};
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
} else {
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
m_current_state.attribute.href = stringview_ify(2);
LibVT: Fix progress bars not getting reset
2021-05-17 16:32:11 +02:00
// FIXME: Respect the provided ID
Everywhere: Rename {Deprecated => Byte}String This commit un-deprecates DeprecatedString, and repurposes it as a byte string. As the null state has already been removed, there are no other particularly hairy blockers in repurposing this type as a byte string (what it _really_ is). This commit is auto-generated: $ xs=$(ack -l \bDeprecatedString\b\|deprecated_string AK Userland \ Meta Ports Ladybird Tests Kernel) $ perl -pie 's/\bDeprecatedString\b/ByteString/g; s/deprecated_string/byte_string/g' $xs $ clang-format --style=file -i \ $(git diff --name-only | grep \.cpp\|\.h) $ gn format $(git ls-files '*.gn' '*.gni')
2023-12-16 17:49:34 +03:30
m_current_state.attribute.href_id = ByteString::number(m_next_href_id++);
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
}
LibVT: Fix progress bars not getting reset
2021-05-17 16:32:11 +02:00
#endif
break;
case 9:
if (parameters.size() < 2)
dbgln("Atttempted to set window progress but gave too few parameters");
else if (parameters.size() == 2)
Everywhere: Use to_number<T> instead of to_{int,uint,float,double} In a bunch of cases, this actually ends up simplifying the code as to_number will handle something such as: ``` Optional<I> opt; if constexpr (IsSigned<I>) opt = view.to_int<I>(); else opt = view.to_uint<I>(); ``` For us. The main goal here however is to have a single generic number conversion API between all of the String classes.
2023-12-23 15:59:14 +13:00
m_client.set_window_progress(stringview_ify(1).to_number<int>().value_or(-1), 0);
LibVT: Fix progress bars not getting reset
2021-05-17 16:32:11 +02:00
else
Everywhere: Use to_number<T> instead of to_{int,uint,float,double} In a bunch of cases, this actually ends up simplifying the code as to_number will handle something such as: ``` Optional<I> opt; if constexpr (IsSigned<I>) opt = view.to_int<I>(); else opt = view.to_uint<I>(); ``` For us. The main goal here however is to have a single generic number conversion API between all of the String classes.
2023-12-23 15:59:14 +13:00
m_client.set_window_progress(stringview_ify(1).to_number<int>().value_or(-1), stringview_ify(2).to_number<int>().value_or(0));
LibVT: Fix progress bars not getting reset
2021-05-17 16:32:11 +02:00
break;
default:
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
unimplemented_osc_sequence(parameters, last_byte);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
}
LibVT: Fix progress bars not getting reset
2021-05-17 16:32:11 +02:00
void Terminal::dcs_hook(Parameters, Intermediates, bool, u8)
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
{
dbgln("Received DCS parameters, but we don't support it yet");
}
void Terminal::receive_dcs_char(u8 byte)
{
dbgln_if(TERMINAL_DEBUG, "DCS string character {:c}", byte);
}
void Terminal::execute_dcs_sequence()
{
}
Everywhere: Pass AK::StringView by value
2021-11-11 00:55:02 +01:00
void Terminal::inject_string(StringView str)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
AK: Use size_t for the length of strings Using int was a mistake. This patch changes String, StringImpl, StringView and StringBuilder to use size_t instead of int for lengths. Obviously a lot of code needs to change as a result of this.
2019-12-09 17:45:40 +01:00
for (size_t i = 0; i < str.length(); ++i)
LibVT: Tweak input parsing related names
2020-05-16 19:24:24 +02:00
on_input(str[i]);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
Everywhere: Pass AK::StringView by value
2021-11-11 00:55:02 +01:00
void Terminal::emit_string(StringView string)
LibVT: Support the DA (Device Attributes) request (final 'c') This is used by vttest on startup to query the device for identity.
2020-01-25 19:12:08 +01:00
{
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
m_client.emit((u8 const*)string.characters_without_null_termination(), string.length());
LibVT: Support the DA (Device Attributes) request (final 'c') This is used by vttest on startup to query the device for identity.
2020-01-25 19:12:08 +01:00
}
LibVT: Replace u8 type to u32 for code point Replace KeyEvent text attribute usage with code_point.
2020-06-13 13:56:39 +03:00
void Terminal::handle_key_press(KeyCode key, u32 code_point, u8 flags)
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
{
bool ctrl = flags & Mod_Ctrl;
bool alt = flags & Mod_Alt;
bool shift = flags & Mod_Shift;
LibVT+LibLine: Use `1;mods` CSI parameters for ctrl/alt/shift-arrow keys xterms send a bitmask (+ 1) in the 2nd CSI parameter if "special" keys (arrow keys, pgup/down, etc) are sent with modifiers held down. Serenity's Terminal used to send ^[[O, which is a nonexistent escape sequence and a misread of VT100's ^[O (ie the '[' is replaced by 'O'). Since the xterm scheme also supports shift and alt modifiers, switch to that. More flexible, and makes ctrl-left/right and alt-left/right work in SerenityOS's bash port. Also do this for page up/down. No behavior change for SerenityOS's Shell.
2020-09-13 21:08:19 -04:00
unsigned modifier_mask = int(shift) + (int(alt) << 1) + (int(ctrl) << 2);
auto emit_final_with_modifier = [this, modifier_mask](char final) {
LibVT: Implement support for Cursor Keys Mode (DECCKM)
2021-09-30 11:44:20 +02:00
char escape_character = m_cursor_keys_mode == CursorKeysMode::Application ? 'O' : '[';
LibVT: Use StringBuilder's inline capacity instead of temporary Strings This let's us avoid heap allocations.
2022-02-15 21:12:30 +02:00
StringBuilder builder;
LibVT+LibLine: Use `1;mods` CSI parameters for ctrl/alt/shift-arrow keys xterms send a bitmask (+ 1) in the 2nd CSI parameter if "special" keys (arrow keys, pgup/down, etc) are sent with modifiers held down. Serenity's Terminal used to send ^[[O, which is a nonexistent escape sequence and a misread of VT100's ^[O (ie the '[' is replaced by 'O'). Since the xterm scheme also supports shift and alt modifiers, switch to that. More flexible, and makes ctrl-left/right and alt-left/right work in SerenityOS's bash port. Also do this for page up/down. No behavior change for SerenityOS's Shell.
2020-09-13 21:08:19 -04:00
if (modifier_mask)
LibVT: Use StringBuilder's inline capacity instead of temporary Strings This let's us avoid heap allocations.
2022-02-15 21:12:30 +02:00
MUST(builder.try_appendff("\e{}1;{}{:c}", escape_character, modifier_mask + 1, final)); // StringBuilder's inline capacity of 256 is enough to guarantee no allocations
LibVT+LibLine: Use `1;mods` CSI parameters for ctrl/alt/shift-arrow keys xterms send a bitmask (+ 1) in the 2nd CSI parameter if "special" keys (arrow keys, pgup/down, etc) are sent with modifiers held down. Serenity's Terminal used to send ^[[O, which is a nonexistent escape sequence and a misread of VT100's ^[O (ie the '[' is replaced by 'O'). Since the xterm scheme also supports shift and alt modifiers, switch to that. More flexible, and makes ctrl-left/right and alt-left/right work in SerenityOS's bash port. Also do this for page up/down. No behavior change for SerenityOS's Shell.
2020-09-13 21:08:19 -04:00
else
LibVT: Use StringBuilder's inline capacity instead of temporary Strings This let's us avoid heap allocations.
2022-02-15 21:12:30 +02:00
MUST(builder.try_appendff("\e{}{:c}", escape_character, final)); // StringBuilder's inline capacity of 256 is enough to guarantee no allocations
emit_string(builder.string_view());
LibVT+LibLine: Use `1;mods` CSI parameters for ctrl/alt/shift-arrow keys xterms send a bitmask (+ 1) in the 2nd CSI parameter if "special" keys (arrow keys, pgup/down, etc) are sent with modifiers held down. Serenity's Terminal used to send ^[[O, which is a nonexistent escape sequence and a misread of VT100's ^[O (ie the '[' is replaced by 'O'). Since the xterm scheme also supports shift and alt modifiers, switch to that. More flexible, and makes ctrl-left/right and alt-left/right work in SerenityOS's bash port. Also do this for page up/down. No behavior change for SerenityOS's Shell.
2020-09-13 21:08:19 -04:00
};
LibVT: Use xterm modifier scheme for tilde keys too
2020-09-13 21:31:59 -04:00
auto emit_tilde_with_modifier = [this, modifier_mask](unsigned num) {
LibVT: Use StringBuilder's inline capacity instead of temporary Strings This let's us avoid heap allocations.
2022-02-15 21:12:30 +02:00
StringBuilder builder;
LibVT: Use xterm modifier scheme for tilde keys too
2020-09-13 21:31:59 -04:00
if (modifier_mask)
LibVT: Use StringBuilder's inline capacity instead of temporary Strings This let's us avoid heap allocations.
2022-02-15 21:12:30 +02:00
MUST(builder.try_appendff("\e[{};{}~", num, modifier_mask + 1)); // StringBuilder's inline capacity of 256 is enough to guarantee no allocations
LibVT: Use xterm modifier scheme for tilde keys too
2020-09-13 21:31:59 -04:00
else
LibVT: Use StringBuilder's inline capacity instead of temporary Strings This let's us avoid heap allocations.
2022-02-15 21:12:30 +02:00
MUST(builder.try_appendff("\e[{}~", num)); // StringBuilder's inline capacity of 256 is enough to guarantee no allocations
emit_string(builder.string_view());
LibVT: Use xterm modifier scheme for tilde keys too
2020-09-13 21:31:59 -04:00
};
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
switch (key) {
case KeyCode::Key_Up:
LibVT+LibLine: Use `1;mods` CSI parameters for ctrl/alt/shift-arrow keys xterms send a bitmask (+ 1) in the 2nd CSI parameter if "special" keys (arrow keys, pgup/down, etc) are sent with modifiers held down. Serenity's Terminal used to send ^[[O, which is a nonexistent escape sequence and a misread of VT100's ^[O (ie the '[' is replaced by 'O'). Since the xterm scheme also supports shift and alt modifiers, switch to that. More flexible, and makes ctrl-left/right and alt-left/right work in SerenityOS's bash port. Also do this for page up/down. No behavior change for SerenityOS's Shell.
2020-09-13 21:08:19 -04:00
emit_final_with_modifier('A');
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
return;
case KeyCode::Key_Down:
LibVT+LibLine: Use `1;mods` CSI parameters for ctrl/alt/shift-arrow keys xterms send a bitmask (+ 1) in the 2nd CSI parameter if "special" keys (arrow keys, pgup/down, etc) are sent with modifiers held down. Serenity's Terminal used to send ^[[O, which is a nonexistent escape sequence and a misread of VT100's ^[O (ie the '[' is replaced by 'O'). Since the xterm scheme also supports shift and alt modifiers, switch to that. More flexible, and makes ctrl-left/right and alt-left/right work in SerenityOS's bash port. Also do this for page up/down. No behavior change for SerenityOS's Shell.
2020-09-13 21:08:19 -04:00
emit_final_with_modifier('B');
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
return;
case KeyCode::Key_Right:
LibVT+LibLine: Use `1;mods` CSI parameters for ctrl/alt/shift-arrow keys xterms send a bitmask (+ 1) in the 2nd CSI parameter if "special" keys (arrow keys, pgup/down, etc) are sent with modifiers held down. Serenity's Terminal used to send ^[[O, which is a nonexistent escape sequence and a misread of VT100's ^[O (ie the '[' is replaced by 'O'). Since the xterm scheme also supports shift and alt modifiers, switch to that. More flexible, and makes ctrl-left/right and alt-left/right work in SerenityOS's bash port. Also do this for page up/down. No behavior change for SerenityOS's Shell.
2020-09-13 21:08:19 -04:00
emit_final_with_modifier('C');
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
return;
case KeyCode::Key_Left:
LibVT+LibLine: Use `1;mods` CSI parameters for ctrl/alt/shift-arrow keys xterms send a bitmask (+ 1) in the 2nd CSI parameter if "special" keys (arrow keys, pgup/down, etc) are sent with modifiers held down. Serenity's Terminal used to send ^[[O, which is a nonexistent escape sequence and a misread of VT100's ^[O (ie the '[' is replaced by 'O'). Since the xterm scheme also supports shift and alt modifiers, switch to that. More flexible, and makes ctrl-left/right and alt-left/right work in SerenityOS's bash port. Also do this for page up/down. No behavior change for SerenityOS's Shell.
2020-09-13 21:08:19 -04:00
emit_final_with_modifier('D');
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
return;
case KeyCode::Key_Insert:
LibVT: Use xterm modifier scheme for tilde keys too
2020-09-13 21:31:59 -04:00
emit_tilde_with_modifier(2);
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
return;
case KeyCode::Key_Delete:
LibVT: Use xterm modifier scheme for tilde keys too
2020-09-13 21:31:59 -04:00
emit_tilde_with_modifier(3);
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
return;
case KeyCode::Key_Home:
LibVT+LibLine: Use `1;mods` CSI parameters for ctrl/alt/shift-arrow keys xterms send a bitmask (+ 1) in the 2nd CSI parameter if "special" keys (arrow keys, pgup/down, etc) are sent with modifiers held down. Serenity's Terminal used to send ^[[O, which is a nonexistent escape sequence and a misread of VT100's ^[O (ie the '[' is replaced by 'O'). Since the xterm scheme also supports shift and alt modifiers, switch to that. More flexible, and makes ctrl-left/right and alt-left/right work in SerenityOS's bash port. Also do this for page up/down. No behavior change for SerenityOS's Shell.
2020-09-13 21:08:19 -04:00
emit_final_with_modifier('H');
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
return;
case KeyCode::Key_End:
LibVT+LibLine: Use `1;mods` CSI parameters for ctrl/alt/shift-arrow keys xterms send a bitmask (+ 1) in the 2nd CSI parameter if "special" keys (arrow keys, pgup/down, etc) are sent with modifiers held down. Serenity's Terminal used to send ^[[O, which is a nonexistent escape sequence and a misread of VT100's ^[O (ie the '[' is replaced by 'O'). Since the xterm scheme also supports shift and alt modifiers, switch to that. More flexible, and makes ctrl-left/right and alt-left/right work in SerenityOS's bash port. Also do this for page up/down. No behavior change for SerenityOS's Shell.
2020-09-13 21:08:19 -04:00
emit_final_with_modifier('F');
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
return;
case KeyCode::Key_PageUp:
LibVT: Use xterm modifier scheme for tilde keys too
2020-09-13 21:31:59 -04:00
emit_tilde_with_modifier(5);
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
return;
case KeyCode::Key_PageDown:
LibVT: Use xterm modifier scheme for tilde keys too
2020-09-13 21:31:59 -04:00
emit_tilde_with_modifier(6);
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
return;
LibVT/LibLine: Delete words when pressing Ctrl+Backspace in Terminal
2022-11-16 04:40:11 -06:00
case KeyCode::Key_Backspace:
if (ctrl) {
// This is an extension that allows Editor.cpp to delete whole words when
// Ctrl+Backspace is pressed. Ctrl cannot be transmitted without a CSI, and
// ANSI delete (127) is within the valid range for CSI codes in Editor.cpp.
// The code also has the same behavior as backspace when emitted with no CSI,
// though the backspace code (8) is preserved when Ctrl is not pressed.
emit_final_with_modifier(127);
return;
}
break;
LibVT: Fix newline handling Before this commit, we would jump to the first column after receiving the '\n' line feed character. This is not the correct behavior, as it should only move the cursor now. Translating the typed Return key into the correct CR LF ("\r\n") is the TTY's job, which was fixed in #7184. Fixes #6820 Fixes #6960
2021-05-17 16:25:35 +02:00
case KeyCode::Key_Return:
// The standard says that CR should be generated by the return key.
// The TTY will take care of translating it to CR LF for the terminal.
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
emit_string("\r"sv);
LibVT: Fix newline handling Before this commit, we would jump to the first column after receiving the '\n' line feed character. This is not the correct behavior, as it should only move the cursor now. Translating the typed Return key into the correct CR LF ("\r\n") is the TTY's job, which was fixed in #7184. Fixes #6820 Fixes #6960
2021-05-17 16:25:35 +02:00
return;
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
default:
break;
}
LibVT: Replace u8 type to u32 for code point Replace KeyEvent text attribute usage with code_point.
2020-06-13 13:56:39 +03:00
if (!code_point) {
LibVT: Fix emitting \0 when pressing a modifier key This causes the kernel to return EOF, which in turn confuses everything. This is a regression from the LibVT port of VirtualConsole.
2020-05-29 22:13:51 +03:00
// Probably a modifier being pressed.
return;
}
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
if (shift && key == KeyCode::Key_Tab) {
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
emit_string("\033[Z"sv);
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
return;
}
// Key event was not one of the above special cases,
// attempt to treat it as a character...
if (ctrl) {
LibVT: Replace u8 type to u32 for code point Replace KeyEvent text attribute usage with code_point.
2020-06-13 13:56:39 +03:00
if (code_point >= 'a' && code_point <= 'z') {
code_point = code_point - 'a' + 1;
} else if (code_point == '\\') {
code_point = 0x1c;
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
}
}
// Alt modifier sends escape prefix.
if (alt)
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
emit_string("\033"sv);
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
LibVT: Replace u8 type to u32 for code point Replace KeyEvent text attribute usage with code_point.
2020-06-13 13:56:39 +03:00
StringBuilder sb;
Unicode: Try s/codepoint/code_point/g again This time, without trailing 's'. Ran: git grep -l 'codepoint' | xargs sed -ie 's/codepoint/code_point/g
2020-08-05 16:31:20 -04:00
sb.append_code_point(code_point);
LibVT: Use StringBuilder::string_view() instead of to_string() This let's us avoid a heap allocation.
2022-02-15 23:43:32 +02:00
emit_string(sb.string_view());
LibVT: Move most of key press handling logic into VT::Terminal This will let us share it between the userspace (TerminalWidget) and the Kernel.
2020-05-27 00:31:30 +03:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::unimplemented_control_code(u8 code)
{
Terminal: Put debug spam in unimplemented_control_code() behind a flag
2021-07-03 17:08:37 +02:00
dbgln_if(TERMINAL_DEBUG, "Unimplemented control code {:02x}", code);
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
}
void Terminal::unimplemented_escape_sequence(Intermediates intermediates, u8 last_byte)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
StringBuilder builder;
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
builder.appendff("Unimplemented escape sequence {:c}", last_byte);
if (!intermediates.is_empty()) {
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
builder.append(", intermediates: "sv);
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
for (size_t i = 0; i < intermediates.size(); ++i)
builder.append((char)intermediates[i]);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
dbgln("{}", builder.string_view());
}
void Terminal::unimplemented_csi_sequence(Parameters parameters, Intermediates intermediates, u8 last_byte)
{
StringBuilder builder;
builder.appendff("Unimplemented CSI sequence: {:c}", last_byte);
if (!parameters.is_empty()) {
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
builder.append(", parameters: ["sv);
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
for (size_t i = 0; i < parameters.size(); ++i)
builder.appendff("{}{}", (i == 0) ? "" : ", ", parameters[i]);
Everywhere: Replace single-char StringView op. arguments with chars This prevents us from needing a sv suffix, and potentially reduces the need to run generic code for a single character (as contains, starts_with, ends_with etc. for a char will be just a length and equality check). No functional changes.
2022-07-11 20:10:18 +00:00
builder.append("]"sv);
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
}
if (!intermediates.is_empty()) {
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
builder.append(", intermediates:"sv);
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
for (size_t i = 0; i < intermediates.size(); ++i)
builder.append((char)intermediates[i]);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Oops, fix dbgln() invocation mistake
2021-02-20 17:16:33 +01:00
dbgln("{}", builder.string_view());
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
void Terminal::unimplemented_osc_sequence(OscParameters parameters, u8 last_byte)
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
{
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
StringBuilder builder;
builder.appendff("Unimplemented OSC sequence parameters: (bel_terminated={}) [ ", last_byte == '\a');
bool first = true;
for (auto parameter : parameters) {
if (!first)
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
builder.append(", "sv);
builder.append('[');
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
for (auto character : parameter)
builder.append((char)character);
Everywhere: Replace single-char StringView op. arguments with chars This prevents us from needing a sv suffix, and potentially reduces the need to run generic code for a single character (as contains, starts_with, ends_with etc. for a char will be just a length and equality check). No functional changes.
2022-07-11 20:10:18 +00:00
builder.append(']');
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
first = false;
}
Everywhere: Add sv suffix to strings relying on StringView(char const*) Each of these strings would previously rely on StringView's char const* constructor overload, which would call __builtin_strlen on the string. Since we now have operator ""sv, we can replace these with much simpler versions. This opens the door to being able to remove StringView(char const*). No functional changes.
2022-07-11 17:32:29 +00:00
builder.append(" ]"sv);
LibVT: Implement new ANSI escape sequence parser This commit replaces the former, hand-written parser with a new one that can be generated automatically according to a state change diagram. The new `EscapeSequenceParser` class provides a more ergonomic interface to dealing with escape sequences. This interface has been inspired by Alacritty's [vte library](https://github.com/alacritty/vte/). I tried to avoid changing the application logic inside the `Terminal` class. While this code has not been thoroughly tested, I can't find regressions in the basic command line utilities or `vttest`. `Terminal` now displays nicer debug messages when it encounters an unknown escape sequence. Defensive programming and bounds checks have been added where we access parameters, and as a result, we can now endure 4-5 seconds of `cat /dev/urandom`. :D We generate EscapeSequenceStateMachine.h when building the in-kernel LibVT, and we assume that the file is already in place when the userland library is being built. This will probably cause problems later on, but I can't find a way to do it nicely.
2021-05-08 20:37:43 +02:00
dbgln("{}", builder.string_view());
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 22:58:51 +03:00
#ifndef KERNEL
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
void Terminal::set_size(u16 columns, u16 rows)
{
LibVT: enforce a minimum size of 1 column and 1 row Fixes #829
2020-01-15 21:13:54 -06:00
if (!columns)
columns = 1;
if (!rows)
rows = 1;
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
if (columns == m_columns && rows == m_rows)
return;
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
// If we're making the terminal larger (column-wise), start at the end and go up, taking cells from the line below.
// otherwise start at the beginning and go down, pushing cells into the line below.
auto resize_and_rewrap = [&](auto& buffer, auto& old_cursor) {
auto cursor_on_line = [&](auto index) {
return index == old_cursor.row ? &old_cursor : nullptr;
};
// Two passes, one from top to bottom, another from bottom to top
for (size_t pass = 0; pass < 2; ++pass) {
auto forwards = (pass == 0) ^ (columns < m_columns);
if (forwards) {
for (size_t i = 1; i <= buffer.size(); ++i) {
auto is_at_seam = i == 1;
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
Line* next_line = is_at_seam ? nullptr : buffer[buffer.size() - i + 1].ptr();
Line* line = buffer[buffer.size() - i].ptr();
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
auto next_cursor = cursor_on_line(buffer.size() - i + 1);
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
line->rewrap(columns, next_line, next_cursor ?: cursor_on_line(buffer.size() - i), !!next_cursor);
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
}
} else {
for (size_t i = 0; i < buffer.size(); ++i) {
auto is_at_seam = i + 1 == buffer.size();
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
Line* next_line = is_at_seam ? nullptr : buffer[i + 1].ptr();
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
auto next_cursor = cursor_on_line(i + 1);
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
buffer[i]->rewrap(columns, next_line, next_cursor ?: cursor_on_line(i), !!next_cursor);
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
}
}
Queue<size_t> lines_to_reevaluate;
for (size_t i = 0; i < buffer.size(); ++i) {
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
if (buffer[i]->length() != columns)
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
lines_to_reevaluate.enqueue(i);
}
while (!lines_to_reevaluate.is_empty()) {
auto index = lines_to_reevaluate.dequeue();
auto is_at_seam = index + 1 == buffer.size();
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
Line* const next_line = is_at_seam ? nullptr : buffer[index + 1].ptr();
Line* const line = buffer[index].ptr();
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
auto next_cursor = cursor_on_line(index + 1);
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
line->rewrap(columns, next_line, next_cursor ?: cursor_on_line(index), !!next_cursor);
if (line->length() > columns) {
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
auto current_cursor = cursor_on_line(index);
// Split the line into two (or more)
++index;
buffer.insert(index, make<Line>(0));
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
VERIFY(buffer[index]->length() == 0);
line->rewrap(columns, buffer[index].ptr(), current_cursor, false);
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
// If we inserted a line and the old cursor was after that line, increment its row
if (!current_cursor && old_cursor.row >= index)
++old_cursor.row;
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
if (buffer[index]->length() != columns)
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
lines_to_reevaluate.enqueue(index);
}
if (next_line && next_line->length() != columns)
lines_to_reevaluate.enqueue(index + 1);
}
}
LibVT: Only resize the line after all rewrapping is done Otherwise we would end up inserting empty cells into the wrapped lines. Fixes #8227.
2021-06-24 20:07:33 +04:30
for (auto& line : buffer)
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
line->set_length(columns);
LibVT: Only resize the line after all rewrapping is done Otherwise we would end up inserting empty cells into the wrapped lines. Fixes #8227.
2021-06-24 20:07:33 +04:30
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
return old_cursor;
};
LibVT: Rewrap the terminal history along with the normal buffer
2021-06-22 20:01:24 +04:30
auto old_history_size = m_history.size();
m_history.extend(move(m_normal_screen_buffer));
CursorPosition cursor_tracker { cursor_row() + old_history_size, cursor_column() };
resize_and_rewrap(m_history, cursor_tracker);
if (auto extra_lines = m_history.size() - rows) {
while (extra_lines > 0) {
if (m_history.size() <= cursor_tracker.row)
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
break;
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
if (m_history.last()->is_empty()) {
if (m_history.size() >= 2 && m_history[m_history.size() - 2]->termination_column().has_value())
LibVT: Rewrap the terminal history along with the normal buffer
2021-06-22 20:01:24 +04:30
break;
--extra_lines;
LibVT: Cast unused smart-pointer return value to void
2021-12-02 12:53:50 +00:00
(void)m_history.take_last();
LibVT: Rewrap the terminal history along with the normal buffer
2021-06-22 20:01:24 +04:30
continue;
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
}
LibVT: Rewrap the terminal history along with the normal buffer
2021-06-22 20:01:24 +04:30
break;
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
}
}
LibVT: Rewrap the terminal history along with the normal buffer
2021-06-22 20:01:24 +04:30
// FIXME: This can use a more performant way to move the last N entries
// from the history into the normal buffer
m_normal_screen_buffer.ensure_capacity(rows);
while (m_normal_screen_buffer.size() < rows) {
if (!m_history.is_empty())
m_normal_screen_buffer.prepend(m_history.take_last());
else
m_normal_screen_buffer.unchecked_append(make<Line>(columns));
}
cursor_tracker.row -= m_history.size();
if (m_history.size() != old_history_size) {
m_client.terminal_history_changed(-old_history_size);
m_client.terminal_history_changed(m_history.size());
}
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
CursorPosition dummy_cursor_tracker {};
resize_and_rewrap(m_alternate_screen_buffer, dummy_cursor_tracker);
if (m_alternate_screen_buffer.size() > rows)
m_alternate_screen_buffer.remove(0, m_alternate_screen_buffer.size() - rows);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
if (rows > m_rows) {
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
while (m_normal_screen_buffer.size() < rows)
m_normal_screen_buffer.append(make<Line>(columns));
while (m_alternate_screen_buffer.size() < rows)
m_alternate_screen_buffer.append(make<Line>(columns));
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
} else {
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
m_normal_screen_buffer.shrink(rows);
m_alternate_screen_buffer.shrink(rows);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
m_columns = columns;
m_rows = rows;
m_scroll_region_top = 0;
m_scroll_region_bottom = rows - 1;
LibVT: Add Alternate Screen Buffer support The Alternate Screen Buffer is used by full-screen terminal applications (like `vim` and `nano`). Its data is stored separately from the normal buffer, therefore after applications using it exit, everything looks like it was before, the bottom of their interfaces isn't visible. An interesting feature is that it does not support scrollback, so it consumes less memory by not having to allocate lines for history. Because of the need to save and restore state between the switches, some correctness issues relating to it were also fixed in this commit.
2021-05-23 15:47:41 +02:00
m_current_state.cursor.clamp(m_rows - 1, m_columns - 1);
m_normal_saved_state.cursor.clamp(m_rows - 1, m_columns - 1);
m_alternate_saved_state.cursor.clamp(m_rows - 1, m_columns - 1);
m_saved_cursor_position.clamp(m_rows - 1, m_columns - 1);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
m_horizontal_tabs.resize(columns);
for (unsigned i = 0; i < columns; ++i)
m_horizontal_tabs[i] = (i % 8) == 0;
// Rightmost column is always last tab on line.
m_horizontal_tabs[columns - 1] = 1;
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
set_cursor(cursor_tracker.row, cursor_tracker.column);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
m_client.terminal_did_resize(m_columns, m_rows);
LibVT: Fix issues running `nano` This commit fixes 3 correctness issues with the ANSI escape sequence handling logic: 1. Default parameters were not handled correctly: the specification says that 0-valued CSI escape sequence parameters should take their default values. 2. We did not call `scroll_{up, down}` when encountering RI/IND commands that reached the scroll margins. This caused nano to only scroll the first line.
2021-05-23 15:57:21 +02:00
dbgln_if(TERMINAL_DEBUG, "Set terminal size: {}x{}", m_rows, m_columns);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 22:58:51 +03:00
#endif
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 22:58:51 +03:00
#ifndef KERNEL
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
void Terminal::invalidate_cursor()
{
LibVT+Terminal: Implement line wrapping This commit implements line wrapping in the terminal, and tries its best to move the cursor to the "correct" position.
2021-06-19 03:53:03 +04:30
if (cursor_row() < active_buffer().size())
Everywhere: Stop using NonnullOwnPtrVector Same as NonnullRefPtrVector: weird semantics, questionable benefits.
2023-03-06 17:16:25 +01:00
active_buffer()[cursor_row()]->set_dirty(true);
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
Attribute Terminal::attribute_at(Position const& position) const
LibVT+Terminal: Support hyperlinks in the terminal :^) We now support basic hyperlinking in the terminal with <OSC>;8;;URL<ST> Links are opened via LaunchServer on Ctrl+LeftMouse.
2020-05-09 16:16:16 +02:00
{
if (!position.is_valid())
return {};
LibVT: Make selection follow terminal history scrollback :^) The buffer positions referred to by a VT::Position now include history scrollback, meaning that a VT::Position with row=0 is at the start of the history. The active terminal buffer keeps moving in VT::Position coordinates whenever we scroll. This allows selection to follow history. It also allows us to click hyperlinks in history. Fixes #957.
2020-05-10 16:59:02 +02:00
if (position.row() >= static_cast<int>(line_count()))
LibVT+Terminal: Support hyperlinks in the terminal :^) We now support basic hyperlinking in the terminal with <OSC>;8;;URL<ST> Links are opened via LaunchServer on Ctrl+LeftMouse.
2020-05-09 16:16:16 +02:00
return {};
auto& line = this->line(position.row());
LibVT: Make VT::Line use a Vector for storage This is preparation for non-destructive terminal resizing which will require more dynamic storage for lines.
2021-02-26 20:28:22 +01:00
if (static_cast<size_t>(position.column()) >= line.length())
LibVT+Terminal: Support hyperlinks in the terminal :^) We now support basic hyperlinking in the terminal with <OSC>;8;;URL<ST> Links are opened via LaunchServer on Ctrl+LeftMouse.
2020-05-09 16:16:16 +02:00
return {};
LibVT: Make VT::Line use a Vector for storage This is preparation for non-destructive terminal resizing which will require more dynamic storage for lines.
2021-02-26 20:28:22 +01:00
return line.attribute_at(position.column());
LibVT+Terminal: Support hyperlinks in the terminal :^) We now support basic hyperlinking in the terminal with <OSC>;8;;URL<ST> Links are opened via LaunchServer on Ctrl+LeftMouse.
2020-05-09 16:16:16 +02:00
}
Kernel/Graphics + SystemServer: Support text mode properly As we removed the support of VBE modesetting that was done by GRUB early on boot, we need to determine if we can modeset the resolution with our drivers, and if not, we should enable text mode and ensure that SystemServer knows about it too. Also, SystemServer should first check if there's a framebuffer device node, which is an indication that text mode was not even if it was requested. Then, if it doesn't find it, it should check what boot_mode argument the user specified (in case it's self-test). This way if we try to use bochs-display device (which is not VGA compatible) and request a text mode, it will not honor the request and will continue with graphical mode. Also try to print critical messages with mininum memory allocations possible. In LibVT, We make the implementation flexible for kernel-specific methods that are implemented in ConsoleImpl class.
2021-04-16 22:58:51 +03:00
#endif
LibVT: Factor out terminal emulation from Terminal to make it reusable Now that we're bringing back the in-kernel virtual console, we should move towards having a single implementation of terminal emulation. This patch rips out the emulation code from the Terminal application and turns it into the beginnings of LibVT. The basic design idea is that users of VT::Terminal will implement and provide a VT::TerminalClient subclass to handle presentation-specific things. We'll need to iterate on this, but it's a start. :^)
2019-08-12 17:32:16 +02:00
}
Reference in a new issue Copy permalink