基于 RamFS 的命令行终端 / Command-line terminal backed by RamFS. More...

#include <terminal.hpp>

Collaboration diagram for LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >:

Public Types
enum class	Mode : uint8_t { CRLF = 0 , LF = 1 , CR = 2 }
	终端换行模式 / Terminal line ending mode. More...

Public Member Functions
	Terminal (LibXR::RamFS &ramfs, RamFS::Dir current_dir=nullptr, ReadPort read_port=STDIO::read_, WritePort *write_port=STDIO::write_, Mode MODE=Mode::CRLF)
	初始化终端的文件系统和读写端口 / Initialize the terminal filesystem and ports.

const HistoryLine &	HistoryFromNewest (int index_from_newest)
	按“从最新到最旧”的顺序取历史记录 Fetches one history entry counting from newest to oldest

void	LineFeed ()
	执行换行操作 Performs a line feed operation

void	UpdateDisplayPosition ()
	更新光标位置 Updates cursor position

bool	CanDisplayChar ()
	检查是否可以显示字符 Checks if a character can be displayed

bool	CanDeleteChar ()
	检查是否可以删除字符 Checks if a character can be deleted

void	AddCharToInputLine (char data)
	向输入行中添加字符，支持在光标位置插入 Adds a character to the input line, supports insertion at the cursor position

void	DisplayChar (char data)
	在终端上显示字符，并根据历史记录模式进行相应操作 Displays a character on the terminal and updates accordingly if history mode is active

void	RemoveCharFromInputLine ()
	从输入行中删除字符，支持在光标位置删除 Removes a character from the input line, supports deletion at the cursor position

void	DeleteChar ()
	处理删除字符操作，支持回退删除，并在历史模式下更新显示 Handles the delete character operation, supports backspace deletion, and updates display in history mode

void	ShowHeader ()
	显示终端提示符，包括当前目录信息 Displays the terminal prompt, including the current directory information

void	ShowTruncatedLineNotice ()
	输出输入行被截断的提示 Prints the notice that the input line was truncated

void	ClearLine ()
	清除当前行 Clears the current line

void	Clear ()
	清除整个终端屏幕 Clears the entire terminal screen

void	ShowHistory ()
	显示历史记录中的输入行，更新终端显示 Displays the input line from history and updates the terminal display

void	CopyHistoryToInputLine ()
	将历史命令复制到输入行，并重置历史索引、光标偏移和截断标记 Copies the history command to the input line and resets the history index, the cursor offset and the truncation mark

void	AddHistory ()
	将当前输入行添加到历史记录 Adds the current input line to the history

void	GetArgs ()
	路径解析、命令执行与补全实现 / Path parsing, command execution, and completion.

RamFS::Dir *	Path2Dir (char *path)
	将路径字符串解析为目录对象 Converts a path string into a directory object

RamFS::File *	Path2File (char *path)
	将路径字符串解析为文件对象 Converts a path string into a file object

void	ExecuteCommand ()
	解析并执行输入的命令 Parses and executes the entered command

void	AutoComplete ()
	实现命令自动补全，匹配目录或文件名 Implements command auto-completion by matching directories or file names

void	Parse (RawData &raw_data)
	输入与控制字符解析实现 / Input and control-character parsing.

void	HandleAnsiCharacter (char data)
	处理 ANSI 序列中的后续字符 Handles the follow-up characters of an ANSI sequence

void	HandleControlCharacter (char data)
	处理控制字符，包括换行、删除、制表符等 Handles control characters such as newline, delete, and tab

void	HandleCharacter (char data)
	处理输入字符，根据类型调用相应的处理函数 Handles input characters, dispatching them to the appropriate handler

Static Public Member Functions
static size_t	HistoryLineSize (const HistoryLine &line)
	行编辑、显示与历史记录实现 / Line editing, display, and command history.

static void	ThreadFun (Terminal *term)
	在线程中读取输入并驱动终端 / Read input and drive the terminal in a thread.

static void	TaskFun (Terminal *term)
	检查读取结果并推进终端输入 / Check read completion and advance terminal input.

Public Attributes
std::atomic< ReadOperation::OperationPollingStatus >	read_status_
	读完成方发布、轮询入口读取的状态 / Read completion status used by the polling entry.

std::atomic< WriteOperation::OperationPollingStatus >	write_status_
	写完成方发布的轮询状态 / Polling status published by write completion.

