terminal.hpp

#pragma once
 
#include <array>
#include <atomic>
#include <cctype>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <utility>
 
#include "libxr_rw.hpp"
#include "ramfs.hpp"
#include "semaphore.hpp"
#include "stack.hpp"
 
namespace LibXR
{
 
template <size_t READ_BUFF_SIZE = 32, size_t MAX_LINE_SIZE = READ_BUFF_SIZE,
          size_t MAX_ARG_NUMBER = 5, size_t MAX_HISTORY_NUMBER = 5>
class Terminal
{
 private:
  using HistoryLine = std::array<char, MAX_LINE_SIZE + 1>;
 
  static constexpr char CLEAR_ALL[] =
      "\033[2J\033[1H";  
  static constexpr char CLEAR_LINE[] =
      "\033[2K\r";  
  static constexpr char CLEAR_BEHIND[] =
      "\033[K";  
  static constexpr char KEY_RIGHT[] = "\033[C";  
  static constexpr char KEY_LEFT[] = "\033[D";   
  static constexpr char KEY_SAVE[] = "\033[s";   
  static constexpr char KEY_LOAD[] =
      "\033[u";  
  static constexpr char DELETE_CHAR[] =
      "\b \b";  
 
  char* StrchrRev(char* str, char c)
  {
    auto len = strlen(str);
    for (int i = static_cast<int>(len - 1); i >= 0; i--)
    {
      if (str[i] == c)
      {
        return str + i;
      }
    }
    return nullptr;
  }
 
 public:
  enum class Mode : uint8_t
  {
    CRLF = 0,  
    LF = 1,    
    CR = 2     
  };
 
  Terminal(LibXR::RamFS& ramfs, RamFS::Dir* current_dir = nullptr,
           ReadPort* read_port = STDIO::read_, WritePort* write_port = STDIO::write_,
           Mode MODE = Mode::CRLF)
      : read_status_(ReadOperation::OperationPollingStatus::READY),
        write_status_(WriteOperation::OperationPollingStatus::READY),
        MODE(MODE),
        write_op_(write_status_),
        read_port_(read_port),
        write_port_(write_port),
        write_stream_(write_port_, write_op_),
        ramfs_(ramfs),
        current_dir_(current_dir ? current_dir : &ramfs_.root_),
        input_line_(MAX_LINE_SIZE + 1),
        history_(MAX_HISTORY_NUMBER)
  {
    ASSERT(read_port != nullptr);
    ASSERT(write_port != nullptr);
    ASSERT(read_port->Readable());
    ASSERT(write_port->Writable());
 
    if (write_port == STDIO::write_)
    {
      if (STDIO::write_mutex_ == nullptr)
      {
        STDIO::write_mutex_ = new LibXR::Mutex();
      }
 
      write_mutex_ = STDIO::write_mutex_;
      STDIO::write_stream_ = &write_stream_;
    }
    else
    {
      write_mutex_ = new LibXR::Mutex();
    }
  }
 
  std::atomic<ReadOperation::OperationPollingStatus> read_status_;
  std::atomic<WriteOperation::OperationPollingStatus> write_status_;
 
  const Mode MODE;                  
  WriteOperation write_op_;         
  ReadPort* read_port_;             
  WritePort* write_port_;           
  WritePort::Stream write_stream_;  
 
  LibXR::Mutex* write_mutex_ = nullptr;  
 
  RamFS& ramfs_;                    
  char read_buff_[READ_BUFF_SIZE];  
 
  size_t request_read_size_ =
      0;  
  RamFS::Dir* current_dir_;        
  uint8_t flag_ansi_ = 0;          
  int offset_ = 0;                 
  Stack<char> input_line_;         
  char* arg_tab_[MAX_ARG_NUMBER];  
  size_t arg_number_ = 0;          
  Queue<HistoryLine> history_;     
  int history_index_ = -1;         
  bool linefeed_flag_ = false;     
  char linefeed_char_ = '\0';      
  bool line_truncated_ =
      false;  
 
#include "display.hpp"
 
#include "command.hpp"
 
#include "input.hpp"
 
#include "driver.hpp"
};
 
}  // namespace LibXR