Debian Codegraph @

deps/winpty/src/agent/Terminal.cc

raw
1 // Copyright (c) 2011-2015 Ryan Prichard
2 //
3 // Permission is hereby granted, free of charge, to any person obtaining a copy
4 // of this software and associated documentation files (the "Software"), to
5 // deal in the Software without restriction, including without limitation the
6 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
7 // sell copies of the Software, and to permit persons to whom the Software is
8 // furnished to do so, subject to the following conditions:
9 //
10 // The above copyright notice and this permission notice shall be included in
11 // all copies or substantial portions of the Software.
12 //
13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
18 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
19 // IN THE SOFTWARE.
20
21 #include "Terminal.h"
22
23 #include <windows.h>
24 #include <stdio.h>
25 #include <string.h>
26
27 #include <string>
28
29 #include "NamedPipe.h"
30 #include "UnicodeEncoding.h"
31 #include "../shared/DebugClient.h"
32 #include "../shared/WinptyAssert.h"
33 #include "../shared/winpty_snprintf.h"
34
35 #define CSI "\x1b["
36
37 // Work around the old MinGW, which lacks COMMON_LVB_LEADING_BYTE and
38 // COMMON_LVB_TRAILING_BYTE.
39 const int WINPTY_COMMON_LVB_LEADING_BYTE = 0x100;
40 const int WINPTY_COMMON_LVB_TRAILING_BYTE = 0x200;
41 const int WINPTY_COMMON_LVB_REVERSE_VIDEO = 0x4000;
42 const int WINPTY_COMMON_LVB_UNDERSCORE = 0x8000;
43
44 const int COLOR_ATTRIBUTE_MASK =
45 FOREGROUND_BLUE |
46 FOREGROUND_GREEN |
47 FOREGROUND_RED |
48 FOREGROUND_INTENSITY |
49 BACKGROUND_BLUE |
50 BACKGROUND_GREEN |
51 BACKGROUND_RED |
52 BACKGROUND_INTENSITY |
53 WINPTY_COMMON_LVB_REVERSE_VIDEO |
54 WINPTY_COMMON_LVB_UNDERSCORE;
55
56 const int FLAG_RED = 1;
57 const int FLAG_GREEN = 2;
58 const int FLAG_BLUE = 4;
59 const int FLAG_BRIGHT = 8;
60
61 const int BLACK = 0;
62 const int DKGRAY = BLACK | FLAG_BRIGHT;
63 const int LTGRAY = FLAG_RED | FLAG_GREEN | FLAG_BLUE;
64 const int WHITE = LTGRAY | FLAG_BRIGHT;
65
66 // SGR parameters (Select Graphic Rendition)
67 const int SGR_FORE = 30;
68 const int SGR_FORE_HI = 90;
69 const int SGR_BACK = 40;
70 const int SGR_BACK_HI = 100;
71
72 namespace {
73
74 static void outUInt(std::string &out, unsigned int n)
75 {
76 char buf[32];
77 char *pbuf = &buf[32];
78 *(--pbuf) = '\0';
79 do {
80 *(--pbuf) = '0' + n % 10;
81 n /= 10;
82 } while (n != 0);
83 out.append(pbuf);
84 }
85
86 static void outputSetColorSgrParams(std::string &out, bool isFore, int color)
87 {
88 out.push_back(';');
89 const int sgrBase = isFore ? SGR_FORE : SGR_BACK;
90 if (color & FLAG_BRIGHT) {
91 // Some terminals don't support the 9X/10X "intensive" color parameters
92 // (e.g. the Eclipse TM terminal as of this writing). Those terminals
93 // will quietly ignore a 9X/10X code, and the other terminals will
94 // ignore a 3X/4X code if it's followed by a 9X/10X code. Therefore,
95 // output a 3X/4X code as a fallback, then override it.
96 const int colorBase = color & ~FLAG_BRIGHT;
97 outUInt(out, sgrBase + colorBase);
98 out.push_back(';');
99 outUInt(out, sgrBase + (SGR_FORE_HI - SGR_FORE) + colorBase);
100 } else {
101 outUInt(out, sgrBase + color);
102 }
103 }
104
105 static void outputSetColor(std::string &out, int color)
106 {
107 int fore = 0;
108 int back = 0;
109 if (color & FOREGROUND_RED) fore |= FLAG_RED;
110 if (color & FOREGROUND_GREEN) fore |= FLAG_GREEN;
111 if (color & FOREGROUND_BLUE) fore |= FLAG_BLUE;
112 if (color & FOREGROUND_INTENSITY) fore |= FLAG_BRIGHT;
113 if (color & BACKGROUND_RED) back |= FLAG_RED;
114 if (color & BACKGROUND_GREEN) back |= FLAG_GREEN;
115 if (color & BACKGROUND_BLUE) back |= FLAG_BLUE;
116 if (color & BACKGROUND_INTENSITY) back |= FLAG_BRIGHT;
117
118 if (color & WINPTY_COMMON_LVB_REVERSE_VIDEO) {
119 // n.b.: The COMMON_LVB_REVERSE_VIDEO flag also swaps
120 // FOREGROUND_INTENSITY and BACKGROUND_INTENSITY. Tested on
121 // Windows 10 v14393.
122 std::swap(fore, back);
123 }
124
125 // Translate the fore/back colors into terminal escape codes using
126 // a heuristic that works OK with common white-on-black or
127 // black-on-white color schemes. We don't know which color scheme
128 // the terminal is using. It is ugly to force white-on-black text
129 // on a black-on-white terminal, and it's even ugly to force the
130 // matching scheme. It's probably relevant that the default
131 // fore/back terminal colors frequently do not match any of the 16
132 // palette colors.
133
134 // Typical default terminal color schemes (according to palette,
135 // when possible):
136 // - mintty: LtGray-on-Black(A)
137 // - putty: LtGray-on-Black(A)
138 // - xterm: LtGray-on-Black(A)
139 // - Konsole: LtGray-on-Black(A)
140 // - JediTerm/JetBrains: Black-on-White(B)
141 // - rxvt: Black-on-White(B)
142
143 // If the background is the default color (black), then it will
144 // map to Black(A) or White(B). If we translate White to White,
145 // then a Black background and a White background in the console
146 // are both White with (B). Therefore, we should translate White
147 // using SGR 7 (Invert). The typical finished mapping table for
148 // background grayscale colors is:
149 //
150 // (A) White => LtGray(fore)
151 // (A) Black => Black(back)
152 // (A) LtGray => LtGray
153 // (A) DkGray => DkGray
154 //
155 // (B) White => Black(fore)
156 // (B) Black => White(back)
157 // (B) LtGray => LtGray
158 // (B) DkGray => DkGray
159 //
160
161 out.append(CSI "0");
162 if (back == BLACK) {
163 if (fore == LTGRAY) {
164 // The "default" foreground color. Use the terminal's
165 // default colors.
166 } else if (fore == WHITE) {
167 // Sending the literal color white would behave poorly if
168 // the terminal were black-on-white. Sending Bold is not
169 // guaranteed to alter the color, but it will make the text
170 // visually distinct, so do that instead.
171 out.append(";1");
172 } else if (fore == DKGRAY) {
173 // Set the foreground color to DkGray(90) with a fallback
174 // of LtGray(37) for terminals that don't handle the 9X SGR
175 // parameters (e.g. Eclipse's TM Terminal as of this
176 // writing).
177 out.append(";37;90");
178 } else {
179 outputSetColorSgrParams(out, true, fore);
180 }
181 } else if (back == WHITE) {
182 // Set the background color using Invert on the default
183 // foreground color, and set the foreground color by setting a
184 // background color.
185
186 // Use the terminal's inverted colors.
187 out.append(";7");
188 if (fore == LTGRAY || fore == BLACK) {
189 // We're likely mapping Console White to terminal LtGray or
190 // Black. If they are the Console foreground color, then
191 // don't set a terminal foreground color to avoid creating
192 // invisible text.
193 } else {
194 outputSetColorSgrParams(out, false, fore);
195 }
196 } else {
197 // Set the foreground and background to match exactly that in
198 // the Windows console.
199 outputSetColorSgrParams(out, true, fore);
200 outputSetColorSgrParams(out, false, back);
201 }
202 if (fore == back) {
203 // The foreground and background colors are exactly equal, so
204 // attempt to hide the text using the Conceal SGR parameter,
205 // which some terminals support.
206 out.append(";8");
207 }
208 if (color & WINPTY_COMMON_LVB_UNDERSCORE) {
209 out.append(";4");
210 }
211 out.push_back('m');
212 }
213
214 static inline unsigned int fixSpecialCharacters(unsigned int ch)
215 {
216 if (ch <= 0x1b) {
217 switch (ch) {
218 // The Windows Console has a popup window (e.g. that appears with
219 // F7) that is sometimes bordered with box-drawing characters.
220 // With the Japanese and Korean system locales (CP932 and CP949),
221 // the UnicodeChar values for the box-drawing characters are 1
222 // through 6. Detect this and map the values to the correct
223 // Unicode values.
224 //
225 // N.B. In the English locale, the UnicodeChar values are correct,
226 // and they identify single-line characters rather than
227 // double-line. In the Chinese Simplified and Traditional locales,
228 // the popups use ASCII characters instead.
229 case 1: return 0x2554; // BOX DRAWINGS DOUBLE DOWN AND RIGHT
230 case 2: return 0x2557; // BOX DRAWINGS DOUBLE DOWN AND LEFT
231 case 3: return 0x255A; // BOX DRAWINGS DOUBLE UP AND RIGHT
232 case 4: return 0x255D; // BOX DRAWINGS DOUBLE UP AND LEFT
233 case 5: return 0x2551; // BOX DRAWINGS DOUBLE VERTICAL
234 case 6: return 0x2550; // BOX DRAWINGS DOUBLE HORIZONTAL
235
236 // Convert an escape character to some other character. This
237 // conversion only applies to console cells containing an escape
238 // character. In newer versions of Windows 10 (e.g. 10.0.10586),
239 // the non-legacy console recognizes escape sequences in
240 // WriteConsole and interprets them without writing them to the
241 // cells of the screen buffer. In that case, the conversion here
242 // does not apply.
243 case 0x1b: return '?';
244 }
245 }
246 return ch;
247 }
248
249 static inline bool isFullWidthCharacter(const CHAR_INFO *data, int width)
250 {
251 if (width < 2) {
252 return false;
253 }
254 return
255 (data[0].Attributes & WINPTY_COMMON_LVB_LEADING_BYTE) &&
256 (data[1].Attributes & WINPTY_COMMON_LVB_TRAILING_BYTE) &&
257 data[0].Char.UnicodeChar == data[1].Char.UnicodeChar;
258 }
259
260 // Scan to find a single Unicode Scalar Value. Full-width characters occupy
261 // two console cells, and this code also tries to handle UTF-16 surrogate
262 // pairs.
263 //
264 // Windows expands at least some wide characters outside the Basic
265 // Multilingual Plane into four cells, such as U+20000:
266 // 1. 0xD840, attr=0x107
267 // 2. 0xD840, attr=0x207
268 // 3. 0xDC00, attr=0x107
269 // 4. 0xDC00, attr=0x207
270 // Even in the Traditional Chinese locale on Windows 10, this text is rendered
271 // as two boxes, but if those boxes are copied-and-pasted, the character is
272 // copied correctly.
273 static inline void scanUnicodeScalarValue(
274 const CHAR_INFO *data, int width,
275 int &outCellCount, unsigned int &outCharValue)
276 {
277 ASSERT(width >= 1);
278
279 const int w1 = isFullWidthCharacter(data, width) ? 2 : 1;
280 const wchar_t c1 = data[0].Char.UnicodeChar;
281
282 if ((c1 & 0xF800) == 0xD800) {
283 // The first cell is either a leading or trailing surrogate pair.
284 if ((c1 & 0xFC00) != 0xD800 ||
285 width <= w1 ||
286 ((data[w1].Char.UnicodeChar & 0xFC00) != 0xDC00)) {
287 // Invalid surrogate pair
288 outCellCount = w1;
289 outCharValue = '?';
290 } else {
291 // Valid surrogate pair
292 outCellCount = w1 + (isFullWidthCharacter(&data[w1], width - w1) ? 2 : 1);
293 outCharValue = decodeSurrogatePair(c1, data[w1].Char.UnicodeChar);
294 }
295 } else {
296 outCellCount = w1;
297 outCharValue = c1;
298 }
299 }
300
301 } // anonymous namespace
302
303 void Terminal::reset(SendClearFlag sendClearFirst, int64_t newLine)
304 {
305 if (sendClearFirst == SendClear && !m_plainMode) {
306 // 0m ==> reset SGR parameters
307 // 1;1H ==> move cursor to top-left position
308 // 2J ==> clear the entire screen
309 m_output.write(CSI "0m" CSI "1;1H" CSI "2J");
310 }
311 m_remoteLine = newLine;
312 m_remoteColumn = 0;
313 m_lineData.clear();
314 m_cursorHidden = false;
315 m_remoteColor = -1;
316 }
317
318 void Terminal::sendLine(int64_t line, const CHAR_INFO *lineData, int width,
319 int cursorColumn)
320 {
321 ASSERT(width >= 1);
322
323 moveTerminalToLine(line);
324
325 // If possible, see if we can append to what we've already output for this
326 // line.
327 if (m_lineDataValid) {
328 ASSERT(m_lineData.size() == static_cast<size_t>(m_remoteColumn));
329 if (m_remoteColumn > 0) {
330 // In normal mode, if m_lineData.size() equals `width`, then we
331 // will have trouble outputing the "erase rest of line" command,
332 // which must be output before reaching the end of the line. In
333 // plain mode, we don't output that command, so we're OK with a
334 // full line.
335 bool okWidth = false;
336 if (m_plainMode) {
337 okWidth = static_cast<size_t>(width) >= m_lineData.size();
338 } else {
339 okWidth = static_cast<size_t>(width) > m_lineData.size();
340 }
341 if (!okWidth ||
342 memcmp(m_lineData.data(), lineData,
343 sizeof(CHAR_INFO) * m_lineData.size()) != 0) {
344 m_lineDataValid = false;
345 }
346 }
347 }
348 if (!m_lineDataValid) {
349 // We can't reuse, so we must reset this line.
350 hideTerminalCursor();
351 if (m_plainMode) {
352 // We can't backtrack, so repeat this line.
353 m_output.write("\r\n");
354 } else {
355 m_output.write("\r");
356 }
357 m_lineDataValid = true;
358 m_lineData.clear();
359 m_remoteColumn = 0;
360 }
361
362 std::string &termLine = m_termLineWorkingBuffer;
363 termLine.clear();
364 size_t trimmedLineLength = 0;
365 int trimmedCellCount = m_lineData.size();
366 bool alreadyErasedLine = false;
367
368 int cellCount = 1;
369 for (int i = m_lineData.size(); i < width; i += cellCount) {
370 if (m_outputColor) {
371 int color = lineData[i].Attributes & COLOR_ATTRIBUTE_MASK;
372 if (color != m_remoteColor) {
373 outputSetColor(termLine, color);
374 trimmedLineLength = termLine.size();
375 m_remoteColor = color;
376
377 // All the cells just up to this color change will be output.
378 trimmedCellCount = i;
379 }
380 }
381 unsigned int ch;
382 scanUnicodeScalarValue(&lineData[i], width - i, cellCount, ch);
383 if (ch == ' ') {
384 // Tentatively add this space character. We'll only output it if
385 // we see something interesting after it.
386 termLine.push_back(' ');
387 } else {
388 if (i + cellCount == width) {
389 // We'd like to erase the line after outputting all non-blank
390 // characters, but this doesn't work if the last cell in the
391 // line is non-blank. At the point, the cursor is positioned
392 // just past the end of the line, but in many terminals,
393 // issuing a CSI 0K at that point also erases the last cell in
394 // the line. Work around this behavior by issuing the erase
395 // one character early in that case.
396 if (!m_plainMode) {
397 termLine.append(CSI "0K"); // Erase from cursor to EOL
398 }
399 alreadyErasedLine = true;
400 }
401 ch = fixSpecialCharacters(ch);
402 char enc[4];
403 int enclen = encodeUtf8(enc, ch);
404 if (enclen == 0) {
405 enc[0] = '?';
406 enclen = 1;
407 }
408 termLine.append(enc, enclen);
409 trimmedLineLength = termLine.size();
410
411 // All the cells up to and including this cell will be output.
412 trimmedCellCount = i + cellCount;
413 }
414 }
415
416 if (cursorColumn != -1 && trimmedCellCount > cursorColumn) {
417 // The line content would run past the cursor, so hide it before we
418 // output.
419 hideTerminalCursor();
420 }
421
422 m_output.write(termLine.data(), trimmedLineLength);
423 if (!alreadyErasedLine && !m_plainMode) {
424 m_output.write(CSI "0K"); // Erase from cursor to EOL
425 }
426
427 ASSERT(trimmedCellCount <= width);
428 m_lineData.insert(m_lineData.end(),
429 &lineData[m_lineData.size()],
430 &lineData[trimmedCellCount]);
431 m_remoteColumn = trimmedCellCount;
432 }
433
434 void Terminal::showTerminalCursor(int column, int64_t line)
435 {
436 moveTerminalToLine(line);
437 if (!m_plainMode) {
438 if (m_remoteColumn != column) {
439 char buffer[32];
440 winpty_snprintf(buffer, CSI "%dG", column + 1);
441 m_output.write(buffer);
442 m_lineDataValid = (column == 0);
443 m_lineData.clear();
444 m_remoteColumn = column;
445 }
446 if (m_cursorHidden) {
447 m_output.write(CSI "?25h");
448 m_cursorHidden = false;
449 }
450 }
451 }
452
453 void Terminal::hideTerminalCursor()
454 {
455 if (!m_plainMode) {
456 if (m_cursorHidden) {
457 return;
458 }
459 m_output.write(CSI "?25l");
460 m_cursorHidden = true;
461 }
462 }
463
464 void Terminal::moveTerminalToLine(int64_t line)
465 {
466 if (line == m_remoteLine) {
467 return;
468 }
469
470 // Do not use CPL or CNL. Konsole 2.5.4 does not support Cursor Previous
471 // Line (CPL) -- there are "Undecodable sequence" errors. gnome-terminal
472 // 2.32.0 does handle it. Cursor Next Line (CNL) does nothing if the
473 // cursor is on the last line already.
474
475 hideTerminalCursor();
476
477 if (line < m_remoteLine) {
478 if (m_plainMode) {
479 // We can't backtrack, so instead repeat the lines again.
480 m_output.write("\r\n");
481 m_remoteLine = line;
482 } else {
483 // Backtrack and overwrite previous lines.
484 // CUrsor Up (CUU)
485 char buffer[32];
486 winpty_snprintf(buffer, "\r" CSI "%uA",
487 static_cast<unsigned int>(m_remoteLine - line));
488 m_output.write(buffer);
489 m_remoteLine = line;
490 }
491 } else if (line > m_remoteLine) {
492 while (line > m_remoteLine) {
493 m_output.write("\r\n");
494 m_remoteLine++;
495 }
496 }
497
498 m_lineDataValid = true;
499 m_lineData.clear();
500 m_remoteColumn = 0;
501 }
502
503 void Terminal::enableMouseMode(bool enabled)
504 {
505 if (m_mouseModeEnabled == enabled || m_plainMode) {
506 return;
507 }
508 m_mouseModeEnabled = enabled;
509 if (enabled) {
510 // Start by disabling UTF-8 coordinate mode (1005), just in case we
511 // have a terminal that does not support 1006/1015 modes, and 1005
512 // happens to be enabled. The UTF-8 coordinates can't be unambiguously
513 // decoded.
514 //
515 // Enable basic mouse support first (1000), then try to switch to
516 // button-move mode (1002), then try full mouse-move mode (1003).
517 // Terminals that don't support a mode will be stuck at the highest
518 // mode they do support.
519 //
520 // Enable encoding mode 1015 first, then try to switch to 1006. On
521 // some terminals, both modes will be enabled, but 1006 will have
522 // priority. On other terminals, 1006 wins because it's listed last.
523 //
524 // See misc/MouseInputNotes.txt for details.
525 m_output.write(
526 CSI "?1005l"
527 CSI "?1000h" CSI "?1002h" CSI "?1003h" CSI "?1015h" CSI "?1006h");
528 } else {
529 // Resetting both encoding modes (1006 and 1015) is necessary, but
530 // apparently we only need to use reset on one of the 100[023] modes.
531 // Doing both doesn't hurt.
532 m_output.write(
533 CSI "?1006l" CSI "?1015l" CSI "?1003l" CSI "?1002l" CSI "?1000l");
534 }
535 }