terminal-vga.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939
  1. /* vim: tabstop=4 shiftwidth=4 noexpandtab
  2. * This file is part of ToaruOS and is released under the terms
  3. * of the NCSA / University of Illinois License - see LICENSE.md
  4. * Copyright (C) 2014 Kevin Lange
  5. *
  6. * Terminal Emulator - VGA
  7. */
  8. #include <stdio.h>
  9. #include <stdint.h>
  10. #include <syscall.h>
  11. #include <string.h>
  12. #include <stdlib.h>
  13. #include <signal.h>
  14. #include <time.h>
  15. #include <fcntl.h>
  16. #include <unistd.h>
  17. #include <sys/stat.h>
  18. #include <sys/ioctl.h>
  19. #include <sys/time.h>
  20. #include <sys/wait.h>
  21. #include <getopt.h>
  22. #include <errno.h>
  23. #include <wchar.h>
  24. #include <toaru/utf8decode.h>
  25. #include <toaru/kbd.h>
  26. #include <toaru/graphics.h>
  27. #include <toaru/termemu.h>
  28. #include "vga-palette.h"
  29. #define USE_BELL 0
  30. /* master and slave pty descriptors */
  31. static int fd_master, fd_slave;
  32. static FILE * terminal;
  33. uint16_t term_width = 80; /* Width of the terminal (in cells) */
  34. uint16_t term_height = 25; /* Height of the terminal (in cells) */
  35. uint16_t csr_x = 0; /* Cursor X */
  36. uint16_t csr_y = 0; /* Cursor Y */
  37. term_cell_t * term_buffer = NULL; /* The terminal cell buffer */
  38. uint32_t current_fg = 7; /* Current foreground color */
  39. uint32_t current_bg = 0; /* Current background color */
  40. uint8_t cursor_on = 1; /* Whether or not the cursor should be rendered */
  41. uint8_t _login_shell = 0; /* Whether we're going to display a login shell or not */
  42. uint8_t _hold_out = 0; /* state indicator on last cell ignore \n */
  43. uint64_t mouse_ticks = 0;
  44. #define char_width 1
  45. #define char_height 1
  46. term_state_t * ansi_state = NULL;
  47. void reinit(); /* Defined way further down */
  48. void term_redraw_cursor();
  49. /* Cursor bink timer */
  50. static unsigned int timer_tick = 0;
  51. void term_clear();
  52. void dump_buffer();
  53. static uint64_t get_ticks(void) {
  54. struct timeval now;
  55. gettimeofday(&now, NULL);
  56. return (uint64_t)now.tv_sec * 1000000LL + (uint64_t)now.tv_usec;
  57. }
  58. static int color_distance(uint32_t a, uint32_t b) {
  59. int a_r = (a & 0xFF0000) >> 16;
  60. int a_g = (a & 0xFF00) >> 8;
  61. int a_b = (a & 0xFF);
  62. int b_r = (b & 0xFF0000) >> 16;
  63. int b_g = (b & 0xFF00) >> 8;
  64. int b_b = (b & 0xFF);
  65. int distance = 0;
  66. distance += abs(a_r - b_r) * 3;
  67. distance += abs(a_g - b_g) * 6;
  68. distance += abs(a_b - b_b) * 10;
  69. return distance;
  70. }
  71. static uint32_t vga_base_colors[] = {
  72. 0x000000,
  73. 0xAA0000,
  74. 0x00AA00,
  75. 0xAA5500,
  76. 0x0000AA,
  77. 0xAA00AA,
  78. 0x00AAAA,
  79. 0xAAAAAA,
  80. 0x555555,
  81. 0xFF5555,
  82. 0x55AA55,
  83. 0xFFFF55,
  84. 0x5555FF,
  85. 0xFF55FF,
  86. 0x55FFFF,
  87. 0xFFFFFF,
  88. };
  89. static int is_gray(uint32_t a) {
  90. int a_r = (a & 0xFF0000) >> 16;
  91. int a_g = (a & 0xFF00) >> 8;
  92. int a_b = (a & 0xFF);
  93. return (a_r == a_g && a_g == a_b);
  94. }
  95. static int best_match(uint32_t a) {
  96. int best_distance = INT32_MAX;
  97. int best_index = 0;
  98. for (int j = 0; j < 16; ++j) {
  99. if (is_gray(a) && !is_gray(vga_base_colors[j]));
  100. int distance = color_distance(a, vga_base_colors[j]);
  101. if (distance < best_distance) {
  102. best_index = j;
  103. best_distance = distance;
  104. }
  105. }
  106. return best_index;
  107. }
  108. volatile int exit_application = 0;
  109. static void set_term_font_size(float s) {
  110. /* do nothing */
  111. }
  112. /* Returns the lower of two shorts */
  113. uint16_t min(uint16_t a, uint16_t b) {
  114. return (a < b) ? a : b;
  115. }
  116. /* Returns the higher of two shorts */
  117. uint16_t max(uint16_t a, uint16_t b) {
  118. return (a > b) ? a : b;
  119. }
  120. void set_title(char * c) {
  121. /* Do nothing */
  122. }
  123. void input_buffer_stuff(char * str) {
  124. size_t s = strlen(str) + 1;
  125. write(fd_master, str, s);
  126. }
  127. unsigned short * textmemptr = (unsigned short *)0xB8000;
  128. void placech(unsigned char c, int x, int y, int attr) {
  129. unsigned short *where;
  130. unsigned att = attr << 8;
  131. where = textmemptr + (y * 80 + x);
  132. *where = c | att;
  133. }
  134. /* ANSI-to-VGA */
  135. char vga_to_ansi[] = {
  136. 0, 4, 2, 6, 1, 5, 3, 7,
  137. 8,12,10,14, 9,13,11,15
  138. };
  139. uint32_t ununicode(uint32_t c) {
  140. switch (c) {
  141. case L'☺': return 1;
  142. case L'☻': return 2;
  143. case L'♥': return 3;
  144. case L'♦': return 4;
  145. case L'♣': return 5;
  146. case L'♠': return 6;
  147. case L'•': return 7;
  148. case L'◘': return 8;
  149. case L'○': return 9;
  150. case L'◙': return 10;
  151. case L'♂': return 11;
  152. case L'♀': return 12;
  153. case L'♪': return 13;
  154. case L'♫': return 14;
  155. case L'☼': return 15;
  156. case L'►': return 16;
  157. case L'◄': return 17;
  158. case L'↕': return 18;
  159. case L'‼': return 19;
  160. case L'¶': return 20;
  161. case L'§': return 21;
  162. case L'▬': return 22;
  163. case L'↨': return 23;
  164. case L'↑': return 24;
  165. case L'↓': return 25;
  166. case L'→': return 26;
  167. case L'←': return 27;
  168. case L'∟': return 28;
  169. case L'↔': return 29;
  170. case L'▲': return 30;
  171. case L'▼': return 31;
  172. /* ASCII text */
  173. case L'⌂': return 127;
  174. case L'Ç': return 128;
  175. case L'ü': return 129;
  176. case L'é': return 130;
  177. case L'â': return 131;
  178. case L'ä': return 132;
  179. case L'à': return 133;
  180. case L'å': return 134;
  181. case L'ç': return 135;
  182. case L'ê': return 136;
  183. case L'ë': return 137;
  184. case L'è': return 138;
  185. case L'ï': return 139;
  186. case L'î': return 140;
  187. case L'ì': return 141;
  188. case L'Ä': return 142;
  189. case L'Å': return 143;
  190. case L'É': return 144;
  191. case L'æ': return 145;
  192. case L'Æ': return 146;
  193. case L'ô': return 147;
  194. case L'ö': return 148;
  195. case L'ò': return 149;
  196. case L'û': return 150;
  197. case L'ù': return 151;
  198. case L'ÿ': return 152;
  199. case L'Ö': return 153;
  200. case L'Ü': return 154;
  201. case L'¢': return 155;
  202. case L'£': return 156;
  203. case L'¥': return 157;
  204. case L'₧': return 158;
  205. case L'ƒ': return 159;
  206. case L'á': return 160;
  207. case L'í': return 161;
  208. case L'ó': return 162;
  209. case L'ú': return 163;
  210. case L'ñ': return 164;
  211. case L'Ñ': return 165;
  212. case L'ª': return 166;
  213. case L'º': return 167;
  214. case L'¿': return 168;
  215. case L'⌐': return 169;
  216. case L'¬': return 170;
  217. case L'½': return 171;
  218. case L'¼': return 172;
  219. case L'¡': return 173;
  220. case L'«': return 174;
  221. case L'»': return 175;
  222. case L'░': return 176;
  223. case L'▒': return 177;
  224. case L'▓': return 178;
  225. case L'│': return 179;
  226. case L'┤': return 180;
  227. case L'╡': return 181;
  228. case L'╢': return 182;
  229. case L'╖': return 183;
  230. case L'╕': return 184;
  231. case L'╣': return 185;
  232. case L'║': return 186;
  233. case L'╗': return 187;
  234. case L'╝': return 188;
  235. case L'╜': return 189;
  236. case L'╛': return 190;
  237. case L'┐': return 191;
  238. case L'└': return 192;
  239. case L'┴': return 193;
  240. case L'┬': return 194;
  241. case L'├': return 195;
  242. case L'─': return 196;
  243. case L'┼': return 197;
  244. case L'╞': return 198;
  245. case L'╟': return 199;
  246. case L'╚': return 200;
  247. case L'╔': return 201;
  248. case L'╩': return 202;
  249. case L'╦': return 203;
  250. case L'╠': return 204;
  251. case L'═': return 205;
  252. case L'╬': return 206;
  253. case L'╧': return 207;
  254. case L'╨': return 208;
  255. case L'╤': return 209;
  256. case L'╥': return 210;
  257. case L'╙': return 211;
  258. case L'╘': return 212;
  259. case L'╒': return 213;
  260. case L'╓': return 214;
  261. case L'╫': return 215;
  262. case L'╪': return 216;
  263. case L'┘': return 217;
  264. case L'┌': return 218;
  265. case L'█': return 219;
  266. case L'▄': return 220;
  267. case L'▌': return 221;
  268. case L'▐': return 222;
  269. case L'▀': return 223;
  270. case L'α': return 224;
  271. case L'ß': return 225;
  272. case L'Γ': return 226;
  273. case L'π': return 227;
  274. case L'Σ': return 228;
  275. case L'σ': return 229;
  276. case L'µ': return 230;
  277. case L'τ': return 231;
  278. case L'Φ': return 232;
  279. case L'Θ': return 233;
  280. case L'Ω': return 234;
  281. case L'δ': return 235;
  282. case L'∞': return 236;
  283. case L'φ': return 237;
  284. case L'ε': return 238;
  285. case L'∩': return 239;
  286. case L'≡': return 240;
  287. case L'±': return 241;
  288. case L'≥': return 242;
  289. case L'≤': return 243;
  290. case L'⌠': return 244;
  291. case L'⌡': return 245;
  292. case L'÷': return 246;
  293. case L'≈': return 247;
  294. case L'°': return 248;
  295. case L'∙': return 249;
  296. case L'·': return 250;
  297. case L'√': return 251;
  298. case L'ⁿ': return 252;
  299. case L'²': return 253;
  300. case L'■': return 254;
  301. }
  302. return 4;
  303. }
  304. void
  305. term_write_char(
  306. uint32_t val,
  307. uint16_t x,
  308. uint16_t y,
  309. uint32_t fg,
  310. uint32_t bg,
  311. uint8_t flags
  312. ) {
  313. if (val > 128) val = ununicode(val);
  314. if (fg > 256) {
  315. fg = best_match(fg);
  316. }
  317. if (bg > 256) {
  318. bg = best_match(bg);
  319. }
  320. if (fg > 16) {
  321. fg = vga_colors[fg];
  322. }
  323. if (bg > 16) {
  324. bg = vga_colors[bg];
  325. }
  326. if (fg == 16) fg = 0;
  327. if (bg == 16) bg = 0;
  328. placech(val, x, y, (vga_to_ansi[fg] & 0xF) | (vga_to_ansi[bg] << 4));
  329. }
  330. static void cell_set(uint16_t x, uint16_t y, uint32_t c, uint32_t fg, uint32_t bg, uint8_t flags) {
  331. if (x >= term_width || y >= term_height) return;
  332. term_cell_t * cell = (term_cell_t *)((uintptr_t)term_buffer + (y * term_width + x) * sizeof(term_cell_t));
  333. cell->c = c;
  334. cell->fg = fg;
  335. cell->bg = bg;
  336. cell->flags = flags;
  337. }
  338. static void cell_redraw(uint16_t x, uint16_t y) {
  339. if (x >= term_width || y >= term_height) return;
  340. term_cell_t * cell = (term_cell_t *)((uintptr_t)term_buffer + (y * term_width + x) * sizeof(term_cell_t));
  341. if (((uint32_t *)cell)[0] == 0x00000000) {
  342. term_write_char(' ', x * char_width, y * char_height, TERM_DEFAULT_FG, TERM_DEFAULT_BG, TERM_DEFAULT_FLAGS);
  343. } else {
  344. term_write_char(cell->c, x * char_width, y * char_height, cell->fg, cell->bg, cell->flags);
  345. }
  346. }
  347. static void cell_redraw_inverted(uint16_t x, uint16_t y) {
  348. if (x >= term_width || y >= term_height) return;
  349. term_cell_t * cell = (term_cell_t *)((uintptr_t)term_buffer + (y * term_width + x) * sizeof(term_cell_t));
  350. if (((uint32_t *)cell)[0] == 0x00000000) {
  351. term_write_char(' ', x * char_width, y * char_height, TERM_DEFAULT_BG, TERM_DEFAULT_FG, TERM_DEFAULT_FLAGS | ANSI_SPECBG);
  352. } else {
  353. term_write_char(cell->c, x * char_width, y * char_height, cell->bg, cell->fg, cell->flags | ANSI_SPECBG);
  354. }
  355. }
  356. static void cell_redraw_box(uint16_t x, uint16_t y) {
  357. if (x >= term_width || y >= term_height) return;
  358. term_cell_t * cell = (term_cell_t *)((uintptr_t)term_buffer + (y * term_width + x) * sizeof(term_cell_t));
  359. if (((uint32_t *)cell)[0] == 0x00000000) {
  360. term_write_char(' ', x * char_width, y * char_height, TERM_DEFAULT_FG, TERM_DEFAULT_BG, TERM_DEFAULT_FLAGS | ANSI_BORDER);
  361. } else {
  362. term_write_char(cell->c, x * char_width, y * char_height, cell->fg, cell->bg, cell->flags | ANSI_BORDER);
  363. }
  364. }
  365. void render_cursor() {
  366. cell_redraw_inverted(csr_x, csr_y);
  367. }
  368. void draw_cursor() {
  369. if (!cursor_on) return;
  370. mouse_ticks = get_ticks();
  371. render_cursor();
  372. }
  373. void term_redraw_all() {
  374. for (uint16_t y = 0; y < term_height; ++y) {
  375. for (uint16_t x = 0; x < term_width; ++x) {
  376. cell_redraw(x,y);
  377. }
  378. }
  379. }
  380. void term_scroll(int how_much) {
  381. if (how_much >= term_height || -how_much >= term_height) {
  382. term_clear();
  383. return;
  384. }
  385. if (how_much == 0) {
  386. return;
  387. }
  388. if (how_much > 0) {
  389. /* Shift terminal cells one row up */
  390. memmove(term_buffer, (void *)((uintptr_t)term_buffer + sizeof(term_cell_t) * term_width), sizeof(term_cell_t) * term_width * (term_height - how_much));
  391. /* Reset the "new" row to clean cells */
  392. memset((void *)((uintptr_t)term_buffer + sizeof(term_cell_t) * term_width * (term_height - how_much)), 0x0, sizeof(term_cell_t) * term_width * how_much);
  393. for (int i = 0; i < how_much; ++i) {
  394. for (uint16_t x = 0; x < term_width; ++x) {
  395. cell_set(x,term_height - how_much,' ', current_fg, current_bg, ansi_state->flags);
  396. }
  397. }
  398. term_redraw_all();
  399. } else {
  400. how_much = -how_much;
  401. /* Shift terminal cells one row up */
  402. memmove((void *)((uintptr_t)term_buffer + sizeof(term_cell_t) * term_width), term_buffer, sizeof(term_cell_t) * term_width * (term_height - how_much));
  403. /* Reset the "new" row to clean cells */
  404. memset(term_buffer, 0x0, sizeof(term_cell_t) * term_width * how_much);
  405. term_redraw_all();
  406. }
  407. }
  408. int is_wide(uint32_t codepoint) {
  409. if (codepoint < 256) return 0;
  410. return wcwidth(codepoint) == 2;
  411. }
  412. void term_write(char c) {
  413. static uint32_t codepoint = 0;
  414. static uint32_t unicode_state = 0;
  415. cell_redraw(csr_x, csr_y);
  416. if (!decode(&unicode_state, &codepoint, (uint8_t)c)) {
  417. if (c == '\r') {
  418. csr_x = 0;
  419. return;
  420. }
  421. if (csr_x == term_width) {
  422. csr_x = 0;
  423. ++csr_y;
  424. }
  425. if (csr_y == term_height) {
  426. term_scroll(1);
  427. csr_y = term_height - 1;
  428. }
  429. if (c == '\n') {
  430. if (csr_x == 0 && _hold_out) {
  431. _hold_out = 0;
  432. return;
  433. }
  434. ++csr_y;
  435. if (csr_y == term_height) {
  436. term_scroll(1);
  437. csr_y = term_height - 1;
  438. }
  439. draw_cursor();
  440. } else if (c == '\007') {
  441. /* bell */
  442. #if USE_BELL
  443. for (int i = 0; i < term_height; ++i) {
  444. for (int j = 0; j < term_width; ++j) {
  445. cell_redraw_inverted(j, i);
  446. }
  447. }
  448. syscall_nanosleep(0,10);
  449. term_redraw_all();
  450. #endif
  451. } else if (c == '\b') {
  452. if (csr_x > 0) {
  453. --csr_x;
  454. }
  455. cell_redraw(csr_x, csr_y);
  456. draw_cursor();
  457. } else if (c == '\t') {
  458. csr_x += (8 - csr_x % 8);
  459. draw_cursor();
  460. } else {
  461. int wide = is_wide(codepoint);
  462. uint8_t flags = ansi_state->flags;
  463. if (wide && csr_x == term_width - 1) {
  464. csr_x = 0;
  465. ++csr_y;
  466. }
  467. if (wide) {
  468. flags = flags | ANSI_WIDE;
  469. }
  470. cell_set(csr_x,csr_y, codepoint, current_fg, current_bg, flags);
  471. cell_redraw(csr_x,csr_y);
  472. csr_x++;
  473. if (wide && csr_x != term_width) {
  474. cell_set(csr_x, csr_y, 0xFFFF, current_fg, current_bg, ansi_state->flags);
  475. cell_redraw(csr_x,csr_y);
  476. cell_redraw(csr_x-1,csr_y);
  477. csr_x++;
  478. }
  479. }
  480. } else if (unicode_state == UTF8_REJECT) {
  481. unicode_state = 0;
  482. }
  483. draw_cursor();
  484. }
  485. void term_set_csr(int x, int y) {
  486. cell_redraw(csr_x,csr_y);
  487. csr_x = x;
  488. csr_y = y;
  489. draw_cursor();
  490. }
  491. int term_get_csr_x() {
  492. return csr_x;
  493. }
  494. int term_get_csr_y() {
  495. return csr_y;
  496. }
  497. void term_set_csr_show(int on) {
  498. cursor_on = on;
  499. }
  500. void term_set_colors(uint32_t fg, uint32_t bg) {
  501. current_fg = fg;
  502. current_bg = bg;
  503. }
  504. void term_redraw_cursor() {
  505. if (term_buffer) {
  506. draw_cursor();
  507. }
  508. }
  509. void flip_cursor() {
  510. static uint8_t cursor_flipped = 0;
  511. if (cursor_flipped) {
  512. cell_redraw(csr_x, csr_y);
  513. } else {
  514. render_cursor();
  515. }
  516. cursor_flipped = 1 - cursor_flipped;
  517. }
  518. void term_set_cell(int x, int y, uint32_t c) {
  519. cell_set(x, y, c, current_fg, current_bg, ansi_state->flags);
  520. cell_redraw(x, y);
  521. }
  522. void term_redraw_cell(int x, int y) {
  523. if (x < 0 || y < 0 || x >= term_width || y >= term_height) return;
  524. cell_redraw(x,y);
  525. }
  526. void term_clear(int i) {
  527. if (i == 2) {
  528. /* Oh dear */
  529. csr_x = 0;
  530. csr_y = 0;
  531. memset((void *)term_buffer, 0x00, term_width * term_height * sizeof(term_cell_t));
  532. term_redraw_all();
  533. } else if (i == 0) {
  534. for (int x = csr_x; x < term_width; ++x) {
  535. term_set_cell(x, csr_y, ' ');
  536. }
  537. for (int y = csr_y + 1; y < term_height; ++y) {
  538. for (int x = 0; x < term_width; ++x) {
  539. term_set_cell(x, y, ' ');
  540. }
  541. }
  542. } else if (i == 1) {
  543. for (int y = 0; y < csr_y; ++y) {
  544. for (int x = 0; x < term_width; ++x) {
  545. term_set_cell(x, y, ' ');
  546. }
  547. }
  548. for (int x = 0; x < csr_x; ++x) {
  549. term_set_cell(x, csr_y, ' ');
  550. }
  551. }
  552. }
  553. #define INPUT_SIZE 1024
  554. char input_buffer[INPUT_SIZE];
  555. int input_collected = 0;
  556. void clear_input() {
  557. memset(input_buffer, 0x0, INPUT_SIZE);
  558. input_collected = 0;
  559. }
  560. uint32_t child_pid = 0;
  561. void handle_input(char c) {
  562. write(fd_master, &c, 1);
  563. }
  564. void handle_input_s(char * c) {
  565. write(fd_master, c, strlen(c));
  566. }
  567. void key_event(int ret, key_event_t * event) {
  568. if (ret) {
  569. if (event->modifiers & KEY_MOD_LEFT_ALT || event->modifiers & KEY_MOD_RIGHT_ALT) {
  570. handle_input('\033');
  571. }
  572. if ((event->modifiers & KEY_MOD_LEFT_SHIFT || event->modifiers & KEY_MOD_RIGHT_SHIFT) &&
  573. event->key == '\t') {
  574. handle_input_s("\033[Z");
  575. return;
  576. }
  577. handle_input(event->key);
  578. } else {
  579. if (event->action == KEY_ACTION_UP) return;
  580. switch (event->keycode) {
  581. case KEY_F1:
  582. handle_input_s("\033OP");
  583. break;
  584. case KEY_F2:
  585. handle_input_s("\033OQ");
  586. break;
  587. case KEY_F3:
  588. handle_input_s("\033OR");
  589. break;
  590. case KEY_F4:
  591. handle_input_s("\033OS");
  592. break;
  593. case KEY_F5:
  594. handle_input_s("\033[15~");
  595. break;
  596. case KEY_F6:
  597. handle_input_s("\033[17~");
  598. break;
  599. case KEY_F7:
  600. handle_input_s("\033[18~");
  601. break;
  602. case KEY_F8:
  603. handle_input_s("\033[19~");
  604. break;
  605. case KEY_F9:
  606. handle_input_s("\033[20~");
  607. break;
  608. case KEY_F10:
  609. handle_input_s("\033[21~");
  610. break;
  611. case KEY_F11:
  612. handle_input_s("\033[23~");
  613. break;
  614. case KEY_F12:
  615. /* XXX This is for testing only */
  616. handle_input_s("テスト");
  617. //handle_input_s("\033[24~");
  618. break;
  619. case KEY_ARROW_UP:
  620. handle_input_s("\033[A");
  621. break;
  622. case KEY_ARROW_DOWN:
  623. handle_input_s("\033[B");
  624. break;
  625. case KEY_ARROW_RIGHT:
  626. handle_input_s("\033[C");
  627. break;
  628. case KEY_ARROW_LEFT:
  629. handle_input_s("\033[D");
  630. break;
  631. case KEY_PAGE_UP:
  632. handle_input_s("\033[5~");
  633. break;
  634. case KEY_PAGE_DOWN:
  635. handle_input_s("\033[6~");
  636. break;
  637. case KEY_HOME:
  638. handle_input_s("\033OH");
  639. break;
  640. case KEY_END:
  641. handle_input_s("\033OF");
  642. break;
  643. case KEY_DEL:
  644. handle_input_s("\033[3~");
  645. break;
  646. }
  647. }
  648. }
  649. void usage(char * argv[]) {
  650. printf(
  651. "VGA Terminal Emulator\n"
  652. "\n"
  653. "usage: %s [-b] [-F] [-h]\n"
  654. "\n"
  655. " -h --help \033[3mShow this help message.\033[0m\n"
  656. "\n",
  657. argv[0]);
  658. }
  659. int unsupported_int(void) { return 0; }
  660. void unsupported(int x, int y, char * data) { }
  661. term_callbacks_t term_callbacks = {
  662. term_write,
  663. term_set_colors,
  664. term_set_csr,
  665. term_get_csr_x,
  666. term_get_csr_y,
  667. term_set_cell,
  668. term_clear,
  669. term_scroll,
  670. term_redraw_cursor,
  671. input_buffer_stuff,
  672. set_term_font_size,
  673. set_title,
  674. unsupported,
  675. unsupported_int,
  676. unsupported_int,
  677. term_set_csr_show,
  678. };
  679. void reinit(int send_sig) {
  680. if (term_buffer) {
  681. /* Do nothing */
  682. } else {
  683. term_buffer = malloc(sizeof(term_cell_t) * term_width * term_height);
  684. memset(term_buffer, 0x0, sizeof(term_cell_t) * term_width * term_height);
  685. }
  686. ansi_state = ansi_init(ansi_state, term_width, term_height, &term_callbacks);
  687. term_redraw_all();
  688. }
  689. void maybe_flip_cursor(void) {
  690. uint64_t ticks = get_ticks();
  691. if (ticks > mouse_ticks + 600000LL) {
  692. mouse_ticks = ticks;
  693. flip_cursor();
  694. }
  695. }
  696. void check_for_exit(void) {
  697. if (exit_application) return;
  698. int pid = waitpid(-1, NULL, WNOHANG);
  699. if (pid != child_pid) return;
  700. /* Clean up */
  701. exit_application = 1;
  702. /* Exit */
  703. char exit_message[] = "[Process terminated]\n";
  704. write(fd_slave, exit_message, sizeof(exit_message));
  705. }
  706. int main(int argc, char ** argv) {
  707. _login_shell = 0;
  708. #if 0
  709. static struct option long_opts[] = {
  710. {"login", no_argument, 0, 'l'},
  711. {"help", no_argument, 0, 'h'},
  712. {0,0,0,0}
  713. };
  714. /* Read some arguments */
  715. int index, c;
  716. while ((c = getopt_long(argc, argv, "hl", long_opts, &index)) != -1) {
  717. if (!c) {
  718. if (long_opts[index].flag == 0) {
  719. c = long_opts[index].val;
  720. }
  721. }
  722. switch (c) {
  723. case 'l':
  724. _login_shell = 1;
  725. break;
  726. case 'h':
  727. usage(argv);
  728. return 0;
  729. break;
  730. case '?':
  731. break;
  732. default:
  733. break;
  734. }
  735. }
  736. putenv("TERM=toaru");
  737. #endif
  738. #if 1
  739. char * _env = malloc(strlen("TERM=toaru"));
  740. sprintf(_env, "TERM=toaru");
  741. size_t env_c = 0;
  742. for (char ** env = environ; *env; env++, env_c++);
  743. char ** env_new = malloc(sizeof(char *) * (env_c + 2));
  744. int set_env = 0;
  745. for (size_t i = 0; i < env_c; ++i) {
  746. if (strstr(environ[i], "TERM=") == environ[i]) {
  747. env_new[i] = _env;
  748. set_env = 1;
  749. } else {
  750. env_new[i] = environ[i];
  751. }
  752. }
  753. if (!set_env) {
  754. env_new[env_c] = _env;
  755. env_c++;
  756. }
  757. env_new[env_c] = NULL;
  758. environ = env_new;
  759. #endif
  760. syscall_openpty(&fd_master, &fd_slave, NULL, NULL, NULL);
  761. terminal = fdopen(fd_slave, "w");
  762. struct winsize w;
  763. w.ws_row = term_height;
  764. w.ws_col = term_width;
  765. w.ws_xpixel = 0;
  766. w.ws_ypixel = 0;
  767. ioctl(fd_master, TIOCSWINSZ, &w);
  768. reinit(0);
  769. fflush(stdin);
  770. system("cursor-off"); /* Might GPF */
  771. int pid = getpid();
  772. uint32_t f = fork();
  773. if (getpid() != pid) {
  774. dup2(fd_slave, 0);
  775. dup2(fd_slave, 1);
  776. dup2(fd_slave, 2);
  777. #if 0
  778. if (argv[optind] != NULL) {
  779. char * tokens[] = {argv[optind], NULL};
  780. int i = execvp(tokens[0], tokens);
  781. fprintf(stderr, "Failed to launch requested startup application.\n");
  782. } else {
  783. #endif
  784. if (_login_shell) {
  785. char * tokens[] = {"/bin/login",NULL};
  786. int i = execvp(tokens[0], tokens);
  787. } else {
  788. char * shell = getenv("SHELL");
  789. if (!shell) shell = "/bin/sh"; /* fallback */
  790. char * tokens[] = {shell,NULL};
  791. int i = execvp(tokens[0], tokens);
  792. }
  793. #if 0
  794. }
  795. #endif
  796. exit_application = 1;
  797. return 1;
  798. } else {
  799. child_pid = f;
  800. int kfd = open("/dev/kbd", O_RDONLY);
  801. key_event_t event;
  802. char c;
  803. key_event_state_t kbd_state = {0};
  804. /* Prune any keyboard input we got before the terminal started. */
  805. struct stat s;
  806. fstat(kfd, &s);
  807. for (int i = 0; i < s.st_size; i++) {
  808. char tmp[1];
  809. read(kfd, tmp, 1);
  810. }
  811. int fds[2] = {fd_master, kfd};
  812. unsigned char buf[1024];
  813. while (!exit_application) {
  814. int index = syscall_fswait2(2,fds,200);
  815. check_for_exit();
  816. if (index == 0) {
  817. maybe_flip_cursor();
  818. int r = read(fd_master, buf, 1024);
  819. for (uint32_t i = 0; i < r; ++i) {
  820. ansi_put(ansi_state, buf[i]);
  821. }
  822. } else if (index == 1) {
  823. maybe_flip_cursor();
  824. int r = read(kfd, &c, 1);
  825. if (r > 0) {
  826. int ret = kbd_scancode(&kbd_state, c, &event);
  827. key_event(ret, &event);
  828. }
  829. } else if (index == 2) {
  830. maybe_flip_cursor();
  831. }
  832. }
  833. }
  834. return 0;
  835. }