1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/vlib/readline/readline_linux.c.v

588 lines
15 KiB
V
Raw Normal View History

2022-01-04 12:21:08 +03:00
// Copyright (c) 2019-2022 Alexander Medvednikov. All rights reserved.
2019-08-30 21:57:54 +03:00
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
//
// Serves as more advanced input method
// based on the work of https://github.com/AmokHuginnsson/replxx
//
2019-08-30 21:57:54 +03:00
module readline
import term
import os
2019-08-30 21:57:54 +03:00
#include <termios.h>
#include <sys/ioctl.h>
const cclen = 10
// Termios stores the terminal options on Linux.
struct C.termios {
mut:
c_iflag int
c_oflag int
c_cflag int
c_lflag int
c_line byte
c_cc [cclen]int
}
struct Termios {
mut:
c_iflag u32
c_oflag u32
c_cflag u32
c_lflag u32
c_line byte
c_cc [cclen]int
}
fn C.tcgetattr(fd int, termios_p &C.termios) int
fn C.tcsetattr(fd int, optional_actions int, const_termios_p &C.termios) int
fn C.raise(sig int)
fn C.getppid() int
// Action defines what actions to be executed.
enum Action {
2020-08-27 12:20:31 +03:00
eof
nothing
insert_character
commit_line
delete_left
delete_right
move_cursor_left
move_cursor_right
move_cursor_begining
move_cursor_end
move_cursor_word_left
move_cursor_word_right
history_previous
history_next
overwrite
clear_screen
suspend
2019-08-30 21:57:54 +03:00
}
// enable_raw_mode enables the raw mode of the terminal.
// In raw mode all key presses are directly sent to the program and no interpretation is done.
// Please note that `enable_raw_mode` catches the `SIGUSER` (CTRL + C) signal.
// For a method that does please see `enable_raw_mode_nosig`.
2020-05-17 14:51:18 +03:00
pub fn (mut r Readline) enable_raw_mode() {
if unsafe { C.tcgetattr(0, &C.termios(&r.orig_termios)) } != 0 {
2020-08-27 12:20:31 +03:00
r.is_tty = false
r.is_raw = false
return
}
mut raw := C.termios{}
unsafe { vmemcpy(&raw, &r.orig_termios, int(sizeof(raw))) }
// println('> r.orig_termios: $r.orig_termios')
// println('> raw: $raw')
2020-08-27 12:20:31 +03:00
raw.c_iflag &= ~(C.BRKINT | C.ICRNL | C.INPCK | C.ISTRIP | C.IXON)
raw.c_cflag |= C.CS8
2020-08-27 12:20:31 +03:00
raw.c_lflag &= ~(C.ECHO | C.ICANON | C.IEXTEN | C.ISIG)
raw.c_cc[C.VMIN] = byte(1)
raw.c_cc[C.VTIME] = byte(0)
unsafe { C.tcsetattr(0, C.TCSADRAIN, &raw) }
// println('> after raw: $raw')
2020-08-27 12:20:31 +03:00
r.is_raw = true
r.is_tty = true
2019-08-30 21:57:54 +03:00
}
// enable_raw_mode_nosig enables the raw mode of the terminal.
// In raw mode all key presses are directly sent to the program and no interpretation is done.
// Please note that `enable_raw_mode_nosig` does not catch the `SIGUSER` (CTRL + C) signal
// as opposed to `enable_raw_mode`.
2020-05-17 14:51:18 +03:00
pub fn (mut r Readline) enable_raw_mode_nosig() {
if unsafe { C.tcgetattr(0, &C.termios(&r.orig_termios)) } != 0 {
2020-08-27 12:20:31 +03:00
r.is_tty = false
r.is_raw = false
return
}
mut raw := C.termios{}
unsafe { vmemcpy(&raw, &r.orig_termios, int(sizeof(raw))) }
2020-08-27 12:20:31 +03:00
raw.c_iflag &= ~(C.BRKINT | C.ICRNL | C.INPCK | C.ISTRIP | C.IXON)
raw.c_cflag |= C.CS8
2020-08-27 12:20:31 +03:00
raw.c_lflag &= ~(C.ECHO | C.ICANON | C.IEXTEN)
raw.c_cc[C.VMIN] = byte(1)
raw.c_cc[C.VTIME] = byte(0)
unsafe { C.tcsetattr(0, C.TCSADRAIN, &raw) }
2020-08-27 12:20:31 +03:00
r.is_raw = true
r.is_tty = true
2019-08-30 21:57:54 +03:00
}
// disable_raw_mode disables the raw mode of the terminal.
// For a description of raw mode please see the `enable_raw_mode` method.
2020-05-17 14:51:18 +03:00
pub fn (mut r Readline) disable_raw_mode() {
2020-08-27 12:20:31 +03:00
if r.is_raw {
unsafe { C.tcsetattr(0, C.TCSADRAIN, &C.termios(&r.orig_termios)) }
2020-08-27 12:20:31 +03:00
r.is_raw = false
}
2019-08-30 21:57:54 +03:00
}
// read_char reads a single character.
2020-03-27 11:55:15 +03:00
pub fn (r Readline) read_char() int {
2020-08-27 12:20:31 +03:00
return utf8_getchar()
2019-08-30 21:57:54 +03:00
}
// read_line_utf8 blocks execution in a loop and awaits user input
// characters from a terminal until `EOF` or `Enter` key is encountered
// in the input stream.
2021-06-30 22:30:28 +03:00
// read_line_utf8 returns the complete input line as an UTF-8 encoded `[]rune` or
// an error if the line is empty.
// The `prompt` `string` is output as a prefix text for the input capturing.
// read_line_utf8 is the main method of the `readline` module and `Readline` struct.
2021-06-30 22:30:28 +03:00
pub fn (mut r Readline) read_line_utf8(prompt string) ?[]rune {
r.current = []rune{}
2020-08-27 12:20:31 +03:00
r.cursor = 0
r.prompt = prompt
r.search_index = 0
r.prompt_offset = get_prompt_offset(prompt)
if r.previous_lines.len <= 1 {
2021-06-30 22:30:28 +03:00
r.previous_lines << []rune{}
r.previous_lines << []rune{}
2020-08-27 12:20:31 +03:00
} else {
2021-06-30 22:30:28 +03:00
r.previous_lines[0] = []rune{}
2020-08-27 12:20:31 +03:00
}
if !r.is_raw {
r.enable_raw_mode()
}
print(r.prompt)
for {
unsafe { C.fflush(C.stdout) }
2020-08-27 12:20:31 +03:00
c := r.read_char()
a := r.analyse(c)
if r.execute(a, c) {
break
}
}
2021-06-30 22:30:28 +03:00
r.previous_lines[0] = []rune{}
2020-08-27 12:20:31 +03:00
r.search_index = 0
r.disable_raw_mode()
2021-06-30 22:30:28 +03:00
if r.current.len == 0 {
2020-08-27 12:20:31 +03:00
return error('empty line')
}
return r.current
}
// read_line does the same as `read_line_utf8` but returns user input as a `string`.
2021-06-30 22:30:28 +03:00
// (As opposed to `[]rune` returned by `read_line_utf8`).
2020-05-17 14:51:18 +03:00
pub fn (mut r Readline) read_line(prompt string) ?string {
s := r.read_line_utf8(prompt) ?
2021-06-30 22:30:28 +03:00
return s.string()
}
// read_line_utf8 blocks execution in a loop and awaits user input
// characters from a terminal until `EOF` or `Enter` key is encountered
// in the input stream.
2021-06-30 22:30:28 +03:00
// read_line_utf8 returns the complete input line as an UTF-8 encoded `[]rune` or
// an error if the line is empty.
// The `prompt` `string` is output as a prefix text for the input capturing.
// read_line_utf8 is the main method of the `readline` module and `Readline` struct.
// NOTE that this version of `read_line_utf8` is a standalone function without
// persistent functionalities (e.g. history).
2021-06-30 22:30:28 +03:00
pub fn read_line_utf8(prompt string) ?[]rune {
2020-08-27 12:20:31 +03:00
mut r := Readline{}
s := r.read_line_utf8(prompt) ?
2020-08-27 12:20:31 +03:00
return s
}
// read_line does the same as `read_line_utf8` but returns user input as a `string`.
2021-06-30 22:30:28 +03:00
// (As opposed to `[]rune` as returned by `read_line_utf8`).
// NOTE that this version of `read_line` is a standalone function without
// persistent functionalities (e.g. history).
pub fn read_line(prompt string) ?string {
2020-08-27 12:20:31 +03:00
mut r := Readline{}
s := r.read_line(prompt) ?
2020-08-27 12:20:31 +03:00
return s
2019-09-23 13:43:24 +03:00
}
// analyse returns an `Action` based on the type of input byte given in `c`.
fn (r Readline) analyse(c int) Action {
if c > 255 {
return Action.insert_character
}
2020-08-27 12:20:31 +03:00
match byte(c) {
`\0`, 0x3, 0x4, 255 {
return .eof
} // NUL, End of Text, End of Transmission
`\n`, `\r` {
return .commit_line
}
`\f` {
return .clear_screen
} // CTRL + L
`\b`, 127 {
return .delete_left
} // BS, DEL
27 {
return r.analyse_control()
} // ESC
1 {
return .move_cursor_begining
} // ^A
5 {
return .move_cursor_end
} // ^E
26 {
return .suspend
} // CTRL + Z, SUB
else {
if c >= ` ` {
return Action.insert_character
}
return Action.nothing
}
2020-08-27 12:20:31 +03:00
}
}
// analyse_control returns an `Action` based on the type of input read by `read_char`.
fn (r Readline) analyse_control() Action {
2020-08-27 12:20:31 +03:00
c := r.read_char()
match byte(c) {
`[` {
sequence := r.read_char()
match byte(sequence) {
`C` { return .move_cursor_right }
`D` { return .move_cursor_left }
`B` { return .history_next }
`A` { return .history_previous }
`1` { return r.analyse_extended_control() }
`2`, `3` { return r.analyse_extended_control_no_eat(byte(sequence)) }
2020-08-27 12:20:31 +03:00
else {}
}
2019-12-07 18:16:19 +03:00
}
2020-08-27 12:20:31 +03:00
else {}
2019-12-07 18:16:19 +03:00
}
2020-08-27 12:20:31 +03:00
/*
//TODO
2019-12-07 18:16:19 +03:00
match c {
case `[`:
sequence := r.read_char()
match sequence {
case `C`: return .move_cursor_right
case `D`: return .move_cursor_left
case `B`: return .history_next
case `A`: return .history_previous
case `1`: return r.analyse_extended_control()
case `2`: return r.analyse_extended_control_no_eat(sequence)
case `3`: return r.analyse_extended_control_no_eat(sequence)
case `9`:
foo()
bar()
else:
}
else:
}
2020-08-27 12:20:31 +03:00
*/
return .nothing
2019-08-31 21:24:33 +03:00
}
// analyse_extended_control returns an `Action` based on the type of input read by `read_char`.
// analyse_extended_control specialises in cursor control.
2019-08-31 21:24:33 +03:00
fn (r Readline) analyse_extended_control() Action {
2020-08-27 12:20:31 +03:00
r.read_char() // Removes ;
c := r.read_char()
match byte(c) {
`5` {
direction := r.read_char()
match byte(direction) {
`C` { return .move_cursor_word_right }
`D` { return .move_cursor_word_left }
else {}
}
}
else {}
}
return .nothing
}
// analyse_extended_control_no_eat returns an `Action` based on the type of input byte given in `c`.
// analyse_extended_control_no_eat specialises in detection of delete and insert keys.
2019-09-04 21:08:41 +03:00
fn (r Readline) analyse_extended_control_no_eat(last_c byte) Action {
2020-08-27 12:20:31 +03:00
c := r.read_char()
match byte(c) {
`~` {
match last_c {
2020-08-27 12:20:31 +03:00
`3` { return .delete_right } // Suppr key
`2` { return .overwrite }
else {}
}
}
2020-08-27 12:20:31 +03:00
else {}
}
return .nothing
}
// execute executes the corresponding methods on `Readline` based on `a Action` and `c int` arguments.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) execute(a Action, c int) bool {
2020-08-27 12:20:31 +03:00
match a {
.eof { return r.eof() }
.insert_character { r.insert_character(c) }
.commit_line { return r.commit_line() }
.delete_left { r.delete_character() }
.delete_right { r.suppr_character() }
.move_cursor_left { r.move_cursor_left() }
.move_cursor_right { r.move_cursor_right() }
.move_cursor_begining { r.move_cursor_begining() }
.move_cursor_end { r.move_cursor_end() }
.move_cursor_word_left { r.move_cursor_word_left() }
.move_cursor_word_right { r.move_cursor_word_right() }
.history_previous { r.history_previous() }
.history_next { r.history_next() }
.overwrite { r.switch_overwrite() }
.clear_screen { r.clear_screen() }
.suspend { r.suspend() }
else {}
}
return false
}
// get_screen_columns returns the number of columns (`width`) in the terminal.
fn get_screen_columns() int {
2020-08-27 12:20:31 +03:00
ws := Winsize{}
cols := if unsafe { C.ioctl(1, C.TIOCGWINSZ, &ws) } == -1 { 80 } else { int(ws.ws_col) }
2020-08-27 12:20:31 +03:00
return cols
}
// shift_cursor warps the cursor to `xpos` with `yoffset`.
fn shift_cursor(xpos int, yoffset int) {
2020-08-27 12:20:31 +03:00
if yoffset != 0 {
if yoffset > 0 {
term.cursor_down(yoffset)
} else {
term.cursor_up(-yoffset)
}
}
// Absolute X position
print('\x1b[${xpos + 1}G')
2020-08-27 12:20:31 +03:00
}
// calculate_screen_position returns a position `[x, y]int` based on various terminal attributes.
fn calculate_screen_position(x_in int, y_in int, screen_columns int, char_count int, inp []int) []int {
2020-12-20 17:40:49 +03:00
mut out := inp.clone()
2020-08-27 12:20:31 +03:00
mut x := x_in
mut y := y_in
out[0] = x
out[1] = y
for chars_remaining := char_count; chars_remaining > 0; {
chars_this_row := if (x + chars_remaining) < screen_columns {
chars_remaining
} else {
screen_columns - x
}
2020-08-27 12:20:31 +03:00
out[0] = x + chars_this_row
out[1] = y
chars_remaining -= chars_this_row
x = 0
y++
}
if out[0] == screen_columns {
out[0] = 0
out[1]++
}
return out
}
// get_prompt_offset computes the length of the `prompt` `string` argument.
fn get_prompt_offset(prompt string) int {
mut len := 0
for i := 0; i < prompt.len; i++ {
if prompt[i] == `\e` {
for ; i < prompt.len && prompt[i] != `m`; i++ {
}
} else {
len = len + 1
}
}
return prompt.len - len
}
// refresh_line redraws the current line, including the prompt.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) refresh_line() {
2020-08-27 12:20:31 +03:00
mut end_of_input := [0, 0]
end_of_input = calculate_screen_position(r.prompt.len, 0, get_screen_columns(), r.current.len,
end_of_input)
2021-06-30 22:30:28 +03:00
end_of_input[1] += r.current.filter(it == `\n`).len
2020-08-27 12:20:31 +03:00
mut cursor_pos := [0, 0]
cursor_pos = calculate_screen_position(r.prompt.len, 0, get_screen_columns(), r.cursor,
cursor_pos)
shift_cursor(0, -r.cursor_row_offset)
term.erase_toend()
print(r.prompt)
2021-06-30 22:30:28 +03:00
print(r.current.string())
2020-08-27 12:20:31 +03:00
if end_of_input[0] == 0 && end_of_input[1] > 0 {
print('\n')
}
shift_cursor(cursor_pos[0] - r.prompt_offset, -(end_of_input[1] - cursor_pos[1]))
r.cursor_row_offset = cursor_pos[1]
}
// eof ends the line *without* a newline.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) eof() bool {
2020-08-27 12:20:31 +03:00
r.previous_lines.insert(1, r.current)
r.cursor = r.current.len
if r.is_tty {
r.refresh_line()
}
return true
2019-09-04 21:08:41 +03:00
}
// insert_character inserts the character `c` at current cursor position.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) insert_character(c int) {
2020-08-27 12:20:31 +03:00
if !r.overwrite || r.cursor == r.current.len {
2021-06-30 22:30:28 +03:00
r.current.insert(r.cursor, c)
2020-08-27 12:20:31 +03:00
} else {
2021-06-30 22:30:28 +03:00
r.current[r.cursor] = rune(c)
2020-08-27 12:20:31 +03:00
}
r.cursor++
// Refresh the line to add the new character
if r.is_tty {
r.refresh_line()
}
}
// Removes the character behind cursor.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) delete_character() {
2020-08-27 12:20:31 +03:00
if r.cursor <= 0 {
return
}
r.cursor--
2021-06-30 22:30:28 +03:00
r.current.delete(r.cursor)
2020-08-27 12:20:31 +03:00
r.refresh_line()
}
// suppr_character removes (suppresses) the character in front of the cursor.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) suppr_character() {
if r.cursor >= r.current.len {
2020-08-27 12:20:31 +03:00
return
}
2021-06-30 22:30:28 +03:00
r.current.delete(r.cursor)
2020-08-27 12:20:31 +03:00
r.refresh_line()
}
// commit_line adds a line break and then stops the main loop.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) commit_line() bool {
2020-08-27 12:20:31 +03:00
r.previous_lines.insert(1, r.current)
2021-06-30 22:30:28 +03:00
r.current << `\n`
2020-08-27 12:20:31 +03:00
r.cursor = r.current.len
if r.is_tty {
r.refresh_line()
println('')
}
return true
}
2019-08-31 21:24:33 +03:00
// move_cursor_left moves the cursor relative one cell to the left.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) move_cursor_left() {
2020-08-27 12:20:31 +03:00
if r.cursor > 0 {
r.cursor--
r.refresh_line()
}
2019-08-31 21:24:33 +03:00
}
// move_cursor_right moves the cursor relative one cell to the right.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) move_cursor_right() {
2020-08-27 12:20:31 +03:00
if r.cursor < r.current.len {
r.cursor++
r.refresh_line()
}
2019-08-31 21:24:33 +03:00
}
// move_cursor_begining moves the cursor to the beginning of the current line.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) move_cursor_begining() {
2020-08-27 12:20:31 +03:00
r.cursor = 0
r.refresh_line()
2019-08-31 21:24:33 +03:00
}
// move_cursor_end moves the cursor to the end of the current line.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) move_cursor_end() {
2020-08-27 12:20:31 +03:00
r.cursor = r.current.len
r.refresh_line()
2019-08-31 21:24:33 +03:00
}
// is_break_character returns true if the character is considered as a word-breaking character.
2019-09-23 13:43:24 +03:00
fn (r Readline) is_break_character(c string) bool {
2020-08-27 12:20:31 +03:00
break_characters := ' \t\v\f\a\b\r\n`~!@#$%^&*()-=+[{]}\\|;:\'",<.>/?'
return break_characters.contains(c)
2019-08-31 21:24:33 +03:00
}
// move_cursor_word_left moves the cursor relative one word length worth to the left.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) move_cursor_word_left() {
2020-08-27 12:20:31 +03:00
if r.cursor > 0 {
2021-06-30 22:30:28 +03:00
for ; r.cursor > 0 && r.is_break_character(r.current[r.cursor - 1].str()); r.cursor-- {
2020-08-27 12:20:31 +03:00
}
2021-06-30 22:30:28 +03:00
for ; r.cursor > 0 && !r.is_break_character(r.current[r.cursor - 1].str()); r.cursor-- {
2020-08-27 12:20:31 +03:00
}
r.refresh_line()
}
2019-08-31 21:24:33 +03:00
}
// move_cursor_word_right moves the cursor relative one word length worth to the right.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) move_cursor_word_right() {
2020-08-27 12:20:31 +03:00
if r.cursor < r.current.len {
2021-06-30 22:30:28 +03:00
for ; r.cursor < r.current.len && r.is_break_character(r.current[r.cursor].str()); r.cursor++ {
2020-08-27 12:20:31 +03:00
}
2021-06-30 22:30:28 +03:00
for ; r.cursor < r.current.len && !r.is_break_character(r.current[r.cursor].str()); r.cursor++ {
2020-08-27 12:20:31 +03:00
}
r.refresh_line()
}
2019-08-31 21:24:33 +03:00
}
2019-09-02 14:14:40 +03:00
// switch_overwrite toggles Readline `overwrite` mode on/off.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) switch_overwrite() {
2020-08-27 12:20:31 +03:00
r.overwrite = !r.overwrite
2019-09-04 21:08:41 +03:00
}
// clear_screen clears the current terminal window contents and positions the cursor at top left.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) clear_screen() {
2020-12-20 17:40:49 +03:00
term.set_cursor_position(x: 1, y: 1)
2020-08-27 12:20:31 +03:00
term.erase_clear()
r.refresh_line()
2019-09-02 14:14:40 +03:00
}
2019-09-03 12:52:00 +03:00
// history_previous sets current line to the content of the previous line in the history buffer.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) history_previous() {
2020-08-27 12:20:31 +03:00
if r.search_index + 2 >= r.previous_lines.len {
return
}
if r.search_index == 0 {
r.previous_lines[0] = r.current
}
r.search_index++
r.current = r.previous_lines[r.search_index]
r.cursor = r.current.len
r.refresh_line()
2019-09-03 12:52:00 +03:00
}
// history_next sets current line to the content of the next line in the history buffer.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) history_next() {
2020-08-27 12:20:31 +03:00
if r.search_index <= 0 {
return
}
r.search_index--
r.current = r.previous_lines[r.search_index]
r.cursor = r.current.len
r.refresh_line()
2019-09-03 12:52:00 +03:00
}
// suspend sends the `SIGSTOP` signal to the terminal.
2020-05-17 14:51:18 +03:00
fn (mut r Readline) suspend() {
is_standalone := os.getenv('VCHILD') != 'true'
r.disable_raw_mode()
if !is_standalone {
// We have to SIGSTOP the parent v process
unsafe {
ppid := C.getppid()
C.kill(ppid, C.SIGSTOP)
}
}
unsafe { C.raise(C.SIGSTOP) }
r.enable_raw_mode()
2020-08-27 12:20:31 +03:00
r.refresh_line()
if r.is_tty {
r.refresh_line()
}
}