7345233fb6
This patch improves the way lldb checks if the terminal it's opened in (if any) supports Unicode or not. On POSIX systems, we check if `LANG` contains `UTF-8`. On Windows, we always return `true` since we use the `WriteToConsoleW` api. This is a relanding of https://github.com/llvm/llvm-project/pull/168603. The tests failed because the bots support Unicode but the tests expect ASCII. To avoid different outputs depending on the environment the tests are running in, this patch always force ASCII in the tests.
492 lines
12 KiB
C++
492 lines
12 KiB
C++
//===-- Terminal.cpp ------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Host/Terminal.h"
|
|
|
|
#include "lldb/Host/Config.h"
|
|
#include "lldb/Host/PosixApi.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
|
|
#include <csignal>
|
|
#include <fcntl.h>
|
|
#include <optional>
|
|
|
|
#if LLDB_ENABLE_TERMIOS
|
|
#include <termios.h>
|
|
#endif
|
|
|
|
using namespace lldb_private;
|
|
|
|
struct Terminal::Data {
|
|
#if LLDB_ENABLE_TERMIOS
|
|
struct termios m_termios; ///< Cached terminal state information.
|
|
#endif
|
|
};
|
|
|
|
bool Terminal::IsATerminal() const { return m_fd >= 0 && ::isatty(m_fd); }
|
|
|
|
#if !LLDB_ENABLE_TERMIOS
|
|
static llvm::Error termiosMissingError() {
|
|
return llvm::createStringError(llvm::inconvertibleErrorCode(),
|
|
"termios support missing in LLDB");
|
|
}
|
|
#endif
|
|
|
|
llvm::Expected<Terminal::Data> Terminal::GetData() {
|
|
#if LLDB_ENABLE_TERMIOS
|
|
if (!FileDescriptorIsValid())
|
|
return llvm::createStringError(llvm::inconvertibleErrorCode(),
|
|
"invalid fd");
|
|
|
|
if (!IsATerminal())
|
|
return llvm::createStringError(llvm::inconvertibleErrorCode(),
|
|
"fd not a terminal");
|
|
|
|
Data data;
|
|
if (::tcgetattr(m_fd, &data.m_termios) != 0)
|
|
return llvm::createStringError(
|
|
std::error_code(errno, std::generic_category()),
|
|
"unable to get teletype attributes");
|
|
return data;
|
|
#else // !LLDB_ENABLE_TERMIOS
|
|
return termiosMissingError();
|
|
#endif // LLDB_ENABLE_TERMIOS
|
|
}
|
|
|
|
llvm::Error Terminal::SetData(const Terminal::Data &data) {
|
|
#if LLDB_ENABLE_TERMIOS
|
|
assert(FileDescriptorIsValid());
|
|
assert(IsATerminal());
|
|
|
|
if (::tcsetattr(m_fd, TCSANOW, &data.m_termios) != 0)
|
|
return llvm::createStringError(
|
|
std::error_code(errno, std::generic_category()),
|
|
"unable to set teletype attributes");
|
|
return llvm::Error::success();
|
|
#else // !LLDB_ENABLE_TERMIOS
|
|
return termiosMissingError();
|
|
#endif // LLDB_ENABLE_TERMIOS
|
|
}
|
|
|
|
llvm::Error Terminal::SetEcho(bool enabled) {
|
|
#if LLDB_ENABLE_TERMIOS
|
|
llvm::Expected<Data> data = GetData();
|
|
if (!data)
|
|
return data.takeError();
|
|
|
|
struct termios &fd_termios = data->m_termios;
|
|
fd_termios.c_lflag &= ~ECHO;
|
|
if (enabled)
|
|
fd_termios.c_lflag |= ECHO;
|
|
return SetData(data.get());
|
|
#else // !LLDB_ENABLE_TERMIOS
|
|
return termiosMissingError();
|
|
#endif // LLDB_ENABLE_TERMIOS
|
|
}
|
|
|
|
llvm::Error Terminal::SetCanonical(bool enabled) {
|
|
#if LLDB_ENABLE_TERMIOS
|
|
llvm::Expected<Data> data = GetData();
|
|
if (!data)
|
|
return data.takeError();
|
|
|
|
struct termios &fd_termios = data->m_termios;
|
|
fd_termios.c_lflag &= ~ICANON;
|
|
if (enabled)
|
|
fd_termios.c_lflag |= ICANON;
|
|
return SetData(data.get());
|
|
#else // !LLDB_ENABLE_TERMIOS
|
|
return termiosMissingError();
|
|
#endif // LLDB_ENABLE_TERMIOS
|
|
}
|
|
|
|
llvm::Error Terminal::SetRaw() {
|
|
#if LLDB_ENABLE_TERMIOS
|
|
llvm::Expected<Data> data = GetData();
|
|
if (!data)
|
|
return data.takeError();
|
|
|
|
struct termios &fd_termios = data->m_termios;
|
|
::cfmakeraw(&fd_termios);
|
|
|
|
// Make sure only one character is needed to return from a read
|
|
// (cfmakeraw() doesn't do this on NetBSD)
|
|
fd_termios.c_cc[VMIN] = 1;
|
|
fd_termios.c_cc[VTIME] = 0;
|
|
|
|
return SetData(data.get());
|
|
#else // !LLDB_ENABLE_TERMIOS
|
|
return termiosMissingError();
|
|
#endif // LLDB_ENABLE_TERMIOS
|
|
}
|
|
|
|
#if LLDB_ENABLE_TERMIOS
|
|
static std::optional<speed_t> baudRateToConst(unsigned int baud_rate) {
|
|
switch (baud_rate) {
|
|
#if defined(B50)
|
|
case 50:
|
|
return B50;
|
|
#endif
|
|
#if defined(B75)
|
|
case 75:
|
|
return B75;
|
|
#endif
|
|
#if defined(B110)
|
|
case 110:
|
|
return B110;
|
|
#endif
|
|
#if defined(B134)
|
|
case 134:
|
|
return B134;
|
|
#endif
|
|
#if defined(B150)
|
|
case 150:
|
|
return B150;
|
|
#endif
|
|
#if defined(B200)
|
|
case 200:
|
|
return B200;
|
|
#endif
|
|
#if defined(B300)
|
|
case 300:
|
|
return B300;
|
|
#endif
|
|
#if defined(B600)
|
|
case 600:
|
|
return B600;
|
|
#endif
|
|
#if defined(B1200)
|
|
case 1200:
|
|
return B1200;
|
|
#endif
|
|
#if defined(B1800)
|
|
case 1800:
|
|
return B1800;
|
|
#endif
|
|
#if defined(B2400)
|
|
case 2400:
|
|
return B2400;
|
|
#endif
|
|
#if defined(B4800)
|
|
case 4800:
|
|
return B4800;
|
|
#endif
|
|
#if defined(B9600)
|
|
case 9600:
|
|
return B9600;
|
|
#endif
|
|
#if defined(B19200)
|
|
case 19200:
|
|
return B19200;
|
|
#endif
|
|
#if defined(B38400)
|
|
case 38400:
|
|
return B38400;
|
|
#endif
|
|
#if defined(B57600)
|
|
case 57600:
|
|
return B57600;
|
|
#endif
|
|
#if defined(B115200)
|
|
case 115200:
|
|
return B115200;
|
|
#endif
|
|
#if defined(B230400)
|
|
case 230400:
|
|
return B230400;
|
|
#endif
|
|
#if defined(B460800)
|
|
case 460800:
|
|
return B460800;
|
|
#endif
|
|
#if defined(B500000)
|
|
case 500000:
|
|
return B500000;
|
|
#endif
|
|
#if defined(B576000)
|
|
case 576000:
|
|
return B576000;
|
|
#endif
|
|
#if defined(B921600)
|
|
case 921600:
|
|
return B921600;
|
|
#endif
|
|
#if defined(B1000000)
|
|
case 1000000:
|
|
return B1000000;
|
|
#endif
|
|
#if defined(B1152000)
|
|
case 1152000:
|
|
return B1152000;
|
|
#endif
|
|
#if defined(B1500000)
|
|
case 1500000:
|
|
return B1500000;
|
|
#endif
|
|
#if defined(B2000000)
|
|
case 2000000:
|
|
return B2000000;
|
|
#endif
|
|
#if defined(B76800)
|
|
case 76800:
|
|
return B76800;
|
|
#endif
|
|
#if defined(B153600)
|
|
case 153600:
|
|
return B153600;
|
|
#endif
|
|
#if defined(B307200)
|
|
case 307200:
|
|
return B307200;
|
|
#endif
|
|
#if defined(B614400)
|
|
case 614400:
|
|
return B614400;
|
|
#endif
|
|
#if defined(B2500000)
|
|
case 2500000:
|
|
return B2500000;
|
|
#endif
|
|
#if defined(B3000000)
|
|
case 3000000:
|
|
return B3000000;
|
|
#endif
|
|
#if defined(B3500000)
|
|
case 3500000:
|
|
return B3500000;
|
|
#endif
|
|
#if defined(B4000000)
|
|
case 4000000:
|
|
return B4000000;
|
|
#endif
|
|
default:
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
llvm::Error Terminal::SetBaudRate(unsigned int baud_rate) {
|
|
#if LLDB_ENABLE_TERMIOS
|
|
llvm::Expected<Data> data = GetData();
|
|
if (!data)
|
|
return data.takeError();
|
|
|
|
struct termios &fd_termios = data->m_termios;
|
|
std::optional<speed_t> val = baudRateToConst(baud_rate);
|
|
if (!val) // invalid value
|
|
return llvm::createStringError(llvm::inconvertibleErrorCode(),
|
|
"baud rate %d unsupported by the platform",
|
|
baud_rate);
|
|
if (::cfsetispeed(&fd_termios, *val) != 0)
|
|
return llvm::createStringError(
|
|
std::error_code(errno, std::generic_category()),
|
|
"setting input baud rate failed");
|
|
if (::cfsetospeed(&fd_termios, *val) != 0)
|
|
return llvm::createStringError(
|
|
std::error_code(errno, std::generic_category()),
|
|
"setting output baud rate failed");
|
|
return SetData(data.get());
|
|
#else // !LLDB_ENABLE_TERMIOS
|
|
return termiosMissingError();
|
|
#endif // LLDB_ENABLE_TERMIOS
|
|
}
|
|
|
|
llvm::Error Terminal::SetStopBits(unsigned int stop_bits) {
|
|
#if LLDB_ENABLE_TERMIOS
|
|
llvm::Expected<Data> data = GetData();
|
|
if (!data)
|
|
return data.takeError();
|
|
|
|
struct termios &fd_termios = data->m_termios;
|
|
switch (stop_bits) {
|
|
case 1:
|
|
fd_termios.c_cflag &= ~CSTOPB;
|
|
break;
|
|
case 2:
|
|
fd_termios.c_cflag |= CSTOPB;
|
|
break;
|
|
default:
|
|
return llvm::createStringError(
|
|
llvm::inconvertibleErrorCode(),
|
|
"invalid stop bit count: %d (must be 1 or 2)", stop_bits);
|
|
}
|
|
return SetData(data.get());
|
|
#else // !LLDB_ENABLE_TERMIOS
|
|
return termiosMissingError();
|
|
#endif // LLDB_ENABLE_TERMIOS
|
|
}
|
|
|
|
llvm::Error Terminal::SetParity(Terminal::Parity parity) {
|
|
#if LLDB_ENABLE_TERMIOS
|
|
llvm::Expected<Data> data = GetData();
|
|
if (!data)
|
|
return data.takeError();
|
|
|
|
struct termios &fd_termios = data->m_termios;
|
|
fd_termios.c_cflag &= ~(
|
|
#if defined(CMSPAR)
|
|
CMSPAR |
|
|
#endif
|
|
PARENB | PARODD);
|
|
|
|
if (parity != Parity::No) {
|
|
fd_termios.c_cflag |= PARENB;
|
|
if (parity == Parity::Odd || parity == Parity::Mark)
|
|
fd_termios.c_cflag |= PARODD;
|
|
if (parity == Parity::Mark || parity == Parity::Space) {
|
|
#if defined(CMSPAR)
|
|
fd_termios.c_cflag |= CMSPAR;
|
|
#else
|
|
return llvm::createStringError(
|
|
llvm::inconvertibleErrorCode(),
|
|
"space/mark parity is not supported by the platform");
|
|
#endif
|
|
}
|
|
}
|
|
return SetData(data.get());
|
|
#else // !LLDB_ENABLE_TERMIOS
|
|
return termiosMissingError();
|
|
#endif // LLDB_ENABLE_TERMIOS
|
|
}
|
|
|
|
llvm::Error Terminal::SetParityCheck(Terminal::ParityCheck parity_check) {
|
|
#if LLDB_ENABLE_TERMIOS
|
|
llvm::Expected<Data> data = GetData();
|
|
if (!data)
|
|
return data.takeError();
|
|
|
|
struct termios &fd_termios = data->m_termios;
|
|
fd_termios.c_iflag &= ~(IGNPAR | PARMRK | INPCK);
|
|
|
|
if (parity_check != ParityCheck::No) {
|
|
fd_termios.c_iflag |= INPCK;
|
|
if (parity_check == ParityCheck::Ignore)
|
|
fd_termios.c_iflag |= IGNPAR;
|
|
else if (parity_check == ParityCheck::Mark)
|
|
fd_termios.c_iflag |= PARMRK;
|
|
}
|
|
return SetData(data.get());
|
|
#else // !LLDB_ENABLE_TERMIOS
|
|
return termiosMissingError();
|
|
#endif // LLDB_ENABLE_TERMIOS
|
|
}
|
|
|
|
llvm::Error Terminal::SetHardwareFlowControl(bool enabled) {
|
|
#if LLDB_ENABLE_TERMIOS
|
|
llvm::Expected<Data> data = GetData();
|
|
if (!data)
|
|
return data.takeError();
|
|
|
|
#if defined(CRTSCTS)
|
|
struct termios &fd_termios = data->m_termios;
|
|
fd_termios.c_cflag &= ~CRTSCTS;
|
|
if (enabled)
|
|
fd_termios.c_cflag |= CRTSCTS;
|
|
return SetData(data.get());
|
|
#else // !defined(CRTSCTS)
|
|
if (enabled)
|
|
return llvm::createStringError(
|
|
llvm::inconvertibleErrorCode(),
|
|
"hardware flow control is not supported by the platform");
|
|
return llvm::Error::success();
|
|
#endif // defined(CRTSCTS)
|
|
#else // !LLDB_ENABLE_TERMIOS
|
|
return termiosMissingError();
|
|
#endif // LLDB_ENABLE_TERMIOS
|
|
}
|
|
|
|
bool Terminal::SupportsUnicode() {
|
|
#ifdef _WIN32
|
|
return true;
|
|
#else
|
|
static std::optional<bool> g_result;
|
|
if (g_result)
|
|
return g_result.value();
|
|
|
|
const char *lang_var = std::getenv("LANG");
|
|
if (!lang_var)
|
|
return false;
|
|
g_result =
|
|
llvm::StringRef(lang_var).lower().find("utf-8") != std::string::npos;
|
|
return g_result.value();
|
|
#endif
|
|
}
|
|
|
|
TerminalState::TerminalState(Terminal term, bool save_process_group)
|
|
: m_tty(term) {
|
|
Save(term, save_process_group);
|
|
}
|
|
|
|
TerminalState::~TerminalState() { Restore(); }
|
|
|
|
void TerminalState::Clear() {
|
|
m_tty.Clear();
|
|
m_tflags = -1;
|
|
m_data.reset();
|
|
m_process_group = -1;
|
|
}
|
|
|
|
bool TerminalState::Save(Terminal term, bool save_process_group) {
|
|
Clear();
|
|
m_tty = term;
|
|
if (m_tty.IsATerminal()) {
|
|
#if LLDB_ENABLE_POSIX
|
|
int fd = m_tty.GetFileDescriptor();
|
|
m_tflags = ::fcntl(fd, F_GETFL, 0);
|
|
#if LLDB_ENABLE_TERMIOS
|
|
std::unique_ptr<Terminal::Data> new_data{new Terminal::Data()};
|
|
if (::tcgetattr(fd, &new_data->m_termios) == 0)
|
|
m_data = std::move(new_data);
|
|
#endif // LLDB_ENABLE_TERMIOS
|
|
if (save_process_group)
|
|
m_process_group = ::tcgetpgrp(fd);
|
|
#endif // LLDB_ENABLE_POSIX
|
|
}
|
|
return IsValid();
|
|
}
|
|
|
|
bool TerminalState::Restore() const {
|
|
#if LLDB_ENABLE_POSIX
|
|
if (IsValid()) {
|
|
const int fd = m_tty.GetFileDescriptor();
|
|
if (TFlagsIsValid())
|
|
fcntl(fd, F_SETFL, m_tflags);
|
|
|
|
#if LLDB_ENABLE_TERMIOS
|
|
if (TTYStateIsValid())
|
|
tcsetattr(fd, TCSANOW, &m_data->m_termios);
|
|
#endif // LLDB_ENABLE_TERMIOS
|
|
|
|
if (ProcessGroupIsValid()) {
|
|
// Save the original signal handler.
|
|
void (*saved_sigttou_callback)(int) = nullptr;
|
|
saved_sigttou_callback = (void (*)(int))signal(SIGTTOU, SIG_IGN);
|
|
// Set the process group
|
|
tcsetpgrp(fd, m_process_group);
|
|
// Restore the original signal handler.
|
|
signal(SIGTTOU, saved_sigttou_callback);
|
|
}
|
|
return true;
|
|
}
|
|
#endif // LLDB_ENABLE_POSIX
|
|
return false;
|
|
}
|
|
|
|
bool TerminalState::IsValid() const {
|
|
return m_tty.FileDescriptorIsValid() &&
|
|
(TFlagsIsValid() || TTYStateIsValid() || ProcessGroupIsValid());
|
|
}
|
|
|
|
bool TerminalState::TFlagsIsValid() const { return m_tflags != -1; }
|
|
|
|
bool TerminalState::TTYStateIsValid() const { return bool(m_data); }
|
|
|
|
bool TerminalState::ProcessGroupIsValid() const {
|
|
return static_cast<int32_t>(m_process_group) != -1;
|
|
}
|