github-mirror/fish-shell
2
0
Fork 0
mirror of https://github.com/fish-shell/fish-shell.git synced 2025-02-01 18:38:47 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Refactor input_common.cpp:readb

Browse Source 
readb is used to read a single byte from stdin, or maybe update universal
variables, or maybe invoke completion handlers, etc. Previously it
returned char_event_t but this is more complex than necessary; instead we
can just have it return a single byte, or one of a few special error
codes. This makes the readb's role more clear.
This commit is contained in:
ridiculousfish 2021-04-10 17:34:28 -07:00
parent 78147abe8a
commit 939aba02de
3 changed files with 122 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/input.cpp
View File

@ -480,7 +480,7 @@ class event_queue_peeker_t {
}
peeked_.push_back(newevt);
}
// Now we have peeked far enough, check the event.
// Now we have peeked far enough; check the event.
// If it matches the char, then increment the index.
if (peeked_.at(idx_).maybe_char() == c) {
idx_++;

210
src/input_common.cpp
View File

@ -39,84 +39,84 @@ static int wait_on_escape_ms = WAIT_ON_ESCAPE_DEFAULT;
input_event_queue_t::input_event_queue_t(int in, interrupt_handler_t handler)
: in_(in), interrupt_handler_(std::move(handler)) {}
/// Internal function used by input_common_readch to read one byte from fd 0. This function should
/// only be called by input_common_readch().
char_event_t input_event_queue_t::readb() {
/// Internal function used by readch to read one byte.
/// This calls select() on three fds: input (e.g. stdin), the ioport notifier fd (for main thread
/// requests), and the uvar notifier. This returns either the byte which was read, or one of the
/// special values below.
enum {
// The in fd has been closed.
readb_eof = -1,
// select() was interrupted by a signal.
readb_interrupted = -2,
// Our uvar notifier reported a change (either through poll() or its fd).
readb_uvar_notified = -3,
// Our ioport reported a change, so service main thread requests.
readb_ioport_notified = -4,
};
using readb_result_t = int;
static readb_result_t readb(int in_fd) {
assert(in_fd >= 0 && "Invalid in fd");
universal_notifier_t& notifier = universal_notifier_t::default_notifier();
select_wrapper_t fdset;
for (;;) {
fdset.clear();
fdset.add(in_);
fdset.add(in_fd);
int ioport = iothread_port();
if (ioport > 0) {
fdset.add(ioport);
}
// Add the completion ioport.
int ioport_fd = iothread_port();
fdset.add(ioport_fd);
// Get our uvar notifier.
universal_notifier_t& notifier = universal_notifier_t::default_notifier();
// Get the uvar notifier fd (possibly none).
int notifier_fd = notifier.notification_fd();
if (notifier_fd > 0) {
fdset.add(notifier_fd);
}
fdset.add(notifier_fd);
// Get its suggested delay (possibly none).
uint64_t timeout_usec = select_wrapper_t::kNoTimeout;
if (auto notifier_usec_delay = notifier.usec_delay_between_polls()) {
timeout_usec = notifier_usec_delay;
// Note a 0 here means do not poll.
uint64_t timeout = select_wrapper_t::kNoTimeout;
if (uint64_t usecs_delay = notifier.usec_delay_between_polls()) {
timeout = usecs_delay;
}
int res = fdset.select(timeout_usec);
if (res < 0) {
// Here's where we call select().
int select_res = fdset.select(timeout);
if (select_res < 0) {
if (errno == EINTR || errno == EAGAIN) {
// Some uvar notifiers rely on signals - see #7671.
if (notifier.poll()) {
env_universal_barrier();
}
if (interrupt_handler_) {
if (auto interrupt_evt = interrupt_handler_()) {
return *interrupt_evt;
} else if (auto mc = try_pop()) {
return *mc;
}
}
// A signal.
return readb_interrupted;
} else {
// Some fd was invalid, so probably the tty has been closed.
return readb_eof;
}
}
// select() did not return an error, so we may have a readable fd.
// The priority order is: uvars, stdin, ioport.
// Check to see if we want a universal variable barrier.
// This may come about through readability, or through a call to poll().
if (notifier.poll() ||
(fdset.test(notifier_fd) && notifier.notification_fd_became_readable(notifier_fd))) {
return readb_uvar_notified;
}
// Check stdin.
if (fdset.test(in_fd)) {
unsigned char arr[1];
if (read_blocked(in_fd, arr, 1) != 1) {
// The terminal has been closed.
return char_event_type_t::eof;
}
} else {
// Check to see if we want a universal variable barrier.
bool barrier_from_poll = notifier.poll();
bool barrier_from_readability = false;
if (notifier_fd > 0 && fdset.test(notifier_fd)) {
barrier_from_readability = notifier.notification_fd_became_readable(notifier_fd);
}
if (barrier_from_poll || barrier_from_readability) {
if (env_universal_barrier()) {
// A variable change may have triggered a repaint, etc.
if (auto mc = try_pop()) {
return *mc;
}
}
return readb_eof;
}
// The common path is to return a (non-negative) char.
return static_cast<int>(arr[0]);
}
if (fdset.test(in_)) {
unsigned char arr[1];
if (read_blocked(in_, arr, 1) != 1) {
// The teminal has been closed.
return char_event_type_t::eof;
}
// We read from stdin, so don't loop.
return arr[0];
}
// Check for iothread completions only if there is no data to be read from the stdin.
// This gives priority to the foreground.
if (ioport > 0 && fdset.test(ioport)) {
iothread_service_main();
if (auto mc = try_pop()) {
return mc.acquire();
}
}
// Check for iothread completions only if there is no data to be read from the stdin.
// This gives priority to the foreground.
if (fdset.test(ioport_fd)) {
return readb_ioport_notified;
}
}
}
@ -152,39 +152,67 @@ maybe_t<char_event_t> input_event_queue_t::try_pop() {
char_event_t input_event_queue_t::readch() {
ASSERT_IS_MAIN_THREAD();
if (auto mc = try_pop()) {
return mc.acquire();
}
wchar_t res;
wchar_t res{};
mbstate_t state = {};
while (true) {
auto evt = readb();
if (!evt.is_char()) {
return evt;
for (;;) {
// Do we have something enqueued already?
// Note this may be initially true, or it may become true through calls to
// iothread_service_main() or env_universal_barrier() below.
if (auto mevt = try_pop()) {
return mevt.acquire();
}
wint_t b = evt.get_char();
if (MB_CUR_MAX == 1) {
return b; // single-byte locale, all values are legal
}
readb_result_t rr = readb(in_);
switch (rr) {
case readb_eof:
return char_event_type_t::eof;
char bb = b;
size_t sz = std::mbrtowc(&res, &bb, 1, &state);
switch (sz) {
case static_cast<size_t>(-1): {
std::memset(&state, '\0', sizeof(state));
FLOG(reader, L"Illegal input");
return char_event_type_t::check_exit;
}
case static_cast<size_t>(-2): {
case readb_interrupted:
// FIXME: here signals may break multibyte sequences.
if (interrupt_handler_) {
if (auto interrupt_evt = interrupt_handler_()) {
return interrupt_evt.acquire();
}
}
break;
}
case 0: {
return 0;
}
case readb_uvar_notified:
env_universal_barrier();
break;
case readb_ioport_notified:
iothread_service_main();
break;
default: {
return res;
assert(rr >= 0 && rr <= UCHAR_MAX &&
"Read byte out of bounds - missing error case?");
char read_byte = static_cast<char>(static_cast<unsigned char>(rr));
if (MB_CUR_MAX == 1) {
// single-byte locale, all values are legal
res = read_byte;
return res;
}
size_t sz = std::mbrtowc(&res, &read_byte, 1, &state);
switch (sz) {
case static_cast<size_t>(-1):
std::memset(&state, '\0', sizeof(state));
FLOG(reader, L"Illegal input");
return char_event_type_t::check_exit;
case static_cast<size_t>(-2):
// Sequence not yet complete.
break;
case 0:
// Actual nul char.
return 0;
default:
// Sequence complete.
return res;
}
break;
}
}
}

8
src/input_common.h
View File

@ -178,7 +178,7 @@ class char_event_t {
/// Adjust the escape timeout.
class environment_t;
void update_wait_on_escape_ms(const environment_t& vars);
void update_wait_on_escape_ms(const environment_t &vars);
/// A function type called when select() is interrupted by a signal.
/// The function maybe returns an event which is propagated back to the caller.
@ -211,7 +211,7 @@ class input_event_queue_t {
/// Add multiple characters or readline events to the front of the queue of unread characters.
/// The order of the provided events is not changed, i.e. they are not inserted in reverse
/// order.
template<typename Iterator>
template <typename Iterator>
void insert_front(const Iterator begin, const Iterator end) {
queue_.insert(queue_.begin(), begin, end);
}
@ -223,10 +223,6 @@ class input_event_queue_t {
/// \return the next event in the queue, or none if the queue is empty.
maybe_t<char_event_t> try_pop();
/// Read at most one byte from stdin, and return the event.
/// If select() is interrupted by a signal, then invoke the interrupt handler.
char_event_t readb();
int in_{0};
const interrupt_handler_t interrupt_handler_;
std::deque<char_event_t> queue_;