Terminal.cpp 31 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207
  1. /*
  2. * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  3. * All rights reserved.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions are met:
  7. *
  8. * 1. Redistributions of source code must retain the above copyright notice, this
  9. * list of conditions and the following disclaimer.
  10. *
  11. * 2. Redistributions in binary form must reproduce the above copyright notice,
  12. * this list of conditions and the following disclaimer in the documentation
  13. * and/or other materials provided with the distribution.
  14. *
  15. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  16. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  18. * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  19. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  21. * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  22. * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  23. * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25. */
  26. #include <AK/StringBuilder.h>
  27. #include <AK/StringView.h>
  28. #include <LibVT/Terminal.h>
  29. #include <string.h>
  30. //#define TERMINAL_DEBUG
  31. namespace VT {
  32. Terminal::Terminal(TerminalClient& client)
  33. : m_client(client)
  34. {
  35. }
  36. Terminal::~Terminal()
  37. {
  38. }
  39. void Terminal::clear()
  40. {
  41. for (size_t i = 0; i < rows(); ++i)
  42. m_lines[i].clear(m_current_attribute);
  43. set_cursor(0, 0);
  44. }
  45. void Terminal::clear_including_history()
  46. {
  47. m_history.clear();
  48. m_history_start = 0;
  49. clear();
  50. m_client.terminal_history_changed();
  51. }
  52. inline bool is_valid_parameter_character(u8 ch)
  53. {
  54. return ch >= 0x30 && ch <= 0x3f;
  55. }
  56. inline bool is_valid_intermediate_character(u8 ch)
  57. {
  58. return ch >= 0x20 && ch <= 0x2f;
  59. }
  60. inline bool is_valid_final_character(u8 ch)
  61. {
  62. return ch >= 0x40 && ch <= 0x7e;
  63. }
  64. void Terminal::alter_mode(bool should_set, bool question_param, const ParamVector& params)
  65. {
  66. int mode = 2;
  67. if (params.size() > 0) {
  68. mode = params[0];
  69. }
  70. if (!question_param) {
  71. switch (mode) {
  72. // FIXME: implement *something* for this
  73. default:
  74. unimplemented_escape();
  75. break;
  76. }
  77. } else {
  78. switch (mode) {
  79. case 25:
  80. // Hide cursor command, but doesn't need to be run (for now, because
  81. // we don't do inverse control codes anyways)
  82. if (should_set)
  83. dbgln("Terminal: Hide Cursor escapecode received. Not needed: ignored.");
  84. else
  85. dbgln("Terminal: Show Cursor escapecode received. Not needed: ignored.");
  86. break;
  87. default:
  88. break;
  89. }
  90. }
  91. }
  92. void Terminal::RM(bool question_param, const ParamVector& params)
  93. {
  94. // RM – Reset Mode
  95. alter_mode(true, question_param, params);
  96. }
  97. void Terminal::SM(bool question_param, const ParamVector& params)
  98. {
  99. // SM – Set Mode
  100. alter_mode(false, question_param, params);
  101. }
  102. void Terminal::SGR(const ParamVector& params)
  103. {
  104. // SGR – Select Graphic Rendition
  105. if (params.is_empty()) {
  106. m_current_attribute.reset();
  107. return;
  108. }
  109. if (params.size() >= 3) {
  110. bool should_set = true;
  111. auto kind = params[1];
  112. u32 color = 0;
  113. switch (kind) {
  114. case 5: // 8-bit
  115. color = xterm_colors[params[2]];
  116. break;
  117. case 2: // 24-bit
  118. for (size_t i = 0; i < 3; ++i) {
  119. u8 component = 0;
  120. if (params.size() - 2 > i) {
  121. component = params[i + 2];
  122. }
  123. color <<= 8;
  124. color |= component;
  125. }
  126. break;
  127. default:
  128. should_set = false;
  129. break;
  130. }
  131. if (should_set) {
  132. if (params[0] == 38) {
  133. m_current_attribute.foreground_color = color;
  134. return;
  135. } else if (params[0] == 48) {
  136. m_current_attribute.background_color = color;
  137. return;
  138. }
  139. }
  140. }
  141. for (auto param : params) {
  142. switch (param) {
  143. case 0:
  144. // Reset
  145. m_current_attribute.reset();
  146. break;
  147. case 1:
  148. m_current_attribute.flags |= Attribute::Bold;
  149. break;
  150. case 3:
  151. m_current_attribute.flags |= Attribute::Italic;
  152. break;
  153. case 4:
  154. m_current_attribute.flags |= Attribute::Underline;
  155. break;
  156. case 5:
  157. m_current_attribute.flags |= Attribute::Blink;
  158. break;
  159. case 7:
  160. m_current_attribute.flags |= Attribute::Negative;
  161. break;
  162. case 22:
  163. m_current_attribute.flags &= ~Attribute::Bold;
  164. break;
  165. case 23:
  166. m_current_attribute.flags &= ~Attribute::Italic;
  167. break;
  168. case 24:
  169. m_current_attribute.flags &= ~Attribute::Underline;
  170. break;
  171. case 25:
  172. m_current_attribute.flags &= ~Attribute::Blink;
  173. break;
  174. case 27:
  175. m_current_attribute.flags &= ~Attribute::Negative;
  176. break;
  177. case 30:
  178. case 31:
  179. case 32:
  180. case 33:
  181. case 34:
  182. case 35:
  183. case 36:
  184. case 37:
  185. // Foreground color
  186. if (m_current_attribute.flags & Attribute::Bold)
  187. param += 8;
  188. m_current_attribute.foreground_color = xterm_colors[param - 30];
  189. break;
  190. case 39:
  191. // reset foreground
  192. m_current_attribute.foreground_color = Attribute::default_foreground_color;
  193. break;
  194. case 40:
  195. case 41:
  196. case 42:
  197. case 43:
  198. case 44:
  199. case 45:
  200. case 46:
  201. case 47:
  202. // Background color
  203. if (m_current_attribute.flags & Attribute::Bold)
  204. param += 8;
  205. m_current_attribute.background_color = xterm_colors[param - 40];
  206. break;
  207. case 49:
  208. // reset background
  209. m_current_attribute.background_color = Attribute::default_background_color;
  210. break;
  211. default:
  212. dbgln("FIXME: SGR: p: {}", param);
  213. }
  214. }
  215. }
  216. void Terminal::escape$s(const ParamVector&)
  217. {
  218. m_saved_cursor_row = m_cursor_row;
  219. m_saved_cursor_column = m_cursor_column;
  220. }
  221. void Terminal::escape$u(const ParamVector&)
  222. {
  223. set_cursor(m_saved_cursor_row, m_saved_cursor_column);
  224. }
  225. void Terminal::escape$t(const ParamVector& params)
  226. {
  227. if (params.size() < 1)
  228. return;
  229. dbgln("FIXME: escape$t: Ps: {} (param count: {})", params[0], params.size());
  230. }
  231. void Terminal::DECSTBM(const ParamVector& params)
  232. {
  233. // DECSTBM – Set Top and Bottom Margins ("Scrolling Region")
  234. unsigned top = 1;
  235. unsigned bottom = m_rows;
  236. if (params.size() >= 1)
  237. top = params[0];
  238. if (params.size() >= 2)
  239. bottom = params[1];
  240. if ((bottom - top) < 2 || bottom > m_rows) {
  241. dbgln("Error: DECSTBM: scrolling region invalid: {}-{}", top, bottom);
  242. return;
  243. }
  244. m_scroll_region_top = top - 1;
  245. m_scroll_region_bottom = bottom - 1;
  246. set_cursor(0, 0);
  247. }
  248. void Terminal::CUP(const ParamVector& params)
  249. {
  250. // CUP – Cursor Position
  251. unsigned row = 1;
  252. unsigned col = 1;
  253. if (params.size() >= 1)
  254. row = params[0];
  255. if (params.size() >= 2)
  256. col = params[1];
  257. set_cursor(row - 1, col - 1);
  258. }
  259. void Terminal::HVP(const ParamVector& params)
  260. {
  261. // HVP – Horizontal and Vertical Position
  262. unsigned row = 1;
  263. unsigned col = 1;
  264. if (params.size() >= 1)
  265. row = params[0];
  266. if (params.size() >= 2)
  267. col = params[1];
  268. set_cursor(row - 1, col - 1);
  269. }
  270. void Terminal::CUU(const ParamVector& params)
  271. {
  272. // CUU – Cursor Up
  273. int num = 1;
  274. if (params.size() >= 1)
  275. num = params[0];
  276. if (num == 0)
  277. num = 1;
  278. int new_row = (int)m_cursor_row - num;
  279. if (new_row < 0)
  280. new_row = 0;
  281. set_cursor(new_row, m_cursor_column);
  282. }
  283. void Terminal::CUD(const ParamVector& params)
  284. {
  285. // CUD – Cursor Down
  286. int num = 1;
  287. if (params.size() >= 1)
  288. num = params[0];
  289. if (num == 0)
  290. num = 1;
  291. int new_row = (int)m_cursor_row + num;
  292. if (new_row >= m_rows)
  293. new_row = m_rows - 1;
  294. set_cursor(new_row, m_cursor_column);
  295. }
  296. void Terminal::CUF(const ParamVector& params)
  297. {
  298. // CUF – Cursor Forward
  299. int num = 1;
  300. if (params.size() >= 1)
  301. num = params[0];
  302. if (num == 0)
  303. num = 1;
  304. int new_column = (int)m_cursor_column + num;
  305. if (new_column >= m_columns)
  306. new_column = m_columns - 1;
  307. set_cursor(m_cursor_row, new_column);
  308. }
  309. void Terminal::CUB(const ParamVector& params)
  310. {
  311. // CUB – Cursor Backward
  312. int num = 1;
  313. if (params.size() >= 1)
  314. num = params[0];
  315. if (num == 0)
  316. num = 1;
  317. int new_column = (int)m_cursor_column - num;
  318. if (new_column < 0)
  319. new_column = 0;
  320. set_cursor(m_cursor_row, new_column);
  321. }
  322. void Terminal::escape$G(const ParamVector& params)
  323. {
  324. int new_column = 1;
  325. if (params.size() >= 1)
  326. new_column = params[0] - 1;
  327. if (new_column < 0)
  328. new_column = 0;
  329. set_cursor(m_cursor_row, new_column);
  330. }
  331. void Terminal::escape$b(const ParamVector& params)
  332. {
  333. if (params.size() < 1)
  334. return;
  335. for (unsigned i = 0; i < params[0]; ++i)
  336. put_character_at(m_cursor_row, m_cursor_column++, m_last_code_point);
  337. }
  338. void Terminal::escape$d(const ParamVector& params)
  339. {
  340. int new_row = 1;
  341. if (params.size() >= 1)
  342. new_row = params[0] - 1;
  343. if (new_row < 0)
  344. new_row = 0;
  345. set_cursor(new_row, m_cursor_column);
  346. }
  347. void Terminal::escape$X(const ParamVector& params)
  348. {
  349. // Erase characters (without moving cursor)
  350. int num = 1;
  351. if (params.size() >= 1)
  352. num = params[0];
  353. if (num == 0)
  354. num = 1;
  355. // Clear from cursor to end of line.
  356. for (int i = m_cursor_column; i < num; ++i) {
  357. put_character_at(m_cursor_row, i, ' ');
  358. }
  359. }
  360. void Terminal::EL(const ParamVector& params)
  361. {
  362. int mode = 0;
  363. if (params.size() >= 1)
  364. mode = params[0];
  365. switch (mode) {
  366. case 0:
  367. // Clear from cursor to end of line.
  368. for (int i = m_cursor_column; i < m_columns; ++i) {
  369. put_character_at(m_cursor_row, i, ' ');
  370. }
  371. break;
  372. case 1:
  373. // Clear from cursor to beginning of line.
  374. for (int i = 0; i <= m_cursor_column; ++i) {
  375. put_character_at(m_cursor_row, i, ' ');
  376. }
  377. break;
  378. case 2:
  379. // Clear the complete line
  380. for (int i = 0; i < m_columns; ++i) {
  381. put_character_at(m_cursor_row, i, ' ');
  382. }
  383. break;
  384. default:
  385. unimplemented_escape();
  386. break;
  387. }
  388. }
  389. void Terminal::ED(const ParamVector& params)
  390. {
  391. // ED - Erase in Display
  392. int mode = 0;
  393. if (params.size() >= 1)
  394. mode = params[0];
  395. switch (mode) {
  396. case 0:
  397. // Clear from cursor to end of screen.
  398. for (int i = m_cursor_column; i < m_columns; ++i)
  399. put_character_at(m_cursor_row, i, ' ');
  400. for (int row = m_cursor_row + 1; row < m_rows; ++row) {
  401. for (int column = 0; column < m_columns; ++column) {
  402. put_character_at(row, column, ' ');
  403. }
  404. }
  405. break;
  406. case 1:
  407. // Clear from cursor to beginning of screen.
  408. for (int i = m_cursor_column; i >= 0; --i)
  409. put_character_at(m_cursor_row, i, ' ');
  410. for (int row = m_cursor_row - 1; row >= 0; --row) {
  411. for (int column = 0; column < m_columns; ++column) {
  412. put_character_at(row, column, ' ');
  413. }
  414. }
  415. break;
  416. case 2:
  417. clear();
  418. break;
  419. case 3:
  420. // FIXME: <esc>[3J should also clear the scrollback buffer.
  421. clear();
  422. break;
  423. default:
  424. unimplemented_escape();
  425. break;
  426. }
  427. }
  428. void Terminal::escape$S(const ParamVector& params)
  429. {
  430. int count = 1;
  431. if (params.size() >= 1)
  432. count = params[0];
  433. for (u16 i = 0; i < count; i++)
  434. scroll_up();
  435. }
  436. void Terminal::escape$T(const ParamVector& params)
  437. {
  438. int count = 1;
  439. if (params.size() >= 1)
  440. count = params[0];
  441. for (u16 i = 0; i < count; i++)
  442. scroll_down();
  443. }
  444. void Terminal::escape$L(const ParamVector& params)
  445. {
  446. int count = 1;
  447. if (params.size() >= 1)
  448. count = params[0];
  449. invalidate_cursor();
  450. for (; count > 0; --count) {
  451. m_lines.insert(m_cursor_row + m_scroll_region_top, make<Line>(m_columns));
  452. if (m_scroll_region_bottom + 1 < m_lines.size())
  453. m_lines.remove(m_scroll_region_bottom + 1);
  454. else
  455. m_lines.remove(m_lines.size() - 1);
  456. }
  457. m_need_full_flush = true;
  458. }
  459. void Terminal::DA(const ParamVector&)
  460. {
  461. // DA - Device Attributes
  462. emit_string("\033[?1;0c");
  463. }
  464. void Terminal::escape$M(const ParamVector& params)
  465. {
  466. int count = 1;
  467. if (params.size() >= 1)
  468. count = params[0];
  469. if (count == 1 && m_cursor_row == 0) {
  470. scroll_up();
  471. return;
  472. }
  473. int max_count = m_rows - (m_scroll_region_top + m_cursor_row);
  474. count = min(count, max_count);
  475. for (int c = count; c > 0; --c) {
  476. m_lines.remove(m_cursor_row + m_scroll_region_top);
  477. if (m_scroll_region_bottom < m_lines.size())
  478. m_lines.insert(m_scroll_region_bottom, make<Line>(m_columns));
  479. else
  480. m_lines.append(make<Line>(m_columns));
  481. }
  482. }
  483. void Terminal::escape$P(const ParamVector& params)
  484. {
  485. int num = 1;
  486. if (params.size() >= 1)
  487. num = params[0];
  488. if (num == 0)
  489. num = 1;
  490. auto& line = m_lines[m_cursor_row];
  491. // Move n characters of line to the left
  492. for (int i = m_cursor_column; i < line.length() - num; i++)
  493. line.set_code_point(i, line.code_point(i + num));
  494. // Fill remainder of line with blanks
  495. for (int i = line.length() - num; i < line.length(); i++)
  496. line.set_code_point(i, ' ');
  497. line.set_dirty(true);
  498. }
  499. void Terminal::execute_xterm_command()
  500. {
  501. ParamVector numeric_params;
  502. auto param_string = String::copy(m_xterm_parameters);
  503. auto params = param_string.split(';', true);
  504. m_xterm_parameters.clear_with_capacity();
  505. for (auto& parampart : params)
  506. numeric_params.append(parampart.to_uint().value_or(0));
  507. while (params.size() < 3) {
  508. params.append(String::empty());
  509. numeric_params.append(0);
  510. }
  511. m_final = '@';
  512. if (numeric_params.is_empty()) {
  513. dbgln("Empty Xterm params?");
  514. return;
  515. }
  516. switch (numeric_params[0]) {
  517. case 0:
  518. case 1:
  519. case 2:
  520. m_client.set_window_title(params[1]);
  521. break;
  522. case 8:
  523. if (params[2].is_empty()) {
  524. m_current_attribute.href = String();
  525. m_current_attribute.href_id = String();
  526. } else {
  527. m_current_attribute.href = params[2];
  528. // FIXME: Respect the provided ID
  529. m_current_attribute.href_id = String::format("%u", m_next_href_id++);
  530. }
  531. break;
  532. case 9:
  533. m_client.set_window_progress(numeric_params[1], numeric_params[2]);
  534. break;
  535. default:
  536. unimplemented_xterm_escape();
  537. break;
  538. }
  539. }
  540. void Terminal::execute_escape_sequence(u8 final)
  541. {
  542. bool question_param = false;
  543. m_final = final;
  544. ParamVector params;
  545. if (m_parameters.size() > 0 && m_parameters[0] == '?') {
  546. question_param = true;
  547. m_parameters.remove(0);
  548. }
  549. auto paramparts = String::copy(m_parameters).split(';');
  550. for (auto& parampart : paramparts) {
  551. auto value = parampart.to_uint();
  552. if (!value.has_value()) {
  553. // FIXME: Should we do something else?
  554. m_parameters.clear_with_capacity();
  555. m_intermediates.clear_with_capacity();
  556. return;
  557. }
  558. params.append(value.value());
  559. }
  560. switch (final) {
  561. case 'A':
  562. CUU(params);
  563. break;
  564. case 'B':
  565. CUD(params);
  566. break;
  567. case 'C':
  568. CUF(params);
  569. break;
  570. case 'D':
  571. CUB(params);
  572. break;
  573. case 'H':
  574. CUP(params);
  575. break;
  576. case 'J':
  577. ED(params);
  578. break;
  579. case 'K':
  580. EL(params);
  581. break;
  582. case 'M':
  583. escape$M(params);
  584. break;
  585. case 'P':
  586. escape$P(params);
  587. break;
  588. case 'S':
  589. escape$S(params);
  590. break;
  591. case 'T':
  592. escape$T(params);
  593. break;
  594. case 'L':
  595. escape$L(params);
  596. break;
  597. case 'G':
  598. escape$G(params);
  599. break;
  600. case 'X':
  601. escape$X(params);
  602. break;
  603. case 'b':
  604. escape$b(params);
  605. break;
  606. case 'd':
  607. escape$d(params);
  608. break;
  609. case 'm':
  610. SGR(params);
  611. break;
  612. case 's':
  613. escape$s(params);
  614. break;
  615. case 'u':
  616. escape$u(params);
  617. break;
  618. case 't':
  619. escape$t(params);
  620. break;
  621. case 'r':
  622. DECSTBM(params);
  623. break;
  624. case 'l':
  625. RM(question_param, params);
  626. break;
  627. case 'h':
  628. SM(question_param, params);
  629. break;
  630. case 'c':
  631. DA(params);
  632. break;
  633. case 'f':
  634. HVP(params);
  635. break;
  636. case 'n':
  637. DSR(params);
  638. break;
  639. case '@':
  640. ICH(params);
  641. break;
  642. default:
  643. dbgln("Terminal::execute_escape_sequence: Unhandled final '{:c}'", final);
  644. break;
  645. }
  646. m_parameters.clear_with_capacity();
  647. m_intermediates.clear_with_capacity();
  648. }
  649. void Terminal::newline()
  650. {
  651. u16 new_row = m_cursor_row;
  652. if (m_cursor_row == m_scroll_region_bottom) {
  653. scroll_up();
  654. } else {
  655. ++new_row;
  656. }
  657. set_cursor(new_row, 0);
  658. }
  659. void Terminal::scroll_up()
  660. {
  661. // NOTE: We have to invalidate the cursor first.
  662. invalidate_cursor();
  663. if (m_scroll_region_top == 0) {
  664. auto line = move(m_lines.ptr_at(m_scroll_region_top));
  665. add_line_to_history(move(line));
  666. m_client.terminal_history_changed();
  667. }
  668. m_lines.remove(m_scroll_region_top);
  669. m_lines.insert(m_scroll_region_bottom, make<Line>(m_columns));
  670. m_need_full_flush = true;
  671. }
  672. void Terminal::scroll_down()
  673. {
  674. // NOTE: We have to invalidate the cursor first.
  675. invalidate_cursor();
  676. m_lines.remove(m_scroll_region_bottom);
  677. m_lines.insert(m_scroll_region_top, make<Line>(m_columns));
  678. m_need_full_flush = true;
  679. }
  680. void Terminal::set_cursor(unsigned a_row, unsigned a_column)
  681. {
  682. unsigned row = min(a_row, m_rows - 1u);
  683. unsigned column = min(a_column, m_columns - 1u);
  684. if (row == m_cursor_row && column == m_cursor_column)
  685. return;
  686. ASSERT(row < rows());
  687. ASSERT(column < columns());
  688. invalidate_cursor();
  689. m_cursor_row = row;
  690. m_cursor_column = column;
  691. m_stomp = false;
  692. invalidate_cursor();
  693. }
  694. void Terminal::put_character_at(unsigned row, unsigned column, u32 code_point)
  695. {
  696. ASSERT(row < rows());
  697. ASSERT(column < columns());
  698. auto& line = m_lines[row];
  699. line.set_code_point(column, code_point);
  700. line.attributes()[column] = m_current_attribute;
  701. line.attributes()[column].flags |= Attribute::Touched;
  702. line.set_dirty(true);
  703. m_last_code_point = code_point;
  704. }
  705. void Terminal::NEL()
  706. {
  707. // NEL - Next Line
  708. newline();
  709. }
  710. void Terminal::IND()
  711. {
  712. // IND - Index (move down)
  713. CUD({});
  714. }
  715. void Terminal::RI()
  716. {
  717. // RI - Reverse Index (move up)
  718. CUU({});
  719. }
  720. void Terminal::DSR(const ParamVector& params)
  721. {
  722. if (params.size() == 1 && params[0] == 5) {
  723. // Device status
  724. emit_string("\033[0n"); // Terminal status OK!
  725. } else if (params.size() == 1 && params[0] == 6) {
  726. // Cursor position query
  727. emit_string(String::format("\033[%d;%dR", m_cursor_row + 1, m_cursor_column + 1));
  728. } else {
  729. dbgln("Unknown DSR");
  730. }
  731. }
  732. void Terminal::ICH(const ParamVector& params)
  733. {
  734. int num = 0;
  735. if (params.size() >= 1) {
  736. num = params[0];
  737. }
  738. if (num == 0)
  739. num = 1;
  740. auto& line = m_lines[m_cursor_row];
  741. // Move characters after cursor to the right
  742. for (int i = line.length() - num; i >= m_cursor_column; --i)
  743. line.set_code_point(i + num, line.code_point(i));
  744. // Fill n characters after cursor with blanks
  745. for (int i = 0; i < num; i++)
  746. line.set_code_point(m_cursor_column + i, ' ');
  747. line.set_dirty(true);
  748. }
  749. void Terminal::on_input(u8 ch)
  750. {
  751. #ifdef TERMINAL_DEBUG
  752. dbgln("Terminal::on_input: {:#02x} ({:c}), fg={}, bg={}\n", ch, ch, m_current_attribute.foreground_color, m_current_attribute.background_color);
  753. #endif
  754. auto fail_utf8_parse = [this] {
  755. m_parser_state = Normal;
  756. on_code_point(U'�');
  757. };
  758. auto advance_utf8_parse = [this, ch] {
  759. m_parser_code_point <<= 6;
  760. m_parser_code_point |= ch & 0x3f;
  761. if (m_parser_state == UTF8Needs1Byte) {
  762. on_code_point(m_parser_code_point);
  763. m_parser_state = Normal;
  764. } else {
  765. m_parser_state = (ParserState)(m_parser_state + 1);
  766. }
  767. };
  768. switch (m_parser_state) {
  769. case GotEscape:
  770. if (ch == '[') {
  771. m_parser_state = ExpectParameter;
  772. } else if (ch == '(') {
  773. m_swallow_current = true;
  774. m_parser_state = ExpectParameter;
  775. } else if (ch == ']') {
  776. m_parser_state = ExpectXtermParameter;
  777. m_xterm_parameters.clear_with_capacity();
  778. } else if (ch == '#') {
  779. m_parser_state = ExpectHashtagDigit;
  780. } else if (ch == 'D') {
  781. IND();
  782. m_parser_state = Normal;
  783. return;
  784. } else if (ch == 'M') {
  785. RI();
  786. m_parser_state = Normal;
  787. return;
  788. } else if (ch == 'E') {
  789. NEL();
  790. m_parser_state = Normal;
  791. return;
  792. } else {
  793. dbgln("Unexpected character in GotEscape '{}'", (char)ch);
  794. m_parser_state = Normal;
  795. }
  796. return;
  797. case ExpectHashtagDigit:
  798. if (ch >= '0' && ch <= '9') {
  799. execute_hashtag(ch);
  800. m_parser_state = Normal;
  801. }
  802. return;
  803. case ExpectXtermParameter:
  804. if (ch == 27) {
  805. m_parser_state = ExpectStringTerminator;
  806. return;
  807. }
  808. if (ch == 7) {
  809. execute_xterm_command();
  810. m_parser_state = Normal;
  811. return;
  812. }
  813. m_xterm_parameters.append(ch);
  814. return;
  815. case ExpectStringTerminator:
  816. if (ch == '\\')
  817. execute_xterm_command();
  818. else
  819. dbgln("Unexpected string terminator: {:#02x}", ch);
  820. m_parser_state = Normal;
  821. return;
  822. case ExpectParameter:
  823. if (is_valid_parameter_character(ch)) {
  824. m_parameters.append(ch);
  825. return;
  826. }
  827. m_parser_state = ExpectIntermediate;
  828. [[fallthrough]];
  829. case ExpectIntermediate:
  830. if (is_valid_intermediate_character(ch)) {
  831. m_intermediates.append(ch);
  832. return;
  833. }
  834. m_parser_state = ExpectFinal;
  835. [[fallthrough]];
  836. case ExpectFinal:
  837. if (is_valid_final_character(ch)) {
  838. m_parser_state = Normal;
  839. if (!m_swallow_current)
  840. execute_escape_sequence(ch);
  841. m_swallow_current = false;
  842. return;
  843. }
  844. m_parser_state = Normal;
  845. m_swallow_current = false;
  846. return;
  847. case UTF8Needs1Byte:
  848. case UTF8Needs2Bytes:
  849. case UTF8Needs3Bytes:
  850. if ((ch & 0xc0) != 0x80) {
  851. fail_utf8_parse();
  852. } else {
  853. advance_utf8_parse();
  854. }
  855. return;
  856. case Normal:
  857. if (!(ch & 0x80))
  858. break;
  859. if ((ch & 0xe0) == 0xc0) {
  860. m_parser_state = UTF8Needs1Byte;
  861. m_parser_code_point = ch & 0x1f;
  862. return;
  863. }
  864. if ((ch & 0xf0) == 0xe0) {
  865. m_parser_state = UTF8Needs2Bytes;
  866. m_parser_code_point = ch & 0x0f;
  867. return;
  868. }
  869. if ((ch & 0xf8) == 0xf0) {
  870. m_parser_state = UTF8Needs3Bytes;
  871. m_parser_code_point = ch & 0x07;
  872. return;
  873. }
  874. fail_utf8_parse();
  875. return;
  876. }
  877. switch (ch) {
  878. case '\0':
  879. return;
  880. case '\033':
  881. m_parser_state = GotEscape;
  882. m_swallow_current = false;
  883. return;
  884. case 8: // Backspace
  885. if (m_cursor_column) {
  886. set_cursor(m_cursor_row, m_cursor_column - 1);
  887. return;
  888. }
  889. return;
  890. case '\a':
  891. m_client.beep();
  892. return;
  893. case '\t': {
  894. for (unsigned i = m_cursor_column + 1; i < columns(); ++i) {
  895. if (m_horizontal_tabs[i]) {
  896. set_cursor(m_cursor_row, i);
  897. return;
  898. }
  899. }
  900. return;
  901. }
  902. case '\r':
  903. set_cursor(m_cursor_row, 0);
  904. return;
  905. case '\n':
  906. newline();
  907. return;
  908. }
  909. on_code_point(ch);
  910. }
  911. void Terminal::on_code_point(u32 code_point)
  912. {
  913. auto new_column = m_cursor_column + 1;
  914. if (new_column < columns()) {
  915. put_character_at(m_cursor_row, m_cursor_column, code_point);
  916. set_cursor(m_cursor_row, new_column);
  917. return;
  918. }
  919. if (m_stomp) {
  920. m_stomp = false;
  921. newline();
  922. put_character_at(m_cursor_row, m_cursor_column, code_point);
  923. set_cursor(m_cursor_row, 1);
  924. } else {
  925. // Curious: We wait once on the right-hand side
  926. m_stomp = true;
  927. put_character_at(m_cursor_row, m_cursor_column, code_point);
  928. }
  929. }
  930. void Terminal::inject_string(const StringView& str)
  931. {
  932. for (size_t i = 0; i < str.length(); ++i)
  933. on_input(str[i]);
  934. }
  935. void Terminal::emit_string(const StringView& string)
  936. {
  937. m_client.emit((const u8*)string.characters_without_null_termination(), string.length());
  938. }
  939. void Terminal::handle_key_press(KeyCode key, u32 code_point, u8 flags)
  940. {
  941. bool ctrl = flags & Mod_Ctrl;
  942. bool alt = flags & Mod_Alt;
  943. bool shift = flags & Mod_Shift;
  944. unsigned modifier_mask = int(shift) + (int(alt) << 1) + (int(ctrl) << 2);
  945. auto emit_final_with_modifier = [this, modifier_mask](char final) {
  946. if (modifier_mask)
  947. emit_string(String::format("\e[1;%d%c", modifier_mask + 1, final));
  948. else
  949. emit_string(String::format("\e[%c", final));
  950. };
  951. auto emit_tilde_with_modifier = [this, modifier_mask](unsigned num) {
  952. if (modifier_mask)
  953. emit_string(String::format("\e[%d;%d~", num, modifier_mask + 1));
  954. else
  955. emit_string(String::format("\e[%d~", num));
  956. };
  957. switch (key) {
  958. case KeyCode::Key_Up:
  959. emit_final_with_modifier('A');
  960. return;
  961. case KeyCode::Key_Down:
  962. emit_final_with_modifier('B');
  963. return;
  964. case KeyCode::Key_Right:
  965. emit_final_with_modifier('C');
  966. return;
  967. case KeyCode::Key_Left:
  968. emit_final_with_modifier('D');
  969. return;
  970. case KeyCode::Key_Insert:
  971. emit_tilde_with_modifier(2);
  972. return;
  973. case KeyCode::Key_Delete:
  974. emit_tilde_with_modifier(3);
  975. return;
  976. case KeyCode::Key_Home:
  977. emit_final_with_modifier('H');
  978. return;
  979. case KeyCode::Key_End:
  980. emit_final_with_modifier('F');
  981. return;
  982. case KeyCode::Key_PageUp:
  983. emit_tilde_with_modifier(5);
  984. return;
  985. case KeyCode::Key_PageDown:
  986. emit_tilde_with_modifier(6);
  987. return;
  988. default:
  989. break;
  990. }
  991. if (!code_point) {
  992. // Probably a modifier being pressed.
  993. return;
  994. }
  995. if (shift && key == KeyCode::Key_Tab) {
  996. emit_string("\033[Z");
  997. return;
  998. }
  999. // Key event was not one of the above special cases,
  1000. // attempt to treat it as a character...
  1001. if (ctrl) {
  1002. if (code_point >= 'a' && code_point <= 'z') {
  1003. code_point = code_point - 'a' + 1;
  1004. } else if (code_point == '\\') {
  1005. code_point = 0x1c;
  1006. }
  1007. }
  1008. // Alt modifier sends escape prefix.
  1009. if (alt)
  1010. emit_string("\033");
  1011. StringBuilder sb;
  1012. sb.append_code_point(code_point);
  1013. emit_string(sb.to_string());
  1014. }
  1015. void Terminal::unimplemented_escape()
  1016. {
  1017. StringBuilder builder;
  1018. builder.appendf("((Unimplemented escape: %c", m_final);
  1019. if (!m_parameters.is_empty()) {
  1020. builder.append(" parameters:");
  1021. for (size_t i = 0; i < m_parameters.size(); ++i)
  1022. builder.append((char)m_parameters[i]);
  1023. }
  1024. if (!m_intermediates.is_empty()) {
  1025. builder.append(" intermediates:");
  1026. for (size_t i = 0; i < m_intermediates.size(); ++i)
  1027. builder.append((char)m_intermediates[i]);
  1028. }
  1029. builder.append("))");
  1030. inject_string(builder.to_string());
  1031. }
  1032. void Terminal::unimplemented_xterm_escape()
  1033. {
  1034. auto message = String::format("((Unimplemented xterm escape: %c))\n", m_final);
  1035. inject_string(message);
  1036. }
  1037. void Terminal::set_size(u16 columns, u16 rows)
  1038. {
  1039. if (!columns)
  1040. columns = 1;
  1041. if (!rows)
  1042. rows = 1;
  1043. if (columns == m_columns && rows == m_rows)
  1044. return;
  1045. if (rows > m_rows) {
  1046. while (m_lines.size() < rows)
  1047. m_lines.append(make<Line>(columns));
  1048. } else {
  1049. m_lines.shrink(rows);
  1050. }
  1051. for (int i = 0; i < rows; ++i)
  1052. m_lines[i].set_length(columns);
  1053. m_columns = columns;
  1054. m_rows = rows;
  1055. m_scroll_region_top = 0;
  1056. m_scroll_region_bottom = rows - 1;
  1057. m_cursor_row = min((int)m_cursor_row, m_rows - 1);
  1058. m_cursor_column = min((int)m_cursor_column, m_columns - 1);
  1059. m_saved_cursor_row = min((int)m_saved_cursor_row, m_rows - 1);
  1060. m_saved_cursor_column = min((int)m_saved_cursor_column, m_columns - 1);
  1061. m_horizontal_tabs.resize(columns);
  1062. for (unsigned i = 0; i < columns; ++i)
  1063. m_horizontal_tabs[i] = (i % 8) == 0;
  1064. // Rightmost column is always last tab on line.
  1065. m_horizontal_tabs[columns - 1] = 1;
  1066. m_client.terminal_did_resize(m_columns, m_rows);
  1067. }
  1068. void Terminal::invalidate_cursor()
  1069. {
  1070. m_lines[m_cursor_row].set_dirty(true);
  1071. }
  1072. void Terminal::execute_hashtag(u8 hashtag)
  1073. {
  1074. switch (hashtag) {
  1075. case '8':
  1076. // Confidence Test - Fill screen with E's
  1077. for (size_t row = 0; row < m_rows; ++row) {
  1078. for (size_t column = 0; column < m_columns; ++column) {
  1079. put_character_at(row, column, 'E');
  1080. }
  1081. }
  1082. break;
  1083. default:
  1084. dbgln("Unknown hashtag: '{}'", (char)hashtag);
  1085. }
  1086. }
  1087. Attribute Terminal::attribute_at(const Position& position) const
  1088. {
  1089. if (!position.is_valid())
  1090. return {};
  1091. if (position.row() >= static_cast<int>(line_count()))
  1092. return {};
  1093. auto& line = this->line(position.row());
  1094. if (position.column() >= line.length())
  1095. return {};
  1096. return line.attributes()[position.column()];
  1097. }
  1098. }