const Mode	MODE
	终端换行模式 / Terminal line feed mode

WriteOperation	write_op_
	终端写操作 / Terminal write operation

ReadPort *	read_port_
	读取端口 / Read port

WritePort *	write_port_
	写入端口 / Write port

WritePort::Stream	write_stream_
	写入流 / Write stream

LibXR::Mutex *	write_mutex_ = nullptr
	写入端口互斥锁 / Write port mutex

RamFS &	ramfs_
	关联的文件系统 / Associated file system

char	read_buff_ [READ_BUFF_SIZE]
	读取缓冲区 / Read buffer

size_t	request_read_size_
	本轮计划读取的字节数 / Byte count requested for the current read attempt.

RamFS::Dir *	current_dir_
	当前目录 / Current directory

uint8_t	flag_ansi_ = 0
	ANSI 控制字符状态 / ANSI control character state.

int	offset_ = 0
	光标偏移 / Cursor offset

Stack< char >	input_line_
	输入行缓冲区 / Input line buffer

char *	arg_tab_ [MAX_ARG_NUMBER]
	命令参数列表 / Command argument list

size_t	arg_number_ = 0
	参数数量 / Number of arguments

Queue< HistoryLine >	history_
	历史命令 / History of commands

int	history_index_ = -1
	当前历史索引 / Current history index

bool	linefeed_flag_ = false
	CRLF 抑制标志 / CRLF suppression flag.

char	linefeed_char_ = '\0'
	上一个换行字符 / Previous line feed character

bool	line_truncated_
	当前输入行丢弃过超长字符 / Characters beyond MAX_LINE_SIZE were dropped

Detailed Description

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 LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >

基于 RamFS 的命令行终端 / Command-line terminal backed by RamFS.

Template Parameters

READ_BUFF_SIZE	读取缓冲区大小 / Read buffer size.
MAX_LINE_SIZE	最大输入行长度（字符数）。超出的字符不回显、不写入当前行，回车时先输出一行截断提示，再照常执行已保留的部分。 Maximum input line length in characters. Further characters are neither echoed nor stored; on Enter a truncation notice is printed and the kept part is executed as usual.
MAX_ARG_NUMBER	最大参数数量 / Maximum argument count.
MAX_HISTORY_NUMBER	最大历史记录数量 / Maximum history entry count.

Definition at line 33 of file terminal.hpp.

Member Enumeration Documentation

◆ Mode

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>

enum class LibXR::Terminal::Mode : uint8_t

strong

终端换行模式 / Terminal line ending mode.

Enumerator
CRLF	回车换行 / Carriage Return + Line Feed (`\r\n`)
LF	仅换行 / Line Feed (`\n`)
CR	仅回车 / Carriage Return (`\r`)

Definition at line 85 of file terminal.hpp.

  {
    CRLF = 0,  
    LF = 1,    
    CR = 2     
  };

Constructor & Destructor Documentation

◆ Terminal()

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>

LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::Terminal	(	LibXR::RamFS &	ramfs,
		RamFS::Dir *	current_dir = nullptr,
		ReadPort *	read_port = STDIO::read_,
		WritePort *	write_port = STDIO::write_,
		Mode	MODE = Mode::CRLF )

inline

初始化终端的文件系统和读写端口 / Initialize the terminal filesystem and ports.

Parameters

ramfs	关联的文件系统 / Associated filesystem.
current_dir	当前目录，默认根目录 / Current directory; defaults to the root.
read_port	读端口，默认标准输入 / Read port; defaults to standard input.
write_port	写端口，默认标准输出 / Write port; defaults to standard output.
MODE	换行模式，默认 CRLF / Line ending mode; defaults to CRLF.

Note: 构造时分配存储 / Allocates storage during construction.

Definition at line 102 of file terminal.hpp.

      : 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();
    }
  }

Member Function Documentation

◆ AddCharToInputLine()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::AddCharToInputLine ( char data )

inline

向输入行中添加字符，支持在光标位置插入 Adds a character to the input line, supports insertion at the cursor position

Parameters

data	要添加的字符 / The character to add

