Debian Codegraph @

vt_posix.go

raw
1 //go:build linux || darwin || dragonfly || solaris || openbsd || netbsd || freebsd
2 // +build linux darwin dragonfly solaris openbsd netbsd freebsd
3
4 package terminal
5
6 import (
7 "bufio"
8 "bytes"
9 "io"
10 "os"
11 "os/exec"
12 "unicode"
13 "unicode/utf8"
14
15 "github.com/creack/pty"
16 )
17
18 // VT represents the virtual terminal emulator.
19 type VT struct {
20 dest *State
21 rc io.ReadCloser
22 br *bufio.Reader
23 pty *os.File
24 }
25
26 // Start initializes a virtual terminal emulator with the target state
27 // and a new pty file by starting the *exec.Command. The returned
28 // *os.File is the pty file.
29 func Start(state *State, cmd *exec.Cmd) (*VT, *os.File, error) {
30 var err error
31 t := &VT{
32 dest: state,
33 }
34 t.pty, err = pty.Start(cmd)
35 if err != nil {
36 return nil, nil, err
37 }
38 t.rc = t.pty
39 t.init()
40 return t, t.pty, nil
41 }
42
43 // Create initializes a virtual terminal emulator with the target state
44 // and io.ReadCloser input.
45 func Create(state *State, rc io.ReadCloser) (*VT, error) {
46 t := &VT{
47 dest: state,
48 rc: rc,
49 }
50 t.init()
51 return t, nil
52 }
53
54 func (t *VT) init() {
55 t.br = bufio.NewReader(t.rc)
56 t.dest.numlock = true
57 t.dest.state = t.dest.parse
58 t.dest.cur.attr.fg = DefaultFG
59 t.dest.cur.attr.bg = DefaultBG
60 t.Resize(80, 24)
61 t.dest.reset()
62 }
63
64 // File returns the pty file.
65 func (t *VT) File() *os.File {
66 return t.pty
67 }
68
69 // Write parses input and writes terminal changes to state.
70 func (t *VT) Write(p []byte) (int, error) {
71 var written int
72 r := bytes.NewReader(p)
73 t.dest.lock()
74 defer t.dest.unlock()
75 for {
76 c, sz, err := r.ReadRune()
77 if err != nil {
78 if err == io.EOF {
79 break
80 }
81 return written, err
82 }
83 written += sz
84 if c == unicode.ReplacementChar && sz == 1 {
85 if r.Len() == 0 {
86 // not enough bytes for a full rune
87 return written - 1, nil
88 }
89 t.dest.logln("invalid utf8 sequence")
90 continue
91 }
92 t.dest.put(c)
93 }
94 return written, nil
95 }
96
97 // Close closes the pty or io.ReadCloser.
98 func (t *VT) Close() error {
99 return t.rc.Close()
100 }
101
102 // Parse blocks on read on pty or io.ReadCloser, then parses sequences until
103 // buffer empties. State is locked as soon as first rune is read, and unlocked
104 // when buffer is empty.
105 // TODO: add tests for expected blocking behavior
106 func (t *VT) Parse() error {
107 var locked bool
108 defer func() {
109 if locked {
110 t.dest.unlock()
111 }
112 }()
113 for {
114 c, sz, err := t.br.ReadRune()
115 if err != nil {
116 return err
117 }
118 if c == unicode.ReplacementChar && sz == 1 {
119 t.dest.logln("invalid utf8 sequence")
120 break
121 }
122 if !locked {
123 t.dest.lock()
124 locked = true
125 }
126
127 // put rune for parsing and update state
128 t.dest.put(c)
129
130 // break if our buffer is empty, or if buffer contains an
131 // incomplete rune.
132 n := t.br.Buffered()
133 if n == 0 || (n < 4 && !fullRuneBuffered(t.br)) {
134 break
135 }
136 }
137 return nil
138 }
139
140 func fullRuneBuffered(br *bufio.Reader) bool {
141 n := br.Buffered()
142 buf, err := br.Peek(n)
143 if err != nil {
144 return false
145 }
146 return utf8.FullRune(buf)
147 }
148
149 // Resize reports new size to pty and updates state.
150 func (t *VT) Resize(cols, rows int) {
151 t.dest.lock()
152 defer t.dest.unlock()
153 _ = t.dest.resize(cols, rows)
154 t.ptyResize()
155 }