//go:build linux || darwin || dragonfly || solaris || openbsd || netbsd || freebsd // +build linux darwin dragonfly solaris openbsd netbsd freebsd package terminal import ( "bufio" "bytes" "io" "os" "os/exec" "unicode" "unicode/utf8" "github.com/creack/pty" ) // VT represents the virtual terminal emulator. type VT struct { dest *State rc io.ReadCloser br *bufio.Reader pty *os.File } // Start initializes a virtual terminal emulator with the target state // and a new pty file by starting the *exec.Command. The returned // *os.File is the pty file. func Start(state *State, cmd *exec.Cmd) (*VT, *os.File, error) { var err error t := &VT{ dest: state, } t.pty, err = pty.Start(cmd) if err != nil { return nil, nil, err } t.rc = t.pty t.init() return t, t.pty, nil } // Create initializes a virtual terminal emulator with the target state // and io.ReadCloser input. func Create(state *State, rc io.ReadCloser) (*VT, error) { t := &VT{ dest: state, rc: rc, } t.init() return t, nil } func (t *VT) init() { t.br = bufio.NewReader(t.rc) t.dest.numlock = true t.dest.state = t.dest.parse t.dest.cur.attr.fg = DefaultFG t.dest.cur.attr.bg = DefaultBG t.Resize(80, 24) t.dest.reset() } // File returns the pty file. func (t *VT) File() *os.File { return t.pty } // Write parses input and writes terminal changes to state. func (t *VT) Write(p []byte) (int, error) { var written int r := bytes.NewReader(p) t.dest.lock() defer t.dest.unlock() for { c, sz, err := r.ReadRune() if err != nil { if err == io.EOF { break } return written, err } written += sz if c == unicode.ReplacementChar && sz == 1 { if r.Len() == 0 { // not enough bytes for a full rune return written - 1, nil } t.dest.logln("invalid utf8 sequence") continue } t.dest.put(c) } return written, nil } // Close closes the pty or io.ReadCloser. func (t *VT) Close() error { return t.rc.Close() } // Parse blocks on read on pty or io.ReadCloser, then parses sequences until // buffer empties. State is locked as soon as first rune is read, and unlocked // when buffer is empty. // TODO: add tests for expected blocking behavior func (t *VT) Parse() error { var locked bool defer func() { if locked { t.dest.unlock() } }() for { c, sz, err := t.br.ReadRune() if err != nil { return err } if c == unicode.ReplacementChar && sz == 1 { t.dest.logln("invalid utf8 sequence") break } if !locked { t.dest.lock() locked = true } // put rune for parsing and update state t.dest.put(c) // break if our buffer is empty, or if buffer contains an // incomplete rune. n := t.br.Buffered() if n == 0 || (n < 4 && !fullRuneBuffered(t.br)) { break } } return nil } func fullRuneBuffered(br *bufio.Reader) bool { n := br.Buffered() buf, err := br.Peek(n) if err != nil { return false } return utf8.FullRune(buf) } // Resize reports new size to pty and updates state. func (t *VT) Resize(cols, rows int) { t.dest.lock() defer t.dest.unlock() _ = t.dest.resize(cols, rows) t.ptyResize() }