terminal_input_parser.cpp

Go to the documentation of this file.

#include "ftxui/component/terminal_input_parser.hpp"
 
#include <cstdint>  // for uint32_t
#include <memory>   // for unique_ptr
#include <utility>  // for move
 
#include "ftxui/component/event.hpp"  // for Event
#include "ftxui/component/task.hpp"   // for Task
 
namespace ftxui {
 
TerminalInputParser::TerminalInputParser(Sender<Task> out)
    : out_(std::move(out)) {}
 
void TerminalInputParser::Timeout(int time) {
  timeout_ += time;
  const int timeout_threshold = 50;
  if (timeout_ < timeout_threshold) {
    return;
  }
  timeout_ = 0;
  if (!pending_.empty()) {
    Send(SPECIAL);
  }
}
 
void TerminalInputParser::Add(char c) {
  pending_ += c;
  timeout_ = 0;
  position_ = -1;
  Send(Parse());
}
 
unsigned char TerminalInputParser::Current() {
  return pending_[position_];
}
 
bool TerminalInputParser::Eat() {
  position_++;
  return position_ < (int)pending_.size();
}
 
void TerminalInputParser::Send(TerminalInputParser::Output output) {
  switch (output.type) {
    case UNCOMPLETED:
      return;
 
    case DROP:
      pending_.clear();
      return;
 
    case CHARACTER:
      out_->Send(Event::Character(std::move(pending_)));
      pending_.clear();
      return;
 
    case SPECIAL:
      // Microsoft's terminal uses a different new line character for the return
      // key. This also happens with linux with the `bind` command:
      // See https://github.com/ArthurSonzogni/FTXUI/issues/337
      // Here, we uniformize the new line character to `\n`.
      if (pending_ == "\r") {
        out_->Send(Event::Special("\n"));
      } else {
        out_->Send(Event::Special(std::move(pending_)));
      }
      pending_.clear();
      return;
 
    case MOUSE:
      out_->Send(Event::Mouse(std::move(pending_), output.mouse));  // NOLINT
      pending_.clear();
      return;
 
    case CURSOR_REPORTING:
      out_->Send(Event::CursorReporting(std::move(pending_),  // NOLINT
                                        output.cursor.x,      // NOLINT
                                        output.cursor.y));    // NOLINT
      pending_.clear();
      return;
  }
  // NOT_REACHED().
}
 
TerminalInputParser::Output TerminalInputParser::Parse() {
  if (!Eat()) {
    return UNCOMPLETED;
  }
 
  switch (Current()) {
    case 24:  // CAN NOLINT
    case 26:  // SUB NOLINT
      return DROP;
 
    case '\x1B':
      return ParseESC();
    default:
      break;
  }
 
  if (Current() < 32) {  // C0 NOLINT
    return SPECIAL;
  }
 
  if (Current() == 127) {  // Delete // NOLINT
    return SPECIAL;
  }
 
  return ParseUTF8();
}
 
// Code point <-> UTF-8 conversion
//
// ┏━━━━━━━━┳━━━━━━━━┳━━━━━━━━┳━━━━━━━━┓
// ┃Byte 1  ┃Byte 2  ┃Byte 3  ┃Byte 4  ┃
// ┡━━━━━━━━╇━━━━━━━━╇━━━━━━━━╇━━━━━━━━┩
// │0xxxxxxx│        │        │        │
// ├────────┼────────┼────────┼────────┤
// │110xxxxx│10xxxxxx│        │        │
// ├────────┼────────┼────────┼────────┤
// │1110xxxx│10xxxxxx│10xxxxxx│        │
// ├────────┼────────┼────────┼────────┤
// │11110xxx│10xxxxxx│10xxxxxx│10xxxxxx│
// └────────┴────────┴────────┴────────┘
//
// Then some sequences are illegal if it exist a shorter representation of the
// same codepoint.
TerminalInputParser::Output TerminalInputParser::ParseUTF8() {
  auto head = static_cast<unsigned char>(Current());
  unsigned char selector = 0b1000'0000;  // NOLINT
 
  // The non code-point part of the first byte.
  unsigned char mask = selector;
 
  // Find the first zero in the first byte.
  unsigned int first_zero = 8;            // NOLINT
  for (unsigned int i = 0; i < 8; ++i) {  // NOLINT
    mask |= selector;
    if (!(head & selector)) {
      first_zero = i;
      break;
    }
    selector >>= 1U;
  }
 
  // Accumulate the value of the first byte.
  auto value = uint32_t(head & ~mask);  // NOLINT
 
  // Invalid UTF8, with more than 5 bytes.
  const unsigned int max_utf8_bytes = 5;
  if (first_zero == 1 || first_zero >= max_utf8_bytes) {
    return DROP;
  }
 
  // Multi byte UTF-8.
  for (unsigned int i = 2; i <= first_zero; ++i) {
    if (!Eat()) {
      return UNCOMPLETED;
    }
 
    // Invalid continuation byte.
    head = static_cast<unsigned char>(Current());
    if ((head & 0b1100'0000) != 0b1000'0000) {  // NOLINT
      return DROP;
    }
    value <<= 6;                  // NOLINT
    value += head & 0b0011'1111;  // NOLINT
  }
 
  // Check for overlong UTF8 encoding.
  int extra_byte = 0;
  if (value <= 0b000'0000'0111'1111) {                 // NOLINT
    extra_byte = 0;                                    // NOLINT
  } else if (value <= 0b000'0111'1111'1111) {          // NOLINT
    extra_byte = 1;                                    // NOLINT
  } else if (value <= 0b1111'1111'1111'1111) {         // NOLINT
    extra_byte = 2;                                    // NOLINT
  } else if (value <= 0b1'0000'1111'1111'1111'1111) {  // NOLINT
    extra_byte = 3;                                    // NOLINT
  } else {                                             // NOLINT
    return DROP;
  }
 
  if (extra_byte != position_) {
    return DROP;
  }
 
  return CHARACTER;
}
 
TerminalInputParser::Output TerminalInputParser::ParseESC() {
  if (!Eat()) {
    return UNCOMPLETED;
  }
  switch (Current()) {
    case 'P':
      return ParseDCS();
    case '[':
      return ParseCSI();
    case ']':
      return ParseOSC();
    default:
      if (!Eat()) {
        return UNCOMPLETED;
      } else {
        return SPECIAL;
      }
  }
}
 
TerminalInputParser::Output TerminalInputParser::ParseDCS() {
  // Parse until the string terminator ST.
  while (true) {
    if (!Eat()) {
      return UNCOMPLETED;
    }
 
    if (Current() != '\x1B') {
      continue;
    }
 
    if (!Eat()) {
      return UNCOMPLETED;
    }
 
    if (Current() != '\\') {
      continue;
    }
 
    return SPECIAL;
  }
}
 
TerminalInputParser::Output TerminalInputParser::ParseCSI() {
  bool altered = false;
  int argument = 0;
  std::vector<int> arguments;
  while (true) {
    if (!Eat()) {
      return UNCOMPLETED;
    }
 
    if (Current() == '<') {
      altered = true;
      continue;
    }
 
    if (Current() >= '0' && Current() <= '9') {
      argument *= 10;  // NOLINT
      argument += int(Current() - '0');
      continue;
    }
 
    if (Current() == ';') {
      arguments.push_back(argument);
      argument = 0;
      continue;
    }
 
    if (Current() >= ' ' && Current() <= '~' && Current() != '<') {
      arguments.push_back(argument);
      argument = 0;  // NOLINT
      switch (Current()) {
        case 'M':
          return ParseMouse(altered, true, std::move(arguments));
        case 'm':
          return ParseMouse(altered, false, std::move(arguments));
        case 'R':
          return ParseCursorReporting(std::move(arguments));
        default:
          return SPECIAL;
      }
    }
 
    // Invalid ESC in CSI.
    if (Current() == '\x1B') {
      return SPECIAL;
    }
  }
}
 
TerminalInputParser::Output TerminalInputParser::ParseOSC() {
  // Parse until the string terminator ST.
  while (true) {
    if (!Eat()) {
      return UNCOMPLETED;
    }
    if (Current() != '\x1B') {
      continue;
    }
    if (!Eat()) {
      return UNCOMPLETED;
    }
    if (Current() != '\\') {
      continue;
    }
    return SPECIAL;
  }
}
 
TerminalInputParser::Output TerminalInputParser::ParseMouse(  // NOLINT
    bool altered,
    bool pressed,
    std::vector<int> arguments) {
  if (arguments.size() != 3) {
    return SPECIAL;
  }
 
  (void)altered;
 
  Output output(MOUSE);
  output.mouse.button = Mouse::Button((arguments[0] & 3) +          // NOLINT
                                      ((arguments[0] & 64) >> 4));  // NOLINT
  output.mouse.motion = Mouse::Motion(pressed);                     // NOLINT
  output.mouse.shift = bool(arguments[0] & 4);                      // NOLINT
  output.mouse.meta = bool(arguments[0] & 8);                       // NOLINT
  output.mouse.x = arguments[1];                                    // NOLINT
  output.mouse.y = arguments[2];                                    // NOLINT
  return output;
}
 
// NOLINTNEXTLINE
TerminalInputParser::Output TerminalInputParser::ParseCursorReporting(
    std::vector<int> arguments) {
  if (arguments.size() != 2) {
    return SPECIAL;
  }
  Output output(CURSOR_REPORTING);
  output.cursor.y = arguments[0];  // NOLINT
  output.cursor.x = arguments[1];  // NOLINT
  return output;
}
 
}  // namespace ftxui
 
// Copyright 2020 Arthur Sonzogni. All rights reserved.
// Use of this source code is governed by the MIT license that can be found in
// the LICENSE file.