mirror of
https://github.com/SerenityOS/serenity
synced 2024-09-16 06:30:41 +00:00
525 lines
13 KiB
C++
525 lines
13 KiB
C++
#include "VirtualConsole.h"
|
|
#include "kmalloc.h"
|
|
#include "i386.h"
|
|
#include "IO.h"
|
|
#include "StdLib.h"
|
|
#include "KeyboardDevice.h"
|
|
#include <AK/AKString.h>
|
|
|
|
static byte* s_vga_buffer;
|
|
static VirtualConsole* s_consoles[6];
|
|
static int s_active_console;
|
|
|
|
void VirtualConsole::get_vga_cursor(byte& row, byte& column)
|
|
{
|
|
word value;
|
|
IO::out8(0x3d4, 0x0e);
|
|
value = IO::in8(0x3d5) << 8;
|
|
IO::out8(0x3d4, 0x0f);
|
|
value |= IO::in8(0x3d5);
|
|
row = value / columns();
|
|
column = value % columns();
|
|
}
|
|
|
|
void VirtualConsole::flush_vga_cursor()
|
|
{
|
|
word value = m_current_vga_start_address + (m_cursor_row * columns() + m_cursor_column);
|
|
IO::out8(0x3d4, 0x0e);
|
|
IO::out8(0x3d5, MSB(value));
|
|
IO::out8(0x3d4, 0x0f);
|
|
IO::out8(0x3d5, LSB(value));
|
|
}
|
|
|
|
void VirtualConsole::initialize()
|
|
{
|
|
s_vga_buffer = (byte*)0xb8000;
|
|
memset(s_consoles, 0, sizeof(s_consoles));
|
|
s_active_console = -1;
|
|
}
|
|
|
|
VirtualConsole::VirtualConsole(unsigned index, InitialContents initial_contents)
|
|
: TTY(4, index)
|
|
, m_index(index)
|
|
{
|
|
set_size(80, 25);
|
|
m_horizontal_tabs = static_cast<byte*>(kmalloc(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;
|
|
|
|
s_consoles[index] = this;
|
|
m_buffer = (byte*)kmalloc_eternal(rows() * columns() * 2);
|
|
if (initial_contents == AdoptCurrentVGABuffer) {
|
|
memcpy(m_buffer, s_vga_buffer, rows() * columns() * 2);
|
|
get_vga_cursor(m_cursor_row, m_cursor_column);
|
|
} else {
|
|
word* line_mem = reinterpret_cast<word*>(m_buffer);
|
|
for (word i = 0; i < rows() * columns(); ++i)
|
|
line_mem[i] = 0x0720;
|
|
}
|
|
}
|
|
|
|
VirtualConsole::~VirtualConsole()
|
|
{
|
|
kfree(m_horizontal_tabs);
|
|
m_horizontal_tabs = nullptr;
|
|
}
|
|
|
|
void VirtualConsole::clear()
|
|
{
|
|
word* linemem = m_active ? (word*)s_vga_buffer : (word*)m_buffer;
|
|
for (word i = 0; i < rows() * columns(); ++i)
|
|
linemem[i] = 0x0720;
|
|
if (m_active)
|
|
set_vga_start_row(0);
|
|
set_cursor(0, 0);
|
|
}
|
|
|
|
void VirtualConsole::switch_to(unsigned index)
|
|
{
|
|
if ((int)index == s_active_console)
|
|
return;
|
|
dbgprintf("VC: Switch to %u (%p)\n", index, s_consoles[index]);
|
|
ASSERT(index < 6);
|
|
ASSERT(s_consoles[index]);
|
|
InterruptDisabler disabler;
|
|
if (s_active_console != -1)
|
|
s_consoles[s_active_console]->set_active(false);
|
|
s_active_console = index;
|
|
s_consoles[s_active_console]->set_active(true);
|
|
Console::the().set_implementation(s_consoles[s_active_console]);
|
|
}
|
|
|
|
void VirtualConsole::set_active(bool b)
|
|
{
|
|
if (b == m_active)
|
|
return;
|
|
|
|
InterruptDisabler disabler;
|
|
|
|
m_active = b;
|
|
if (!m_active) {
|
|
memcpy(m_buffer, m_current_vga_window, rows() * columns() * 2);
|
|
return;
|
|
}
|
|
|
|
memcpy(s_vga_buffer, m_buffer, rows() * columns() * 2);
|
|
set_vga_start_row(0);
|
|
flush_vga_cursor();
|
|
|
|
#if 0
|
|
Keyboard::the().set_client(this);
|
|
#endif
|
|
}
|
|
|
|
inline bool is_valid_parameter_character(byte ch)
|
|
{
|
|
return ch >= 0x30 && ch <= 0x3f;
|
|
}
|
|
|
|
inline bool is_valid_intermediate_character(byte ch)
|
|
{
|
|
return ch >= 0x20 && ch <= 0x2f;
|
|
}
|
|
|
|
inline bool is_valid_final_character(byte ch)
|
|
{
|
|
return ch >= 0x40 && ch <= 0x7e;
|
|
}
|
|
|
|
unsigned parse_uint(const String& str, bool& ok)
|
|
{
|
|
unsigned value = 0;
|
|
for (size_t i = 0; i < str.length(); ++i) {
|
|
if (str[i] < '0' || str[i] > '9') {
|
|
ok = false;
|
|
return 0;
|
|
}
|
|
value = value * 10;
|
|
value += str[i] - '0';
|
|
}
|
|
ok = true;
|
|
return value;
|
|
}
|
|
|
|
enum class VGAColor : byte {
|
|
Black = 0,
|
|
Blue,
|
|
Green,
|
|
Cyan,
|
|
Red,
|
|
Magenta,
|
|
Brown,
|
|
LightGray,
|
|
DarkGray,
|
|
BrightBlue,
|
|
BrightGreen,
|
|
BrightCyan,
|
|
BrightRed,
|
|
BrightMagenta,
|
|
Yellow,
|
|
White,
|
|
};
|
|
|
|
enum class ANSIColor : byte {
|
|
Black = 0,
|
|
Red,
|
|
Green,
|
|
Brown,
|
|
Blue,
|
|
Magenta,
|
|
Cyan,
|
|
LightGray,
|
|
DarkGray,
|
|
BrightRed,
|
|
BrightGreen,
|
|
Yellow,
|
|
BrightBlue,
|
|
BrightMagenta,
|
|
BrightCyan,
|
|
White,
|
|
};
|
|
|
|
static inline VGAColor ansi_color_to_vga(ANSIColor color)
|
|
{
|
|
switch (color) {
|
|
case ANSIColor::Black: return VGAColor::Black;
|
|
case ANSIColor::Red: return VGAColor::Red;
|
|
case ANSIColor::Brown: return VGAColor::Brown;
|
|
case ANSIColor::Blue: return VGAColor::Blue;
|
|
case ANSIColor::Magenta: return VGAColor::Magenta;
|
|
case ANSIColor::Green: return VGAColor::Green;
|
|
case ANSIColor::Cyan: return VGAColor::Cyan;
|
|
case ANSIColor::LightGray: return VGAColor::LightGray;
|
|
case ANSIColor::DarkGray: return VGAColor::DarkGray;
|
|
case ANSIColor::BrightRed: return VGAColor::BrightRed;
|
|
case ANSIColor::BrightGreen: return VGAColor::BrightGreen;
|
|
case ANSIColor::Yellow: return VGAColor::Yellow;
|
|
case ANSIColor::BrightBlue: return VGAColor::BrightBlue;
|
|
case ANSIColor::BrightMagenta: return VGAColor::BrightMagenta;
|
|
case ANSIColor::BrightCyan: return VGAColor::BrightCyan;
|
|
case ANSIColor::White: return VGAColor::White;
|
|
}
|
|
ASSERT_NOT_REACHED();
|
|
return VGAColor::LightGray;
|
|
}
|
|
|
|
static inline byte ansi_color_to_vga(byte color)
|
|
{
|
|
return (byte)ansi_color_to_vga((ANSIColor)color);
|
|
}
|
|
|
|
void VirtualConsole::escape$m(const Vector<unsigned>& params)
|
|
{
|
|
for (auto param : params) {
|
|
switch (param) {
|
|
case 0:
|
|
// Reset
|
|
m_current_attribute = 0x07;
|
|
break;
|
|
case 1:
|
|
// Bold
|
|
m_current_attribute |= 8;
|
|
break;
|
|
case 30:
|
|
case 31:
|
|
case 32:
|
|
case 33:
|
|
case 34:
|
|
case 35:
|
|
case 36:
|
|
case 37:
|
|
// Foreground color
|
|
m_current_attribute &= ~0x7;
|
|
m_current_attribute |= ansi_color_to_vga(param - 30);
|
|
break;
|
|
case 40:
|
|
case 41:
|
|
case 42:
|
|
case 43:
|
|
case 44:
|
|
case 45:
|
|
case 46:
|
|
case 47:
|
|
// Background color
|
|
m_current_attribute &= ~0x70;
|
|
m_current_attribute |= ansi_color_to_vga(param - 30) << 8;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void VirtualConsole::escape$s(const Vector<unsigned>&)
|
|
{
|
|
m_saved_cursor_row = m_cursor_row;
|
|
m_saved_cursor_column = m_cursor_column;
|
|
}
|
|
|
|
void VirtualConsole::escape$u(const Vector<unsigned>&)
|
|
{
|
|
set_cursor(m_saved_cursor_row, m_saved_cursor_column);
|
|
}
|
|
|
|
void VirtualConsole::escape$H(const Vector<unsigned>& params)
|
|
{
|
|
unsigned row = 1;
|
|
unsigned col = 1;
|
|
if (params.size() >= 1)
|
|
row = params[0];
|
|
if (params.size() >= 2)
|
|
col = params[1];
|
|
set_cursor(row - 1, col - 1);
|
|
}
|
|
|
|
void VirtualConsole::escape$A(const Vector<unsigned>& params)
|
|
{
|
|
int num = 1;
|
|
if (params.size() >= 1)
|
|
num = params[0];
|
|
int new_row = (int)m_cursor_row - num;
|
|
if (new_row < 0)
|
|
new_row = 0;
|
|
set_cursor(new_row, m_cursor_column);
|
|
}
|
|
|
|
void VirtualConsole::escape$D(const Vector<unsigned>& params)
|
|
{
|
|
int num = 1;
|
|
if (params.size() >= 1)
|
|
num = params[0];
|
|
int new_column = (int)m_cursor_column - num;
|
|
if (new_column < 0)
|
|
new_column = 0;
|
|
set_cursor(m_cursor_row, new_column);
|
|
}
|
|
|
|
void VirtualConsole::escape$J(const Vector<unsigned>& params)
|
|
{
|
|
int mode = 0;
|
|
if (params.size() >= 1)
|
|
mode = params[0];
|
|
switch (mode) {
|
|
case 0:
|
|
// FIXME: Clear from cursor to end of screen.
|
|
not_implemented();
|
|
break;
|
|
case 1:
|
|
// FIXME: Clear from cursor to beginning of screen.
|
|
not_implemented();
|
|
break;
|
|
case 2:
|
|
clear();
|
|
break;
|
|
case 3:
|
|
// FIXME: <esc>[3J should also clear the scrollback buffer.
|
|
clear();
|
|
break;
|
|
}
|
|
}
|
|
|
|
void VirtualConsole::execute_escape_sequence(byte final)
|
|
{
|
|
auto paramparts = String((const char*)m_parameters.data(), m_parameters.size()).split(';');
|
|
Vector<unsigned> params;
|
|
for (auto& parampart : paramparts) {
|
|
bool ok;
|
|
unsigned value = parse_uint(parampart, ok);
|
|
if (!ok) {
|
|
// FIXME: Should we do something else?
|
|
return;
|
|
}
|
|
params.append(value);
|
|
}
|
|
switch (final) {
|
|
case 'A': escape$A(params); break;
|
|
case 'D': escape$D(params); break;
|
|
case 'H': escape$H(params); break;
|
|
case 'J': escape$J(params); break;
|
|
case 'm': escape$m(params); break;
|
|
case 's': escape$s(params); break;
|
|
case 'u': escape$u(params); break;
|
|
default: break;
|
|
}
|
|
|
|
m_parameters.clear();
|
|
m_intermediates.clear();
|
|
}
|
|
|
|
void VirtualConsole::clear_vga_row(word row)
|
|
{
|
|
word* linemem = (word*)&m_current_vga_window[row * 160];
|
|
for (word i = 0; i < columns(); ++i)
|
|
linemem[i] = 0x0720;
|
|
}
|
|
|
|
void VirtualConsole::scroll_up()
|
|
{
|
|
if (m_cursor_row == (rows() - 1)) {
|
|
if (m_active) {
|
|
if (m_vga_start_row >= 160) {
|
|
memcpy(s_vga_buffer, m_current_vga_window + 160, (rows() - 1) * columns() * 2);
|
|
set_vga_start_row(0);
|
|
clear_vga_row(24);
|
|
} else {
|
|
set_vga_start_row(m_vga_start_row + 1);
|
|
clear_vga_row(24);
|
|
}
|
|
} else {
|
|
memcpy(m_buffer, m_buffer + 160, 160 * 24);
|
|
word* linemem = (word*)&m_buffer[24 * 160];
|
|
for (word i = 0; i < columns(); ++i)
|
|
linemem[i] = 0x0720;
|
|
}
|
|
} else {
|
|
++m_cursor_row;
|
|
}
|
|
m_cursor_column = 0;
|
|
}
|
|
|
|
void VirtualConsole::set_cursor(unsigned row, unsigned column)
|
|
{
|
|
ASSERT(row < rows());
|
|
ASSERT(column < columns());
|
|
m_cursor_row = row;
|
|
m_cursor_column = column;
|
|
if (m_active)
|
|
flush_vga_cursor();
|
|
}
|
|
|
|
void VirtualConsole::put_character_at(unsigned row, unsigned column, byte ch)
|
|
{
|
|
ASSERT(row < rows());
|
|
ASSERT(column < columns());
|
|
word cur = (row * 160) + (column * 2);
|
|
if (m_active) {
|
|
word cur = (row * 160) + (column * 2);
|
|
m_current_vga_window[cur] = ch;
|
|
m_current_vga_window[cur + 1] = m_current_attribute;
|
|
} else {
|
|
m_buffer[cur] = ch;
|
|
m_buffer[cur + 1] = m_current_attribute;
|
|
}
|
|
}
|
|
|
|
void VirtualConsole::on_char(byte ch)
|
|
{
|
|
switch (m_escape_state) {
|
|
case ExpectBracket:
|
|
if (ch == '[')
|
|
m_escape_state = ExpectParameter;
|
|
else
|
|
m_escape_state = Normal;
|
|
return;
|
|
case ExpectParameter:
|
|
if (is_valid_parameter_character(ch)) {
|
|
m_parameters.append(ch);
|
|
return;
|
|
}
|
|
m_escape_state = ExpectIntermediate;
|
|
[[fallthrough]];
|
|
case ExpectIntermediate:
|
|
if (is_valid_intermediate_character(ch)) {
|
|
m_intermediates.append(ch);
|
|
return;
|
|
}
|
|
m_escape_state = ExpectFinal;
|
|
[[fallthrough]];
|
|
case ExpectFinal:
|
|
if (is_valid_final_character(ch)) {
|
|
m_escape_state = Normal;
|
|
execute_escape_sequence(ch);
|
|
return;
|
|
}
|
|
m_escape_state = Normal;
|
|
return;
|
|
case Normal:
|
|
break;
|
|
}
|
|
|
|
switch (ch) {
|
|
case '\0':
|
|
return;
|
|
case '\033':
|
|
m_escape_state = ExpectBracket;
|
|
return;
|
|
case 8: // Backspace
|
|
if (m_cursor_column) {
|
|
set_cursor(m_cursor_row, m_cursor_column - 1);
|
|
put_character_at(m_cursor_row, m_cursor_column, ' ');
|
|
return;
|
|
}
|
|
break;
|
|
case '\a':
|
|
// FIXME: Bell!
|
|
return;
|
|
case '\t': {
|
|
for (unsigned i = m_cursor_column; i < columns(); ++i) {
|
|
if (m_horizontal_tabs[i]) {
|
|
set_cursor(m_cursor_row, i);
|
|
return;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
case '\n':
|
|
scroll_up();
|
|
set_cursor(m_cursor_row, m_cursor_column);
|
|
return;
|
|
}
|
|
|
|
put_character_at(m_cursor_row, m_cursor_column, ch);
|
|
|
|
++m_cursor_column;
|
|
if (m_cursor_column >= columns())
|
|
scroll_up();
|
|
set_cursor(m_cursor_row, m_cursor_column);
|
|
}
|
|
|
|
void VirtualConsole::on_key_pressed(KeyboardDevice::Event key)
|
|
{
|
|
if (key.ctrl()) {
|
|
if (key.character >= 'a' && key.character <= 'z') {
|
|
emit(key.character - 'a' + 1);
|
|
return;
|
|
} else if (key.character == '\\') {
|
|
emit(0x1c);
|
|
return;
|
|
}
|
|
}
|
|
emit(key.character);
|
|
}
|
|
|
|
void VirtualConsole::on_sysconsole_receive(byte ch)
|
|
{
|
|
InterruptDisabler disabler;
|
|
auto old_attribute = m_current_attribute;
|
|
m_current_attribute = 0x03;
|
|
on_char(ch);
|
|
m_current_attribute = old_attribute;
|
|
}
|
|
|
|
ssize_t VirtualConsole::on_tty_write(const byte* data, size_t size)
|
|
{
|
|
InterruptDisabler disabler;
|
|
for (size_t i = 0; i < size; ++i)
|
|
on_char(data[i]);
|
|
return size;
|
|
}
|
|
|
|
String VirtualConsole::tty_name() const
|
|
{
|
|
return String::format("/dev/tty%u", m_index);
|
|
}
|
|
|
|
void VirtualConsole::set_vga_start_row(word row)
|
|
{
|
|
m_vga_start_row = row;
|
|
m_current_vga_start_address = row * columns();
|
|
m_current_vga_window = s_vga_buffer + row * 160;
|
|
IO::out8(0x3d4, 0x0c);
|
|
IO::out8(0x3d5, MSB(m_current_vga_start_address));
|
|
IO::out8(0x3d4, 0x0d);
|
|
IO::out8(0x3d5, LSB(m_current_vga_start_address));
|
|
}
|