Terminal.cpp 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047
  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 <LibVT/Terminal.h>
  28. //#define TERMINAL_DEBUG
  29. namespace VT {
  30. Terminal::Terminal(TerminalClient& client)
  31. : m_client(client)
  32. {
  33. }
  34. Terminal::~Terminal()
  35. {
  36. }
  37. Terminal::Line::Line(u16 length)
  38. {
  39. set_length(length);
  40. }
  41. Terminal::Line::~Line()
  42. {
  43. delete[] characters;
  44. delete[] attributes;
  45. }
  46. void Terminal::Line::set_length(u16 new_length)
  47. {
  48. if (m_length == new_length)
  49. return;
  50. auto* new_characters = new u8[new_length];
  51. auto* new_attributes = new Attribute[new_length];
  52. memset(new_characters, ' ', new_length);
  53. if (characters && attributes) {
  54. memcpy(new_characters, characters, min(m_length, new_length));
  55. memcpy(new_attributes, attributes, min(m_length, new_length) * sizeof(Attribute));
  56. }
  57. delete[] characters;
  58. delete[] attributes;
  59. characters = new_characters;
  60. attributes = new_attributes;
  61. m_length = new_length;
  62. }
  63. void Terminal::Line::clear(Attribute attribute)
  64. {
  65. if (dirty) {
  66. memset(characters, ' ', m_length);
  67. for (u16 i = 0; i < m_length; ++i)
  68. attributes[i] = attribute;
  69. return;
  70. }
  71. for (unsigned i = 0; i < m_length; ++i) {
  72. if (characters[i] != ' ')
  73. dirty = true;
  74. characters[i] = ' ';
  75. }
  76. for (unsigned i = 0; i < m_length; ++i) {
  77. if (attributes[i] != attribute)
  78. dirty = true;
  79. attributes[i] = attribute;
  80. }
  81. }
  82. bool Terminal::Line::has_only_one_background_color() const
  83. {
  84. if (!m_length)
  85. return true;
  86. // FIXME: Cache this result?
  87. auto color = attributes[0].background_color;
  88. for (size_t i = 1; i < m_length; ++i) {
  89. if (attributes[i].background_color != color)
  90. return false;
  91. }
  92. return true;
  93. }
  94. void Terminal::clear()
  95. {
  96. for (size_t i = 0; i < rows(); ++i)
  97. line(i).clear(m_current_attribute);
  98. set_cursor(0, 0);
  99. }
  100. inline bool is_valid_parameter_character(u8 ch)
  101. {
  102. return ch >= 0x30 && ch <= 0x3f;
  103. }
  104. inline bool is_valid_intermediate_character(u8 ch)
  105. {
  106. return ch >= 0x20 && ch <= 0x2f;
  107. }
  108. inline bool is_valid_final_character(u8 ch)
  109. {
  110. return ch >= 0x40 && ch <= 0x7e;
  111. }
  112. void Terminal::alter_mode(bool should_set, bool question_param, const ParamVector& params)
  113. {
  114. int mode = 2;
  115. if (params.size() > 0) {
  116. mode = params[0];
  117. }
  118. if (!question_param) {
  119. switch (mode) {
  120. // FIXME: implement *something* for this
  121. default:
  122. unimplemented_escape();
  123. break;
  124. }
  125. } else {
  126. switch (mode) {
  127. case 25:
  128. // Hide cursor command, but doesn't need to be run (for now, because
  129. // we don't do inverse control codes anyways)
  130. if (should_set)
  131. dbgprintf("Terminal: Hide Cursor escapecode recieved. Not needed: ignored.\n");
  132. else
  133. dbgprintf("Terminal: Show Cursor escapecode recieved. Not needed: ignored.\n");
  134. break;
  135. default:
  136. break;
  137. }
  138. }
  139. }
  140. void Terminal::RM(bool question_param, const ParamVector& params)
  141. {
  142. // RM – Reset Mode
  143. alter_mode(true, question_param, params);
  144. }
  145. void Terminal::SM(bool question_param, const ParamVector& params)
  146. {
  147. // SM – Set Mode
  148. alter_mode(false, question_param, params);
  149. }
  150. void Terminal::SGR(const ParamVector& params)
  151. {
  152. // SGR – Select Graphic Rendition
  153. if (params.is_empty()) {
  154. m_current_attribute.reset();
  155. return;
  156. }
  157. if (params.size() == 3 && params[1] == 5) {
  158. if (params[0] == 38) {
  159. m_current_attribute.foreground_color = params[2];
  160. return;
  161. } else if (params[0] == 48) {
  162. m_current_attribute.background_color = params[2];
  163. return;
  164. }
  165. }
  166. for (auto param : params) {
  167. switch (param) {
  168. case 0:
  169. // Reset
  170. m_current_attribute.reset();
  171. break;
  172. case 1:
  173. m_current_attribute.flags |= Attribute::Bold;
  174. break;
  175. case 3:
  176. m_current_attribute.flags |= Attribute::Italic;
  177. break;
  178. case 4:
  179. m_current_attribute.flags |= Attribute::Underline;
  180. break;
  181. case 5:
  182. m_current_attribute.flags |= Attribute::Blink;
  183. break;
  184. case 7:
  185. m_current_attribute.flags |= Attribute::Negative;
  186. break;
  187. case 22:
  188. m_current_attribute.flags &= ~Attribute::Bold;
  189. break;
  190. case 23:
  191. m_current_attribute.flags &= ~Attribute::Italic;
  192. break;
  193. case 24:
  194. m_current_attribute.flags &= ~Attribute::Underline;
  195. break;
  196. case 25:
  197. m_current_attribute.flags &= ~Attribute::Blink;
  198. break;
  199. case 27:
  200. m_current_attribute.flags &= ~Attribute::Negative;
  201. break;
  202. case 30:
  203. case 31:
  204. case 32:
  205. case 33:
  206. case 34:
  207. case 35:
  208. case 36:
  209. case 37:
  210. // Foreground color
  211. if (m_current_attribute.flags & Attribute::Bold)
  212. param += 8;
  213. m_current_attribute.foreground_color = param - 30;
  214. break;
  215. case 39:
  216. // reset foreground
  217. m_current_attribute.foreground_color = Attribute::default_foreground_color;
  218. break;
  219. case 40:
  220. case 41:
  221. case 42:
  222. case 43:
  223. case 44:
  224. case 45:
  225. case 46:
  226. case 47:
  227. // Background color
  228. if (m_current_attribute.flags & Attribute::Bold)
  229. param += 8;
  230. m_current_attribute.background_color = param - 40;
  231. break;
  232. case 49:
  233. // reset background
  234. m_current_attribute.background_color = Attribute::default_background_color;
  235. break;
  236. default:
  237. dbgprintf("FIXME: SGR: p: %u\n", param);
  238. }
  239. }
  240. }
  241. void Terminal::escape$s(const ParamVector&)
  242. {
  243. m_saved_cursor_row = m_cursor_row;
  244. m_saved_cursor_column = m_cursor_column;
  245. }
  246. void Terminal::escape$u(const ParamVector&)
  247. {
  248. set_cursor(m_saved_cursor_row, m_saved_cursor_column);
  249. }
  250. void Terminal::escape$t(const ParamVector& params)
  251. {
  252. if (params.size() < 1)
  253. return;
  254. dbgprintf("FIXME: escape$t: Ps: %u (param count: %d)\n", params[0], params.size());
  255. }
  256. void Terminal::DECSTBM(const ParamVector& params)
  257. {
  258. // DECSTBM – Set Top and Bottom Margins ("Scrolling Region")
  259. unsigned top = 1;
  260. unsigned bottom = m_rows;
  261. if (params.size() >= 1)
  262. top = params[0];
  263. if (params.size() >= 2)
  264. bottom = params[1];
  265. if ((bottom - top) < 2 || bottom > m_rows) {
  266. dbgprintf("Error: DECSTBM: scrolling region invalid: %u-%u\n", top, bottom);
  267. return;
  268. }
  269. m_scroll_region_top = top - 1;
  270. m_scroll_region_bottom = bottom - 1;
  271. set_cursor(0, 0);
  272. }
  273. void Terminal::CUP(const ParamVector& params)
  274. {
  275. // CUP – Cursor Position
  276. unsigned row = 1;
  277. unsigned col = 1;
  278. if (params.size() >= 1)
  279. row = params[0];
  280. if (params.size() >= 2)
  281. col = params[1];
  282. set_cursor(row - 1, col - 1);
  283. }
  284. void Terminal::HVP(const ParamVector& params)
  285. {
  286. // HVP – Horizontal and Vertical Position
  287. unsigned row = 1;
  288. unsigned col = 1;
  289. if (params.size() >= 1)
  290. row = params[0];
  291. if (params.size() >= 2)
  292. col = params[1];
  293. set_cursor(row - 1, col - 1);
  294. }
  295. void Terminal::CUU(const ParamVector& params)
  296. {
  297. // CUU – Cursor Up
  298. int num = 1;
  299. if (params.size() >= 1)
  300. num = params[0];
  301. if (num == 0)
  302. num = 1;
  303. int new_row = (int)m_cursor_row - num;
  304. if (new_row < 0)
  305. new_row = 0;
  306. set_cursor(new_row, m_cursor_column);
  307. }
  308. void Terminal::CUD(const ParamVector& params)
  309. {
  310. // CUD – Cursor Down
  311. int num = 1;
  312. if (params.size() >= 1)
  313. num = params[0];
  314. if (num == 0)
  315. num = 1;
  316. int new_row = (int)m_cursor_row + num;
  317. if (new_row >= m_rows)
  318. new_row = m_rows - 1;
  319. set_cursor(new_row, m_cursor_column);
  320. }
  321. void Terminal::CUF(const ParamVector& params)
  322. {
  323. // CUF – Cursor Forward
  324. int num = 1;
  325. if (params.size() >= 1)
  326. num = params[0];
  327. if (num == 0)
  328. num = 1;
  329. int new_column = (int)m_cursor_column + num;
  330. if (new_column >= m_columns)
  331. new_column = m_columns - 1;
  332. set_cursor(m_cursor_row, new_column);
  333. }
  334. void Terminal::CUB(const ParamVector& params)
  335. {
  336. // CUB – Cursor Backward
  337. int num = 1;
  338. if (params.size() >= 1)
  339. num = params[0];
  340. if (num == 0)
  341. num = 1;
  342. int new_column = (int)m_cursor_column - num;
  343. if (new_column < 0)
  344. new_column = 0;
  345. set_cursor(m_cursor_row, new_column);
  346. }
  347. void Terminal::escape$G(const ParamVector& params)
  348. {
  349. int new_column = 1;
  350. if (params.size() >= 1)
  351. new_column = params[0] - 1;
  352. if (new_column < 0)
  353. new_column = 0;
  354. set_cursor(m_cursor_row, new_column);
  355. }
  356. void Terminal::escape$b(const ParamVector& params)
  357. {
  358. if (params.size() < 1)
  359. return;
  360. for (unsigned i = 0; i < params[0]; ++i)
  361. put_character_at(m_cursor_row, m_cursor_column++, m_last_char);
  362. }
  363. void Terminal::escape$d(const ParamVector& params)
  364. {
  365. int new_row = 1;
  366. if (params.size() >= 1)
  367. new_row = params[0] - 1;
  368. if (new_row < 0)
  369. new_row = 0;
  370. set_cursor(new_row, m_cursor_column);
  371. }
  372. void Terminal::escape$X(const ParamVector& params)
  373. {
  374. // Erase characters (without moving cursor)
  375. int num = 1;
  376. if (params.size() >= 1)
  377. num = params[0];
  378. if (num == 0)
  379. num = 1;
  380. // Clear from cursor to end of line.
  381. for (int i = m_cursor_column; i < num; ++i) {
  382. put_character_at(m_cursor_row, i, ' ');
  383. }
  384. }
  385. void Terminal::EL(const ParamVector& params)
  386. {
  387. int mode = 0;
  388. if (params.size() >= 1)
  389. mode = params[0];
  390. switch (mode) {
  391. case 0:
  392. // Clear from cursor to end of line.
  393. for (int i = m_cursor_column; i < m_columns; ++i) {
  394. put_character_at(m_cursor_row, i, ' ');
  395. }
  396. break;
  397. case 1:
  398. // Clear from cursor to beginning of line.
  399. for (int i = 0; i <= m_cursor_column; ++i) {
  400. put_character_at(m_cursor_row, i, ' ');
  401. }
  402. break;
  403. case 2:
  404. // Clear the complete line
  405. for (int i = 0; i < m_columns; ++i) {
  406. put_character_at(m_cursor_row, i, ' ');
  407. }
  408. break;
  409. default:
  410. unimplemented_escape();
  411. break;
  412. }
  413. }
  414. void Terminal::ED(const ParamVector& params)
  415. {
  416. // ED - Erase in Display
  417. int mode = 0;
  418. if (params.size() >= 1)
  419. mode = params[0];
  420. switch (mode) {
  421. case 0:
  422. // Clear from cursor to end of screen.
  423. for (int i = m_cursor_column; i < m_columns; ++i)
  424. put_character_at(m_cursor_row, i, ' ');
  425. for (int row = m_cursor_row + 1; row < m_rows; ++row) {
  426. for (int column = 0; column < m_columns; ++column) {
  427. put_character_at(row, column, ' ');
  428. }
  429. }
  430. break;
  431. case 1:
  432. // Clear from cursor to beginning of screen.
  433. for (int i = m_cursor_column; i >= 0; --i)
  434. put_character_at(m_cursor_row, i, ' ');
  435. for (int row = m_cursor_row - 1; row >= 0; --row) {
  436. for (int column = 0; column < m_columns; ++column) {
  437. put_character_at(row, column, ' ');
  438. }
  439. }
  440. break;
  441. case 2:
  442. clear();
  443. break;
  444. case 3:
  445. // FIXME: <esc>[3J should also clear the scrollback buffer.
  446. clear();
  447. break;
  448. default:
  449. unimplemented_escape();
  450. break;
  451. }
  452. }
  453. void Terminal::escape$S(const ParamVector& params)
  454. {
  455. int count = 1;
  456. if (params.size() >= 1)
  457. count = params[0];
  458. for (u16 i = 0; i < count; i++)
  459. scroll_up();
  460. }
  461. void Terminal::escape$T(const ParamVector& params)
  462. {
  463. int count = 1;
  464. if (params.size() >= 1)
  465. count = params[0];
  466. for (u16 i = 0; i < count; i++)
  467. scroll_down();
  468. }
  469. void Terminal::escape$L(const ParamVector& params)
  470. {
  471. int count = 1;
  472. if (params.size() >= 1)
  473. count = params[0];
  474. invalidate_cursor();
  475. for (; count > 0; --count) {
  476. m_lines.insert(m_cursor_row + m_scroll_region_top, make<Line>(m_columns));
  477. if (m_scroll_region_bottom + 1 < m_lines.size())
  478. m_lines.remove(m_scroll_region_bottom + 1);
  479. else
  480. m_lines.remove(m_lines.size() - 1);
  481. }
  482. m_need_full_flush = true;
  483. }
  484. void Terminal::DA(const ParamVector&)
  485. {
  486. // DA - Device Attributes
  487. emit_string("\033[?1;0c");
  488. }
  489. void Terminal::escape$M(const ParamVector& params)
  490. {
  491. int count = 1;
  492. if (params.size() >= 1)
  493. count = params[0];
  494. if (count == 1 && m_cursor_row == 0) {
  495. scroll_up();
  496. return;
  497. }
  498. int max_count = m_rows - (m_scroll_region_top + m_cursor_row);
  499. count = min(count, max_count);
  500. for (int c = count; c > 0; --c) {
  501. m_lines.remove(m_cursor_row + m_scroll_region_top);
  502. if (m_scroll_region_bottom < m_lines.size())
  503. m_lines.insert(m_scroll_region_bottom, make<Line>(m_columns));
  504. else
  505. m_lines.append(make<Line>(m_columns));
  506. }
  507. }
  508. void Terminal::escape$P(const ParamVector& params)
  509. {
  510. int num = 1;
  511. if (params.size() >= 1)
  512. num = params[0];
  513. if (num == 0)
  514. num = 1;
  515. auto& line = this->line(m_cursor_row);
  516. // Move n characters of line to the left
  517. for (int i = m_cursor_column; i < line.m_length - num; i++)
  518. line.characters[i] = line.characters[i + num];
  519. // Fill remainder of line with blanks
  520. for (int i = line.m_length - num; i < line.m_length; i++)
  521. line.characters[i] = ' ';
  522. line.dirty = true;
  523. }
  524. void Terminal::execute_xterm_command()
  525. {
  526. m_final = '@';
  527. bool ok;
  528. unsigned value = String::copy(m_xterm_param1).to_uint(ok);
  529. if (ok) {
  530. switch (value) {
  531. case 0:
  532. case 1:
  533. case 2:
  534. m_client.set_window_title(String::copy(m_xterm_param2));
  535. break;
  536. default:
  537. unimplemented_xterm_escape();
  538. break;
  539. }
  540. }
  541. m_xterm_param1.clear_with_capacity();
  542. m_xterm_param2.clear_with_capacity();
  543. }
  544. void Terminal::execute_escape_sequence(u8 final)
  545. {
  546. bool question_param = false;
  547. m_final = final;
  548. ParamVector params;
  549. if (m_parameters.size() > 0 && m_parameters[0] == '?') {
  550. question_param = true;
  551. m_parameters.remove(0);
  552. }
  553. auto paramparts = String::copy(m_parameters).split(';');
  554. for (auto& parampart : paramparts) {
  555. bool ok;
  556. unsigned value = parampart.to_uint(ok);
  557. if (!ok) {
  558. // FIXME: Should we do something else?
  559. m_parameters.clear_with_capacity();
  560. m_intermediates.clear_with_capacity();
  561. return;
  562. }
  563. params.append(value);
  564. }
  565. #if defined(TERMINAL_DEBUG)
  566. dbgprintf("Terminal::execute_escape_sequence: Handled final '%c'\n", final);
  567. dbgprintf("Params: ");
  568. for (auto& p : params) {
  569. dbgprintf("%d ", p);
  570. }
  571. dbgprintf("\b\n");
  572. #endif
  573. switch (final) {
  574. case 'A':
  575. CUU(params);
  576. break;
  577. case 'B':
  578. CUD(params);
  579. break;
  580. case 'C':
  581. CUF(params);
  582. break;
  583. case 'D':
  584. CUB(params);
  585. break;
  586. case 'H':
  587. CUP(params);
  588. break;
  589. case 'J':
  590. ED(params);
  591. break;
  592. case 'K':
  593. EL(params);
  594. break;
  595. case 'M':
  596. escape$M(params);
  597. break;
  598. case 'P':
  599. escape$P(params);
  600. break;
  601. case 'S':
  602. escape$S(params);
  603. break;
  604. case 'T':
  605. escape$T(params);
  606. break;
  607. case 'L':
  608. escape$L(params);
  609. break;
  610. case 'G':
  611. escape$G(params);
  612. break;
  613. case 'X':
  614. escape$X(params);
  615. break;
  616. case 'b':
  617. escape$b(params);
  618. break;
  619. case 'd':
  620. escape$d(params);
  621. break;
  622. case 'm':
  623. SGR(params);
  624. break;
  625. case 's':
  626. escape$s(params);
  627. break;
  628. case 'u':
  629. escape$u(params);
  630. break;
  631. case 't':
  632. escape$t(params);
  633. break;
  634. case 'r':
  635. DECSTBM(params);
  636. break;
  637. case 'l':
  638. RM(question_param, params);
  639. break;
  640. case 'h':
  641. SM(question_param, params);
  642. break;
  643. case 'c':
  644. DA(params);
  645. break;
  646. case 'f':
  647. HVP(params);
  648. break;
  649. default:
  650. dbgprintf("Terminal::execute_escape_sequence: Unhandled final '%c'\n", final);
  651. break;
  652. }
  653. #if defined(TERMINAL_DEBUG)
  654. dbgprintf("\n");
  655. for (auto& line : m_lines) {
  656. dbgprintf("Terminal: Line: ");
  657. for (int i = 0; i < line.m_length; i++) {
  658. dbgprintf("%c", line.characters[i]);
  659. }
  660. dbgprintf("\n");
  661. }
  662. #endif
  663. m_parameters.clear_with_capacity();
  664. m_intermediates.clear_with_capacity();
  665. }
  666. void Terminal::newline()
  667. {
  668. u16 new_row = m_cursor_row;
  669. if (m_cursor_row == m_scroll_region_bottom) {
  670. scroll_up();
  671. } else {
  672. ++new_row;
  673. }
  674. set_cursor(new_row, 0);
  675. }
  676. void Terminal::scroll_up()
  677. {
  678. // NOTE: We have to invalidate the cursor first.
  679. invalidate_cursor();
  680. if (m_scroll_region_top == 0) {
  681. auto line = move(m_lines.ptr_at(m_scroll_region_top));
  682. m_history.append(move(line));
  683. while (m_history.size() > max_history_size())
  684. m_history.take_first();
  685. m_client.terminal_history_changed();
  686. }
  687. m_lines.remove(m_scroll_region_top);
  688. m_lines.insert(m_scroll_region_bottom, make<Line>(m_columns));
  689. m_need_full_flush = true;
  690. }
  691. void Terminal::scroll_down()
  692. {
  693. // NOTE: We have to invalidate the cursor first.
  694. invalidate_cursor();
  695. m_lines.remove(m_scroll_region_bottom);
  696. m_lines.insert(m_scroll_region_top, make<Line>(m_columns));
  697. m_need_full_flush = true;
  698. }
  699. void Terminal::set_cursor(unsigned a_row, unsigned a_column)
  700. {
  701. unsigned row = min(a_row, m_rows - 1u);
  702. unsigned column = min(a_column, m_columns - 1u);
  703. if (row == m_cursor_row && column == m_cursor_column)
  704. return;
  705. ASSERT(row < rows());
  706. ASSERT(column < columns());
  707. invalidate_cursor();
  708. m_cursor_row = row;
  709. m_cursor_column = column;
  710. m_stomp = false;
  711. invalidate_cursor();
  712. }
  713. void Terminal::put_character_at(unsigned row, unsigned column, u8 ch)
  714. {
  715. ASSERT(row < rows());
  716. ASSERT(column < columns());
  717. auto& line = this->line(row);
  718. line.characters[column] = ch;
  719. line.attributes[column] = m_current_attribute;
  720. line.attributes[column].flags |= Attribute::Touched;
  721. line.dirty = true;
  722. m_last_char = ch;
  723. }
  724. void Terminal::NEL()
  725. {
  726. // NEL - Next Line
  727. newline();
  728. }
  729. void Terminal::IND()
  730. {
  731. // IND - Index (move down)
  732. CUD({});
  733. }
  734. void Terminal::RI()
  735. {
  736. // RI - Reverse Index (move up)
  737. CUU({});
  738. }
  739. void Terminal::on_char(u8 ch)
  740. {
  741. #ifdef TERMINAL_DEBUG
  742. dbgprintf("Terminal::on_char: %b (%c), fg=%u, bg=%u\n", ch, ch, m_current_attribute.foreground_color, m_current_attribute.background_color);
  743. #endif
  744. switch (m_escape_state) {
  745. case GotEscape:
  746. if (ch == '[') {
  747. m_escape_state = ExpectParameter;
  748. } else if (ch == '(') {
  749. m_swallow_current = true;
  750. m_escape_state = ExpectParameter;
  751. } else if (ch == ']') {
  752. m_escape_state = ExpectXtermParameter1;
  753. } else if (ch == '#') {
  754. m_escape_state = ExpectHashtagDigit;
  755. } else if (ch == 'D') {
  756. IND();
  757. m_escape_state = Normal;
  758. return;
  759. } else if (ch == 'M') {
  760. RI();
  761. m_escape_state = Normal;
  762. return;
  763. } else if (ch == 'E') {
  764. NEL();
  765. m_escape_state = Normal;
  766. return;
  767. } else {
  768. dbg() << "Unexpected character in GotEscape '" << (char)ch << "'";
  769. m_escape_state = Normal;
  770. }
  771. return;
  772. case ExpectHashtagDigit:
  773. if (ch >= '0' && ch <= '9') {
  774. execute_hashtag(ch);
  775. m_escape_state = Normal;
  776. }
  777. break;
  778. case ExpectXtermParameter1:
  779. if (ch != ';') {
  780. m_xterm_param1.append(ch);
  781. return;
  782. }
  783. m_escape_state = ExpectXtermParameter2;
  784. return;
  785. case ExpectXtermParameter2:
  786. if (ch != '\007') {
  787. m_xterm_param2.append(ch);
  788. return;
  789. }
  790. m_escape_state = ExpectXtermFinal;
  791. [[fallthrough]];
  792. case ExpectXtermFinal:
  793. m_escape_state = Normal;
  794. if (ch == '\007')
  795. execute_xterm_command();
  796. return;
  797. case ExpectParameter:
  798. if (is_valid_parameter_character(ch)) {
  799. m_parameters.append(ch);
  800. return;
  801. }
  802. m_escape_state = ExpectIntermediate;
  803. [[fallthrough]];
  804. case ExpectIntermediate:
  805. if (is_valid_intermediate_character(ch)) {
  806. m_intermediates.append(ch);
  807. return;
  808. }
  809. m_escape_state = ExpectFinal;
  810. [[fallthrough]];
  811. case ExpectFinal:
  812. if (is_valid_final_character(ch)) {
  813. m_escape_state = Normal;
  814. if (!m_swallow_current)
  815. execute_escape_sequence(ch);
  816. m_swallow_current = false;
  817. return;
  818. }
  819. m_escape_state = Normal;
  820. m_swallow_current = false;
  821. return;
  822. case Normal:
  823. break;
  824. }
  825. switch (ch) {
  826. case '\0':
  827. return;
  828. case '\033':
  829. m_escape_state = GotEscape;
  830. m_swallow_current = false;
  831. return;
  832. case 8: // Backspace
  833. if (m_cursor_column) {
  834. set_cursor(m_cursor_row, m_cursor_column - 1);
  835. return;
  836. }
  837. return;
  838. case '\a':
  839. m_client.beep();
  840. return;
  841. case '\t': {
  842. for (unsigned i = m_cursor_column + 1; i < columns(); ++i) {
  843. if (m_horizontal_tabs[i]) {
  844. set_cursor(m_cursor_row, i);
  845. return;
  846. }
  847. }
  848. return;
  849. }
  850. case '\r':
  851. set_cursor(m_cursor_row, 0);
  852. return;
  853. case '\n':
  854. newline();
  855. return;
  856. }
  857. auto new_column = m_cursor_column + 1;
  858. if (new_column < columns()) {
  859. put_character_at(m_cursor_row, m_cursor_column, ch);
  860. set_cursor(m_cursor_row, new_column);
  861. } else {
  862. if (m_stomp) {
  863. m_stomp = false;
  864. newline();
  865. put_character_at(m_cursor_row, m_cursor_column, ch);
  866. set_cursor(m_cursor_row, 1);
  867. } else {
  868. // Curious: We wait once on the right-hand side
  869. m_stomp = true;
  870. put_character_at(m_cursor_row, m_cursor_column, ch);
  871. }
  872. }
  873. }
  874. void Terminal::inject_string(const StringView& str)
  875. {
  876. for (size_t i = 0; i < str.length(); ++i)
  877. on_char(str[i]);
  878. }
  879. void Terminal::emit_string(const StringView& str)
  880. {
  881. for (size_t i = 0; i < str.length(); ++i)
  882. m_client.emit_char(str[i]);
  883. }
  884. void Terminal::unimplemented_escape()
  885. {
  886. StringBuilder builder;
  887. builder.appendf("((Unimplemented escape: %c", m_final);
  888. if (!m_parameters.is_empty()) {
  889. builder.append(" parameters:");
  890. for (size_t i = 0; i < m_parameters.size(); ++i)
  891. builder.append((char)m_parameters[i]);
  892. }
  893. if (!m_intermediates.is_empty()) {
  894. builder.append(" intermediates:");
  895. for (size_t i = 0; i < m_intermediates.size(); ++i)
  896. builder.append((char)m_intermediates[i]);
  897. }
  898. builder.append("))");
  899. inject_string(builder.to_string());
  900. }
  901. void Terminal::unimplemented_xterm_escape()
  902. {
  903. auto message = String::format("((Unimplemented xterm escape: %c))\n", m_final);
  904. inject_string(message);
  905. }
  906. void Terminal::set_size(u16 columns, u16 rows)
  907. {
  908. if (!columns)
  909. columns = 1;
  910. if (!rows)
  911. rows = 1;
  912. if (columns == m_columns && rows == m_rows)
  913. return;
  914. #if defined(TERMINAL_DEBUG)
  915. dbgprintf("Terminal: RESIZE to: %d rows\n", rows);
  916. #endif
  917. if (rows > m_rows) {
  918. while (m_lines.size() < rows)
  919. m_lines.append(make<Line>(columns));
  920. } else {
  921. m_lines.shrink(rows);
  922. }
  923. for (int i = 0; i < rows; ++i)
  924. m_lines[i].set_length(columns);
  925. m_columns = columns;
  926. m_rows = rows;
  927. m_scroll_region_top = 0;
  928. m_scroll_region_bottom = rows - 1;
  929. m_cursor_row = min((int)m_cursor_row, m_rows - 1);
  930. m_cursor_column = min((int)m_cursor_column, m_columns - 1);
  931. m_saved_cursor_row = min((int)m_saved_cursor_row, m_rows - 1);
  932. m_saved_cursor_column = min((int)m_saved_cursor_column, m_columns - 1);
  933. m_horizontal_tabs.resize(columns);
  934. for (unsigned i = 0; i < columns; ++i)
  935. m_horizontal_tabs[i] = (i % 8) == 0;
  936. // Rightmost column is always last tab on line.
  937. m_horizontal_tabs[columns - 1] = 1;
  938. m_client.terminal_did_resize(m_columns, m_rows);
  939. }
  940. void Terminal::invalidate_cursor()
  941. {
  942. line(m_cursor_row).dirty = true;
  943. }
  944. void Terminal::execute_hashtag(u8 hashtag)
  945. {
  946. switch (hashtag) {
  947. case '8':
  948. // Confidence Test - Fill screen with E's
  949. for (size_t row = 0; row < m_rows; ++row) {
  950. for (size_t column = 0; column < m_columns; ++column) {
  951. put_character_at(row, column, 'E');
  952. }
  953. }
  954. break;
  955. default:
  956. dbg() << "Unknown hashtag: '" << hashtag << "'";
  957. }
  958. }
  959. }