Definition at line 107 of file terminal.hpp.

                                               : &ramfs_.root_),
        input_line_(MAX_LINE_SIZE + 1),
        history_(MAX_HISTORY_NUMBER)
  {
    ASSERT(read_port != nullptr);
    ASSERT(write_port != nullptr);

◆ AddHistory()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::AddHistory ( )

inline

将当前输入行添加到历史记录 Adds the current input line to the history

Note: 超过 MAX_HISTORY_NUMBER 时，当前实现会丢掉最旧的一条，再压入最新输入。 When MAX_HISTORY_NUMBER is exceeded, the current implementation drops the oldest entry before pushing the newest input line.

Definition at line 317 of file terminal.hpp.

{
 
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

◆ AutoComplete()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::AutoComplete ( )

inline

实现命令自动补全，匹配目录或文件名 Implements command auto-completion by matching directories or file names

Note: 当前自动补全只处理“第一参数且光标在该参数尾部”这一种情况，不会解析后续参数。 The current auto-completion handles only the first argument when the cursor is at that argument's tail; it does not parse later arguments.

Definition at line 240 of file terminal.hpp.

{
 
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

◆ CanDeleteChar()

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>

bool LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::CanDeleteChar ( )

inline

检查是否可以删除字符 Checks if a character can be deleted

Returns: bool 是否可以删除字符 / Whether the character can be deleted

Definition at line 100 of file terminal.hpp.

◆ CanDisplayChar()

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>

bool LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::CanDisplayChar ( )

inline

检查是否可以显示字符 Checks if a character can be displayed

Returns: bool 是否可以显示字符 / Whether the character can be displayed

Definition at line 93 of file terminal.hpp.

◆ Clear()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::Clear ( )

inline

清除整个终端屏幕 Clears the entire terminal screen

Definition at line 264 of file terminal.hpp.

{
 
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

◆ ClearLine()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::ClearLine ( )

inline

清除当前行 Clears the current line

Definition at line 258 of file terminal.hpp.

{
 
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

◆ CopyHistoryToInputLine()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::CopyHistoryToInputLine ( )

inline

将历史命令复制到输入行，并重置历史索引、光标偏移和截断标记 Copies the history command to the input line and resets the history index, the cursor offset and the truncation mark

Definition at line 295 of file terminal.hpp.

{
 
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

◆ DeleteChar()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::DeleteChar ( )

inline

处理删除字符操作，支持回退删除，并在历史模式下更新显示 Handles the delete character operation, supports backspace deletion, and updates display in history mode

Definition at line 181 of file terminal.hpp.

◆ DisplayChar()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::DisplayChar ( char data )

inline

在终端上显示字符，并根据历史记录模式进行相应操作 Displays a character on the terminal and updates accordingly if history mode is active

Parameters

data	要显示的字符 / The character to display

Definition at line 126 of file terminal.hpp.

    {
      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_;        

◆ ExecuteCommand()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::ExecuteCommand ( )

inline

解析并执行输入的命令 Parses and executes the entered command

Note: 当前实现只内建了 cd 和 ls；其它命令都按“把第一个参数当 RamFS 可执行文件路径”来处理。 The current implementation provides only the built-in cd and ls; every other command is handled by treating the first argument as the path of an executable RamFS file.

Definition at line 152 of file terminal.hpp.

◆ GetArgs()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::GetArgs ( )

inline

路径解析、命令执行与补全实现 / Path parsing, command execution, and completion.

Terminal 的命令解析片段 Command-parsing fragment of Terminal

Note: 这一组函数只负责把当前输入行解释成命令：参数切分、路径解析、内建命令执行、可执行文件查找以及自动补全。 This group is responsible only for interpreting the current input line as a command: argument tokenization, path resolution, built-in command execution, executable lookup, and auto-completion.

解析输入行，将其拆分为参数数组 Parses the input line and splits it into argument array

Note: 该过程会原地把空格改成 \0，并把每个参数起始位置填进 arg_tab_。 This process overwrites spaces in-place with \0 and stores each argument start pointer into arg_tab_.

Definition at line 21 of file terminal.hpp.

34{

35 private:

◆ HandleAnsiCharacter()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::HandleAnsiCharacter ( char data )

inline

处理 ANSI 序列中的后续字符 Handles the follow-up characters of an ANSI sequence

Parameters

data	输入字符 / The input character

Note: 当前实现只识别箭头键对应的尾字符；其它 ANSI 序列会被静默忽略。 The current implementation recognizes only the tail characters used by arrow keys; other ANSI sequences are ignored silently.

Definition at line 37 of file terminal.hpp.

  {
    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     
  };
 

◆ HandleCharacter()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::HandleCharacter ( char data )

inline

处理输入字符，根据类型调用相应的处理函数 Handles input characters, dispatching them to the appropriate handler

Parameters

data	输入的字符 / The input character

Definition at line 171 of file terminal.hpp.

◆ HandleControlCharacter()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::HandleControlCharacter ( char data )

inline

处理控制字符，包括换行、删除、制表符等 Handles control characters such as newline, delete, and tab

Parameters

data	输入的控制字符 / The input control character

Note: 这里还负责去掉一对 \r\n / \n\r 双换行中的重复第二字节，避免一次回车被当成两次命令提交。 This path also suppresses the duplicated second byte of one \r\n / \n\r pair so a single Enter key does not submit the command twice.

Definition at line 111 of file terminal.hpp.

                                               : &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;     

◆ HistoryFromNewest()

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>

const HistoryLine & LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::HistoryFromNewest ( int index_from_newest )

inline

按“从最新到最旧”的顺序取历史记录 Fetches one history entry counting from newest to oldest

Parameters

index_from_newest 从最新一条开始的偏移；0 表示最新一条 Offset counted from the newest entry; 0 means the newest one

Returns: const HistoryLine& 对应的历史记录 Reference to the requested history entry

Note: Queue::operator[] 支持负索引从尾部反向访问，但这里把这个细节包起来，避免调用点直接暴露 history_[-index - 1] 这种难读写法。 Queue::operator[] supports negative indices to walk backward from the tail, but this helper hides that detail so call sites do not have to expose the hard-to-read history_[-index - 1] form directly.

Definition at line 42 of file terminal.hpp.

◆ HistoryLineSize()

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>

static size_t LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::HistoryLineSize ( const HistoryLine & line )

inlinestatic

行编辑、显示与历史记录实现 / Line editing, display, and command history.

Terminal 的显示与历史记录片段 Display and history fragment of Terminal

Note: 这一组函数只负责行编辑、提示符显示、光标移动，以及历史记录的展示/拷回。 This group is responsible only for line editing, prompt rendering, cursor movement, and displaying / restoring history entries.

计算一条历史命令的实际文本长度 Calculates the actual text length of one stored history line

Parameters

line	历史命令缓存 / Stored history line

Returns: size_t 历史命令的实际长度 Actual length of the history line

Definition at line 18 of file terminal.hpp.

18{

19

◆ LineFeed()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::LineFeed ( )

inline

执行换行操作 Performs a line feed operation

Note: 具体输出 \r\n、\n 还是 \r 由构造时选定的 MODE 决定。 The actual emitted line ending is selected by the MODE chosen at construction time.

Definition at line 57 of file terminal.hpp.

  {
    auto len = strlen(str);
    for (int i = static_cast<int>(len - 1); i >= 0; i--)

◆ Parse()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::Parse ( RawData & raw_data )

inline

输入与控制字符解析实现 / Input and control-character parsing.

Terminal 的输入解析片段 Input-parsing fragment of Terminal

Note: 这一组函数只负责把读到的原始字节分发成 ANSI 序列、可显示字符或控制字符，不直接处理文件系统命令语义。 This group is responsible only for routing raw bytes into ANSI sequences, printable characters, or control characters; it does not directly own filesystem-command semantics.

解析输入数据流，将其转换为字符并处理 Parses the input data stream, converting it into characters and processing them

Parameters

raw_data 输入的原始数据 / Input raw data

Definition at line 19 of file terminal.hpp.

◆ Path2Dir()

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>

RamFS::Dir * LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::Path2Dir ( char * path )

inline

将路径字符串解析为目录对象 Converts a path string into a directory object

Parameters

path	目录路径字符串 / The directory path string

Returns: RamFS::Dir* 解析出的目录指针，若找不到则返回 nullptr Pointer to the resolved directory, or nullptr if not found

Note: 解析过程中会暂时把路径中的 / 改写成 \0 再恢复，所以调用方必须传入可写缓冲区，而不是字符串常量。 The resolver temporarily rewrites / to \0 and restores it later, so callers must provide a writable buffer rather than a string literal.

Definition at line 52 of file terminal.hpp.

  {
    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     
  };
 

◆ Path2File()

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>

RamFS::File * LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::Path2File ( char * path )

inline

将路径字符串解析为文件对象 Converts a path string into a file object

Parameters

path	文件路径字符串 / The file path string

Returns: RamFS::File* 解析出的文件指针，若找不到则返回 nullptr Pointer to the resolved file, or nullptr if not found

Note: 这个解析同样会临时切开路径字符串，因此也要求 path 可写。 This resolver also temporarily splits the path string and therefore requires path to be writable.

Definition at line 110 of file terminal.hpp.

                                               : &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_;

◆ RemoveCharFromInputLine()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::RemoveCharFromInputLine ( )

inline

从输入行中删除字符，支持在光标位置删除 Removes a character from the input line, supports deletion at the cursor position

Definition at line 163 of file terminal.hpp.

◆ ShowHeader()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::ShowHeader ( )

inline

显示终端提示符，包括当前目录信息 Displays the terminal prompt, including the current directory information

Definition at line 214 of file terminal.hpp.

{
 
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

◆ ShowHistory()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::ShowHistory ( )

inline

显示历史记录中的输入行，更新终端显示 Displays the input line from history and updates the terminal display

Note: 当 history_index_ < 0 时，这里回显的是当前尚未提交的输入行，而不是历史项。 When history_index_ < 0, this echoes the current in-progress input line rather than one history entry.

Definition at line 274 of file terminal.hpp.

{
 
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

◆ ShowTruncatedLineNotice()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::ShowTruncatedLineNotice ( )

inline

输出输入行被截断的提示 Prints the notice that the input line was truncated

Note: 提示写明保留的字符数，即模板参数 MAX_LINE_SIZE，随后换行。 The notice names the kept character count, the template parameter MAX_LINE_SIZE, and ends with a line feed.

Definition at line 237 of file terminal.hpp.

{
 
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

◆ TaskFun()

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>

static void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::TaskFun ( Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER > * term )

inlinestatic

检查读取结果并推进终端输入 / Check read completion and advance terminal input.

Parameters

term	终端实例 / Terminal instance.

Note: 首次调用发起读取；RUNNING 时返回，DONE 时解析并提交输出，再发起下次读取。 ERROR 时重新读取。解析和输出提交受 write_mutex_ 保护。 Starts a read on first use; returns for RUNNING. On DONE, parses and commits output, then starts the next read. On ERROR, restarts reading. Parsing and output submission hold write_mutex_.

Definition at line 46 of file terminal.hpp.

  {
    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     
  };

◆ ThreadFun()

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>

static void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::ThreadFun ( Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER > * term )

inlinestatic

在线程中读取输入并驱动终端 / Read input and drive the terminal in a thread.

Parameters

term	终端实例 / Terminal instance.

Note: 无数据时通过零长度 BLOCK 读等待队列非空；取得输入后，在 write_mutex_ 保护下解析并提交输出。 With no data, a zero-length BLOCK read waits for a nonempty queue. Received input is parsed and output committed under write_mutex_.

Definition at line 15 of file terminal.hpp.

{
 
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:

◆ UpdateDisplayPosition()

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>

void LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::UpdateDisplayPosition ( )

inline

更新光标位置 Updates cursor position

Note: 这里只重绘光标右侧的可见后缀；光标左侧的内容已经在输入缓冲区中保留。 This redraws only the visible suffix to the right of the cursor; the left side is already preserved in the input buffer.

Definition at line 81 of file terminal.hpp.

       :
  enum class Mode : uint8_t
  {

Member Data Documentation

◆ arg_number_

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>

size_t LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::arg_number_ = 0

参数数量 / Number of arguments

Definition at line 161 of file terminal.hpp.

◆ arg_tab_

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>

char* LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::arg_tab_[MAX_ARG_NUMBER]

命令参数列表 / Command argument list

Definition at line 160 of file terminal.hpp.

◆ current_dir_

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>

RamFS::Dir* LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::current_dir_

当前目录 / Current directory

Definition at line 156 of file terminal.hpp.

◆ flag_ansi_

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>

uint8_t LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::flag_ansi_ = 0

ANSI 控制字符状态 / ANSI control character state.

Definition at line 157 of file terminal.hpp.

◆ history_

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>

Queue<HistoryLine> LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::history_

历史命令 / History of commands

Definition at line 162 of file terminal.hpp.

◆ history_index_

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>

int LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::history_index_ = -1

当前历史索引 / Current history index

Definition at line 163 of file terminal.hpp.

◆ input_line_

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>

Stack<char> LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::input_line_

输入行缓冲区 / Input line buffer

Definition at line 159 of file terminal.hpp.

◆ line_truncated_

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>

bool LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::line_truncated_

Initial value:

=

false

当前输入行丢弃过超长字符 / Characters beyond MAX_LINE_SIZE were dropped

Definition at line 166 of file terminal.hpp.

◆ linefeed_char_

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>

char LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::linefeed_char_ = '\0'

上一个换行字符 / Previous line feed character

Definition at line 165 of file terminal.hpp.

◆ linefeed_flag_

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>

bool LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::linefeed_flag_ = false

CRLF 抑制标志 / CRLF suppression flag.

Definition at line 164 of file terminal.hpp.

◆ MODE

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>

const Mode LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::MODE

终端换行模式 / Terminal line feed mode

Definition at line 143 of file terminal.hpp.

◆ offset_

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>

int LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::offset_ = 0

光标偏移 / Cursor offset

Definition at line 158 of file terminal.hpp.

◆ ramfs_

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>

RamFS& LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::ramfs_

关联的文件系统 / Associated file system

Definition at line 151 of file terminal.hpp.

◆ read_buff_

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>

char LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::read_buff_[READ_BUFF_SIZE]

读取缓冲区 / Read buffer

Definition at line 152 of file terminal.hpp.

◆ read_port_

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>

ReadPort* LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::read_port_

读取端口 / Read port

Definition at line 145 of file terminal.hpp.

◆ read_status_

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>

std::atomic<ReadOperation::OperationPollingStatus> LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::read_status_

读完成方发布、轮询入口读取的状态 / Read completion status used by the polling entry.

Definition at line 139 of file terminal.hpp.

◆ request_read_size_

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>

size_t LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::request_read_size_

Initial value:

=

0

本轮计划读取的字节数 / Byte count requested for the current read attempt.

Definition at line 154 of file terminal.hpp.

◆ write_mutex_

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>

LibXR::Mutex* LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::write_mutex_ = nullptr

写入端口互斥锁 / Write port mutex

Definition at line 149 of file terminal.hpp.

◆ write_op_

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>

WriteOperation LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::write_op_

终端写操作 / Terminal write operation

Definition at line 144 of file terminal.hpp.

◆ write_port_

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>

WritePort* LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::write_port_

写入端口 / Write port

Definition at line 146 of file terminal.hpp.

◆ write_status_

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>

std::atomic<WriteOperation::OperationPollingStatus> LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::write_status_

写完成方发布的轮询状态 / Polling status published by write completion.

Definition at line 141 of file terminal.hpp.

◆ write_stream_

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>

WritePort::Stream LibXR::Terminal< READ_BUFF_SIZE, MAX_LINE_SIZE, MAX_ARG_NUMBER, MAX_HISTORY_NUMBER >::write_stream_

写入流 / Write stream

Definition at line 147 of file terminal.hpp.

The documentation for this class was generated from the following file:

src/middleware/terminal/terminal.hpp

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Member Enumeration Documentation

◆ Mode

Constructor & Destructor Documentation

◆ Terminal()

Member Function Documentation

◆ AddCharToInputLine()

◆ AddHistory()

◆ AutoComplete()

◆ CanDeleteChar()

◆ CanDisplayChar()

◆ Clear()

◆ ClearLine()

◆ CopyHistoryToInputLine()

◆ DeleteChar()

◆ DisplayChar()

◆ ExecuteCommand()

◆ GetArgs()

◆ HandleAnsiCharacter()

◆ HandleCharacter()

◆ HandleControlCharacter()

◆ HistoryFromNewest()

◆ HistoryLineSize()

◆ LineFeed()

◆ Parse()

◆ Path2Dir()

◆ Path2File()

◆ RemoveCharFromInputLine()

◆ ShowHeader()

◆ ShowHistory()

◆ ShowTruncatedLineNotice()

◆ TaskFun()

◆ ThreadFun()

◆ UpdateDisplayPosition()

Member Data Documentation

◆ arg_number_

◆ arg_tab_

◆ current_dir_

◆ flag_ansi_

◆ history_

◆ history_index_

◆ input_line_

◆ line_truncated_

◆ linefeed_char_

◆ linefeed_flag_

◆ MODE

◆ offset_

◆ ramfs_

◆ read_buff_

◆ read_port_

◆ read_status_

◆ request_read_size_

◆ write_mutex_

◆ write_op_

◆ write_port_

◆ write_status_

◆ write_stream_