termbox.h (191232B)
1 /* This program is licensed under the terms of GNU GPL v3 or (at your option) 2 * any later version. Copyright (C) 2022-2026 Страхиња Радић. 3 * See the file LICENSE for exact copyright and license details. */ 4 5 /* 6 This file is based on the termbox2 TUI library, (c) 2021 termbox developers. 7 8 License notice from the original termbox2.h from the termbox2 repository 9 follows: 10 11 MIT License 12 13 Copyright (c) 2010-2020 nsf <no.smile.face@gmail.com> 14 2015-2025 Adam Saponara <as@php.net> 15 16 Permission is hereby granted, free of charge, to any person obtaining a copy 17 of this software and associated documentation files (the "Software"), to deal 18 in the Software without restriction, including without limitation the rights 19 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 20 copies of the Software, and to permit persons to whom the Software is 21 furnished to do so, subject to the following conditions: 22 23 The above copyright notice and this permission notice shall be included in all 24 copies or substantial portions of the Software. 25 26 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 27 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 28 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 29 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 30 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 31 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 32 SOFTWARE. 33 */ 34 35 #ifndef TERMBOX_H_INCL 36 #define TERMBOX_H_INCL 37 38 #ifndef _XOPEN_SOURCE 39 #define _XOPEN_SOURCE 40 #endif 41 42 #ifndef _DEFAULT_SOURCE 43 #define _DEFAULT_SOURCE 44 #endif 45 46 #include <errno.h> 47 #include <fcntl.h> 48 #include <limits.h> 49 #include <signal.h> 50 #include <stdarg.h> 51 #include <stdint.h> 52 #include <stdio.h> 53 #include <stdlib.h> 54 #include <string.h> 55 #include <sys/ioctl.h> 56 #include <sys/select.h> 57 #include <sys/stat.h> 58 #include <sys/time.h> 59 #include <sys/types.h> 60 #include <termios.h> 61 #include <unistd.h> 62 63 #ifdef PATH_MAX 64 #define TB_PATH_MAX PATH_MAX 65 #else 66 #define TB_PATH_MAX 4096 67 #endif 68 69 #ifdef __cplusplus 70 extern "C" { 71 #endif 72 73 // __ffi_start 74 75 #define TB_VERSION_STR "2.7.0-dev" 76 77 /* The following compile-time options are supported: 78 * 79 * TB_OPT_ATTR_W: Integer width of `fg` and `bg` attributes. Valid values 80 * (assuming system support) are 16, 32, and 64. (See 81 * `uintattr_t`). 32 or 64 enables output mode 82 * `TB_OUTPUT_TRUECOLOR`. 64 enables additional style 83 * attributes. (See `tb_set_output_mode`.) Larger values 84 * consume more memory in exchange for more features. 85 * Defaults to 16. 86 * 87 * TB_OPT_EGC: If set, enable extended grapheme cluster support 88 * (`tb_extend_cell`, `tb_set_cell_ex`). Consumes more 89 * memory. Defaults off. 90 * 91 * TB_OPT_PRINTF_BUF: Write buffer size for printf operations. Represents the 92 * largest string that can be sent in one call to 93 * `tb_print*` and `tb_send*` functions. Defaults to 4096. 94 * 95 * TB_OPT_READ_BUF: Read buffer size for tty reads. Defaults to 64. 96 * 97 * TB_OPT_LIBC_WCHAR: If set, use libc's `wcwidth(3)`, `iswprint(3)`, etc 98 * instead of the built-in Unicode-aware versions. Note, 99 * libc's are locale-dependent and the caller must 100 * `setlocale(3)` `LC_CTYPE` to UTF-8. Defaults to built-in. 101 * 102 * TB_OPT_TRUECOLOR: Deprecated. Sets TB_OPT_ATTR_W to 32 if not already set. 103 */ 104 105 #if defined(TB_LIB_OPTS) || 0 // __tb_lib_opts 106 /* Ensure consistent compile-time options when using as a shared library */ 107 #undef TB_OPT_ATTR_W 108 #undef TB_OPT_EGC 109 #undef TB_OPT_PRINTF_BUF 110 #undef TB_OPT_READ_BUF 111 #undef TB_OPT_LIBC_WCHAR 112 #define TB_OPT_ATTR_W 64 113 #define TB_OPT_EGC 114 #endif 115 116 /* Ensure sane `TB_OPT_ATTR_W` (16, 32, or 64) */ 117 #if defined TB_OPT_ATTR_W && TB_OPT_ATTR_W == 16 118 #elif defined TB_OPT_ATTR_W && TB_OPT_ATTR_W == 32 119 #elif defined TB_OPT_ATTR_W && TB_OPT_ATTR_W == 64 120 #else 121 #undef TB_OPT_ATTR_W 122 #if defined TB_OPT_TRUECOLOR // Deprecated. Back-compat for old flag. 123 #define TB_OPT_ATTR_W 32 124 #else 125 #define TB_OPT_ATTR_W 16 126 #endif 127 #endif 128 129 /* Include wchar if opting libc */ 130 #ifdef TB_OPT_LIBC_WCHAR 131 #include <wchar.h> 132 #include <wctype.h> 133 #endif 134 135 /* ASCII key constants (`tb_event.key`) */ 136 #define TB_KEY_CTRL_TILDE 0x00 137 #define TB_KEY_CTRL_2 0x00 // clash with `CTRL_TILDE` 138 #define TB_KEY_CTRL_A 0x01 139 #define TB_KEY_CTRL_B 0x02 140 #define TB_KEY_CTRL_C 0x03 141 #define TB_KEY_CTRL_D 0x04 142 #define TB_KEY_CTRL_E 0x05 143 #define TB_KEY_CTRL_F 0x06 144 #define TB_KEY_CTRL_G 0x07 145 #define TB_KEY_BACKSPACE 0x08 146 #define TB_KEY_CTRL_H 0x08 // clash with `CTRL_BACKSPACE` 147 #define TB_KEY_TAB 0x09 148 #define TB_KEY_CTRL_I 0x09 // clash with `TAB` 149 #define TB_KEY_CTRL_J 0x0a 150 #define TB_KEY_CTRL_K 0x0b 151 #define TB_KEY_CTRL_L 0x0c 152 #define TB_KEY_ENTER 0x0d 153 #define TB_KEY_CTRL_M 0x0d // clash with `ENTER` 154 #define TB_KEY_CTRL_N 0x0e 155 #define TB_KEY_CTRL_O 0x0f 156 #define TB_KEY_CTRL_P 0x10 157 #define TB_KEY_CTRL_Q 0x11 158 #define TB_KEY_CTRL_R 0x12 159 #define TB_KEY_CTRL_S 0x13 160 #define TB_KEY_CTRL_T 0x14 161 #define TB_KEY_CTRL_U 0x15 162 #define TB_KEY_CTRL_V 0x16 163 #define TB_KEY_CTRL_W 0x17 164 #define TB_KEY_CTRL_X 0x18 165 #define TB_KEY_CTRL_Y 0x19 166 #define TB_KEY_CTRL_Z 0x1a 167 #define TB_KEY_ESC 0x1b 168 #define TB_KEY_CTRL_LSQ_BRACKET 0x1b // clash with 'ESC' 169 #define TB_KEY_CTRL_3 0x1b // clash with 'ESC' 170 #define TB_KEY_CTRL_4 0x1c 171 #define TB_KEY_CTRL_BACKSLASH 0x1c // clash with 'CTRL_4' 172 #define TB_KEY_CTRL_5 0x1d 173 #define TB_KEY_CTRL_RSQ_BRACKET 0x1d // clash with 'CTRL_5' 174 #define TB_KEY_CTRL_6 0x1e 175 #define TB_KEY_CTRL_7 0x1f 176 #define TB_KEY_CTRL_SLASH 0x1f // clash with 'CTRL_7' 177 #define TB_KEY_CTRL_UNDERSCORE 0x1f // clash with 'CTRL_7' 178 #define TB_KEY_SPACE 0x20 179 #define TB_KEY_BACKSPACE2 0x7f 180 #define TB_KEY_CTRL_8 0x7f // clash with 'BACKSPACE2' 181 182 #define tb_key_i(i) 0xffff - (i) 183 /* Terminal-dependent key constants (`tb_event.key`) and terminfo caps */ 184 /* BEGIN codegen h */ 185 /* Produced by ./codegen.sh on Tue, 03 Sep 2024 04:17:47 +0000 */ 186 #define TB_KEY_F1 (0xffff - 0) 187 #define TB_KEY_F2 (0xffff - 1) 188 #define TB_KEY_F3 (0xffff - 2) 189 #define TB_KEY_F4 (0xffff - 3) 190 #define TB_KEY_F5 (0xffff - 4) 191 #define TB_KEY_F6 (0xffff - 5) 192 #define TB_KEY_F7 (0xffff - 6) 193 #define TB_KEY_F8 (0xffff - 7) 194 #define TB_KEY_F9 (0xffff - 8) 195 #define TB_KEY_F10 (0xffff - 9) 196 #define TB_KEY_F11 (0xffff - 10) 197 #define TB_KEY_F12 (0xffff - 11) 198 #define TB_KEY_INSERT (0xffff - 12) 199 #define TB_KEY_DELETE (0xffff - 13) 200 #define TB_KEY_HOME (0xffff - 14) 201 #define TB_KEY_END (0xffff - 15) 202 #define TB_KEY_PGUP (0xffff - 16) 203 #define TB_KEY_PGDN (0xffff - 17) 204 #define TB_KEY_ARROW_UP (0xffff - 18) 205 #define TB_KEY_ARROW_DOWN (0xffff - 19) 206 #define TB_KEY_ARROW_LEFT (0xffff - 20) 207 #define TB_KEY_ARROW_RIGHT (0xffff - 21) 208 #define TB_KEY_BACK_TAB (0xffff - 22) 209 #define TB_KEY_MOUSE_LEFT (0xffff - 23) 210 #define TB_KEY_MOUSE_RIGHT (0xffff - 24) 211 #define TB_KEY_MOUSE_MIDDLE (0xffff - 25) 212 #define TB_KEY_MOUSE_RELEASE (0xffff - 26) 213 #define TB_KEY_MOUSE_WHEEL_UP (0xffff - 27) 214 #define TB_KEY_MOUSE_WHEEL_DOWN (0xffff - 28) 215 216 #define TB_CAP_F1 0 217 #define TB_CAP_F2 1 218 #define TB_CAP_F3 2 219 #define TB_CAP_F4 3 220 #define TB_CAP_F5 4 221 #define TB_CAP_F6 5 222 #define TB_CAP_F7 6 223 #define TB_CAP_F8 7 224 #define TB_CAP_F9 8 225 #define TB_CAP_F10 9 226 #define TB_CAP_F11 10 227 #define TB_CAP_F12 11 228 #define TB_CAP_INSERT 12 229 #define TB_CAP_DELETE 13 230 #define TB_CAP_HOME 14 231 #define TB_CAP_END 15 232 #define TB_CAP_PGUP 16 233 #define TB_CAP_PGDN 17 234 #define TB_CAP_ARROW_UP 18 235 #define TB_CAP_ARROW_DOWN 19 236 #define TB_CAP_ARROW_LEFT 20 237 #define TB_CAP_ARROW_RIGHT 21 238 #define TB_CAP_BACK_TAB 22 239 #define TB_CAP__COUNT_KEYS 23 240 #define TB_CAP_ENTER_CA 23 241 #define TB_CAP_EXIT_CA 24 242 #define TB_CAP_SHOW_CURSOR 25 243 #define TB_CAP_HIDE_CURSOR 26 244 #define TB_CAP_CLEAR_SCREEN 27 245 #define TB_CAP_SGR0 28 246 #define TB_CAP_UNDERLINE 29 247 #define TB_CAP_BOLD 30 248 #define TB_CAP_BLINK 31 249 #define TB_CAP_ITALIC 32 250 #define TB_CAP_REVERSE 33 251 #define TB_CAP_ENTER_KEYPAD 34 252 #define TB_CAP_EXIT_KEYPAD 35 253 #define TB_CAP_DIM 36 254 #define TB_CAP_INVISIBLE 37 255 #define TB_CAP__COUNT 38 256 /* END codegen h */ 257 258 /* Some hard-coded caps */ 259 #define TB_HARDCAP_ENTER_MOUSE "\x1b[?1000h\x1b[?1002h\x1b[?1015h\x1b[?1006h" 260 #define TB_HARDCAP_EXIT_MOUSE "\x1b[?1006l\x1b[?1015l\x1b[?1002l\x1b[?1000l" 261 #define TB_HARDCAP_STRIKEOUT "\x1b[9m" 262 #define TB_HARDCAP_UNDERLINE_2 "\x1b[21m" 263 #define TB_HARDCAP_OVERLINE "\x1b[53m" 264 265 /* Colors (numeric) and attributes (bitwise) (`tb_cell.fg`, `tb_cell.bg`) */ 266 #define TB_DEFAULT 0x0000 267 #define TB_BLACK 0x0001 268 #define TB_RED 0x0002 269 #define TB_GREEN 0x0003 270 #define TB_YELLOW 0x0004 271 #define TB_BLUE 0x0005 272 #define TB_MAGENTA 0x0006 273 #define TB_CYAN 0x0007 274 #define TB_WHITE 0x0008 275 276 #if TB_OPT_ATTR_W == 16 277 #define TB_BOLD 0x0100 278 #define TB_UNDERLINE 0x0200 279 #define TB_REVERSE 0x0400 280 #define TB_ITALIC 0x0800 281 #define TB_BLINK 0x1000 282 #define TB_HI_BLACK 0x2000 283 #define TB_BRIGHT 0x4000 284 #define TB_DIM 0x8000 285 #define TB_256_BLACK TB_HI_BLACK // `TB_256_BLACK` is deprecated 286 #else 287 // `TB_OPT_ATTR_W` is 32 or 64 288 #define TB_BOLD 0x01000000 289 #define TB_UNDERLINE 0x02000000 290 #define TB_REVERSE 0x04000000 291 #define TB_ITALIC 0x08000000 292 #define TB_BLINK 0x10000000 293 #define TB_HI_BLACK 0x20000000 294 #define TB_BRIGHT 0x40000000 295 #define TB_DIM 0x80000000 296 #define TB_TRUECOLOR_BOLD TB_BOLD // `TB_TRUECOLOR_*` is deprecated 297 #define TB_TRUECOLOR_UNDERLINE TB_UNDERLINE 298 #define TB_TRUECOLOR_REVERSE TB_REVERSE 299 #define TB_TRUECOLOR_ITALIC TB_ITALIC 300 #define TB_TRUECOLOR_BLINK TB_BLINK 301 #define TB_TRUECOLOR_BLACK TB_HI_BLACK 302 #endif 303 304 #if TB_OPT_ATTR_W == 64 305 #define TB_STRIKEOUT 0x0000000100000000 306 #define TB_UNDERLINE_2 0x0000000200000000 307 #define TB_OVERLINE 0x0000000400000000 308 #define TB_INVISIBLE 0x0000000800000000 309 #endif 310 311 /* Event types (`tb_event.type`) */ 312 #define TB_EVENT_KEY 1 313 #define TB_EVENT_RESIZE 2 314 #define TB_EVENT_MOUSE 3 315 316 /* Key modifiers (bitwise) (`tb_event.mod`) */ 317 #define TB_MOD_ALT 1 318 #define TB_MOD_CTRL 2 319 #define TB_MOD_SHIFT 4 320 #define TB_MOD_MOTION 8 321 322 /* Input modes (bitwise) (`tb_set_input_mode`) */ 323 #define TB_INPUT_CURRENT 0 324 #define TB_INPUT_ESC 1 325 #define TB_INPUT_ALT 2 326 #define TB_INPUT_MOUSE 4 327 328 /* Output modes (`tb_set_output_mode`) */ 329 #define TB_OUTPUT_CURRENT 0 330 #define TB_OUTPUT_NORMAL 1 331 #define TB_OUTPUT_256 2 332 #define TB_OUTPUT_216 3 333 #define TB_OUTPUT_GRAYSCALE 4 334 #if TB_OPT_ATTR_W >= 32 335 #define TB_OUTPUT_TRUECOLOR 5 336 #endif 337 338 /* Common function return values unless otherwise noted. 339 * 340 * Library behavior is undefined after receiving `TB_ERR_MEM`. Callers may 341 * attempt reinitializing by freeing memory, invoking `tb_shutdown`, then 342 * `tb_init`. 343 */ 344 #define TB_OK 0 345 #define TB_ERR -1 346 #define TB_ERR_NEED_MORE -2 347 #define TB_ERR_INIT_ALREADY -3 348 #define TB_ERR_INIT_OPEN -4 349 #define TB_ERR_MEM -5 350 #define TB_ERR_NO_EVENT -6 351 #define TB_ERR_NO_TERM -7 352 #define TB_ERR_NOT_INIT -8 353 #define TB_ERR_OUT_OF_BOUNDS -9 354 #define TB_ERR_READ -10 355 #define TB_ERR_RESIZE_IOCTL -11 356 #define TB_ERR_RESIZE_PIPE -12 357 #define TB_ERR_RESIZE_SIGACTION -13 358 #define TB_ERR_POLL -14 359 #define TB_ERR_TCGETATTR -15 360 #define TB_ERR_TCSETATTR -16 361 #define TB_ERR_UNSUPPORTED_TERM -17 362 #define TB_ERR_RESIZE_WRITE -18 363 #define TB_ERR_RESIZE_POLL -19 364 #define TB_ERR_RESIZE_READ -20 365 #define TB_ERR_RESIZE_SSCANF -21 366 #define TB_ERR_CAP_COLLISION -22 367 368 #define TB_ERR_SELECT TB_ERR_POLL 369 #define TB_ERR_RESIZE_SELECT TB_ERR_RESIZE_POLL 370 371 /* Deprecated. Function types to be used with `tb_set_func`. */ 372 #define TB_FUNC_EXTRACT_PRE 0 373 #define TB_FUNC_EXTRACT_POST 1 374 375 /* Define this to set the size of the buffer used in `tb_printf` 376 * and `tb_sendf` 377 */ 378 #ifndef TB_OPT_PRINTF_BUF 379 #define TB_OPT_PRINTF_BUF 4096 380 #endif 381 382 /* Define this to set the size of the read buffer used when reading 383 * from the tty 384 */ 385 #ifndef TB_OPT_READ_BUF 386 #define TB_OPT_READ_BUF 64 387 #endif 388 389 /* Define this for limited back compat with termbox v1 */ 390 #ifdef TB_OPT_V1_COMPAT 391 #define tb_change_cell tb_set_cell 392 #define tb_put_cell(x, y, c) tb_set_cell((x), (y), (c)->ch, (c)->fg, (c)->bg) 393 #define tb_set_clear_attributes tb_set_clear_attrs 394 #define tb_select_input_mode tb_set_input_mode 395 #define tb_select_output_mode tb_set_output_mode 396 #endif 397 398 /* Define these to swap in a different allocator */ 399 #ifndef tb_malloc 400 #define tb_malloc malloc 401 #define tb_realloc realloc 402 #define tb_free free 403 #endif 404 405 #if TB_OPT_ATTR_W == 64 406 typedef uint64_t uintattr_t; 407 #elif TB_OPT_ATTR_W == 32 408 typedef uint32_t uintattr_t; 409 #else // 16 410 typedef uint16_t uintattr_t; 411 #endif 412 413 /* A cell in a 2d grid representing the terminal screen. 414 * 415 * The terminal screen is represented as 2d array of cells. The structure is 416 * optimized for dealing with single-width (`wcwidth==1`) Unicode codepoints, 417 * however some support for grapheme clusters (e.g., combining diacritical 418 * marks) and wide codepoints (e.g., Hiragana) is provided through `ech`, 419 * `nech`, and `cech` via `tb_set_cell_ex`. `ech` is only valid when `nech>0`, 420 * otherwise `ch` is used. 421 * 422 * For non-single-width codepoints, given `W=wcwidth(ch || ech)`: 423 * 424 * when `W<=0`: termbox forces a single-width cell. Callers should avoid this 425 * if aiming to render text accurately. Callers may use 426 * `tb_set_cell_ex` or `tb_print*` to render `W==0` combining 427 * characters. 428 * 429 * when `W>=2`: termbox zeroes out the following `W-1` cells and skips sending 430 * them to the tty. So, e.g., if the caller sets `x=0,y=0` to a 431 * `W==2` codepoint, the caller's next set should be at `x=2,y=0`. 432 * Anything set at `x=1,y=0` will be ignored. If there are not 433 * enough columns remaining on the line to render `W` cells, spaces 434 * are sent instead. 435 * 436 * See `tb_present` for implementation. 437 */ 438 struct tb_cell { 439 uint32_t ch; // a Unicode codepoint 440 uintattr_t fg; // bitwise foreground attributes 441 uintattr_t bg; // bitwise background attributes 442 #ifdef TB_OPT_EGC 443 uint32_t *ech; // a grapheme cluster of Unicode codepoints, 0-terminated 444 size_t nech; // num elements in ech, 0 means use ch instead of ech 445 size_t cech; // num elements allocated for ech 446 #endif 447 }; 448 449 /* An incoming event from the tty. 450 * 451 * Given the event type, the following fields are relevant: 452 * 453 * when `TB_EVENT_KEY`: `key` xor `ch` (one will be zero) and `mod`. Note 454 * there is overlap between `TB_MOD_CTRL` and 455 * `TB_KEY_CTRL_*`. `TB_MOD_CTRL` and `TB_MOD_SHIFT` are 456 * only set as modifiers to `TB_KEY_ARROW_*`. 457 * 458 * when `TB_EVENT_RESIZE`: `w` and `h` 459 * 460 * when `TB_EVENT_MOUSE`: `key` (`TB_KEY_MOUSE_*`), `x`, and `y` 461 */ 462 struct tb_event { 463 uint8_t type; // one of `TB_EVENT_*` constants 464 uint8_t mod; // bitwise `TB_MOD_*` constants 465 uint16_t key; // one of `TB_KEY_*` constants 466 uint32_t ch; // a Unicode codepoint 467 int32_t w; // resize width 468 int32_t h; // resize height 469 int32_t x; // mouse x 470 int32_t y; // mouse y 471 }; 472 473 /* Initialize the termbox library. This function should be called before any 474 * other functions. `tb_init` is equivalent to `tb_init_file("/dev/tty")`. After 475 * successful initialization, the library must be finalized using `tb_shutdown`. 476 */ 477 int tb_init(void); 478 int tb_init_file(const char *path); 479 int tb_init_fd(int ttyfd); 480 int tb_init_rwfd(int rfd, int wfd); 481 int tb_shutdown(int deallocate); 482 483 /* Return the size of the internal back buffer (which is the same as terminal's 484 * window size in rows and columns). The internal buffer can be resized after 485 * `tb_clear` or `tb_present` calls. Both dimensions have an unspecified 486 * negative value when called before `tb_init` or after `tb_shutdown`. 487 */ 488 int tb_width(void); 489 int tb_height(void); 490 491 /* Clear the internal back buffer using `TB_DEFAULT` or the attributes set by 492 * `tb_set_clear_attrs`. 493 */ 494 int tb_clear(void); 495 int tb_set_clear_attrs(uintattr_t fg, uintattr_t bg); 496 497 /* Synchronize the internal back buffer with the terminal by writing to tty. */ 498 int tb_present(void); 499 500 /* Clear the internal front buffer effectively forcing a complete re-render of 501 * the back buffer to the tty. It is not necessary to call this under normal 502 * circumstances. 503 */ 504 int tb_invalidate(void); 505 506 /* Set the position of the cursor. Upper-left cell is (0, 0). */ 507 int tb_set_cursor(int cx, int cy); 508 int tb_hide_cursor(void); 509 510 /* Set cell contents in the internal back buffer at the specified position. 511 * 512 * Use `tb_set_cell_ex` for rendering grapheme clusters (e.g., combining 513 * diacritical marks). 514 * 515 * Calling `tb_set_cell(x, y, ch, fg, bg)` is equivalent to 516 * `tb_set_cell_ex(x, y, &ch, 1, fg, bg)`. 517 * 518 * `tb_extend_cell` is a shortcut for appending 1 codepoint to `tb_cell.ech`. 519 * 520 * Non-printable (`iswprint(3)`) codepoints are replaced with `U+FFFD` at render 521 * time. 522 */ 523 int tb_set_cell(int x, int y, uint32_t ch, uintattr_t fg, uintattr_t bg); 524 int tb_set_cell_ex(int x, int y, uint32_t *ch, size_t nch, uintattr_t fg, 525 uintattr_t bg); 526 int tb_extend_cell(int x, int y, uint32_t ch); 527 528 /* Return a pointer to the cell at the specified position. 529 * 530 * Cell memory may be invalid or freed after subsequent library calls, so 531 * callers must copy any data that they need to persist across calls. Modifying 532 * cell memory results in undefined behavior. 533 * 534 * Callers may use pointer math to access cells relative to the requested one. 535 * The cell grid memory layout is a contiguous array indexable by the expression 536 * `(y * width) + x`. 537 * 538 * If `back` is non-zero, return cell from the internal back buffer. Otherwise, 539 * return cell from the front buffer. Note the front buffer is updated on each 540 * call to `tb_present`, whereas the back buffer is updated immediately by 541 * `tb_set_cell` and other functions that modify cell contents. 542 * 543 * If the position is invalid, `TB_ERR_OUT_OF_BOUNDS` is returned. 544 */ 545 int tb_get_cell(int x, int y, int back, struct tb_cell **cell); 546 547 /* Set the input mode. Termbox has two input modes: 548 * 549 * 1. `TB_INPUT_ESC` 550 * When escape (`\x1b`) is in the buffer and there's no match for an escape 551 * sequence, a key event for `TB_KEY_ESC` is returned. 552 * 553 * 2. `TB_INPUT_ALT` 554 * When escape (`\x1b`) is in the buffer and there's no match for an escape 555 * sequence, the next keyboard event is returned with a `TB_MOD_ALT` 556 * modifier. 557 * 558 * You can also apply `TB_INPUT_MOUSE` via bitwise OR operation to either of the 559 * modes (e.g., `TB_INPUT_ESC | TB_INPUT_MOUSE`) to receive `TB_EVENT_MOUSE` 560 * events. If none of the main two modes were set, but the mouse mode was, 561 * `TB_INPUT_ESC` is used. If for some reason you've decided to use 562 * `TB_INPUT_ESC | TB_INPUT_ALT`, it will behave as if only `TB_INPUT_ESC` was 563 * selected. 564 * 565 * If mode is `TB_INPUT_CURRENT`, return the current input mode. 566 * 567 * The default input mode is `TB_INPUT_ESC`. 568 */ 569 int tb_set_input_mode(int mode); 570 571 /* Set the output mode. Termbox has multiple output modes: 572 * 573 * 1. `TB_OUTPUT_NORMAL` => [0..8] 574 * 575 * This mode provides 8 different colors: 576 * `TB_BLACK`, `TB_RED`, `TB_GREEN`, `TB_YELLOW`, 577 * `TB_BLUE`, `TB_MAGENTA`, `TB_CYAN`, `TB_WHITE` 578 * 579 * Plus `TB_DEFAULT` which skips sending a color code (i.e., uses the 580 * terminal's default color). 581 * 582 * Colors (including `TB_DEFAULT`) may be bitwise OR'd with attributes: 583 * `TB_BOLD`, `TB_UNDERLINE`, `TB_REVERSE`, `TB_ITALIC`, `TB_BLINK`, 584 * `TB_BRIGHT`, `TB_DIM` 585 * 586 * The following style attributes are also available if compiled with 587 * `TB_OPT_ATTR_W` set to 64: 588 * `TB_STRIKEOUT`, `TB_UNDERLINE_2`, `TB_OVERLINE`, `TB_INVISIBLE` 589 * 590 * As in all modes, the value 0 is interpreted as `TB_DEFAULT` for 591 * convenience. 592 * 593 * Some notes: `TB_REVERSE` and `TB_BRIGHT` can be applied as either `fg` or 594 * `bg` attributes for the same effect. The rest of the attributes apply to 595 * `fg` only and are ignored as `bg` attributes. 596 * 597 * Example usage: `tb_set_cell(x, y, '@', TB_BLACK | TB_BOLD, TB_RED)` 598 * 599 * 2. `TB_OUTPUT_256` => [0..255] + `TB_HI_BLACK` 600 * 601 * In this mode you get 256 distinct colors (plus default): 602 * 0x00 (1): `TB_DEFAULT` 603 * `TB_HI_BLACK` (1): `TB_BLACK` in `TB_OUTPUT_NORMAL` 604 * 0x01..0x07 (7): the next 7 colors as in `TB_OUTPUT_NORMAL` 605 * 0x08..0x0f (8): bright versions of the above 606 * 0x10..0xe7 (216): 216 different colors 607 * 0xe8..0xff (24): 24 different shades of gray 608 * 609 * All `TB_*` style attributes except `TB_BRIGHT` may be bitwise OR'd as in 610 * `TB_OUTPUT_NORMAL`. 611 * 612 * Note `TB_HI_BLACK` must be used for black, as 0x00 represents default. 613 * 614 * 3. `TB_OUTPUT_216` => [0..216] 615 * 616 * This mode supports the 216-color range of `TB_OUTPUT_256` only, but you 617 * don't need to provide an offset: 618 * 0x00 (1): `TB_DEFAULT` 619 * 0x01..0xd8 (216): 216 different colors 620 * 621 * 4. `TB_OUTPUT_GRAYSCALE` => [0..24] 622 * 623 * This mode supports the 24-color range of `TB_OUTPUT_256` only, but you 624 * don't need to provide an offset: 625 * 0x00 (1): `TB_DEFAULT` 626 * 0x01..0x18 (24): 24 different shades of gray 627 * 628 * 5. `TB_OUTPUT_TRUECOLOR` => [0x000000..0xffffff] + `TB_HI_BLACK` 629 * 630 * This mode provides 24-bit color on supported terminals. The format is 631 * 0xRRGGBB. 632 * 633 * All `TB_*` style attributes except `TB_BRIGHT` may be bitwise OR'd as in 634 * `TB_OUTPUT_NORMAL`. 635 * 636 * Note `TB_HI_BLACK` must be used for black, as 0x000000 represents default. 637 * 638 * To use the terminal default color (i.e., to not send an escape code), pass 639 * `TB_DEFAULT`. For convenience, the value 0 is interpreted as `TB_DEFAULT` in 640 * all modes. 641 * 642 * Note, cell attributes persist after switching output modes. Any translation 643 * between, for example, `TB_OUTPUT_NORMAL`'s `TB_RED` and 644 * `TB_OUTPUT_TRUECOLOR`'s 0xff0000 must be performed by the caller. Also note 645 * that cells previously rendered in one mode may persist unchanged until the 646 * front buffer is cleared (such as after a resize event) at which point it will 647 * be re-interpreted and flushed according to the current mode. Callers may 648 * invoke `tb_invalidate` if it is desirable to immediately re-interpret and 649 * flush the entire screen according to the current mode. 650 * 651 * Note, not all terminals support all output modes, especially beyond 652 * `TB_OUTPUT_NORMAL`. There is also no very reliable way to determine color 653 * support dynamically. If portability is desired, callers are recommended to 654 * use `TB_OUTPUT_NORMAL` or make output mode end-user configurable. The same 655 * advice applies to style attributes. 656 * 657 * If mode is `TB_OUTPUT_CURRENT`, return the current output mode. 658 * 659 * The default output mode is `TB_OUTPUT_NORMAL`. 660 */ 661 int tb_set_output_mode(int mode); 662 663 /* Wait for an event up to `timeout_ms` milliseconds and populate `event` with 664 * it. If no event is available within the timeout period, `TB_ERR_NO_EVENT` 665 * is returned. On a resize event, the underlying `select(2)` call may be 666 * interrupted, yielding a return code of `TB_ERR_POLL`. In this case, you may 667 * check `errno` via `tb_last_errno`. If it's `EINTR`, you may elect to ignore 668 * that and call `tb_peek_event` again. 669 */ 670 int tb_peek_event(struct tb_event *event, int timeout_ms); 671 672 /* Same as `tb_peek_event` except no timeout. */ 673 int tb_poll_event(struct tb_event *event); 674 675 /* Internal termbox fds that can be used with `poll(2)`, `select(2)`, etc. 676 * externally. Callers must invoke `tb_poll_event` or `tb_peek_event` if 677 * fds become readable. 678 */ 679 int tb_get_fds(int *ttyfd, int *resizefd); 680 681 /* Print and printf functions. Specify param `out_w` to determine width of 682 * printed string. Strings are interpreted as UTF-8. 683 * 684 * Non-printable characters (`iswprint(3)`) and truncated UTF-8 byte sequences 685 * are replaced with U+FFFD. 686 * 687 * Newlines (`\n`) are supported with the caveat that `out_w` will return the 688 * width of the string as if it were on a single line. 689 * 690 * If the starting coordinate is out of bounds, `TB_ERR_OUT_OF_BOUNDS` is 691 * returned. If the starting coordinate is in bounds, but goes out of bounds, 692 * then the out-of-bounds portions of the string are ignored. 693 * 694 * For finer control, use `tb_set_cell`. 695 */ 696 int tb_print(int x, int y, uintattr_t fg, uintattr_t bg, const char *str); 697 int tb_printf(int x, int y, uintattr_t fg, uintattr_t bg, const char *fmt, ...); 698 int tb_print_ex(int x, int y, uintattr_t fg, uintattr_t bg, size_t *out_w, 699 const char *str); 700 int tb_printf_ex(int x, int y, uintattr_t fg, uintattr_t bg, size_t *out_w, 701 const char *fmt, ...); 702 703 /* Send raw bytes to terminal. */ 704 int tb_send(const char *buf, size_t nbuf); 705 int tb_sendf(const char *fmt, ...); 706 707 /* Deprecated. Set custom callbacks. `fn_type` is one of `TB_FUNC_*` constants, 708 * `fn` is a compatible function pointer, or NULL to clear. 709 * 710 * `TB_FUNC_EXTRACT_PRE`: 711 * If specified, invoke this function BEFORE termbox tries to extract any 712 * escape sequences from the input buffer. 713 * 714 * `TB_FUNC_EXTRACT_POST`: 715 * If specified, invoke this function AFTER termbox tries (and fails) to 716 * extract any escape sequences from the input buffer. 717 */ 718 int tb_set_func(int fn_type, int (*fn)(struct tb_event *, size_t *)); 719 720 /* Return byte length of codepoint given first byte of UTF-8 sequence (1-6). */ 721 int tb_utf8_char_length(char c); 722 723 /* Convert UTF-8 null-terminated byte sequence to UTF-32 codepoint. 724 * 725 * If `c` is an empty C string, return 0. `out` is left unchanged. 726 * 727 * If a null byte is encountered in the middle of the codepoint, return a 728 * negative number indicating how many bytes were processed. `out` is left 729 * unchanged. 730 * 731 * Otherwise, return byte length of codepoint (1-6). 732 */ 733 int tb_utf8_char_to_unicode(uint32_t *out, const char *c); 734 735 /* Convert UTF-32 codepoint to UTF-8 null-terminated byte sequence. 736 * 737 * `out` must be char[7] or greater. Return byte length of codepoint (1-6). 738 */ 739 int tb_utf8_unicode_to_char(char *out, uint32_t c); 740 741 /* Library utility functions */ 742 int tb_last_errno(void); 743 const char *tb_strerror(int err); 744 struct tb_cell *tb_cell_buffer(void); // Deprecated 745 int tb_has_truecolor(void); 746 int tb_has_egc(void); 747 int tb_attr_width(void); 748 const char *tb_version(void); 749 int tb_iswprint(uint32_t ch); 750 int tb_wcwidth(uint32_t ch); 751 752 /* Deprecation notice! 753 * 754 * The following will be removed in version 3.x (ABI version 3): 755 * 756 * TB_256_BLACK (use TB_HI_BLACK) 757 * TB_OPT_TRUECOLOR (use TB_OPT_ATTR_W) 758 * TB_TRUECOLOR_BOLD (use TB_BOLD) 759 * TB_TRUECOLOR_UNDERLINE (use TB_UNDERLINE) 760 * TB_TRUECOLOR_REVERSE (use TB_REVERSE) 761 * TB_TRUECOLOR_ITALIC (use TB_ITALIC) 762 * TB_TRUECOLOR_BLINK (use TB_BLINK) 763 * TB_TRUECOLOR_BLACK (use TB_HI_BLACK) 764 * tb_cell_buffer 765 * tb_set_func 766 * TB_FUNC_EXTRACT_PRE 767 * TB_FUNC_EXTRACT_POST 768 */ 769 770 #ifdef __cplusplus 771 } 772 #endif 773 774 #endif // TERMBOX_H_INCL 775 776 #ifdef TB_IMPL 777 778 #define if_err_return(rv, expr) \ 779 if (((rv) = (expr)) != TB_OK) return (rv) 780 #define if_err_break(rv, expr) \ 781 if (((rv) = (expr)) != TB_OK) break 782 #define if_ok_return(rv, expr) \ 783 if (((rv) = (expr)) == TB_OK) return (rv) 784 #define if_ok_or_need_more_return(rv, expr) \ 785 if (((rv) = (expr)) == TB_OK || (rv) == TB_ERR_NEED_MORE) return (rv) 786 787 #define send_literal(rv, a) \ 788 if_err_return((rv), bytebuf_nputs(&global.out, (a), sizeof(a) - 1)) 789 790 #define send_num(rv, nbuf, n) \ 791 if_err_return((rv), \ 792 bytebuf_nputs(&global.out, (nbuf), convert_num((n), (nbuf)))) 793 794 #define snprintf_or_return(rv, str, sz, fmt, ...) \ 795 do { \ 796 (rv) = snprintf((str), (sz), (fmt), __VA_ARGS__); \ 797 if ((rv) < 0 || (rv) >= (int)(sz)) return TB_ERR; \ 798 } while (0) 799 800 #define if_not_init_return() \ 801 if (!global.initialized) return TB_ERR_NOT_INIT 802 803 struct bytebuf { 804 char *buf; 805 size_t len; 806 size_t cap; 807 }; 808 809 struct cellbuf { 810 int width; 811 int height; 812 struct tb_cell *cells; 813 }; 814 815 struct cap_trie { 816 char c; 817 struct cap_trie *children; 818 size_t nchildren; 819 int is_leaf; 820 uint16_t key; 821 uint8_t mod; 822 }; 823 824 struct tb_global { 825 int ttyfd; 826 int rfd; 827 int wfd; 828 int ttyfd_open; 829 int resize_pipefd[2]; 830 int width; 831 int height; 832 int cursor_x; 833 int cursor_y; 834 int last_x; 835 int last_y; 836 uintattr_t fg; 837 uintattr_t bg; 838 uintattr_t last_fg; 839 uintattr_t last_bg; 840 int input_mode; 841 int output_mode; 842 char *terminfo; 843 size_t nterminfo; 844 const char *caps[TB_CAP__COUNT]; 845 struct cap_trie cap_trie; 846 struct bytebuf in; 847 struct bytebuf out; 848 struct cellbuf back; 849 struct cellbuf front; 850 struct termios orig_tios; 851 int has_orig_tios; 852 int last_errno; 853 int initialized; 854 int (*fn_extract_esc_pre)(struct tb_event *, size_t *); 855 int (*fn_extract_esc_post)(struct tb_event *, size_t *); 856 char errbuf[1024]; 857 }; 858 859 static struct tb_global global = {0}; 860 861 /* BEGIN codegen c */ 862 /* Produced by ./codegen.sh on Tue, 03 Sep 2024 04:17:48 +0000 */ 863 864 static const int16_t terminfo_cap_indexes[] = { 865 66, // kf1 (TB_CAP_F1) 866 68, // kf2 (TB_CAP_F2) 867 69, // kf3 (TB_CAP_F3) 868 70, // kf4 (TB_CAP_F4) 869 71, // kf5 (TB_CAP_F5) 870 72, // kf6 (TB_CAP_F6) 871 73, // kf7 (TB_CAP_F7) 872 74, // kf8 (TB_CAP_F8) 873 75, // kf9 (TB_CAP_F9) 874 67, // kf10 (TB_CAP_F10) 875 216, // kf11 (TB_CAP_F11) 876 217, // kf12 (TB_CAP_F12) 877 77, // kich1 (TB_CAP_INSERT) 878 59, // kdch1 (TB_CAP_DELETE) 879 76, // khome (TB_CAP_HOME) 880 164, // kend (TB_CAP_END) 881 82, // kpp (TB_CAP_PGUP) 882 81, // knp (TB_CAP_PGDN) 883 87, // kcuu1 (TB_CAP_ARROW_UP) 884 61, // kcud1 (TB_CAP_ARROW_DOWN) 885 79, // kcub1 (TB_CAP_ARROW_LEFT) 886 83, // kcuf1 (TB_CAP_ARROW_RIGHT) 887 148, // kcbt (TB_CAP_BACK_TAB) 888 28, // smcup (TB_CAP_ENTER_CA) 889 40, // rmcup (TB_CAP_EXIT_CA) 890 16, // cnorm (TB_CAP_SHOW_CURSOR) 891 13, // civis (TB_CAP_HIDE_CURSOR) 892 5, // clear (TB_CAP_CLEAR_SCREEN) 893 39, // sgr0 (TB_CAP_SGR0) 894 36, // smul (TB_CAP_UNDERLINE) 895 27, // bold (TB_CAP_BOLD) 896 26, // blink (TB_CAP_BLINK) 897 311, // sitm (TB_CAP_ITALIC) 898 34, // rev (TB_CAP_REVERSE) 899 89, // smkx (TB_CAP_ENTER_KEYPAD) 900 88, // rmkx (TB_CAP_EXIT_KEYPAD) 901 30, // dim (TB_CAP_DIM) 902 32, // invis (TB_CAP_INVISIBLE) 903 }; 904 905 // xterm 906 static const char *xterm_caps[] = { 907 "\033OP", // kf1 (TB_CAP_F1) 908 "\033OQ", // kf2 (TB_CAP_F2) 909 "\033OR", // kf3 (TB_CAP_F3) 910 "\033OS", // kf4 (TB_CAP_F4) 911 "\033[15~", // kf5 (TB_CAP_F5) 912 "\033[17~", // kf6 (TB_CAP_F6) 913 "\033[18~", // kf7 (TB_CAP_F7) 914 "\033[19~", // kf8 (TB_CAP_F8) 915 "\033[20~", // kf9 (TB_CAP_F9) 916 "\033[21~", // kf10 (TB_CAP_F10) 917 "\033[23~", // kf11 (TB_CAP_F11) 918 "\033[24~", // kf12 (TB_CAP_F12) 919 "\033[2~", // kich1 (TB_CAP_INSERT) 920 "\033[3~", // kdch1 (TB_CAP_DELETE) 921 "\033OH", // khome (TB_CAP_HOME) 922 "\033OF", // kend (TB_CAP_END) 923 "\033[5~", // kpp (TB_CAP_PGUP) 924 "\033[6~", // knp (TB_CAP_PGDN) 925 "\033OA", // kcuu1 (TB_CAP_ARROW_UP) 926 "\033OB", // kcud1 (TB_CAP_ARROW_DOWN) 927 "\033OD", // kcub1 (TB_CAP_ARROW_LEFT) 928 "\033OC", // kcuf1 (TB_CAP_ARROW_RIGHT) 929 "\033[Z", // kcbt (TB_CAP_BACK_TAB) 930 "\033[?1049h\033[22;0;0t", // smcup (TB_CAP_ENTER_CA) 931 "\033[?1049l\033[23;0;0t", // rmcup (TB_CAP_EXIT_CA) 932 "\033[?12l\033[?25h", // cnorm (TB_CAP_SHOW_CURSOR) 933 "\033[?25l", // civis (TB_CAP_HIDE_CURSOR) 934 "\033[H\033[2J", // clear (TB_CAP_CLEAR_SCREEN) 935 "\033(B\033[m", // sgr0 (TB_CAP_SGR0) 936 "\033[4m", // smul (TB_CAP_UNDERLINE) 937 "\033[1m", // bold (TB_CAP_BOLD) 938 "\033[5m", // blink (TB_CAP_BLINK) 939 "\033[3m", // sitm (TB_CAP_ITALIC) 940 "\033[7m", // rev (TB_CAP_REVERSE) 941 "\033[?1h\033=", // smkx (TB_CAP_ENTER_KEYPAD) 942 "\033[?1l\033>", // rmkx (TB_CAP_EXIT_KEYPAD) 943 "\033[2m", // dim (TB_CAP_DIM) 944 "\033[8m", // invis (TB_CAP_INVISIBLE) 945 }; 946 947 // linux 948 static const char *linux_caps[] = { 949 "\033[[A", // kf1 (TB_CAP_F1) 950 "\033[[B", // kf2 (TB_CAP_F2) 951 "\033[[C", // kf3 (TB_CAP_F3) 952 "\033[[D", // kf4 (TB_CAP_F4) 953 "\033[[E", // kf5 (TB_CAP_F5) 954 "\033[17~", // kf6 (TB_CAP_F6) 955 "\033[18~", // kf7 (TB_CAP_F7) 956 "\033[19~", // kf8 (TB_CAP_F8) 957 "\033[20~", // kf9 (TB_CAP_F9) 958 "\033[21~", // kf10 (TB_CAP_F10) 959 "\033[23~", // kf11 (TB_CAP_F11) 960 "\033[24~", // kf12 (TB_CAP_F12) 961 "\033[2~", // kich1 (TB_CAP_INSERT) 962 "\033[3~", // kdch1 (TB_CAP_DELETE) 963 "\033[1~", // khome (TB_CAP_HOME) 964 "\033[4~", // kend (TB_CAP_END) 965 "\033[5~", // kpp (TB_CAP_PGUP) 966 "\033[6~", // knp (TB_CAP_PGDN) 967 "\033[A", // kcuu1 (TB_CAP_ARROW_UP) 968 "\033[B", // kcud1 (TB_CAP_ARROW_DOWN) 969 "\033[D", // kcub1 (TB_CAP_ARROW_LEFT) 970 "\033[C", // kcuf1 (TB_CAP_ARROW_RIGHT) 971 "\033\011", // kcbt (TB_CAP_BACK_TAB) 972 "", // smcup (TB_CAP_ENTER_CA) 973 "", // rmcup (TB_CAP_EXIT_CA) 974 "\033[?25h\033[?0c", // cnorm (TB_CAP_SHOW_CURSOR) 975 "\033[?25l\033[?1c", // civis (TB_CAP_HIDE_CURSOR) 976 "\033[H\033[J", // clear (TB_CAP_CLEAR_SCREEN) 977 "\033[m\017", // sgr0 (TB_CAP_SGR0) 978 "\033[4m", // smul (TB_CAP_UNDERLINE) 979 "\033[1m", // bold (TB_CAP_BOLD) 980 "\033[5m", // blink (TB_CAP_BLINK) 981 "", // sitm (TB_CAP_ITALIC) 982 "\033[7m", // rev (TB_CAP_REVERSE) 983 "", // smkx (TB_CAP_ENTER_KEYPAD) 984 "", // rmkx (TB_CAP_EXIT_KEYPAD) 985 "\033[2m", // dim (TB_CAP_DIM) 986 "", // invis (TB_CAP_INVISIBLE) 987 }; 988 989 // screen 990 static const char *screen_caps[] = { 991 "\033OP", // kf1 (TB_CAP_F1) 992 "\033OQ", // kf2 (TB_CAP_F2) 993 "\033OR", // kf3 (TB_CAP_F3) 994 "\033OS", // kf4 (TB_CAP_F4) 995 "\033[15~", // kf5 (TB_CAP_F5) 996 "\033[17~", // kf6 (TB_CAP_F6) 997 "\033[18~", // kf7 (TB_CAP_F7) 998 "\033[19~", // kf8 (TB_CAP_F8) 999 "\033[20~", // kf9 (TB_CAP_F9) 1000 "\033[21~", // kf10 (TB_CAP_F10) 1001 "\033[23~", // kf11 (TB_CAP_F11) 1002 "\033[24~", // kf12 (TB_CAP_F12) 1003 "\033[2~", // kich1 (TB_CAP_INSERT) 1004 "\033[3~", // kdch1 (TB_CAP_DELETE) 1005 "\033[1~", // khome (TB_CAP_HOME) 1006 "\033[4~", // kend (TB_CAP_END) 1007 "\033[5~", // kpp (TB_CAP_PGUP) 1008 "\033[6~", // knp (TB_CAP_PGDN) 1009 "\033OA", // kcuu1 (TB_CAP_ARROW_UP) 1010 "\033OB", // kcud1 (TB_CAP_ARROW_DOWN) 1011 "\033OD", // kcub1 (TB_CAP_ARROW_LEFT) 1012 "\033OC", // kcuf1 (TB_CAP_ARROW_RIGHT) 1013 "\033[Z", // kcbt (TB_CAP_BACK_TAB) 1014 "\033[?1049h", // smcup (TB_CAP_ENTER_CA) 1015 "\033[?1049l", // rmcup (TB_CAP_EXIT_CA) 1016 "\033[34h\033[?25h", // cnorm (TB_CAP_SHOW_CURSOR) 1017 "\033[?25l", // civis (TB_CAP_HIDE_CURSOR) 1018 "\033[H\033[J", // clear (TB_CAP_CLEAR_SCREEN) 1019 "\033[m\017", // sgr0 (TB_CAP_SGR0) 1020 "\033[4m", // smul (TB_CAP_UNDERLINE) 1021 "\033[1m", // bold (TB_CAP_BOLD) 1022 "\033[5m", // blink (TB_CAP_BLINK) 1023 "", // sitm (TB_CAP_ITALIC) 1024 "\033[7m", // rev (TB_CAP_REVERSE) 1025 "\033[?1h\033=", // smkx (TB_CAP_ENTER_KEYPAD) 1026 "\033[?1l\033>", // rmkx (TB_CAP_EXIT_KEYPAD) 1027 "\033[2m", // dim (TB_CAP_DIM) 1028 "", // invis (TB_CAP_INVISIBLE) 1029 }; 1030 1031 // rxvt-256color 1032 static const char *rxvt_256color_caps[] = { 1033 "\033[11~", // kf1 (TB_CAP_F1) 1034 "\033[12~", // kf2 (TB_CAP_F2) 1035 "\033[13~", // kf3 (TB_CAP_F3) 1036 "\033[14~", // kf4 (TB_CAP_F4) 1037 "\033[15~", // kf5 (TB_CAP_F5) 1038 "\033[17~", // kf6 (TB_CAP_F6) 1039 "\033[18~", // kf7 (TB_CAP_F7) 1040 "\033[19~", // kf8 (TB_CAP_F8) 1041 "\033[20~", // kf9 (TB_CAP_F9) 1042 "\033[21~", // kf10 (TB_CAP_F10) 1043 "\033[23~", // kf11 (TB_CAP_F11) 1044 "\033[24~", // kf12 (TB_CAP_F12) 1045 "\033[2~", // kich1 (TB_CAP_INSERT) 1046 "\033[3~", // kdch1 (TB_CAP_DELETE) 1047 "\033[7~", // khome (TB_CAP_HOME) 1048 "\033[8~", // kend (TB_CAP_END) 1049 "\033[5~", // kpp (TB_CAP_PGUP) 1050 "\033[6~", // knp (TB_CAP_PGDN) 1051 "\033[A", // kcuu1 (TB_CAP_ARROW_UP) 1052 "\033[B", // kcud1 (TB_CAP_ARROW_DOWN) 1053 "\033[D", // kcub1 (TB_CAP_ARROW_LEFT) 1054 "\033[C", // kcuf1 (TB_CAP_ARROW_RIGHT) 1055 "\033[Z", // kcbt (TB_CAP_BACK_TAB) 1056 "\0337\033[?47h", // smcup (TB_CAP_ENTER_CA) 1057 "\033[2J\033[?47l\0338", // rmcup (TB_CAP_EXIT_CA) 1058 "\033[?25h", // cnorm (TB_CAP_SHOW_CURSOR) 1059 "\033[?25l", // civis (TB_CAP_HIDE_CURSOR) 1060 "\033[H\033[2J", // clear (TB_CAP_CLEAR_SCREEN) 1061 "\033[m\017", // sgr0 (TB_CAP_SGR0) 1062 "\033[4m", // smul (TB_CAP_UNDERLINE) 1063 "\033[1m", // bold (TB_CAP_BOLD) 1064 "\033[5m", // blink (TB_CAP_BLINK) 1065 "", // sitm (TB_CAP_ITALIC) 1066 "\033[7m", // rev (TB_CAP_REVERSE) 1067 "\033=", // smkx (TB_CAP_ENTER_KEYPAD) 1068 "\033>", // rmkx (TB_CAP_EXIT_KEYPAD) 1069 "", // dim (TB_CAP_DIM) 1070 "", // invis (TB_CAP_INVISIBLE) 1071 }; 1072 1073 // rxvt-unicode 1074 static const char *rxvt_unicode_caps[] = { 1075 "\033[11~", // kf1 (TB_CAP_F1) 1076 "\033[12~", // kf2 (TB_CAP_F2) 1077 "\033[13~", // kf3 (TB_CAP_F3) 1078 "\033[14~", // kf4 (TB_CAP_F4) 1079 "\033[15~", // kf5 (TB_CAP_F5) 1080 "\033[17~", // kf6 (TB_CAP_F6) 1081 "\033[18~", // kf7 (TB_CAP_F7) 1082 "\033[19~", // kf8 (TB_CAP_F8) 1083 "\033[20~", // kf9 (TB_CAP_F9) 1084 "\033[21~", // kf10 (TB_CAP_F10) 1085 "\033[23~", // kf11 (TB_CAP_F11) 1086 "\033[24~", // kf12 (TB_CAP_F12) 1087 "\033[2~", // kich1 (TB_CAP_INSERT) 1088 "\033[3~", // kdch1 (TB_CAP_DELETE) 1089 "\033[7~", // khome (TB_CAP_HOME) 1090 "\033[8~", // kend (TB_CAP_END) 1091 "\033[5~", // kpp (TB_CAP_PGUP) 1092 "\033[6~", // knp (TB_CAP_PGDN) 1093 "\033[A", // kcuu1 (TB_CAP_ARROW_UP) 1094 "\033[B", // kcud1 (TB_CAP_ARROW_DOWN) 1095 "\033[D", // kcub1 (TB_CAP_ARROW_LEFT) 1096 "\033[C", // kcuf1 (TB_CAP_ARROW_RIGHT) 1097 "\033[Z", // kcbt (TB_CAP_BACK_TAB) 1098 "\033[?1049h", // smcup (TB_CAP_ENTER_CA) 1099 "\033[r\033[?1049l", // rmcup (TB_CAP_EXIT_CA) 1100 "\033[?12l\033[?25h", // cnorm (TB_CAP_SHOW_CURSOR) 1101 "\033[?25l", // civis (TB_CAP_HIDE_CURSOR) 1102 "\033[H\033[2J", // clear (TB_CAP_CLEAR_SCREEN) 1103 "\033[m\033(B", // sgr0 (TB_CAP_SGR0) 1104 "\033[4m", // smul (TB_CAP_UNDERLINE) 1105 "\033[1m", // bold (TB_CAP_BOLD) 1106 "\033[5m", // blink (TB_CAP_BLINK) 1107 "\033[3m", // sitm (TB_CAP_ITALIC) 1108 "\033[7m", // rev (TB_CAP_REVERSE) 1109 "\033=", // smkx (TB_CAP_ENTER_KEYPAD) 1110 "\033>", // rmkx (TB_CAP_EXIT_KEYPAD) 1111 "", // dim (TB_CAP_DIM) 1112 "", // invis (TB_CAP_INVISIBLE) 1113 }; 1114 1115 // Eterm 1116 static const char *eterm_caps[] = { 1117 "\033[11~", // kf1 (TB_CAP_F1) 1118 "\033[12~", // kf2 (TB_CAP_F2) 1119 "\033[13~", // kf3 (TB_CAP_F3) 1120 "\033[14~", // kf4 (TB_CAP_F4) 1121 "\033[15~", // kf5 (TB_CAP_F5) 1122 "\033[17~", // kf6 (TB_CAP_F6) 1123 "\033[18~", // kf7 (TB_CAP_F7) 1124 "\033[19~", // kf8 (TB_CAP_F8) 1125 "\033[20~", // kf9 (TB_CAP_F9) 1126 "\033[21~", // kf10 (TB_CAP_F10) 1127 "\033[23~", // kf11 (TB_CAP_F11) 1128 "\033[24~", // kf12 (TB_CAP_F12) 1129 "\033[2~", // kich1 (TB_CAP_INSERT) 1130 "\033[3~", // kdch1 (TB_CAP_DELETE) 1131 "\033[7~", // khome (TB_CAP_HOME) 1132 "\033[8~", // kend (TB_CAP_END) 1133 "\033[5~", // kpp (TB_CAP_PGUP) 1134 "\033[6~", // knp (TB_CAP_PGDN) 1135 "\033[A", // kcuu1 (TB_CAP_ARROW_UP) 1136 "\033[B", // kcud1 (TB_CAP_ARROW_DOWN) 1137 "\033[D", // kcub1 (TB_CAP_ARROW_LEFT) 1138 "\033[C", // kcuf1 (TB_CAP_ARROW_RIGHT) 1139 "", // kcbt (TB_CAP_BACK_TAB) 1140 "\0337\033[?47h", // smcup (TB_CAP_ENTER_CA) 1141 "\033[2J\033[?47l\0338", // rmcup (TB_CAP_EXIT_CA) 1142 "\033[?25h", // cnorm (TB_CAP_SHOW_CURSOR) 1143 "\033[?25l", // civis (TB_CAP_HIDE_CURSOR) 1144 "\033[H\033[2J", // clear (TB_CAP_CLEAR_SCREEN) 1145 "\033[m\017", // sgr0 (TB_CAP_SGR0) 1146 "\033[4m", // smul (TB_CAP_UNDERLINE) 1147 "\033[1m", // bold (TB_CAP_BOLD) 1148 "\033[5m", // blink (TB_CAP_BLINK) 1149 "", // sitm (TB_CAP_ITALIC) 1150 "\033[7m", // rev (TB_CAP_REVERSE) 1151 "", // smkx (TB_CAP_ENTER_KEYPAD) 1152 "", // rmkx (TB_CAP_EXIT_KEYPAD) 1153 "", // dim (TB_CAP_DIM) 1154 "", // invis (TB_CAP_INVISIBLE) 1155 }; 1156 1157 static struct { 1158 const char *name; 1159 const char **caps; 1160 const char *alias; 1161 } builtin_terms[] = { 1162 {"xterm", xterm_caps, "" }, 1163 {"linux", linux_caps, "" }, 1164 {"screen", screen_caps, "tmux"}, 1165 {"rxvt-256color", rxvt_256color_caps, "" }, 1166 {"rxvt-unicode", rxvt_unicode_caps, "rxvt"}, 1167 {"Eterm", eterm_caps, "" }, 1168 {NULL, NULL, NULL }, 1169 }; 1170 1171 /* END codegen c */ 1172 1173 static struct { 1174 const char *cap; 1175 const uint16_t key; 1176 const uint8_t mod; 1177 } builtin_mod_caps[] = { 1178 // xterm arrows 1179 {"\x1b[1;2A", TB_KEY_ARROW_UP, TB_MOD_SHIFT }, 1180 {"\x1b[1;3A", TB_KEY_ARROW_UP, TB_MOD_ALT }, 1181 {"\x1b[1;4A", TB_KEY_ARROW_UP, TB_MOD_ALT | TB_MOD_SHIFT }, 1182 {"\x1b[1;5A", TB_KEY_ARROW_UP, TB_MOD_CTRL }, 1183 {"\x1b[1;6A", TB_KEY_ARROW_UP, TB_MOD_CTRL | TB_MOD_SHIFT }, 1184 {"\x1b[1;7A", TB_KEY_ARROW_UP, TB_MOD_CTRL | TB_MOD_ALT }, 1185 {"\x1b[1;8A", TB_KEY_ARROW_UP, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1186 1187 {"\x1b[1;2B", TB_KEY_ARROW_DOWN, TB_MOD_SHIFT }, 1188 {"\x1b[1;3B", TB_KEY_ARROW_DOWN, TB_MOD_ALT }, 1189 {"\x1b[1;4B", TB_KEY_ARROW_DOWN, TB_MOD_ALT | TB_MOD_SHIFT }, 1190 {"\x1b[1;5B", TB_KEY_ARROW_DOWN, TB_MOD_CTRL }, 1191 {"\x1b[1;6B", TB_KEY_ARROW_DOWN, TB_MOD_CTRL | TB_MOD_SHIFT }, 1192 {"\x1b[1;7B", TB_KEY_ARROW_DOWN, TB_MOD_CTRL | TB_MOD_ALT }, 1193 {"\x1b[1;8B", TB_KEY_ARROW_DOWN, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1194 1195 {"\x1b[1;2C", TB_KEY_ARROW_RIGHT, TB_MOD_SHIFT }, 1196 {"\x1b[1;3C", TB_KEY_ARROW_RIGHT, TB_MOD_ALT }, 1197 {"\x1b[1;4C", TB_KEY_ARROW_RIGHT, TB_MOD_ALT | TB_MOD_SHIFT }, 1198 {"\x1b[1;5C", TB_KEY_ARROW_RIGHT, TB_MOD_CTRL }, 1199 {"\x1b[1;6C", TB_KEY_ARROW_RIGHT, TB_MOD_CTRL | TB_MOD_SHIFT }, 1200 {"\x1b[1;7C", TB_KEY_ARROW_RIGHT, TB_MOD_CTRL | TB_MOD_ALT }, 1201 {"\x1b[1;8C", TB_KEY_ARROW_RIGHT, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1202 1203 {"\x1b[1;2D", TB_KEY_ARROW_LEFT, TB_MOD_SHIFT }, 1204 {"\x1b[1;3D", TB_KEY_ARROW_LEFT, TB_MOD_ALT }, 1205 {"\x1b[1;4D", TB_KEY_ARROW_LEFT, TB_MOD_ALT | TB_MOD_SHIFT }, 1206 {"\x1b[1;5D", TB_KEY_ARROW_LEFT, TB_MOD_CTRL }, 1207 {"\x1b[1;6D", TB_KEY_ARROW_LEFT, TB_MOD_CTRL | TB_MOD_SHIFT }, 1208 {"\x1b[1;7D", TB_KEY_ARROW_LEFT, TB_MOD_CTRL | TB_MOD_ALT }, 1209 {"\x1b[1;8D", TB_KEY_ARROW_LEFT, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1210 1211 // xterm keys 1212 {"\x1b[1;2H", TB_KEY_HOME, TB_MOD_SHIFT }, 1213 {"\x1b[1;3H", TB_KEY_HOME, TB_MOD_ALT }, 1214 {"\x1b[1;4H", TB_KEY_HOME, TB_MOD_ALT | TB_MOD_SHIFT }, 1215 {"\x1b[1;5H", TB_KEY_HOME, TB_MOD_CTRL }, 1216 {"\x1b[1;6H", TB_KEY_HOME, TB_MOD_CTRL | TB_MOD_SHIFT }, 1217 {"\x1b[1;7H", TB_KEY_HOME, TB_MOD_CTRL | TB_MOD_ALT }, 1218 {"\x1b[1;8H", TB_KEY_HOME, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1219 1220 {"\x1b[1;2F", TB_KEY_END, TB_MOD_SHIFT }, 1221 {"\x1b[1;3F", TB_KEY_END, TB_MOD_ALT }, 1222 {"\x1b[1;4F", TB_KEY_END, TB_MOD_ALT | TB_MOD_SHIFT }, 1223 {"\x1b[1;5F", TB_KEY_END, TB_MOD_CTRL }, 1224 {"\x1b[1;6F", TB_KEY_END, TB_MOD_CTRL | TB_MOD_SHIFT }, 1225 {"\x1b[1;7F", TB_KEY_END, TB_MOD_CTRL | TB_MOD_ALT }, 1226 {"\x1b[1;8F", TB_KEY_END, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1227 1228 {"\x1b[2;2~", TB_KEY_INSERT, TB_MOD_SHIFT }, 1229 {"\x1b[2;3~", TB_KEY_INSERT, TB_MOD_ALT }, 1230 {"\x1b[2;4~", TB_KEY_INSERT, TB_MOD_ALT | TB_MOD_SHIFT }, 1231 {"\x1b[2;5~", TB_KEY_INSERT, TB_MOD_CTRL }, 1232 {"\x1b[2;6~", TB_KEY_INSERT, TB_MOD_CTRL | TB_MOD_SHIFT }, 1233 {"\x1b[2;7~", TB_KEY_INSERT, TB_MOD_CTRL | TB_MOD_ALT }, 1234 {"\x1b[2;8~", TB_KEY_INSERT, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1235 1236 {"\x1b[3;2~", TB_KEY_DELETE, TB_MOD_SHIFT }, 1237 {"\x1b[3;3~", TB_KEY_DELETE, TB_MOD_ALT }, 1238 {"\x1b[3;4~", TB_KEY_DELETE, TB_MOD_ALT | TB_MOD_SHIFT }, 1239 {"\x1b[3;5~", TB_KEY_DELETE, TB_MOD_CTRL }, 1240 {"\x1b[3;6~", TB_KEY_DELETE, TB_MOD_CTRL | TB_MOD_SHIFT }, 1241 {"\x1b[3;7~", TB_KEY_DELETE, TB_MOD_CTRL | TB_MOD_ALT }, 1242 {"\x1b[3;8~", TB_KEY_DELETE, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1243 1244 {"\x1b[5;2~", TB_KEY_PGUP, TB_MOD_SHIFT }, 1245 {"\x1b[5;3~", TB_KEY_PGUP, TB_MOD_ALT }, 1246 {"\x1b[5;4~", TB_KEY_PGUP, TB_MOD_ALT | TB_MOD_SHIFT }, 1247 {"\x1b[5;5~", TB_KEY_PGUP, TB_MOD_CTRL }, 1248 {"\x1b[5;6~", TB_KEY_PGUP, TB_MOD_CTRL | TB_MOD_SHIFT }, 1249 {"\x1b[5;7~", TB_KEY_PGUP, TB_MOD_CTRL | TB_MOD_ALT }, 1250 {"\x1b[5;8~", TB_KEY_PGUP, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1251 1252 {"\x1b[6;2~", TB_KEY_PGDN, TB_MOD_SHIFT }, 1253 {"\x1b[6;3~", TB_KEY_PGDN, TB_MOD_ALT }, 1254 {"\x1b[6;4~", TB_KEY_PGDN, TB_MOD_ALT | TB_MOD_SHIFT }, 1255 {"\x1b[6;5~", TB_KEY_PGDN, TB_MOD_CTRL }, 1256 {"\x1b[6;6~", TB_KEY_PGDN, TB_MOD_CTRL | TB_MOD_SHIFT }, 1257 {"\x1b[6;7~", TB_KEY_PGDN, TB_MOD_CTRL | TB_MOD_ALT }, 1258 {"\x1b[6;8~", TB_KEY_PGDN, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1259 1260 {"\x1b[1;2P", TB_KEY_F1, TB_MOD_SHIFT }, 1261 {"\x1b[1;3P", TB_KEY_F1, TB_MOD_ALT }, 1262 {"\x1b[1;4P", TB_KEY_F1, TB_MOD_ALT | TB_MOD_SHIFT }, 1263 {"\x1b[1;5P", TB_KEY_F1, TB_MOD_CTRL }, 1264 {"\x1b[1;6P", TB_KEY_F1, TB_MOD_CTRL | TB_MOD_SHIFT }, 1265 {"\x1b[1;7P", TB_KEY_F1, TB_MOD_CTRL | TB_MOD_ALT }, 1266 {"\x1b[1;8P", TB_KEY_F1, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1267 1268 {"\x1b[1;2Q", TB_KEY_F2, TB_MOD_SHIFT }, 1269 {"\x1b[1;3Q", TB_KEY_F2, TB_MOD_ALT }, 1270 {"\x1b[1;4Q", TB_KEY_F2, TB_MOD_ALT | TB_MOD_SHIFT }, 1271 {"\x1b[1;5Q", TB_KEY_F2, TB_MOD_CTRL }, 1272 {"\x1b[1;6Q", TB_KEY_F2, TB_MOD_CTRL | TB_MOD_SHIFT }, 1273 {"\x1b[1;7Q", TB_KEY_F2, TB_MOD_CTRL | TB_MOD_ALT }, 1274 {"\x1b[1;8Q", TB_KEY_F2, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1275 1276 {"\x1b[1;2R", TB_KEY_F3, TB_MOD_SHIFT }, 1277 {"\x1b[1;3R", TB_KEY_F3, TB_MOD_ALT }, 1278 {"\x1b[1;4R", TB_KEY_F3, TB_MOD_ALT | TB_MOD_SHIFT }, 1279 {"\x1b[1;5R", TB_KEY_F3, TB_MOD_CTRL }, 1280 {"\x1b[1;6R", TB_KEY_F3, TB_MOD_CTRL | TB_MOD_SHIFT }, 1281 {"\x1b[1;7R", TB_KEY_F3, TB_MOD_CTRL | TB_MOD_ALT }, 1282 {"\x1b[1;8R", TB_KEY_F3, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1283 1284 {"\x1b[1;2S", TB_KEY_F4, TB_MOD_SHIFT }, 1285 {"\x1b[1;3S", TB_KEY_F4, TB_MOD_ALT }, 1286 {"\x1b[1;4S", TB_KEY_F4, TB_MOD_ALT | TB_MOD_SHIFT }, 1287 {"\x1b[1;5S", TB_KEY_F4, TB_MOD_CTRL }, 1288 {"\x1b[1;6S", TB_KEY_F4, TB_MOD_CTRL | TB_MOD_SHIFT }, 1289 {"\x1b[1;7S", TB_KEY_F4, TB_MOD_CTRL | TB_MOD_ALT }, 1290 {"\x1b[1;8S", TB_KEY_F4, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1291 1292 {"\x1b[15;2~", TB_KEY_F5, TB_MOD_SHIFT }, 1293 {"\x1b[15;3~", TB_KEY_F5, TB_MOD_ALT }, 1294 {"\x1b[15;4~", TB_KEY_F5, TB_MOD_ALT | TB_MOD_SHIFT }, 1295 {"\x1b[15;5~", TB_KEY_F5, TB_MOD_CTRL }, 1296 {"\x1b[15;6~", TB_KEY_F5, TB_MOD_CTRL | TB_MOD_SHIFT }, 1297 {"\x1b[15;7~", TB_KEY_F5, TB_MOD_CTRL | TB_MOD_ALT }, 1298 {"\x1b[15;8~", TB_KEY_F5, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1299 1300 {"\x1b[17;2~", TB_KEY_F6, TB_MOD_SHIFT }, 1301 {"\x1b[17;3~", TB_KEY_F6, TB_MOD_ALT }, 1302 {"\x1b[17;4~", TB_KEY_F6, TB_MOD_ALT | TB_MOD_SHIFT }, 1303 {"\x1b[17;5~", TB_KEY_F6, TB_MOD_CTRL }, 1304 {"\x1b[17;6~", TB_KEY_F6, TB_MOD_CTRL | TB_MOD_SHIFT }, 1305 {"\x1b[17;7~", TB_KEY_F6, TB_MOD_CTRL | TB_MOD_ALT }, 1306 {"\x1b[17;8~", TB_KEY_F6, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1307 1308 {"\x1b[18;2~", TB_KEY_F7, TB_MOD_SHIFT }, 1309 {"\x1b[18;3~", TB_KEY_F7, TB_MOD_ALT }, 1310 {"\x1b[18;4~", TB_KEY_F7, TB_MOD_ALT | TB_MOD_SHIFT }, 1311 {"\x1b[18;5~", TB_KEY_F7, TB_MOD_CTRL }, 1312 {"\x1b[18;6~", TB_KEY_F7, TB_MOD_CTRL | TB_MOD_SHIFT }, 1313 {"\x1b[18;7~", TB_KEY_F7, TB_MOD_CTRL | TB_MOD_ALT }, 1314 {"\x1b[18;8~", TB_KEY_F7, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1315 1316 {"\x1b[19;2~", TB_KEY_F8, TB_MOD_SHIFT }, 1317 {"\x1b[19;3~", TB_KEY_F8, TB_MOD_ALT }, 1318 {"\x1b[19;4~", TB_KEY_F8, TB_MOD_ALT | TB_MOD_SHIFT }, 1319 {"\x1b[19;5~", TB_KEY_F8, TB_MOD_CTRL }, 1320 {"\x1b[19;6~", TB_KEY_F8, TB_MOD_CTRL | TB_MOD_SHIFT }, 1321 {"\x1b[19;7~", TB_KEY_F8, TB_MOD_CTRL | TB_MOD_ALT }, 1322 {"\x1b[19;8~", TB_KEY_F8, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1323 1324 {"\x1b[20;2~", TB_KEY_F9, TB_MOD_SHIFT }, 1325 {"\x1b[20;3~", TB_KEY_F9, TB_MOD_ALT }, 1326 {"\x1b[20;4~", TB_KEY_F9, TB_MOD_ALT | TB_MOD_SHIFT }, 1327 {"\x1b[20;5~", TB_KEY_F9, TB_MOD_CTRL }, 1328 {"\x1b[20;6~", TB_KEY_F9, TB_MOD_CTRL | TB_MOD_SHIFT }, 1329 {"\x1b[20;7~", TB_KEY_F9, TB_MOD_CTRL | TB_MOD_ALT }, 1330 {"\x1b[20;8~", TB_KEY_F9, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1331 1332 {"\x1b[21;2~", TB_KEY_F10, TB_MOD_SHIFT }, 1333 {"\x1b[21;3~", TB_KEY_F10, TB_MOD_ALT }, 1334 {"\x1b[21;4~", TB_KEY_F10, TB_MOD_ALT | TB_MOD_SHIFT }, 1335 {"\x1b[21;5~", TB_KEY_F10, TB_MOD_CTRL }, 1336 {"\x1b[21;6~", TB_KEY_F10, TB_MOD_CTRL | TB_MOD_SHIFT }, 1337 {"\x1b[21;7~", TB_KEY_F10, TB_MOD_CTRL | TB_MOD_ALT }, 1338 {"\x1b[21;8~", TB_KEY_F10, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1339 1340 {"\x1b[23;2~", TB_KEY_F11, TB_MOD_SHIFT }, 1341 {"\x1b[23;3~", TB_KEY_F11, TB_MOD_ALT }, 1342 {"\x1b[23;4~", TB_KEY_F11, TB_MOD_ALT | TB_MOD_SHIFT }, 1343 {"\x1b[23;5~", TB_KEY_F11, TB_MOD_CTRL }, 1344 {"\x1b[23;6~", TB_KEY_F11, TB_MOD_CTRL | TB_MOD_SHIFT }, 1345 {"\x1b[23;7~", TB_KEY_F11, TB_MOD_CTRL | TB_MOD_ALT }, 1346 {"\x1b[23;8~", TB_KEY_F11, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1347 1348 {"\x1b[24;2~", TB_KEY_F12, TB_MOD_SHIFT }, 1349 {"\x1b[24;3~", TB_KEY_F12, TB_MOD_ALT }, 1350 {"\x1b[24;4~", TB_KEY_F12, TB_MOD_ALT | TB_MOD_SHIFT }, 1351 {"\x1b[24;5~", TB_KEY_F12, TB_MOD_CTRL }, 1352 {"\x1b[24;6~", TB_KEY_F12, TB_MOD_CTRL | TB_MOD_SHIFT }, 1353 {"\x1b[24;7~", TB_KEY_F12, TB_MOD_CTRL | TB_MOD_ALT }, 1354 {"\x1b[24;8~", TB_KEY_F12, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1355 1356 // rxvt arrows 1357 {"\x1b[a", TB_KEY_ARROW_UP, TB_MOD_SHIFT }, 1358 {"\x1b\x1b[A", TB_KEY_ARROW_UP, TB_MOD_ALT }, 1359 {"\x1b\x1b[a", TB_KEY_ARROW_UP, TB_MOD_ALT | TB_MOD_SHIFT }, 1360 {"\x1bOa", TB_KEY_ARROW_UP, TB_MOD_CTRL }, 1361 {"\x1b\x1bOa", TB_KEY_ARROW_UP, TB_MOD_CTRL | TB_MOD_ALT }, 1362 1363 {"\x1b[b", TB_KEY_ARROW_DOWN, TB_MOD_SHIFT }, 1364 {"\x1b\x1b[B", TB_KEY_ARROW_DOWN, TB_MOD_ALT }, 1365 {"\x1b\x1b[b", TB_KEY_ARROW_DOWN, TB_MOD_ALT | TB_MOD_SHIFT }, 1366 {"\x1bOb", TB_KEY_ARROW_DOWN, TB_MOD_CTRL }, 1367 {"\x1b\x1bOb", TB_KEY_ARROW_DOWN, TB_MOD_CTRL | TB_MOD_ALT }, 1368 1369 {"\x1b[c", TB_KEY_ARROW_RIGHT, TB_MOD_SHIFT }, 1370 {"\x1b\x1b[C", TB_KEY_ARROW_RIGHT, TB_MOD_ALT }, 1371 {"\x1b\x1b[c", TB_KEY_ARROW_RIGHT, TB_MOD_ALT | TB_MOD_SHIFT }, 1372 {"\x1bOc", TB_KEY_ARROW_RIGHT, TB_MOD_CTRL }, 1373 {"\x1b\x1bOc", TB_KEY_ARROW_RIGHT, TB_MOD_CTRL | TB_MOD_ALT }, 1374 1375 {"\x1b[d", TB_KEY_ARROW_LEFT, TB_MOD_SHIFT }, 1376 {"\x1b\x1b[D", TB_KEY_ARROW_LEFT, TB_MOD_ALT }, 1377 {"\x1b\x1b[d", TB_KEY_ARROW_LEFT, TB_MOD_ALT | TB_MOD_SHIFT }, 1378 {"\x1bOd", TB_KEY_ARROW_LEFT, TB_MOD_CTRL }, 1379 {"\x1b\x1bOd", TB_KEY_ARROW_LEFT, TB_MOD_CTRL | TB_MOD_ALT }, 1380 1381 // rxvt keys 1382 {"\x1b[7$", TB_KEY_HOME, TB_MOD_SHIFT }, 1383 {"\x1b\x1b[7~", TB_KEY_HOME, TB_MOD_ALT }, 1384 {"\x1b\x1b[7$", TB_KEY_HOME, TB_MOD_ALT | TB_MOD_SHIFT }, 1385 {"\x1b[7^", TB_KEY_HOME, TB_MOD_CTRL }, 1386 {"\x1b[7@", TB_KEY_HOME, TB_MOD_CTRL | TB_MOD_SHIFT }, 1387 {"\x1b\x1b[7^", TB_KEY_HOME, TB_MOD_CTRL | TB_MOD_ALT }, 1388 {"\x1b\x1b[7@", TB_KEY_HOME, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1389 1390 {"\x1b\x1b[8~", TB_KEY_END, TB_MOD_ALT }, 1391 {"\x1b\x1b[8$", TB_KEY_END, TB_MOD_ALT | TB_MOD_SHIFT }, 1392 {"\x1b[8^", TB_KEY_END, TB_MOD_CTRL }, 1393 {"\x1b\x1b[8^", TB_KEY_END, TB_MOD_CTRL | TB_MOD_ALT }, 1394 {"\x1b\x1b[8@", TB_KEY_END, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1395 {"\x1b[8@", TB_KEY_END, TB_MOD_CTRL | TB_MOD_SHIFT }, 1396 {"\x1b[8$", TB_KEY_END, TB_MOD_SHIFT }, 1397 1398 {"\x1b\x1b[2~", TB_KEY_INSERT, TB_MOD_ALT }, 1399 {"\x1b\x1b[2$", TB_KEY_INSERT, TB_MOD_ALT | TB_MOD_SHIFT }, 1400 {"\x1b[2^", TB_KEY_INSERT, TB_MOD_CTRL }, 1401 {"\x1b\x1b[2^", TB_KEY_INSERT, TB_MOD_CTRL | TB_MOD_ALT }, 1402 {"\x1b\x1b[2@", TB_KEY_INSERT, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1403 {"\x1b[2@", TB_KEY_INSERT, TB_MOD_CTRL | TB_MOD_SHIFT }, 1404 {"\x1b[2$", TB_KEY_INSERT, TB_MOD_SHIFT }, 1405 1406 {"\x1b\x1b[3~", TB_KEY_DELETE, TB_MOD_ALT }, 1407 {"\x1b\x1b[3$", TB_KEY_DELETE, TB_MOD_ALT | TB_MOD_SHIFT }, 1408 {"\x1b[3^", TB_KEY_DELETE, TB_MOD_CTRL }, 1409 {"\x1b\x1b[3^", TB_KEY_DELETE, TB_MOD_CTRL | TB_MOD_ALT }, 1410 {"\x1b\x1b[3@", TB_KEY_DELETE, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1411 {"\x1b[3@", TB_KEY_DELETE, TB_MOD_CTRL | TB_MOD_SHIFT }, 1412 {"\x1b[3$", TB_KEY_DELETE, TB_MOD_SHIFT }, 1413 1414 {"\x1b\x1b[5~", TB_KEY_PGUP, TB_MOD_ALT }, 1415 {"\x1b\x1b[5$", TB_KEY_PGUP, TB_MOD_ALT | TB_MOD_SHIFT }, 1416 {"\x1b[5^", TB_KEY_PGUP, TB_MOD_CTRL }, 1417 {"\x1b\x1b[5^", TB_KEY_PGUP, TB_MOD_CTRL | TB_MOD_ALT }, 1418 {"\x1b\x1b[5@", TB_KEY_PGUP, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1419 {"\x1b[5@", TB_KEY_PGUP, TB_MOD_CTRL | TB_MOD_SHIFT }, 1420 {"\x1b[5$", TB_KEY_PGUP, TB_MOD_SHIFT }, 1421 1422 {"\x1b\x1b[6~", TB_KEY_PGDN, TB_MOD_ALT }, 1423 {"\x1b\x1b[6$", TB_KEY_PGDN, TB_MOD_ALT | TB_MOD_SHIFT }, 1424 {"\x1b[6^", TB_KEY_PGDN, TB_MOD_CTRL }, 1425 {"\x1b\x1b[6^", TB_KEY_PGDN, TB_MOD_CTRL | TB_MOD_ALT }, 1426 {"\x1b\x1b[6@", TB_KEY_PGDN, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1427 {"\x1b[6@", TB_KEY_PGDN, TB_MOD_CTRL | TB_MOD_SHIFT }, 1428 {"\x1b[6$", TB_KEY_PGDN, TB_MOD_SHIFT }, 1429 1430 {"\x1b\x1b[11~", TB_KEY_F1, TB_MOD_ALT }, 1431 {"\x1b\x1b[23~", TB_KEY_F1, TB_MOD_ALT | TB_MOD_SHIFT }, 1432 {"\x1b[11^", TB_KEY_F1, TB_MOD_CTRL }, 1433 {"\x1b\x1b[11^", TB_KEY_F1, TB_MOD_CTRL | TB_MOD_ALT }, 1434 {"\x1b\x1b[23^", TB_KEY_F1, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1435 {"\x1b[23^", TB_KEY_F1, TB_MOD_CTRL | TB_MOD_SHIFT }, 1436 {"\x1b[23~", TB_KEY_F1, TB_MOD_SHIFT }, 1437 1438 {"\x1b\x1b[12~", TB_KEY_F2, TB_MOD_ALT }, 1439 {"\x1b\x1b[24~", TB_KEY_F2, TB_MOD_ALT | TB_MOD_SHIFT }, 1440 {"\x1b[12^", TB_KEY_F2, TB_MOD_CTRL }, 1441 {"\x1b\x1b[12^", TB_KEY_F2, TB_MOD_CTRL | TB_MOD_ALT }, 1442 {"\x1b\x1b[24^", TB_KEY_F2, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1443 {"\x1b[24^", TB_KEY_F2, TB_MOD_CTRL | TB_MOD_SHIFT }, 1444 {"\x1b[24~", TB_KEY_F2, TB_MOD_SHIFT }, 1445 1446 {"\x1b\x1b[13~", TB_KEY_F3, TB_MOD_ALT }, 1447 {"\x1b\x1b[25~", TB_KEY_F3, TB_MOD_ALT | TB_MOD_SHIFT }, 1448 {"\x1b[13^", TB_KEY_F3, TB_MOD_CTRL }, 1449 {"\x1b\x1b[13^", TB_KEY_F3, TB_MOD_CTRL | TB_MOD_ALT }, 1450 {"\x1b\x1b[25^", TB_KEY_F3, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1451 {"\x1b[25^", TB_KEY_F3, TB_MOD_CTRL | TB_MOD_SHIFT }, 1452 {"\x1b[25~", TB_KEY_F3, TB_MOD_SHIFT }, 1453 1454 {"\x1b\x1b[14~", TB_KEY_F4, TB_MOD_ALT }, 1455 {"\x1b\x1b[26~", TB_KEY_F4, TB_MOD_ALT | TB_MOD_SHIFT }, 1456 {"\x1b[14^", TB_KEY_F4, TB_MOD_CTRL }, 1457 {"\x1b\x1b[14^", TB_KEY_F4, TB_MOD_CTRL | TB_MOD_ALT }, 1458 {"\x1b\x1b[26^", TB_KEY_F4, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1459 {"\x1b[26^", TB_KEY_F4, TB_MOD_CTRL | TB_MOD_SHIFT }, 1460 {"\x1b[26~", TB_KEY_F4, TB_MOD_SHIFT }, 1461 1462 {"\x1b\x1b[15~", TB_KEY_F5, TB_MOD_ALT }, 1463 {"\x1b\x1b[28~", TB_KEY_F5, TB_MOD_ALT | TB_MOD_SHIFT }, 1464 {"\x1b[15^", TB_KEY_F5, TB_MOD_CTRL }, 1465 {"\x1b\x1b[15^", TB_KEY_F5, TB_MOD_CTRL | TB_MOD_ALT }, 1466 {"\x1b\x1b[28^", TB_KEY_F5, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1467 {"\x1b[28^", TB_KEY_F5, TB_MOD_CTRL | TB_MOD_SHIFT }, 1468 {"\x1b[28~", TB_KEY_F5, TB_MOD_SHIFT }, 1469 1470 {"\x1b\x1b[17~", TB_KEY_F6, TB_MOD_ALT }, 1471 {"\x1b\x1b[29~", TB_KEY_F6, TB_MOD_ALT | TB_MOD_SHIFT }, 1472 {"\x1b[17^", TB_KEY_F6, TB_MOD_CTRL }, 1473 {"\x1b\x1b[17^", TB_KEY_F6, TB_MOD_CTRL | TB_MOD_ALT }, 1474 {"\x1b\x1b[29^", TB_KEY_F6, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1475 {"\x1b[29^", TB_KEY_F6, TB_MOD_CTRL | TB_MOD_SHIFT }, 1476 {"\x1b[29~", TB_KEY_F6, TB_MOD_SHIFT }, 1477 1478 {"\x1b\x1b[18~", TB_KEY_F7, TB_MOD_ALT }, 1479 {"\x1b\x1b[31~", TB_KEY_F7, TB_MOD_ALT | TB_MOD_SHIFT }, 1480 {"\x1b[18^", TB_KEY_F7, TB_MOD_CTRL }, 1481 {"\x1b\x1b[18^", TB_KEY_F7, TB_MOD_CTRL | TB_MOD_ALT }, 1482 {"\x1b\x1b[31^", TB_KEY_F7, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1483 {"\x1b[31^", TB_KEY_F7, TB_MOD_CTRL | TB_MOD_SHIFT }, 1484 {"\x1b[31~", TB_KEY_F7, TB_MOD_SHIFT }, 1485 1486 {"\x1b\x1b[19~", TB_KEY_F8, TB_MOD_ALT }, 1487 {"\x1b\x1b[32~", TB_KEY_F8, TB_MOD_ALT | TB_MOD_SHIFT }, 1488 {"\x1b[19^", TB_KEY_F8, TB_MOD_CTRL }, 1489 {"\x1b\x1b[19^", TB_KEY_F8, TB_MOD_CTRL | TB_MOD_ALT }, 1490 {"\x1b\x1b[32^", TB_KEY_F8, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1491 {"\x1b[32^", TB_KEY_F8, TB_MOD_CTRL | TB_MOD_SHIFT }, 1492 {"\x1b[32~", TB_KEY_F8, TB_MOD_SHIFT }, 1493 1494 {"\x1b\x1b[20~", TB_KEY_F9, TB_MOD_ALT }, 1495 {"\x1b\x1b[33~", TB_KEY_F9, TB_MOD_ALT | TB_MOD_SHIFT }, 1496 {"\x1b[20^", TB_KEY_F9, TB_MOD_CTRL }, 1497 {"\x1b\x1b[20^", TB_KEY_F9, TB_MOD_CTRL | TB_MOD_ALT }, 1498 {"\x1b\x1b[33^", TB_KEY_F9, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1499 {"\x1b[33^", TB_KEY_F9, TB_MOD_CTRL | TB_MOD_SHIFT }, 1500 {"\x1b[33~", TB_KEY_F9, TB_MOD_SHIFT }, 1501 1502 {"\x1b\x1b[21~", TB_KEY_F10, TB_MOD_ALT }, 1503 {"\x1b\x1b[34~", TB_KEY_F10, TB_MOD_ALT | TB_MOD_SHIFT }, 1504 {"\x1b[21^", TB_KEY_F10, TB_MOD_CTRL }, 1505 {"\x1b\x1b[21^", TB_KEY_F10, TB_MOD_CTRL | TB_MOD_ALT }, 1506 {"\x1b\x1b[34^", TB_KEY_F10, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1507 {"\x1b[34^", TB_KEY_F10, TB_MOD_CTRL | TB_MOD_SHIFT }, 1508 {"\x1b[34~", TB_KEY_F10, TB_MOD_SHIFT }, 1509 1510 {"\x1b\x1b[23~", TB_KEY_F11, TB_MOD_ALT }, 1511 {"\x1b\x1b[23$", TB_KEY_F11, TB_MOD_ALT | TB_MOD_SHIFT }, 1512 {"\x1b[23^", TB_KEY_F11, TB_MOD_CTRL }, 1513 {"\x1b\x1b[23^", TB_KEY_F11, TB_MOD_CTRL | TB_MOD_ALT }, 1514 {"\x1b\x1b[23@", TB_KEY_F11, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1515 {"\x1b[23@", TB_KEY_F11, TB_MOD_CTRL | TB_MOD_SHIFT }, 1516 {"\x1b[23$", TB_KEY_F11, TB_MOD_SHIFT }, 1517 1518 {"\x1b\x1b[24~", TB_KEY_F12, TB_MOD_ALT }, 1519 {"\x1b\x1b[24$", TB_KEY_F12, TB_MOD_ALT | TB_MOD_SHIFT }, 1520 {"\x1b[24^", TB_KEY_F12, TB_MOD_CTRL }, 1521 {"\x1b\x1b[24^", TB_KEY_F12, TB_MOD_CTRL | TB_MOD_ALT }, 1522 {"\x1b\x1b[24@", TB_KEY_F12, TB_MOD_CTRL | TB_MOD_ALT | TB_MOD_SHIFT}, 1523 {"\x1b[24@", TB_KEY_F12, TB_MOD_CTRL | TB_MOD_SHIFT }, 1524 {"\x1b[24$", TB_KEY_F12, TB_MOD_SHIFT }, 1525 1526 // linux console/putty arrows 1527 {"\x1b[A", TB_KEY_ARROW_UP, TB_MOD_SHIFT }, 1528 {"\x1b[B", TB_KEY_ARROW_DOWN, TB_MOD_SHIFT }, 1529 {"\x1b[C", TB_KEY_ARROW_RIGHT, TB_MOD_SHIFT }, 1530 {"\x1b[D", TB_KEY_ARROW_LEFT, TB_MOD_SHIFT }, 1531 1532 // more putty arrows 1533 {"\x1bOA", TB_KEY_ARROW_UP, TB_MOD_CTRL }, 1534 {"\x1b\x1bOA", TB_KEY_ARROW_UP, TB_MOD_CTRL | TB_MOD_ALT }, 1535 {"\x1bOB", TB_KEY_ARROW_DOWN, TB_MOD_CTRL }, 1536 {"\x1b\x1bOB", TB_KEY_ARROW_DOWN, TB_MOD_CTRL | TB_MOD_ALT }, 1537 {"\x1bOC", TB_KEY_ARROW_RIGHT, TB_MOD_CTRL }, 1538 {"\x1b\x1bOC", TB_KEY_ARROW_RIGHT, TB_MOD_CTRL | TB_MOD_ALT }, 1539 {"\x1bOD", TB_KEY_ARROW_LEFT, TB_MOD_CTRL }, 1540 {"\x1b\x1bOD", TB_KEY_ARROW_LEFT, TB_MOD_CTRL | TB_MOD_ALT }, 1541 1542 {NULL, 0, 0 }, 1543 }; 1544 1545 static const unsigned char utf8_length[256] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1546 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1547 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1548 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1549 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1550 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1551 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1552 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1553 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1554 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1555 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 1, 1}; 1556 1557 static const unsigned char utf8_mask[6] = {0x7f, 0x1f, 0x0f, 0x07, 0x03, 0x01}; 1558 1559 #ifndef TB_OPT_LIBC_WCHAR 1560 static struct { 1561 uint32_t range_start; 1562 uint32_t range_end; 1563 int width; // -1 means iswprint==0, otherwise wcwidth value (0, 1, or 2) 1564 } wcwidth_table[] = { 1565 // clang-format off 1566 {0x000001, 0x00001f, -1}, {0x000020, 0x00007e, 1}, {0x00007f, 0x00009f, -1}, 1567 {0x0000a0, 0x0002ff, 1}, {0x000300, 0x00036f, 0}, {0x000370, 0x000377, 1}, 1568 {0x000378, 0x000379, -1}, {0x00037a, 0x00037f, 1}, {0x000380, 0x000383, -1}, 1569 {0x000384, 0x00038a, 1}, {0x00038b, 0x00038b, -1}, {0x00038c, 0x00038c, 1}, 1570 {0x00038d, 0x00038d, -1}, {0x00038e, 0x0003a1, 1}, {0x0003a2, 0x0003a2, -1}, 1571 {0x0003a3, 0x000482, 1}, {0x000483, 0x000489, 0}, {0x00048a, 0x00052f, 1}, 1572 {0x000530, 0x000530, -1}, {0x000531, 0x000556, 1}, {0x000557, 0x000558, -1}, 1573 {0x000559, 0x00058a, 1}, {0x00058b, 0x00058c, -1}, {0x00058d, 0x00058f, 1}, 1574 {0x000590, 0x000590, -1}, {0x000591, 0x0005bd, 0}, {0x0005be, 0x0005be, 1}, 1575 {0x0005bf, 0x0005bf, 0}, {0x0005c0, 0x0005c0, 1}, {0x0005c1, 0x0005c2, 0}, 1576 {0x0005c3, 0x0005c3, 1}, {0x0005c4, 0x0005c5, 0}, {0x0005c6, 0x0005c6, 1}, 1577 {0x0005c7, 0x0005c7, 0}, {0x0005c8, 0x0005cf, -1}, {0x0005d0, 0x0005ea, 1}, 1578 {0x0005eb, 0x0005ee, -1}, {0x0005ef, 0x0005f4, 1}, {0x0005f5, 0x0005ff, -1}, 1579 {0x000600, 0x00060f, 1}, {0x000610, 0x00061a, 0}, {0x00061b, 0x00061b, 1}, 1580 {0x00061c, 0x00061c, 0}, {0x00061d, 0x00064a, 1}, {0x00064b, 0x00065f, 0}, 1581 {0x000660, 0x00066f, 1}, {0x000670, 0x000670, 0}, {0x000671, 0x0006d5, 1}, 1582 {0x0006d6, 0x0006dc, 0}, {0x0006dd, 0x0006de, 1}, {0x0006df, 0x0006e4, 0}, 1583 {0x0006e5, 0x0006e6, 1}, {0x0006e7, 0x0006e8, 0}, {0x0006e9, 0x0006e9, 1}, 1584 {0x0006ea, 0x0006ed, 0}, {0x0006ee, 0x00070d, 1}, {0x00070e, 0x00070e, -1}, 1585 {0x00070f, 0x000710, 1}, {0x000711, 0x000711, 0}, {0x000712, 0x00072f, 1}, 1586 {0x000730, 0x00074a, 0}, {0x00074b, 0x00074c, -1}, {0x00074d, 0x0007a5, 1}, 1587 {0x0007a6, 0x0007b0, 0}, {0x0007b1, 0x0007b1, 1}, {0x0007b2, 0x0007bf, -1}, 1588 {0x0007c0, 0x0007ea, 1}, {0x0007eb, 0x0007f3, 0}, {0x0007f4, 0x0007fa, 1}, 1589 {0x0007fb, 0x0007fc, -1}, {0x0007fd, 0x0007fd, 0}, {0x0007fe, 0x000815, 1}, 1590 {0x000816, 0x000819, 0}, {0x00081a, 0x00081a, 1}, {0x00081b, 0x000823, 0}, 1591 {0x000824, 0x000824, 1}, {0x000825, 0x000827, 0}, {0x000828, 0x000828, 1}, 1592 {0x000829, 0x00082d, 0}, {0x00082e, 0x00082f, -1}, {0x000830, 0x00083e, 1}, 1593 {0x00083f, 0x00083f, -1}, {0x000840, 0x000858, 1}, {0x000859, 0x00085b, 0}, 1594 {0x00085c, 0x00085d, -1}, {0x00085e, 0x00085e, 1}, {0x00085f, 0x00085f, -1}, 1595 {0x000860, 0x00086a, 1}, {0x00086b, 0x00086f, -1}, {0x000870, 0x00088e, 1}, 1596 {0x00088f, 0x00088f, -1}, {0x000890, 0x000891, 1}, {0x000892, 0x000896, -1}, 1597 {0x000897, 0x00089f, 0}, {0x0008a0, 0x0008c9, 1}, {0x0008ca, 0x0008e1, 0}, 1598 {0x0008e2, 0x0008e2, 1}, {0x0008e3, 0x000902, 0}, {0x000903, 0x000939, 1}, 1599 {0x00093a, 0x00093a, 0}, {0x00093b, 0x00093b, 1}, {0x00093c, 0x00093c, 0}, 1600 {0x00093d, 0x000940, 1}, {0x000941, 0x000948, 0}, {0x000949, 0x00094c, 1}, 1601 {0x00094d, 0x00094d, 0}, {0x00094e, 0x000950, 1}, {0x000951, 0x000957, 0}, 1602 {0x000958, 0x000961, 1}, {0x000962, 0x000963, 0}, {0x000964, 0x000980, 1}, 1603 {0x000981, 0x000981, 0}, {0x000982, 0x000983, 1}, {0x000984, 0x000984, -1}, 1604 {0x000985, 0x00098c, 1}, {0x00098d, 0x00098e, -1}, {0x00098f, 0x000990, 1}, 1605 {0x000991, 0x000992, -1}, {0x000993, 0x0009a8, 1}, {0x0009a9, 0x0009a9, -1}, 1606 {0x0009aa, 0x0009b0, 1}, {0x0009b1, 0x0009b1, -1}, {0x0009b2, 0x0009b2, 1}, 1607 {0x0009b3, 0x0009b5, -1}, {0x0009b6, 0x0009b9, 1}, {0x0009ba, 0x0009bb, -1}, 1608 {0x0009bc, 0x0009bc, 0}, {0x0009bd, 0x0009c0, 1}, {0x0009c1, 0x0009c4, 0}, 1609 {0x0009c5, 0x0009c6, -1}, {0x0009c7, 0x0009c8, 1}, {0x0009c9, 0x0009ca, -1}, 1610 {0x0009cb, 0x0009cc, 1}, {0x0009cd, 0x0009cd, 0}, {0x0009ce, 0x0009ce, 1}, 1611 {0x0009cf, 0x0009d6, -1}, {0x0009d7, 0x0009d7, 1}, {0x0009d8, 0x0009db, -1}, 1612 {0x0009dc, 0x0009dd, 1}, {0x0009de, 0x0009de, -1}, {0x0009df, 0x0009e1, 1}, 1613 {0x0009e2, 0x0009e3, 0}, {0x0009e4, 0x0009e5, -1}, {0x0009e6, 0x0009fd, 1}, 1614 {0x0009fe, 0x0009fe, 0}, {0x0009ff, 0x000a00, -1}, {0x000a01, 0x000a02, 0}, 1615 {0x000a03, 0x000a03, 1}, {0x000a04, 0x000a04, -1}, {0x000a05, 0x000a0a, 1}, 1616 {0x000a0b, 0x000a0e, -1}, {0x000a0f, 0x000a10, 1}, {0x000a11, 0x000a12, -1}, 1617 {0x000a13, 0x000a28, 1}, {0x000a29, 0x000a29, -1}, {0x000a2a, 0x000a30, 1}, 1618 {0x000a31, 0x000a31, -1}, {0x000a32, 0x000a33, 1}, {0x000a34, 0x000a34, -1}, 1619 {0x000a35, 0x000a36, 1}, {0x000a37, 0x000a37, -1}, {0x000a38, 0x000a39, 1}, 1620 {0x000a3a, 0x000a3b, -1}, {0x000a3c, 0x000a3c, 0}, {0x000a3d, 0x000a3d, -1}, 1621 {0x000a3e, 0x000a40, 1}, {0x000a41, 0x000a42, 0}, {0x000a43, 0x000a46, -1}, 1622 {0x000a47, 0x000a48, 0}, {0x000a49, 0x000a4a, -1}, {0x000a4b, 0x000a4d, 0}, 1623 {0x000a4e, 0x000a50, -1}, {0x000a51, 0x000a51, 0}, {0x000a52, 0x000a58, -1}, 1624 {0x000a59, 0x000a5c, 1}, {0x000a5d, 0x000a5d, -1}, {0x000a5e, 0x000a5e, 1}, 1625 {0x000a5f, 0x000a65, -1}, {0x000a66, 0x000a6f, 1}, {0x000a70, 0x000a71, 0}, 1626 {0x000a72, 0x000a74, 1}, {0x000a75, 0x000a75, 0}, {0x000a76, 0x000a76, 1}, 1627 {0x000a77, 0x000a80, -1}, {0x000a81, 0x000a82, 0}, {0x000a83, 0x000a83, 1}, 1628 {0x000a84, 0x000a84, -1}, {0x000a85, 0x000a8d, 1}, {0x000a8e, 0x000a8e, -1}, 1629 {0x000a8f, 0x000a91, 1}, {0x000a92, 0x000a92, -1}, {0x000a93, 0x000aa8, 1}, 1630 {0x000aa9, 0x000aa9, -1}, {0x000aaa, 0x000ab0, 1}, {0x000ab1, 0x000ab1, -1}, 1631 {0x000ab2, 0x000ab3, 1}, {0x000ab4, 0x000ab4, -1}, {0x000ab5, 0x000ab9, 1}, 1632 {0x000aba, 0x000abb, -1}, {0x000abc, 0x000abc, 0}, {0x000abd, 0x000ac0, 1}, 1633 {0x000ac1, 0x000ac5, 0}, {0x000ac6, 0x000ac6, -1}, {0x000ac7, 0x000ac8, 0}, 1634 {0x000ac9, 0x000ac9, 1}, {0x000aca, 0x000aca, -1}, {0x000acb, 0x000acc, 1}, 1635 {0x000acd, 0x000acd, 0}, {0x000ace, 0x000acf, -1}, {0x000ad0, 0x000ad0, 1}, 1636 {0x000ad1, 0x000adf, -1}, {0x000ae0, 0x000ae1, 1}, {0x000ae2, 0x000ae3, 0}, 1637 {0x000ae4, 0x000ae5, -1}, {0x000ae6, 0x000af1, 1}, {0x000af2, 0x000af8, -1}, 1638 {0x000af9, 0x000af9, 1}, {0x000afa, 0x000aff, 0}, {0x000b00, 0x000b00, -1}, 1639 {0x000b01, 0x000b01, 0}, {0x000b02, 0x000b03, 1}, {0x000b04, 0x000b04, -1}, 1640 {0x000b05, 0x000b0c, 1}, {0x000b0d, 0x000b0e, -1}, {0x000b0f, 0x000b10, 1}, 1641 {0x000b11, 0x000b12, -1}, {0x000b13, 0x000b28, 1}, {0x000b29, 0x000b29, -1}, 1642 {0x000b2a, 0x000b30, 1}, {0x000b31, 0x000b31, -1}, {0x000b32, 0x000b33, 1}, 1643 {0x000b34, 0x000b34, -1}, {0x000b35, 0x000b39, 1}, {0x000b3a, 0x000b3b, -1}, 1644 {0x000b3c, 0x000b3c, 0}, {0x000b3d, 0x000b3e, 1}, {0x000b3f, 0x000b3f, 0}, 1645 {0x000b40, 0x000b40, 1}, {0x000b41, 0x000b44, 0}, {0x000b45, 0x000b46, -1}, 1646 {0x000b47, 0x000b48, 1}, {0x000b49, 0x000b4a, -1}, {0x000b4b, 0x000b4c, 1}, 1647 {0x000b4d, 0x000b4d, 0}, {0x000b4e, 0x000b54, -1}, {0x000b55, 0x000b56, 0}, 1648 {0x000b57, 0x000b57, 1}, {0x000b58, 0x000b5b, -1}, {0x000b5c, 0x000b5d, 1}, 1649 {0x000b5e, 0x000b5e, -1}, {0x000b5f, 0x000b61, 1}, {0x000b62, 0x000b63, 0}, 1650 {0x000b64, 0x000b65, -1}, {0x000b66, 0x000b77, 1}, {0x000b78, 0x000b81, -1}, 1651 {0x000b82, 0x000b82, 0}, {0x000b83, 0x000b83, 1}, {0x000b84, 0x000b84, -1}, 1652 {0x000b85, 0x000b8a, 1}, {0x000b8b, 0x000b8d, -1}, {0x000b8e, 0x000b90, 1}, 1653 {0x000b91, 0x000b91, -1}, {0x000b92, 0x000b95, 1}, {0x000b96, 0x000b98, -1}, 1654 {0x000b99, 0x000b9a, 1}, {0x000b9b, 0x000b9b, -1}, {0x000b9c, 0x000b9c, 1}, 1655 {0x000b9d, 0x000b9d, -1}, {0x000b9e, 0x000b9f, 1}, {0x000ba0, 0x000ba2, -1}, 1656 {0x000ba3, 0x000ba4, 1}, {0x000ba5, 0x000ba7, -1}, {0x000ba8, 0x000baa, 1}, 1657 {0x000bab, 0x000bad, -1}, {0x000bae, 0x000bb9, 1}, {0x000bba, 0x000bbd, -1}, 1658 {0x000bbe, 0x000bbf, 1}, {0x000bc0, 0x000bc0, 0}, {0x000bc1, 0x000bc2, 1}, 1659 {0x000bc3, 0x000bc5, -1}, {0x000bc6, 0x000bc8, 1}, {0x000bc9, 0x000bc9, -1}, 1660 {0x000bca, 0x000bcc, 1}, {0x000bcd, 0x000bcd, 0}, {0x000bce, 0x000bcf, -1}, 1661 {0x000bd0, 0x000bd0, 1}, {0x000bd1, 0x000bd6, -1}, {0x000bd7, 0x000bd7, 1}, 1662 {0x000bd8, 0x000be5, -1}, {0x000be6, 0x000bfa, 1}, {0x000bfb, 0x000bff, -1}, 1663 {0x000c00, 0x000c00, 0}, {0x000c01, 0x000c03, 1}, {0x000c04, 0x000c04, 0}, 1664 {0x000c05, 0x000c0c, 1}, {0x000c0d, 0x000c0d, -1}, {0x000c0e, 0x000c10, 1}, 1665 {0x000c11, 0x000c11, -1}, {0x000c12, 0x000c28, 1}, {0x000c29, 0x000c29, -1}, 1666 {0x000c2a, 0x000c39, 1}, {0x000c3a, 0x000c3b, -1}, {0x000c3c, 0x000c3c, 0}, 1667 {0x000c3d, 0x000c3d, 1}, {0x000c3e, 0x000c40, 0}, {0x000c41, 0x000c44, 1}, 1668 {0x000c45, 0x000c45, -1}, {0x000c46, 0x000c48, 0}, {0x000c49, 0x000c49, -1}, 1669 {0x000c4a, 0x000c4d, 0}, {0x000c4e, 0x000c54, -1}, {0x000c55, 0x000c56, 0}, 1670 {0x000c57, 0x000c57, -1}, {0x000c58, 0x000c5a, 1}, {0x000c5b, 0x000c5c, -1}, 1671 {0x000c5d, 0x000c5d, 1}, {0x000c5e, 0x000c5f, -1}, {0x000c60, 0x000c61, 1}, 1672 {0x000c62, 0x000c63, 0}, {0x000c64, 0x000c65, -1}, {0x000c66, 0x000c6f, 1}, 1673 {0x000c70, 0x000c76, -1}, {0x000c77, 0x000c80, 1}, {0x000c81, 0x000c81, 0}, 1674 {0x000c82, 0x000c8c, 1}, {0x000c8d, 0x000c8d, -1}, {0x000c8e, 0x000c90, 1}, 1675 {0x000c91, 0x000c91, -1}, {0x000c92, 0x000ca8, 1}, {0x000ca9, 0x000ca9, -1}, 1676 {0x000caa, 0x000cb3, 1}, {0x000cb4, 0x000cb4, -1}, {0x000cb5, 0x000cb9, 1}, 1677 {0x000cba, 0x000cbb, -1}, {0x000cbc, 0x000cbc, 0}, {0x000cbd, 0x000cbe, 1}, 1678 {0x000cbf, 0x000cbf, 0}, {0x000cc0, 0x000cc4, 1}, {0x000cc5, 0x000cc5, -1}, 1679 {0x000cc6, 0x000cc6, 0}, {0x000cc7, 0x000cc8, 1}, {0x000cc9, 0x000cc9, -1}, 1680 {0x000cca, 0x000ccb, 1}, {0x000ccc, 0x000ccd, 0}, {0x000cce, 0x000cd4, -1}, 1681 {0x000cd5, 0x000cd6, 1}, {0x000cd7, 0x000cdc, -1}, {0x000cdd, 0x000cde, 1}, 1682 {0x000cdf, 0x000cdf, -1}, {0x000ce0, 0x000ce1, 1}, {0x000ce2, 0x000ce3, 0}, 1683 {0x000ce4, 0x000ce5, -1}, {0x000ce6, 0x000cef, 1}, {0x000cf0, 0x000cf0, -1}, 1684 {0x000cf1, 0x000cf3, 1}, {0x000cf4, 0x000cff, -1}, {0x000d00, 0x000d01, 0}, 1685 {0x000d02, 0x000d0c, 1}, {0x000d0d, 0x000d0d, -1}, {0x000d0e, 0x000d10, 1}, 1686 {0x000d11, 0x000d11, -1}, {0x000d12, 0x000d3a, 1}, {0x000d3b, 0x000d3c, 0}, 1687 {0x000d3d, 0x000d40, 1}, {0x000d41, 0x000d44, 0}, {0x000d45, 0x000d45, -1}, 1688 {0x000d46, 0x000d48, 1}, {0x000d49, 0x000d49, -1}, {0x000d4a, 0x000d4c, 1}, 1689 {0x000d4d, 0x000d4d, 0}, {0x000d4e, 0x000d4f, 1}, {0x000d50, 0x000d53, -1}, 1690 {0x000d54, 0x000d61, 1}, {0x000d62, 0x000d63, 0}, {0x000d64, 0x000d65, -1}, 1691 {0x000d66, 0x000d7f, 1}, {0x000d80, 0x000d80, -1}, {0x000d81, 0x000d81, 0}, 1692 {0x000d82, 0x000d83, 1}, {0x000d84, 0x000d84, -1}, {0x000d85, 0x000d96, 1}, 1693 {0x000d97, 0x000d99, -1}, {0x000d9a, 0x000db1, 1}, {0x000db2, 0x000db2, -1}, 1694 {0x000db3, 0x000dbb, 1}, {0x000dbc, 0x000dbc, -1}, {0x000dbd, 0x000dbd, 1}, 1695 {0x000dbe, 0x000dbf, -1}, {0x000dc0, 0x000dc6, 1}, {0x000dc7, 0x000dc9, -1}, 1696 {0x000dca, 0x000dca, 0}, {0x000dcb, 0x000dce, -1}, {0x000dcf, 0x000dd1, 1}, 1697 {0x000dd2, 0x000dd4, 0}, {0x000dd5, 0x000dd5, -1}, {0x000dd6, 0x000dd6, 0}, 1698 {0x000dd7, 0x000dd7, -1}, {0x000dd8, 0x000ddf, 1}, {0x000de0, 0x000de5, -1}, 1699 {0x000de6, 0x000def, 1}, {0x000df0, 0x000df1, -1}, {0x000df2, 0x000df4, 1}, 1700 {0x000df5, 0x000e00, -1}, {0x000e01, 0x000e30, 1}, {0x000e31, 0x000e31, 0}, 1701 {0x000e32, 0x000e33, 1}, {0x000e34, 0x000e3a, 0}, {0x000e3b, 0x000e3e, -1}, 1702 {0x000e3f, 0x000e46, 1}, {0x000e47, 0x000e4e, 0}, {0x000e4f, 0x000e5b, 1}, 1703 {0x000e5c, 0x000e80, -1}, {0x000e81, 0x000e82, 1}, {0x000e83, 0x000e83, -1}, 1704 {0x000e84, 0x000e84, 1}, {0x000e85, 0x000e85, -1}, {0x000e86, 0x000e8a, 1}, 1705 {0x000e8b, 0x000e8b, -1}, {0x000e8c, 0x000ea3, 1}, {0x000ea4, 0x000ea4, -1}, 1706 {0x000ea5, 0x000ea5, 1}, {0x000ea6, 0x000ea6, -1}, {0x000ea7, 0x000eb0, 1}, 1707 {0x000eb1, 0x000eb1, 0}, {0x000eb2, 0x000eb3, 1}, {0x000eb4, 0x000ebc, 0}, 1708 {0x000ebd, 0x000ebd, 1}, {0x000ebe, 0x000ebf, -1}, {0x000ec0, 0x000ec4, 1}, 1709 {0x000ec5, 0x000ec5, -1}, {0x000ec6, 0x000ec6, 1}, {0x000ec7, 0x000ec7, -1}, 1710 {0x000ec8, 0x000ece, 0}, {0x000ecf, 0x000ecf, -1}, {0x000ed0, 0x000ed9, 1}, 1711 {0x000eda, 0x000edb, -1}, {0x000edc, 0x000edf, 1}, {0x000ee0, 0x000eff, -1}, 1712 {0x000f00, 0x000f17, 1}, {0x000f18, 0x000f19, 0}, {0x000f1a, 0x000f34, 1}, 1713 {0x000f35, 0x000f35, 0}, {0x000f36, 0x000f36, 1}, {0x000f37, 0x000f37, 0}, 1714 {0x000f38, 0x000f38, 1}, {0x000f39, 0x000f39, 0}, {0x000f3a, 0x000f47, 1}, 1715 {0x000f48, 0x000f48, -1}, {0x000f49, 0x000f6c, 1}, {0x000f6d, 0x000f70, -1}, 1716 {0x000f71, 0x000f7e, 0}, {0x000f7f, 0x000f7f, 1}, {0x000f80, 0x000f84, 0}, 1717 {0x000f85, 0x000f85, 1}, {0x000f86, 0x000f87, 0}, {0x000f88, 0x000f8c, 1}, 1718 {0x000f8d, 0x000f97, 0}, {0x000f98, 0x000f98, -1}, {0x000f99, 0x000fbc, 0}, 1719 {0x000fbd, 0x000fbd, -1}, {0x000fbe, 0x000fc5, 1}, {0x000fc6, 0x000fc6, 0}, 1720 {0x000fc7, 0x000fcc, 1}, {0x000fcd, 0x000fcd, -1}, {0x000fce, 0x000fda, 1}, 1721 {0x000fdb, 0x000fff, -1}, {0x001000, 0x00102c, 1}, {0x00102d, 0x001030, 0}, 1722 {0x001031, 0x001031, 1}, {0x001032, 0x001037, 0}, {0x001038, 0x001038, 1}, 1723 {0x001039, 0x00103a, 0}, {0x00103b, 0x00103c, 1}, {0x00103d, 0x00103e, 0}, 1724 {0x00103f, 0x001057, 1}, {0x001058, 0x001059, 0}, {0x00105a, 0x00105d, 1}, 1725 {0x00105e, 0x001060, 0}, {0x001061, 0x001070, 1}, {0x001071, 0x001074, 0}, 1726 {0x001075, 0x001081, 1}, {0x001082, 0x001082, 0}, {0x001083, 0x001084, 1}, 1727 {0x001085, 0x001086, 0}, {0x001087, 0x00108c, 1}, {0x00108d, 0x00108d, 0}, 1728 {0x00108e, 0x00109c, 1}, {0x00109d, 0x00109d, 0}, {0x00109e, 0x0010c5, 1}, 1729 {0x0010c6, 0x0010c6, -1}, {0x0010c7, 0x0010c7, 1}, {0x0010c8, 0x0010cc, -1}, 1730 {0x0010cd, 0x0010cd, 1}, {0x0010ce, 0x0010cf, -1}, {0x0010d0, 0x0010ff, 1}, 1731 {0x001100, 0x00115f, 2}, {0x001160, 0x0011ff, 0}, {0x001200, 0x001248, 1}, 1732 {0x001249, 0x001249, -1}, {0x00124a, 0x00124d, 1}, {0x00124e, 0x00124f, -1}, 1733 {0x001250, 0x001256, 1}, {0x001257, 0x001257, -1}, {0x001258, 0x001258, 1}, 1734 {0x001259, 0x001259, -1}, {0x00125a, 0x00125d, 1}, {0x00125e, 0x00125f, -1}, 1735 {0x001260, 0x001288, 1}, {0x001289, 0x001289, -1}, {0x00128a, 0x00128d, 1}, 1736 {0x00128e, 0x00128f, -1}, {0x001290, 0x0012b0, 1}, {0x0012b1, 0x0012b1, -1}, 1737 {0x0012b2, 0x0012b5, 1}, {0x0012b6, 0x0012b7, -1}, {0x0012b8, 0x0012be, 1}, 1738 {0x0012bf, 0x0012bf, -1}, {0x0012c0, 0x0012c0, 1}, {0x0012c1, 0x0012c1, -1}, 1739 {0x0012c2, 0x0012c5, 1}, {0x0012c6, 0x0012c7, -1}, {0x0012c8, 0x0012d6, 1}, 1740 {0x0012d7, 0x0012d7, -1}, {0x0012d8, 0x001310, 1}, {0x001311, 0x001311, -1}, 1741 {0x001312, 0x001315, 1}, {0x001316, 0x001317, -1}, {0x001318, 0x00135a, 1}, 1742 {0x00135b, 0x00135c, -1}, {0x00135d, 0x00135f, 0}, {0x001360, 0x00137c, 1}, 1743 {0x00137d, 0x00137f, -1}, {0x001380, 0x001399, 1}, {0x00139a, 0x00139f, -1}, 1744 {0x0013a0, 0x0013f5, 1}, {0x0013f6, 0x0013f7, -1}, {0x0013f8, 0x0013fd, 1}, 1745 {0x0013fe, 0x0013ff, -1}, {0x001400, 0x00169c, 1}, {0x00169d, 0x00169f, -1}, 1746 {0x0016a0, 0x0016f8, 1}, {0x0016f9, 0x0016ff, -1}, {0x001700, 0x001711, 1}, 1747 {0x001712, 0x001714, 0}, {0x001715, 0x001715, 1}, {0x001716, 0x00171e, -1}, 1748 {0x00171f, 0x001731, 1}, {0x001732, 0x001733, 0}, {0x001734, 0x001736, 1}, 1749 {0x001737, 0x00173f, -1}, {0x001740, 0x001751, 1}, {0x001752, 0x001753, 0}, 1750 {0x001754, 0x00175f, -1}, {0x001760, 0x00176c, 1}, {0x00176d, 0x00176d, -1}, 1751 {0x00176e, 0x001770, 1}, {0x001771, 0x001771, -1}, {0x001772, 0x001773, 0}, 1752 {0x001774, 0x00177f, -1}, {0x001780, 0x0017b3, 1}, {0x0017b4, 0x0017b5, 0}, 1753 {0x0017b6, 0x0017b6, 1}, {0x0017b7, 0x0017bd, 0}, {0x0017be, 0x0017c5, 1}, 1754 {0x0017c6, 0x0017c6, 0}, {0x0017c7, 0x0017c8, 1}, {0x0017c9, 0x0017d3, 0}, 1755 {0x0017d4, 0x0017dc, 1}, {0x0017dd, 0x0017dd, 0}, {0x0017de, 0x0017df, -1}, 1756 {0x0017e0, 0x0017e9, 1}, {0x0017ea, 0x0017ef, -1}, {0x0017f0, 0x0017f9, 1}, 1757 {0x0017fa, 0x0017ff, -1}, {0x001800, 0x00180a, 1}, {0x00180b, 0x00180f, 0}, 1758 {0x001810, 0x001819, 1}, {0x00181a, 0x00181f, -1}, {0x001820, 0x001878, 1}, 1759 {0x001879, 0x00187f, -1}, {0x001880, 0x001884, 1}, {0x001885, 0x001886, 0}, 1760 {0x001887, 0x0018a8, 1}, {0x0018a9, 0x0018a9, 0}, {0x0018aa, 0x0018aa, 1}, 1761 {0x0018ab, 0x0018af, -1}, {0x0018b0, 0x0018f5, 1}, {0x0018f6, 0x0018ff, -1}, 1762 {0x001900, 0x00191e, 1}, {0x00191f, 0x00191f, -1}, {0x001920, 0x001922, 0}, 1763 {0x001923, 0x001926, 1}, {0x001927, 0x001928, 0}, {0x001929, 0x00192b, 1}, 1764 {0x00192c, 0x00192f, -1}, {0x001930, 0x001931, 1}, {0x001932, 0x001932, 0}, 1765 {0x001933, 0x001938, 1}, {0x001939, 0x00193b, 0}, {0x00193c, 0x00193f, -1}, 1766 {0x001940, 0x001940, 1}, {0x001941, 0x001943, -1}, {0x001944, 0x00196d, 1}, 1767 {0x00196e, 0x00196f, -1}, {0x001970, 0x001974, 1}, {0x001975, 0x00197f, -1}, 1768 {0x001980, 0x0019ab, 1}, {0x0019ac, 0x0019af, -1}, {0x0019b0, 0x0019c9, 1}, 1769 {0x0019ca, 0x0019cf, -1}, {0x0019d0, 0x0019da, 1}, {0x0019db, 0x0019dd, -1}, 1770 {0x0019de, 0x001a16, 1}, {0x001a17, 0x001a18, 0}, {0x001a19, 0x001a1a, 1}, 1771 {0x001a1b, 0x001a1b, 0}, {0x001a1c, 0x001a1d, -1}, {0x001a1e, 0x001a55, 1}, 1772 {0x001a56, 0x001a56, 0}, {0x001a57, 0x001a57, 1}, {0x001a58, 0x001a5e, 0}, 1773 {0x001a5f, 0x001a5f, -1}, {0x001a60, 0x001a60, 0}, {0x001a61, 0x001a61, 1}, 1774 {0x001a62, 0x001a62, 0}, {0x001a63, 0x001a64, 1}, {0x001a65, 0x001a6c, 0}, 1775 {0x001a6d, 0x001a72, 1}, {0x001a73, 0x001a7c, 0}, {0x001a7d, 0x001a7e, -1}, 1776 {0x001a7f, 0x001a7f, 0}, {0x001a80, 0x001a89, 1}, {0x001a8a, 0x001a8f, -1}, 1777 {0x001a90, 0x001a99, 1}, {0x001a9a, 0x001a9f, -1}, {0x001aa0, 0x001aad, 1}, 1778 {0x001aae, 0x001aaf, -1}, {0x001ab0, 0x001ace, 0}, {0x001acf, 0x001aff, -1}, 1779 {0x001b00, 0x001b03, 0}, {0x001b04, 0x001b33, 1}, {0x001b34, 0x001b34, 0}, 1780 {0x001b35, 0x001b35, 1}, {0x001b36, 0x001b3a, 0}, {0x001b3b, 0x001b3b, 1}, 1781 {0x001b3c, 0x001b3c, 0}, {0x001b3d, 0x001b41, 1}, {0x001b42, 0x001b42, 0}, 1782 {0x001b43, 0x001b4c, 1}, {0x001b4d, 0x001b4d, -1}, {0x001b4e, 0x001b6a, 1}, 1783 {0x001b6b, 0x001b73, 0}, {0x001b74, 0x001b7f, 1}, {0x001b80, 0x001b81, 0}, 1784 {0x001b82, 0x001ba1, 1}, {0x001ba2, 0x001ba5, 0}, {0x001ba6, 0x001ba7, 1}, 1785 {0x001ba8, 0x001ba9, 0}, {0x001baa, 0x001baa, 1}, {0x001bab, 0x001bad, 0}, 1786 {0x001bae, 0x001be5, 1}, {0x001be6, 0x001be6, 0}, {0x001be7, 0x001be7, 1}, 1787 {0x001be8, 0x001be9, 0}, {0x001bea, 0x001bec, 1}, {0x001bed, 0x001bed, 0}, 1788 {0x001bee, 0x001bee, 1}, {0x001bef, 0x001bf1, 0}, {0x001bf2, 0x001bf3, 1}, 1789 {0x001bf4, 0x001bfb, -1}, {0x001bfc, 0x001c2b, 1}, {0x001c2c, 0x001c33, 0}, 1790 {0x001c34, 0x001c35, 1}, {0x001c36, 0x001c37, 0}, {0x001c38, 0x001c3a, -1}, 1791 {0x001c3b, 0x001c49, 1}, {0x001c4a, 0x001c4c, -1}, {0x001c4d, 0x001c8a, 1}, 1792 {0x001c8b, 0x001c8f, -1}, {0x001c90, 0x001cba, 1}, {0x001cbb, 0x001cbc, -1}, 1793 {0x001cbd, 0x001cc7, 1}, {0x001cc8, 0x001ccf, -1}, {0x001cd0, 0x001cd2, 0}, 1794 {0x001cd3, 0x001cd3, 1}, {0x001cd4, 0x001ce0, 0}, {0x001ce1, 0x001ce1, 1}, 1795 {0x001ce2, 0x001ce8, 0}, {0x001ce9, 0x001cec, 1}, {0x001ced, 0x001ced, 0}, 1796 {0x001cee, 0x001cf3, 1}, {0x001cf4, 0x001cf4, 0}, {0x001cf5, 0x001cf7, 1}, 1797 {0x001cf8, 0x001cf9, 0}, {0x001cfa, 0x001cfa, 1}, {0x001cfb, 0x001cff, -1}, 1798 {0x001d00, 0x001dbf, 1}, {0x001dc0, 0x001dff, 0}, {0x001e00, 0x001f15, 1}, 1799 {0x001f16, 0x001f17, -1}, {0x001f18, 0x001f1d, 1}, {0x001f1e, 0x001f1f, -1}, 1800 {0x001f20, 0x001f45, 1}, {0x001f46, 0x001f47, -1}, {0x001f48, 0x001f4d, 1}, 1801 {0x001f4e, 0x001f4f, -1}, {0x001f50, 0x001f57, 1}, {0x001f58, 0x001f58, -1}, 1802 {0x001f59, 0x001f59, 1}, {0x001f5a, 0x001f5a, -1}, {0x001f5b, 0x001f5b, 1}, 1803 {0x001f5c, 0x001f5c, -1}, {0x001f5d, 0x001f5d, 1}, {0x001f5e, 0x001f5e, -1}, 1804 {0x001f5f, 0x001f7d, 1}, {0x001f7e, 0x001f7f, -1}, {0x001f80, 0x001fb4, 1}, 1805 {0x001fb5, 0x001fb5, -1}, {0x001fb6, 0x001fc4, 1}, {0x001fc5, 0x001fc5, -1}, 1806 {0x001fc6, 0x001fd3, 1}, {0x001fd4, 0x001fd5, -1}, {0x001fd6, 0x001fdb, 1}, 1807 {0x001fdc, 0x001fdc, -1}, {0x001fdd, 0x001fef, 1}, {0x001ff0, 0x001ff1, -1}, 1808 {0x001ff2, 0x001ff4, 1}, {0x001ff5, 0x001ff5, -1}, {0x001ff6, 0x001ffe, 1}, 1809 {0x001fff, 0x001fff, -1}, {0x002000, 0x00200a, 1}, {0x00200b, 0x00200f, 0}, 1810 {0x002010, 0x002027, 1}, {0x002028, 0x002029, -1}, {0x00202a, 0x00202e, 0}, 1811 {0x00202f, 0x00205f, 1}, {0x002060, 0x002064, 0}, {0x002065, 0x002065, -1}, 1812 {0x002066, 0x00206f, 0}, {0x002070, 0x002071, 1}, {0x002072, 0x002073, -1}, 1813 {0x002074, 0x00208e, 1}, {0x00208f, 0x00208f, -1}, {0x002090, 0x00209c, 1}, 1814 {0x00209d, 0x00209f, -1}, {0x0020a0, 0x0020c0, 1}, {0x0020c1, 0x0020cf, -1}, 1815 {0x0020d0, 0x0020f0, 0}, {0x0020f1, 0x0020ff, -1}, {0x002100, 0x00218b, 1}, 1816 {0x00218c, 0x00218f, -1}, {0x002190, 0x002319, 1}, {0x00231a, 0x00231b, 2}, 1817 {0x00231c, 0x002328, 1}, {0x002329, 0x00232a, 2}, {0x00232b, 0x0023e8, 1}, 1818 {0x0023e9, 0x0023ec, 2}, {0x0023ed, 0x0023ef, 1}, {0x0023f0, 0x0023f0, 2}, 1819 {0x0023f1, 0x0023f2, 1}, {0x0023f3, 0x0023f3, 2}, {0x0023f4, 0x002429, 1}, 1820 {0x00242a, 0x00243f, -1}, {0x002440, 0x00244a, 1}, {0x00244b, 0x00245f, -1}, 1821 {0x002460, 0x0025fc, 1}, {0x0025fd, 0x0025fe, 2}, {0x0025ff, 0x002613, 1}, 1822 {0x002614, 0x002615, 2}, {0x002616, 0x00262f, 1}, {0x002630, 0x002637, 2}, 1823 {0x002638, 0x002647, 1}, {0x002648, 0x002653, 2}, {0x002654, 0x00267e, 1}, 1824 {0x00267f, 0x00267f, 2}, {0x002680, 0x002689, 1}, {0x00268a, 0x00268f, 2}, 1825 {0x002690, 0x002692, 1}, {0x002693, 0x002693, 2}, {0x002694, 0x0026a0, 1}, 1826 {0x0026a1, 0x0026a1, 2}, {0x0026a2, 0x0026a9, 1}, {0x0026aa, 0x0026ab, 2}, 1827 {0x0026ac, 0x0026bc, 1}, {0x0026bd, 0x0026be, 2}, {0x0026bf, 0x0026c3, 1}, 1828 {0x0026c4, 0x0026c5, 2}, {0x0026c6, 0x0026cd, 1}, {0x0026ce, 0x0026ce, 2}, 1829 {0x0026cf, 0x0026d3, 1}, {0x0026d4, 0x0026d4, 2}, {0x0026d5, 0x0026e9, 1}, 1830 {0x0026ea, 0x0026ea, 2}, {0x0026eb, 0x0026f1, 1}, {0x0026f2, 0x0026f3, 2}, 1831 {0x0026f4, 0x0026f4, 1}, {0x0026f5, 0x0026f5, 2}, {0x0026f6, 0x0026f9, 1}, 1832 {0x0026fa, 0x0026fa, 2}, {0x0026fb, 0x0026fc, 1}, {0x0026fd, 0x0026fd, 2}, 1833 {0x0026fe, 0x002704, 1}, {0x002705, 0x002705, 2}, {0x002706, 0x002709, 1}, 1834 {0x00270a, 0x00270b, 2}, {0x00270c, 0x002727, 1}, {0x002728, 0x002728, 2}, 1835 {0x002729, 0x00274b, 1}, {0x00274c, 0x00274c, 2}, {0x00274d, 0x00274d, 1}, 1836 {0x00274e, 0x00274e, 2}, {0x00274f, 0x002752, 1}, {0x002753, 0x002755, 2}, 1837 {0x002756, 0x002756, 1}, {0x002757, 0x002757, 2}, {0x002758, 0x002794, 1}, 1838 {0x002795, 0x002797, 2}, {0x002798, 0x0027af, 1}, {0x0027b0, 0x0027b0, 2}, 1839 {0x0027b1, 0x0027be, 1}, {0x0027bf, 0x0027bf, 2}, {0x0027c0, 0x002b1a, 1}, 1840 {0x002b1b, 0x002b1c, 2}, {0x002b1d, 0x002b4f, 1}, {0x002b50, 0x002b50, 2}, 1841 {0x002b51, 0x002b54, 1}, {0x002b55, 0x002b55, 2}, {0x002b56, 0x002b73, 1}, 1842 {0x002b74, 0x002b75, -1}, {0x002b76, 0x002b95, 1}, {0x002b96, 0x002b96, -1}, 1843 {0x002b97, 0x002cee, 1}, {0x002cef, 0x002cf1, 0}, {0x002cf2, 0x002cf3, 1}, 1844 {0x002cf4, 0x002cf8, -1}, {0x002cf9, 0x002d25, 1}, {0x002d26, 0x002d26, -1}, 1845 {0x002d27, 0x002d27, 1}, {0x002d28, 0x002d2c, -1}, {0x002d2d, 0x002d2d, 1}, 1846 {0x002d2e, 0x002d2f, -1}, {0x002d30, 0x002d67, 1}, {0x002d68, 0x002d6e, -1}, 1847 {0x002d6f, 0x002d70, 1}, {0x002d71, 0x002d7e, -1}, {0x002d7f, 0x002d7f, 0}, 1848 {0x002d80, 0x002d96, 1}, {0x002d97, 0x002d9f, -1}, {0x002da0, 0x002da6, 1}, 1849 {0x002da7, 0x002da7, -1}, {0x002da8, 0x002dae, 1}, {0x002daf, 0x002daf, -1}, 1850 {0x002db0, 0x002db6, 1}, {0x002db7, 0x002db7, -1}, {0x002db8, 0x002dbe, 1}, 1851 {0x002dbf, 0x002dbf, -1}, {0x002dc0, 0x002dc6, 1}, {0x002dc7, 0x002dc7, -1}, 1852 {0x002dc8, 0x002dce, 1}, {0x002dcf, 0x002dcf, -1}, {0x002dd0, 0x002dd6, 1}, 1853 {0x002dd7, 0x002dd7, -1}, {0x002dd8, 0x002dde, 1}, {0x002ddf, 0x002ddf, -1}, 1854 {0x002de0, 0x002dff, 0}, {0x002e00, 0x002e5d, 1}, {0x002e5e, 0x002e7f, -1}, 1855 {0x002e80, 0x002e99, 2}, {0x002e9a, 0x002e9a, -1}, {0x002e9b, 0x002ef3, 2}, 1856 {0x002ef4, 0x002eff, -1}, {0x002f00, 0x002fd5, 2}, {0x002fd6, 0x002fef, -1}, 1857 {0x002ff0, 0x003029, 2}, {0x00302a, 0x00302d, 0}, {0x00302e, 0x00303e, 2}, 1858 {0x00303f, 0x00303f, 1}, {0x003040, 0x003040, -1}, {0x003041, 0x003096, 2}, 1859 {0x003097, 0x003098, -1}, {0x003099, 0x00309a, 0}, {0x00309b, 0x0030ff, 2}, 1860 {0x003100, 0x003104, -1}, {0x003105, 0x00312f, 2}, {0x003130, 0x003130, -1}, 1861 {0x003131, 0x003163, 2}, {0x003164, 0x003164, 0}, {0x003165, 0x00318e, 2}, 1862 {0x00318f, 0x00318f, -1}, {0x003190, 0x0031e5, 2}, {0x0031e6, 0x0031ee, -1}, 1863 {0x0031ef, 0x00321e, 2}, {0x00321f, 0x00321f, -1}, {0x003220, 0x00a48c, 2}, 1864 {0x00a48d, 0x00a48f, -1}, {0x00a490, 0x00a4c6, 2}, {0x00a4c7, 0x00a4cf, -1}, 1865 {0x00a4d0, 0x00a62b, 1}, {0x00a62c, 0x00a63f, -1}, {0x00a640, 0x00a66e, 1}, 1866 {0x00a66f, 0x00a672, 0}, {0x00a673, 0x00a673, 1}, {0x00a674, 0x00a67d, 0}, 1867 {0x00a67e, 0x00a69d, 1}, {0x00a69e, 0x00a69f, 0}, {0x00a6a0, 0x00a6ef, 1}, 1868 {0x00a6f0, 0x00a6f1, 0}, {0x00a6f2, 0x00a6f7, 1}, {0x00a6f8, 0x00a6ff, -1}, 1869 {0x00a700, 0x00a7cd, 1}, {0x00a7ce, 0x00a7cf, -1}, {0x00a7d0, 0x00a7d1, 1}, 1870 {0x00a7d2, 0x00a7d2, -1}, {0x00a7d3, 0x00a7d3, 1}, {0x00a7d4, 0x00a7d4, -1}, 1871 {0x00a7d5, 0x00a7dc, 1}, {0x00a7dd, 0x00a7f1, -1}, {0x00a7f2, 0x00a801, 1}, 1872 {0x00a802, 0x00a802, 0}, {0x00a803, 0x00a805, 1}, {0x00a806, 0x00a806, 0}, 1873 {0x00a807, 0x00a80a, 1}, {0x00a80b, 0x00a80b, 0}, {0x00a80c, 0x00a824, 1}, 1874 {0x00a825, 0x00a826, 0}, {0x00a827, 0x00a82b, 1}, {0x00a82c, 0x00a82c, 0}, 1875 {0x00a82d, 0x00a82f, -1}, {0x00a830, 0x00a839, 1}, {0x00a83a, 0x00a83f, -1}, 1876 {0x00a840, 0x00a877, 1}, {0x00a878, 0x00a87f, -1}, {0x00a880, 0x00a8c3, 1}, 1877 {0x00a8c4, 0x00a8c5, 0}, {0x00a8c6, 0x00a8cd, -1}, {0x00a8ce, 0x00a8d9, 1}, 1878 {0x00a8da, 0x00a8df, -1}, {0x00a8e0, 0x00a8f1, 0}, {0x00a8f2, 0x00a8fe, 1}, 1879 {0x00a8ff, 0x00a8ff, 0}, {0x00a900, 0x00a925, 1}, {0x00a926, 0x00a92d, 0}, 1880 {0x00a92e, 0x00a946, 1}, {0x00a947, 0x00a951, 0}, {0x00a952, 0x00a953, 1}, 1881 {0x00a954, 0x00a95e, -1}, {0x00a95f, 0x00a95f, 1}, {0x00a960, 0x00a97c, 2}, 1882 {0x00a97d, 0x00a97f, -1}, {0x00a980, 0x00a982, 0}, {0x00a983, 0x00a9b2, 1}, 1883 {0x00a9b3, 0x00a9b3, 0}, {0x00a9b4, 0x00a9b5, 1}, {0x00a9b6, 0x00a9b9, 0}, 1884 {0x00a9ba, 0x00a9bb, 1}, {0x00a9bc, 0x00a9bd, 0}, {0x00a9be, 0x00a9cd, 1}, 1885 {0x00a9ce, 0x00a9ce, -1}, {0x00a9cf, 0x00a9d9, 1}, {0x00a9da, 0x00a9dd, -1}, 1886 {0x00a9de, 0x00a9e4, 1}, {0x00a9e5, 0x00a9e5, 0}, {0x00a9e6, 0x00a9fe, 1}, 1887 {0x00a9ff, 0x00a9ff, -1}, {0x00aa00, 0x00aa28, 1}, {0x00aa29, 0x00aa2e, 0}, 1888 {0x00aa2f, 0x00aa30, 1}, {0x00aa31, 0x00aa32, 0}, {0x00aa33, 0x00aa34, 1}, 1889 {0x00aa35, 0x00aa36, 0}, {0x00aa37, 0x00aa3f, -1}, {0x00aa40, 0x00aa42, 1}, 1890 {0x00aa43, 0x00aa43, 0}, {0x00aa44, 0x00aa4b, 1}, {0x00aa4c, 0x00aa4c, 0}, 1891 {0x00aa4d, 0x00aa4d, 1}, {0x00aa4e, 0x00aa4f, -1}, {0x00aa50, 0x00aa59, 1}, 1892 {0x00aa5a, 0x00aa5b, -1}, {0x00aa5c, 0x00aa7b, 1}, {0x00aa7c, 0x00aa7c, 0}, 1893 {0x00aa7d, 0x00aaaf, 1}, {0x00aab0, 0x00aab0, 0}, {0x00aab1, 0x00aab1, 1}, 1894 {0x00aab2, 0x00aab4, 0}, {0x00aab5, 0x00aab6, 1}, {0x00aab7, 0x00aab8, 0}, 1895 {0x00aab9, 0x00aabd, 1}, {0x00aabe, 0x00aabf, 0}, {0x00aac0, 0x00aac0, 1}, 1896 {0x00aac1, 0x00aac1, 0}, {0x00aac2, 0x00aac2, 1}, {0x00aac3, 0x00aada, -1}, 1897 {0x00aadb, 0x00aaeb, 1}, {0x00aaec, 0x00aaed, 0}, {0x00aaee, 0x00aaf5, 1}, 1898 {0x00aaf6, 0x00aaf6, 0}, {0x00aaf7, 0x00ab00, -1}, {0x00ab01, 0x00ab06, 1}, 1899 {0x00ab07, 0x00ab08, -1}, {0x00ab09, 0x00ab0e, 1}, {0x00ab0f, 0x00ab10, -1}, 1900 {0x00ab11, 0x00ab16, 1}, {0x00ab17, 0x00ab1f, -1}, {0x00ab20, 0x00ab26, 1}, 1901 {0x00ab27, 0x00ab27, -1}, {0x00ab28, 0x00ab2e, 1}, {0x00ab2f, 0x00ab2f, -1}, 1902 {0x00ab30, 0x00ab6b, 1}, {0x00ab6c, 0x00ab6f, -1}, {0x00ab70, 0x00abe4, 1}, 1903 {0x00abe5, 0x00abe5, 0}, {0x00abe6, 0x00abe7, 1}, {0x00abe8, 0x00abe8, 0}, 1904 {0x00abe9, 0x00abec, 1}, {0x00abed, 0x00abed, 0}, {0x00abee, 0x00abef, -1}, 1905 {0x00abf0, 0x00abf9, 1}, {0x00abfa, 0x00abff, -1}, {0x00ac00, 0x00d7a3, 2}, 1906 {0x00d7a4, 0x00d7af, -1}, {0x00d7b0, 0x00d7c6, 0}, {0x00d7c7, 0x00d7ca, -1}, 1907 {0x00d7cb, 0x00d7fb, 0}, {0x00d7fc, 0x00dfff, -1}, {0x00e000, 0x00f8ff, 1}, 1908 {0x00f900, 0x00fa6d, 2}, {0x00fa6e, 0x00fa6f, -1}, {0x00fa70, 0x00fad9, 2}, 1909 {0x00fada, 0x00faff, -1}, {0x00fb00, 0x00fb06, 1}, {0x00fb07, 0x00fb12, -1}, 1910 {0x00fb13, 0x00fb17, 1}, {0x00fb18, 0x00fb1c, -1}, {0x00fb1d, 0x00fb1d, 1}, 1911 {0x00fb1e, 0x00fb1e, 0}, {0x00fb1f, 0x00fb36, 1}, {0x00fb37, 0x00fb37, -1}, 1912 {0x00fb38, 0x00fb3c, 1}, {0x00fb3d, 0x00fb3d, -1}, {0x00fb3e, 0x00fb3e, 1}, 1913 {0x00fb3f, 0x00fb3f, -1}, {0x00fb40, 0x00fb41, 1}, {0x00fb42, 0x00fb42, -1}, 1914 {0x00fb43, 0x00fb44, 1}, {0x00fb45, 0x00fb45, -1}, {0x00fb46, 0x00fbc2, 1}, 1915 {0x00fbc3, 0x00fbd2, -1}, {0x00fbd3, 0x00fd8f, 1}, {0x00fd90, 0x00fd91, -1}, 1916 {0x00fd92, 0x00fdc7, 1}, {0x00fdc8, 0x00fdce, -1}, {0x00fdcf, 0x00fdcf, 1}, 1917 {0x00fdd0, 0x00fdef, -1}, {0x00fdf0, 0x00fdff, 1}, {0x00fe00, 0x00fe0f, 0}, 1918 {0x00fe10, 0x00fe19, 2}, {0x00fe1a, 0x00fe1f, -1}, {0x00fe20, 0x00fe2f, 0}, 1919 {0x00fe30, 0x00fe52, 2}, {0x00fe53, 0x00fe53, -1}, {0x00fe54, 0x00fe66, 2}, 1920 {0x00fe67, 0x00fe67, -1}, {0x00fe68, 0x00fe6b, 2}, {0x00fe6c, 0x00fe6f, -1}, 1921 {0x00fe70, 0x00fe74, 1}, {0x00fe75, 0x00fe75, -1}, {0x00fe76, 0x00fefc, 1}, 1922 {0x00fefd, 0x00fefe, -1}, {0x00feff, 0x00feff, 0}, {0x00ff00, 0x00ff00, -1}, 1923 {0x00ff01, 0x00ff60, 2}, {0x00ff61, 0x00ff9f, 1}, {0x00ffa0, 0x00ffa0, 0}, 1924 {0x00ffa1, 0x00ffbe, 1}, {0x00ffbf, 0x00ffc1, -1}, {0x00ffc2, 0x00ffc7, 1}, 1925 {0x00ffc8, 0x00ffc9, -1}, {0x00ffca, 0x00ffcf, 1}, {0x00ffd0, 0x00ffd1, -1}, 1926 {0x00ffd2, 0x00ffd7, 1}, {0x00ffd8, 0x00ffd9, -1}, {0x00ffda, 0x00ffdc, 1}, 1927 {0x00ffdd, 0x00ffdf, -1}, {0x00ffe0, 0x00ffe6, 2}, {0x00ffe7, 0x00ffe7, -1}, 1928 {0x00ffe8, 0x00ffee, 1}, {0x00ffef, 0x00fff8, -1}, {0x00fff9, 0x00fffd, 1}, 1929 {0x00fffe, 0x00ffff, -1}, {0x010000, 0x01000b, 1}, {0x01000c, 0x01000c, -1}, 1930 {0x01000d, 0x010026, 1}, {0x010027, 0x010027, -1}, {0x010028, 0x01003a, 1}, 1931 {0x01003b, 0x01003b, -1}, {0x01003c, 0x01003d, 1}, {0x01003e, 0x01003e, -1}, 1932 {0x01003f, 0x01004d, 1}, {0x01004e, 0x01004f, -1}, {0x010050, 0x01005d, 1}, 1933 {0x01005e, 0x01007f, -1}, {0x010080, 0x0100fa, 1}, {0x0100fb, 0x0100ff, -1}, 1934 {0x010100, 0x010102, 1}, {0x010103, 0x010106, -1}, {0x010107, 0x010133, 1}, 1935 {0x010134, 0x010136, -1}, {0x010137, 0x01018e, 1}, {0x01018f, 0x01018f, -1}, 1936 {0x010190, 0x01019c, 1}, {0x01019d, 0x01019f, -1}, {0x0101a0, 0x0101a0, 1}, 1937 {0x0101a1, 0x0101cf, -1}, {0x0101d0, 0x0101fc, 1}, {0x0101fd, 0x0101fd, 0}, 1938 {0x0101fe, 0x01027f, -1}, {0x010280, 0x01029c, 1}, {0x01029d, 0x01029f, -1}, 1939 {0x0102a0, 0x0102d0, 1}, {0x0102d1, 0x0102df, -1}, {0x0102e0, 0x0102e0, 0}, 1940 {0x0102e1, 0x0102fb, 1}, {0x0102fc, 0x0102ff, -1}, {0x010300, 0x010323, 1}, 1941 {0x010324, 0x01032c, -1}, {0x01032d, 0x01034a, 1}, {0x01034b, 0x01034f, -1}, 1942 {0x010350, 0x010375, 1}, {0x010376, 0x01037a, 0}, {0x01037b, 0x01037f, -1}, 1943 {0x010380, 0x01039d, 1}, {0x01039e, 0x01039e, -1}, {0x01039f, 0x0103c3, 1}, 1944 {0x0103c4, 0x0103c7, -1}, {0x0103c8, 0x0103d5, 1}, {0x0103d6, 0x0103ff, -1}, 1945 {0x010400, 0x01049d, 1}, {0x01049e, 0x01049f, -1}, {0x0104a0, 0x0104a9, 1}, 1946 {0x0104aa, 0x0104af, -1}, {0x0104b0, 0x0104d3, 1}, {0x0104d4, 0x0104d7, -1}, 1947 {0x0104d8, 0x0104fb, 1}, {0x0104fc, 0x0104ff, -1}, {0x010500, 0x010527, 1}, 1948 {0x010528, 0x01052f, -1}, {0x010530, 0x010563, 1}, {0x010564, 0x01056e, -1}, 1949 {0x01056f, 0x01057a, 1}, {0x01057b, 0x01057b, -1}, {0x01057c, 0x01058a, 1}, 1950 {0x01058b, 0x01058b, -1}, {0x01058c, 0x010592, 1}, {0x010593, 0x010593, -1}, 1951 {0x010594, 0x010595, 1}, {0x010596, 0x010596, -1}, {0x010597, 0x0105a1, 1}, 1952 {0x0105a2, 0x0105a2, -1}, {0x0105a3, 0x0105b1, 1}, {0x0105b2, 0x0105b2, -1}, 1953 {0x0105b3, 0x0105b9, 1}, {0x0105ba, 0x0105ba, -1}, {0x0105bb, 0x0105bc, 1}, 1954 {0x0105bd, 0x0105bf, -1}, {0x0105c0, 0x0105f3, 1}, {0x0105f4, 0x0105ff, -1}, 1955 {0x010600, 0x010736, 1}, {0x010737, 0x01073f, -1}, {0x010740, 0x010755, 1}, 1956 {0x010756, 0x01075f, -1}, {0x010760, 0x010767, 1}, {0x010768, 0x01077f, -1}, 1957 {0x010780, 0x010785, 1}, {0x010786, 0x010786, -1}, {0x010787, 0x0107b0, 1}, 1958 {0x0107b1, 0x0107b1, -1}, {0x0107b2, 0x0107ba, 1}, {0x0107bb, 0x0107ff, -1}, 1959 {0x010800, 0x010805, 1}, {0x010806, 0x010807, -1}, {0x010808, 0x010808, 1}, 1960 {0x010809, 0x010809, -1}, {0x01080a, 0x010835, 1}, {0x010836, 0x010836, -1}, 1961 {0x010837, 0x010838, 1}, {0x010839, 0x01083b, -1}, {0x01083c, 0x01083c, 1}, 1962 {0x01083d, 0x01083e, -1}, {0x01083f, 0x010855, 1}, {0x010856, 0x010856, -1}, 1963 {0x010857, 0x01089e, 1}, {0x01089f, 0x0108a6, -1}, {0x0108a7, 0x0108af, 1}, 1964 {0x0108b0, 0x0108df, -1}, {0x0108e0, 0x0108f2, 1}, {0x0108f3, 0x0108f3, -1}, 1965 {0x0108f4, 0x0108f5, 1}, {0x0108f6, 0x0108fa, -1}, {0x0108fb, 0x01091b, 1}, 1966 {0x01091c, 0x01091e, -1}, {0x01091f, 0x010939, 1}, {0x01093a, 0x01093e, -1}, 1967 {0x01093f, 0x01093f, 1}, {0x010940, 0x01097f, -1}, {0x010980, 0x0109b7, 1}, 1968 {0x0109b8, 0x0109bb, -1}, {0x0109bc, 0x0109cf, 1}, {0x0109d0, 0x0109d1, -1}, 1969 {0x0109d2, 0x010a00, 1}, {0x010a01, 0x010a03, 0}, {0x010a04, 0x010a04, -1}, 1970 {0x010a05, 0x010a06, 0}, {0x010a07, 0x010a0b, -1}, {0x010a0c, 0x010a0f, 0}, 1971 {0x010a10, 0x010a13, 1}, {0x010a14, 0x010a14, -1}, {0x010a15, 0x010a17, 1}, 1972 {0x010a18, 0x010a18, -1}, {0x010a19, 0x010a35, 1}, {0x010a36, 0x010a37, -1}, 1973 {0x010a38, 0x010a3a, 0}, {0x010a3b, 0x010a3e, -1}, {0x010a3f, 0x010a3f, 0}, 1974 {0x010a40, 0x010a48, 1}, {0x010a49, 0x010a4f, -1}, {0x010a50, 0x010a58, 1}, 1975 {0x010a59, 0x010a5f, -1}, {0x010a60, 0x010a9f, 1}, {0x010aa0, 0x010abf, -1}, 1976 {0x010ac0, 0x010ae4, 1}, {0x010ae5, 0x010ae6, 0}, {0x010ae7, 0x010aea, -1}, 1977 {0x010aeb, 0x010af6, 1}, {0x010af7, 0x010aff, -1}, {0x010b00, 0x010b35, 1}, 1978 {0x010b36, 0x010b38, -1}, {0x010b39, 0x010b55, 1}, {0x010b56, 0x010b57, -1}, 1979 {0x010b58, 0x010b72, 1}, {0x010b73, 0x010b77, -1}, {0x010b78, 0x010b91, 1}, 1980 {0x010b92, 0x010b98, -1}, {0x010b99, 0x010b9c, 1}, {0x010b9d, 0x010ba8, -1}, 1981 {0x010ba9, 0x010baf, 1}, {0x010bb0, 0x010bff, -1}, {0x010c00, 0x010c48, 1}, 1982 {0x010c49, 0x010c7f, -1}, {0x010c80, 0x010cb2, 1}, {0x010cb3, 0x010cbf, -1}, 1983 {0x010cc0, 0x010cf2, 1}, {0x010cf3, 0x010cf9, -1}, {0x010cfa, 0x010d23, 1}, 1984 {0x010d24, 0x010d27, 0}, {0x010d28, 0x010d2f, -1}, {0x010d30, 0x010d39, 1}, 1985 {0x010d3a, 0x010d3f, -1}, {0x010d40, 0x010d65, 1}, {0x010d66, 0x010d68, -1}, 1986 {0x010d69, 0x010d6d, 0}, {0x010d6e, 0x010d85, 1}, {0x010d86, 0x010d8d, -1}, 1987 {0x010d8e, 0x010d8f, 1}, {0x010d90, 0x010e5f, -1}, {0x010e60, 0x010e7e, 1}, 1988 {0x010e7f, 0x010e7f, -1}, {0x010e80, 0x010ea9, 1}, {0x010eaa, 0x010eaa, -1}, 1989 {0x010eab, 0x010eac, 0}, {0x010ead, 0x010ead, 1}, {0x010eae, 0x010eaf, -1}, 1990 {0x010eb0, 0x010eb1, 1}, {0x010eb2, 0x010ec1, -1}, {0x010ec2, 0x010ec4, 1}, 1991 {0x010ec5, 0x010efb, -1}, {0x010efc, 0x010eff, 0}, {0x010f00, 0x010f27, 1}, 1992 {0x010f28, 0x010f2f, -1}, {0x010f30, 0x010f45, 1}, {0x010f46, 0x010f50, 0}, 1993 {0x010f51, 0x010f59, 1}, {0x010f5a, 0x010f6f, -1}, {0x010f70, 0x010f81, 1}, 1994 {0x010f82, 0x010f85, 0}, {0x010f86, 0x010f89, 1}, {0x010f8a, 0x010faf, -1}, 1995 {0x010fb0, 0x010fcb, 1}, {0x010fcc, 0x010fdf, -1}, {0x010fe0, 0x010ff6, 1}, 1996 {0x010ff7, 0x010fff, -1}, {0x011000, 0x011000, 1}, {0x011001, 0x011001, 0}, 1997 {0x011002, 0x011037, 1}, {0x011038, 0x011046, 0}, {0x011047, 0x01104d, 1}, 1998 {0x01104e, 0x011051, -1}, {0x011052, 0x01106f, 1}, {0x011070, 0x011070, 0}, 1999 {0x011071, 0x011072, 1}, {0x011073, 0x011074, 0}, {0x011075, 0x011075, 1}, 2000 {0x011076, 0x01107e, -1}, {0x01107f, 0x011081, 0}, {0x011082, 0x0110b2, 1}, 2001 {0x0110b3, 0x0110b6, 0}, {0x0110b7, 0x0110b8, 1}, {0x0110b9, 0x0110ba, 0}, 2002 {0x0110bb, 0x0110c1, 1}, {0x0110c2, 0x0110c2, 0}, {0x0110c3, 0x0110cc, -1}, 2003 {0x0110cd, 0x0110cd, 1}, {0x0110ce, 0x0110cf, -1}, {0x0110d0, 0x0110e8, 1}, 2004 {0x0110e9, 0x0110ef, -1}, {0x0110f0, 0x0110f9, 1}, {0x0110fa, 0x0110ff, -1}, 2005 {0x011100, 0x011102, 0}, {0x011103, 0x011126, 1}, {0x011127, 0x01112b, 0}, 2006 {0x01112c, 0x01112c, 1}, {0x01112d, 0x011134, 0}, {0x011135, 0x011135, -1}, 2007 {0x011136, 0x011147, 1}, {0x011148, 0x01114f, -1}, {0x011150, 0x011172, 1}, 2008 {0x011173, 0x011173, 0}, {0x011174, 0x011176, 1}, {0x011177, 0x01117f, -1}, 2009 {0x011180, 0x011181, 0}, {0x011182, 0x0111b5, 1}, {0x0111b6, 0x0111be, 0}, 2010 {0x0111bf, 0x0111c8, 1}, {0x0111c9, 0x0111cc, 0}, {0x0111cd, 0x0111ce, 1}, 2011 {0x0111cf, 0x0111cf, 0}, {0x0111d0, 0x0111df, 1}, {0x0111e0, 0x0111e0, -1}, 2012 {0x0111e1, 0x0111f4, 1}, {0x0111f5, 0x0111ff, -1}, {0x011200, 0x011211, 1}, 2013 {0x011212, 0x011212, -1}, {0x011213, 0x01122e, 1}, {0x01122f, 0x011231, 0}, 2014 {0x011232, 0x011233, 1}, {0x011234, 0x011234, 0}, {0x011235, 0x011235, 1}, 2015 {0x011236, 0x011237, 0}, {0x011238, 0x01123d, 1}, {0x01123e, 0x01123e, 0}, 2016 {0x01123f, 0x011240, 1}, {0x011241, 0x011241, 0}, {0x011242, 0x01127f, -1}, 2017 {0x011280, 0x011286, 1}, {0x011287, 0x011287, -1}, {0x011288, 0x011288, 1}, 2018 {0x011289, 0x011289, -1}, {0x01128a, 0x01128d, 1}, {0x01128e, 0x01128e, -1}, 2019 {0x01128f, 0x01129d, 1}, {0x01129e, 0x01129e, -1}, {0x01129f, 0x0112a9, 1}, 2020 {0x0112aa, 0x0112af, -1}, {0x0112b0, 0x0112de, 1}, {0x0112df, 0x0112df, 0}, 2021 {0x0112e0, 0x0112e2, 1}, {0x0112e3, 0x0112ea, 0}, {0x0112eb, 0x0112ef, -1}, 2022 {0x0112f0, 0x0112f9, 1}, {0x0112fa, 0x0112ff, -1}, {0x011300, 0x011301, 0}, 2023 {0x011302, 0x011303, 1}, {0x011304, 0x011304, -1}, {0x011305, 0x01130c, 1}, 2024 {0x01130d, 0x01130e, -1}, {0x01130f, 0x011310, 1}, {0x011311, 0x011312, -1}, 2025 {0x011313, 0x011328, 1}, {0x011329, 0x011329, -1}, {0x01132a, 0x011330, 1}, 2026 {0x011331, 0x011331, -1}, {0x011332, 0x011333, 1}, {0x011334, 0x011334, -1}, 2027 {0x011335, 0x011339, 1}, {0x01133a, 0x01133a, -1}, {0x01133b, 0x01133c, 0}, 2028 {0x01133d, 0x01133f, 1}, {0x011340, 0x011340, 0}, {0x011341, 0x011344, 1}, 2029 {0x011345, 0x011346, -1}, {0x011347, 0x011348, 1}, {0x011349, 0x01134a, -1}, 2030 {0x01134b, 0x01134d, 1}, {0x01134e, 0x01134f, -1}, {0x011350, 0x011350, 1}, 2031 {0x011351, 0x011356, -1}, {0x011357, 0x011357, 1}, {0x011358, 0x01135c, -1}, 2032 {0x01135d, 0x011363, 1}, {0x011364, 0x011365, -1}, {0x011366, 0x01136c, 0}, 2033 {0x01136d, 0x01136f, -1}, {0x011370, 0x011374, 0}, {0x011375, 0x01137f, -1}, 2034 {0x011380, 0x011389, 1}, {0x01138a, 0x01138a, -1}, {0x01138b, 0x01138b, 1}, 2035 {0x01138c, 0x01138d, -1}, {0x01138e, 0x01138e, 1}, {0x01138f, 0x01138f, -1}, 2036 {0x011390, 0x0113b5, 1}, {0x0113b6, 0x0113b6, -1}, {0x0113b7, 0x0113ba, 1}, 2037 {0x0113bb, 0x0113c0, 0}, {0x0113c1, 0x0113c1, -1}, {0x0113c2, 0x0113c2, 1}, 2038 {0x0113c3, 0x0113c4, -1}, {0x0113c5, 0x0113c5, 1}, {0x0113c6, 0x0113c6, -1}, 2039 {0x0113c7, 0x0113ca, 1}, {0x0113cb, 0x0113cb, -1}, {0x0113cc, 0x0113cd, 1}, 2040 {0x0113ce, 0x0113ce, 0}, {0x0113cf, 0x0113cf, 1}, {0x0113d0, 0x0113d0, 0}, 2041 {0x0113d1, 0x0113d1, 1}, {0x0113d2, 0x0113d2, 0}, {0x0113d3, 0x0113d5, 1}, 2042 {0x0113d6, 0x0113d6, -1}, {0x0113d7, 0x0113d8, 1}, {0x0113d9, 0x0113e0, -1}, 2043 {0x0113e1, 0x0113e2, 0}, {0x0113e3, 0x0113ff, -1}, {0x011400, 0x011437, 1}, 2044 {0x011438, 0x01143f, 0}, {0x011440, 0x011441, 1}, {0x011442, 0x011444, 0}, 2045 {0x011445, 0x011445, 1}, {0x011446, 0x011446, 0}, {0x011447, 0x01145b, 1}, 2046 {0x01145c, 0x01145c, -1}, {0x01145d, 0x01145d, 1}, {0x01145e, 0x01145e, 0}, 2047 {0x01145f, 0x011461, 1}, {0x011462, 0x01147f, -1}, {0x011480, 0x0114b2, 1}, 2048 {0x0114b3, 0x0114b8, 0}, {0x0114b9, 0x0114b9, 1}, {0x0114ba, 0x0114ba, 0}, 2049 {0x0114bb, 0x0114be, 1}, {0x0114bf, 0x0114c0, 0}, {0x0114c1, 0x0114c1, 1}, 2050 {0x0114c2, 0x0114c3, 0}, {0x0114c4, 0x0114c7, 1}, {0x0114c8, 0x0114cf, -1}, 2051 {0x0114d0, 0x0114d9, 1}, {0x0114da, 0x01157f, -1}, {0x011580, 0x0115b1, 1}, 2052 {0x0115b2, 0x0115b5, 0}, {0x0115b6, 0x0115b7, -1}, {0x0115b8, 0x0115bb, 1}, 2053 {0x0115bc, 0x0115bd, 0}, {0x0115be, 0x0115be, 1}, {0x0115bf, 0x0115c0, 0}, 2054 {0x0115c1, 0x0115db, 1}, {0x0115dc, 0x0115dd, 0}, {0x0115de, 0x0115ff, -1}, 2055 {0x011600, 0x011632, 1}, {0x011633, 0x01163a, 0}, {0x01163b, 0x01163c, 1}, 2056 {0x01163d, 0x01163d, 0}, {0x01163e, 0x01163e, 1}, {0x01163f, 0x011640, 0}, 2057 {0x011641, 0x011644, 1}, {0x011645, 0x01164f, -1}, {0x011650, 0x011659, 1}, 2058 {0x01165a, 0x01165f, -1}, {0x011660, 0x01166c, 1}, {0x01166d, 0x01167f, -1}, 2059 {0x011680, 0x0116aa, 1}, {0x0116ab, 0x0116ab, 0}, {0x0116ac, 0x0116ac, 1}, 2060 {0x0116ad, 0x0116ad, 0}, {0x0116ae, 0x0116af, 1}, {0x0116b0, 0x0116b5, 0}, 2061 {0x0116b6, 0x0116b6, 1}, {0x0116b7, 0x0116b7, 0}, {0x0116b8, 0x0116b9, 1}, 2062 {0x0116ba, 0x0116bf, -1}, {0x0116c0, 0x0116c9, 1}, {0x0116ca, 0x0116cf, -1}, 2063 {0x0116d0, 0x0116e3, 1}, {0x0116e4, 0x0116ff, -1}, {0x011700, 0x01171a, 1}, 2064 {0x01171b, 0x01171c, -1}, {0x01171d, 0x01171d, 0}, {0x01171e, 0x01171e, 1}, 2065 {0x01171f, 0x01171f, 0}, {0x011720, 0x011721, 1}, {0x011722, 0x011725, 0}, 2066 {0x011726, 0x011726, 1}, {0x011727, 0x01172b, 0}, {0x01172c, 0x01172f, -1}, 2067 {0x011730, 0x011746, 1}, {0x011747, 0x0117ff, -1}, {0x011800, 0x01182e, 1}, 2068 {0x01182f, 0x011837, 0}, {0x011838, 0x011838, 1}, {0x011839, 0x01183a, 0}, 2069 {0x01183b, 0x01183b, 1}, {0x01183c, 0x01189f, -1}, {0x0118a0, 0x0118f2, 1}, 2070 {0x0118f3, 0x0118fe, -1}, {0x0118ff, 0x011906, 1}, {0x011907, 0x011908, -1}, 2071 {0x011909, 0x011909, 1}, {0x01190a, 0x01190b, -1}, {0x01190c, 0x011913, 1}, 2072 {0x011914, 0x011914, -1}, {0x011915, 0x011916, 1}, {0x011917, 0x011917, -1}, 2073 {0x011918, 0x011935, 1}, {0x011936, 0x011936, -1}, {0x011937, 0x011938, 1}, 2074 {0x011939, 0x01193a, -1}, {0x01193b, 0x01193c, 0}, {0x01193d, 0x01193d, 1}, 2075 {0x01193e, 0x01193e, 0}, {0x01193f, 0x011942, 1}, {0x011943, 0x011943, 0}, 2076 {0x011944, 0x011946, 1}, {0x011947, 0x01194f, -1}, {0x011950, 0x011959, 1}, 2077 {0x01195a, 0x01199f, -1}, {0x0119a0, 0x0119a7, 1}, {0x0119a8, 0x0119a9, -1}, 2078 {0x0119aa, 0x0119d3, 1}, {0x0119d4, 0x0119d7, 0}, {0x0119d8, 0x0119d9, -1}, 2079 {0x0119da, 0x0119db, 0}, {0x0119dc, 0x0119df, 1}, {0x0119e0, 0x0119e0, 0}, 2080 {0x0119e1, 0x0119e4, 1}, {0x0119e5, 0x0119ff, -1}, {0x011a00, 0x011a00, 1}, 2081 {0x011a01, 0x011a0a, 0}, {0x011a0b, 0x011a32, 1}, {0x011a33, 0x011a38, 0}, 2082 {0x011a39, 0x011a3a, 1}, {0x011a3b, 0x011a3e, 0}, {0x011a3f, 0x011a46, 1}, 2083 {0x011a47, 0x011a47, 0}, {0x011a48, 0x011a4f, -1}, {0x011a50, 0x011a50, 1}, 2084 {0x011a51, 0x011a56, 0}, {0x011a57, 0x011a58, 1}, {0x011a59, 0x011a5b, 0}, 2085 {0x011a5c, 0x011a89, 1}, {0x011a8a, 0x011a96, 0}, {0x011a97, 0x011a97, 1}, 2086 {0x011a98, 0x011a99, 0}, {0x011a9a, 0x011aa2, 1}, {0x011aa3, 0x011aaf, -1}, 2087 {0x011ab0, 0x011af8, 1}, {0x011af9, 0x011aff, -1}, {0x011b00, 0x011b09, 1}, 2088 {0x011b0a, 0x011bbf, -1}, {0x011bc0, 0x011be1, 1}, {0x011be2, 0x011bef, -1}, 2089 {0x011bf0, 0x011bf9, 1}, {0x011bfa, 0x011bff, -1}, {0x011c00, 0x011c08, 1}, 2090 {0x011c09, 0x011c09, -1}, {0x011c0a, 0x011c2f, 1}, {0x011c30, 0x011c36, 0}, 2091 {0x011c37, 0x011c37, -1}, {0x011c38, 0x011c3d, 0}, {0x011c3e, 0x011c3e, 1}, 2092 {0x011c3f, 0x011c3f, 0}, {0x011c40, 0x011c45, 1}, {0x011c46, 0x011c4f, -1}, 2093 {0x011c50, 0x011c6c, 1}, {0x011c6d, 0x011c6f, -1}, {0x011c70, 0x011c8f, 1}, 2094 {0x011c90, 0x011c91, -1}, {0x011c92, 0x011ca7, 0}, {0x011ca8, 0x011ca8, -1}, 2095 {0x011ca9, 0x011ca9, 1}, {0x011caa, 0x011cb0, 0}, {0x011cb1, 0x011cb1, 1}, 2096 {0x011cb2, 0x011cb3, 0}, {0x011cb4, 0x011cb4, 1}, {0x011cb5, 0x011cb6, 0}, 2097 {0x011cb7, 0x011cff, -1}, {0x011d00, 0x011d06, 1}, {0x011d07, 0x011d07, -1}, 2098 {0x011d08, 0x011d09, 1}, {0x011d0a, 0x011d0a, -1}, {0x011d0b, 0x011d30, 1}, 2099 {0x011d31, 0x011d36, 0}, {0x011d37, 0x011d39, -1}, {0x011d3a, 0x011d3a, 0}, 2100 {0x011d3b, 0x011d3b, -1}, {0x011d3c, 0x011d3d, 0}, {0x011d3e, 0x011d3e, -1}, 2101 {0x011d3f, 0x011d45, 0}, {0x011d46, 0x011d46, 1}, {0x011d47, 0x011d47, 0}, 2102 {0x011d48, 0x011d4f, -1}, {0x011d50, 0x011d59, 1}, {0x011d5a, 0x011d5f, -1}, 2103 {0x011d60, 0x011d65, 1}, {0x011d66, 0x011d66, -1}, {0x011d67, 0x011d68, 1}, 2104 {0x011d69, 0x011d69, -1}, {0x011d6a, 0x011d8e, 1}, {0x011d8f, 0x011d8f, -1}, 2105 {0x011d90, 0x011d91, 0}, {0x011d92, 0x011d92, -1}, {0x011d93, 0x011d94, 1}, 2106 {0x011d95, 0x011d95, 0}, {0x011d96, 0x011d96, 1}, {0x011d97, 0x011d97, 0}, 2107 {0x011d98, 0x011d98, 1}, {0x011d99, 0x011d9f, -1}, {0x011da0, 0x011da9, 1}, 2108 {0x011daa, 0x011edf, -1}, {0x011ee0, 0x011ef2, 1}, {0x011ef3, 0x011ef4, 0}, 2109 {0x011ef5, 0x011ef8, 1}, {0x011ef9, 0x011eff, -1}, {0x011f00, 0x011f01, 0}, 2110 {0x011f02, 0x011f10, 1}, {0x011f11, 0x011f11, -1}, {0x011f12, 0x011f35, 1}, 2111 {0x011f36, 0x011f3a, 0}, {0x011f3b, 0x011f3d, -1}, {0x011f3e, 0x011f3f, 1}, 2112 {0x011f40, 0x011f40, 0}, {0x011f41, 0x011f41, 1}, {0x011f42, 0x011f42, 0}, 2113 {0x011f43, 0x011f59, 1}, {0x011f5a, 0x011f5a, 0}, {0x011f5b, 0x011faf, -1}, 2114 {0x011fb0, 0x011fb0, 1}, {0x011fb1, 0x011fbf, -1}, {0x011fc0, 0x011ff1, 1}, 2115 {0x011ff2, 0x011ffe, -1}, {0x011fff, 0x012399, 1}, {0x01239a, 0x0123ff, -1}, 2116 {0x012400, 0x01246e, 1}, {0x01246f, 0x01246f, -1}, {0x012470, 0x012474, 1}, 2117 {0x012475, 0x01247f, -1}, {0x012480, 0x012543, 1}, {0x012544, 0x012f8f, -1}, 2118 {0x012f90, 0x012ff2, 1}, {0x012ff3, 0x012fff, -1}, {0x013000, 0x01343f, 1}, 2119 {0x013440, 0x013440, 0}, {0x013441, 0x013446, 1}, {0x013447, 0x013455, 0}, 2120 {0x013456, 0x01345f, -1}, {0x013460, 0x0143fa, 1}, {0x0143fb, 0x0143ff, -1}, 2121 {0x014400, 0x014646, 1}, {0x014647, 0x0160ff, -1}, {0x016100, 0x01611d, 1}, 2122 {0x01611e, 0x016129, 0}, {0x01612a, 0x01612c, 1}, {0x01612d, 0x01612f, 0}, 2123 {0x016130, 0x016139, 1}, {0x01613a, 0x0167ff, -1}, {0x016800, 0x016a38, 1}, 2124 {0x016a39, 0x016a3f, -1}, {0x016a40, 0x016a5e, 1}, {0x016a5f, 0x016a5f, -1}, 2125 {0x016a60, 0x016a69, 1}, {0x016a6a, 0x016a6d, -1}, {0x016a6e, 0x016abe, 1}, 2126 {0x016abf, 0x016abf, -1}, {0x016ac0, 0x016ac9, 1}, {0x016aca, 0x016acf, -1}, 2127 {0x016ad0, 0x016aed, 1}, {0x016aee, 0x016aef, -1}, {0x016af0, 0x016af4, 0}, 2128 {0x016af5, 0x016af5, 1}, {0x016af6, 0x016aff, -1}, {0x016b00, 0x016b2f, 1}, 2129 {0x016b30, 0x016b36, 0}, {0x016b37, 0x016b45, 1}, {0x016b46, 0x016b4f, -1}, 2130 {0x016b50, 0x016b59, 1}, {0x016b5a, 0x016b5a, -1}, {0x016b5b, 0x016b61, 1}, 2131 {0x016b62, 0x016b62, -1}, {0x016b63, 0x016b77, 1}, {0x016b78, 0x016b7c, -1}, 2132 {0x016b7d, 0x016b8f, 1}, {0x016b90, 0x016d3f, -1}, {0x016d40, 0x016d79, 1}, 2133 {0x016d7a, 0x016e3f, -1}, {0x016e40, 0x016e9a, 1}, {0x016e9b, 0x016eff, -1}, 2134 {0x016f00, 0x016f4a, 1}, {0x016f4b, 0x016f4e, -1}, {0x016f4f, 0x016f4f, 0}, 2135 {0x016f50, 0x016f87, 1}, {0x016f88, 0x016f8e, -1}, {0x016f8f, 0x016f92, 0}, 2136 {0x016f93, 0x016f9f, 1}, {0x016fa0, 0x016fdf, -1}, {0x016fe0, 0x016fe3, 2}, 2137 {0x016fe4, 0x016fe4, 0}, {0x016fe5, 0x016fef, -1}, {0x016ff0, 0x016ff1, 2}, 2138 {0x016ff2, 0x016fff, -1}, {0x017000, 0x0187f7, 2}, {0x0187f8, 0x0187ff, -1}, 2139 {0x018800, 0x018cd5, 2}, {0x018cd6, 0x018cfe, -1}, {0x018cff, 0x018d08, 2}, 2140 {0x018d09, 0x01afef, -1}, {0x01aff0, 0x01aff3, 2}, {0x01aff4, 0x01aff4, -1}, 2141 {0x01aff5, 0x01affb, 2}, {0x01affc, 0x01affc, -1}, {0x01affd, 0x01affe, 2}, 2142 {0x01afff, 0x01afff, -1}, {0x01b000, 0x01b122, 2}, {0x01b123, 0x01b131, -1}, 2143 {0x01b132, 0x01b132, 2}, {0x01b133, 0x01b14f, -1}, {0x01b150, 0x01b152, 2}, 2144 {0x01b153, 0x01b154, -1}, {0x01b155, 0x01b155, 2}, {0x01b156, 0x01b163, -1}, 2145 {0x01b164, 0x01b167, 2}, {0x01b168, 0x01b16f, -1}, {0x01b170, 0x01b2fb, 2}, 2146 {0x01b2fc, 0x01bbff, -1}, {0x01bc00, 0x01bc6a, 1}, {0x01bc6b, 0x01bc6f, -1}, 2147 {0x01bc70, 0x01bc7c, 1}, {0x01bc7d, 0x01bc7f, -1}, {0x01bc80, 0x01bc88, 1}, 2148 {0x01bc89, 0x01bc8f, -1}, {0x01bc90, 0x01bc99, 1}, {0x01bc9a, 0x01bc9b, -1}, 2149 {0x01bc9c, 0x01bc9c, 1}, {0x01bc9d, 0x01bc9e, 0}, {0x01bc9f, 0x01bc9f, 1}, 2150 {0x01bca0, 0x01bca3, 0}, {0x01bca4, 0x01cbff, -1}, {0x01cc00, 0x01ccf9, 1}, 2151 {0x01ccfa, 0x01ccff, -1}, {0x01cd00, 0x01ceb3, 1}, {0x01ceb4, 0x01ceff, -1}, 2152 {0x01cf00, 0x01cf2d, 0}, {0x01cf2e, 0x01cf2f, -1}, {0x01cf30, 0x01cf46, 0}, 2153 {0x01cf47, 0x01cf4f, -1}, {0x01cf50, 0x01cfc3, 1}, {0x01cfc4, 0x01cfff, -1}, 2154 {0x01d000, 0x01d0f5, 1}, {0x01d0f6, 0x01d0ff, -1}, {0x01d100, 0x01d126, 1}, 2155 {0x01d127, 0x01d128, -1}, {0x01d129, 0x01d166, 1}, {0x01d167, 0x01d169, 0}, 2156 {0x01d16a, 0x01d172, 1}, {0x01d173, 0x01d182, 0}, {0x01d183, 0x01d184, 1}, 2157 {0x01d185, 0x01d18b, 0}, {0x01d18c, 0x01d1a9, 1}, {0x01d1aa, 0x01d1ad, 0}, 2158 {0x01d1ae, 0x01d1ea, 1}, {0x01d1eb, 0x01d1ff, -1}, {0x01d200, 0x01d241, 1}, 2159 {0x01d242, 0x01d244, 0}, {0x01d245, 0x01d245, 1}, {0x01d246, 0x01d2bf, -1}, 2160 {0x01d2c0, 0x01d2d3, 1}, {0x01d2d4, 0x01d2df, -1}, {0x01d2e0, 0x01d2f3, 1}, 2161 {0x01d2f4, 0x01d2ff, -1}, {0x01d300, 0x01d356, 2}, {0x01d357, 0x01d35f, -1}, 2162 {0x01d360, 0x01d376, 2}, {0x01d377, 0x01d378, 1}, {0x01d379, 0x01d3ff, -1}, 2163 {0x01d400, 0x01d454, 1}, {0x01d455, 0x01d455, -1}, {0x01d456, 0x01d49c, 1}, 2164 {0x01d49d, 0x01d49d, -1}, {0x01d49e, 0x01d49f, 1}, {0x01d4a0, 0x01d4a1, -1}, 2165 {0x01d4a2, 0x01d4a2, 1}, {0x01d4a3, 0x01d4a4, -1}, {0x01d4a5, 0x01d4a6, 1}, 2166 {0x01d4a7, 0x01d4a8, -1}, {0x01d4a9, 0x01d4ac, 1}, {0x01d4ad, 0x01d4ad, -1}, 2167 {0x01d4ae, 0x01d4b9, 1}, {0x01d4ba, 0x01d4ba, -1}, {0x01d4bb, 0x01d4bb, 1}, 2168 {0x01d4bc, 0x01d4bc, -1}, {0x01d4bd, 0x01d4c3, 1}, {0x01d4c4, 0x01d4c4, -1}, 2169 {0x01d4c5, 0x01d505, 1}, {0x01d506, 0x01d506, -1}, {0x01d507, 0x01d50a, 1}, 2170 {0x01d50b, 0x01d50c, -1}, {0x01d50d, 0x01d514, 1}, {0x01d515, 0x01d515, -1}, 2171 {0x01d516, 0x01d51c, 1}, {0x01d51d, 0x01d51d, -1}, {0x01d51e, 0x01d539, 1}, 2172 {0x01d53a, 0x01d53a, -1}, {0x01d53b, 0x01d53e, 1}, {0x01d53f, 0x01d53f, -1}, 2173 {0x01d540, 0x01d544, 1}, {0x01d545, 0x01d545, -1}, {0x01d546, 0x01d546, 1}, 2174 {0x01d547, 0x01d549, -1}, {0x01d54a, 0x01d550, 1}, {0x01d551, 0x01d551, -1}, 2175 {0x01d552, 0x01d6a5, 1}, {0x01d6a6, 0x01d6a7, -1}, {0x01d6a8, 0x01d7cb, 1}, 2176 {0x01d7cc, 0x01d7cd, -1}, {0x01d7ce, 0x01d9ff, 1}, {0x01da00, 0x01da36, 0}, 2177 {0x01da37, 0x01da3a, 1}, {0x01da3b, 0x01da6c, 0}, {0x01da6d, 0x01da74, 1}, 2178 {0x01da75, 0x01da75, 0}, {0x01da76, 0x01da83, 1}, {0x01da84, 0x01da84, 0}, 2179 {0x01da85, 0x01da8b, 1}, {0x01da8c, 0x01da9a, -1}, {0x01da9b, 0x01da9f, 0}, 2180 {0x01daa0, 0x01daa0, -1}, {0x01daa1, 0x01daaf, 0}, {0x01dab0, 0x01deff, -1}, 2181 {0x01df00, 0x01df1e, 1}, {0x01df1f, 0x01df24, -1}, {0x01df25, 0x01df2a, 1}, 2182 {0x01df2b, 0x01dfff, -1}, {0x01e000, 0x01e006, 0}, {0x01e007, 0x01e007, -1}, 2183 {0x01e008, 0x01e018, 0}, {0x01e019, 0x01e01a, -1}, {0x01e01b, 0x01e021, 0}, 2184 {0x01e022, 0x01e022, -1}, {0x01e023, 0x01e024, 0}, {0x01e025, 0x01e025, -1}, 2185 {0x01e026, 0x01e02a, 0}, {0x01e02b, 0x01e02f, -1}, {0x01e030, 0x01e06d, 1}, 2186 {0x01e06e, 0x01e08e, -1}, {0x01e08f, 0x01e08f, 0}, {0x01e090, 0x01e0ff, -1}, 2187 {0x01e100, 0x01e12c, 1}, {0x01e12d, 0x01e12f, -1}, {0x01e130, 0x01e136, 0}, 2188 {0x01e137, 0x01e13d, 1}, {0x01e13e, 0x01e13f, -1}, {0x01e140, 0x01e149, 1}, 2189 {0x01e14a, 0x01e14d, -1}, {0x01e14e, 0x01e14f, 1}, {0x01e150, 0x01e28f, -1}, 2190 {0x01e290, 0x01e2ad, 1}, {0x01e2ae, 0x01e2ae, 0}, {0x01e2af, 0x01e2bf, -1}, 2191 {0x01e2c0, 0x01e2eb, 1}, {0x01e2ec, 0x01e2ef, 0}, {0x01e2f0, 0x01e2f9, 1}, 2192 {0x01e2fa, 0x01e2fe, -1}, {0x01e2ff, 0x01e2ff, 1}, {0x01e300, 0x01e4cf, -1}, 2193 {0x01e4d0, 0x01e4eb, 1}, {0x01e4ec, 0x01e4ef, 0}, {0x01e4f0, 0x01e4f9, 1}, 2194 {0x01e4fa, 0x01e5cf, -1}, {0x01e5d0, 0x01e5ed, 1}, {0x01e5ee, 0x01e5ef, 0}, 2195 {0x01e5f0, 0x01e5fa, 1}, {0x01e5fb, 0x01e5fe, -1}, {0x01e5ff, 0x01e5ff, 1}, 2196 {0x01e600, 0x01e7df, -1}, {0x01e7e0, 0x01e7e6, 1}, {0x01e7e7, 0x01e7e7, -1}, 2197 {0x01e7e8, 0x01e7eb, 1}, {0x01e7ec, 0x01e7ec, -1}, {0x01e7ed, 0x01e7ee, 1}, 2198 {0x01e7ef, 0x01e7ef, -1}, {0x01e7f0, 0x01e7fe, 1}, {0x01e7ff, 0x01e7ff, -1}, 2199 {0x01e800, 0x01e8c4, 1}, {0x01e8c5, 0x01e8c6, -1}, {0x01e8c7, 0x01e8cf, 1}, 2200 {0x01e8d0, 0x01e8d6, 0}, {0x01e8d7, 0x01e8ff, -1}, {0x01e900, 0x01e943, 1}, 2201 {0x01e944, 0x01e94a, 0}, {0x01e94b, 0x01e94b, 1}, {0x01e94c, 0x01e94f, -1}, 2202 {0x01e950, 0x01e959, 1}, {0x01e95a, 0x01e95d, -1}, {0x01e95e, 0x01e95f, 1}, 2203 {0x01e960, 0x01ec70, -1}, {0x01ec71, 0x01ecb4, 1}, {0x01ecb5, 0x01ed00, -1}, 2204 {0x01ed01, 0x01ed3d, 1}, {0x01ed3e, 0x01edff, -1}, {0x01ee00, 0x01ee03, 1}, 2205 {0x01ee04, 0x01ee04, -1}, {0x01ee05, 0x01ee1f, 1}, {0x01ee20, 0x01ee20, -1}, 2206 {0x01ee21, 0x01ee22, 1}, {0x01ee23, 0x01ee23, -1}, {0x01ee24, 0x01ee24, 1}, 2207 {0x01ee25, 0x01ee26, -1}, {0x01ee27, 0x01ee27, 1}, {0x01ee28, 0x01ee28, -1}, 2208 {0x01ee29, 0x01ee32, 1}, {0x01ee33, 0x01ee33, -1}, {0x01ee34, 0x01ee37, 1}, 2209 {0x01ee38, 0x01ee38, -1}, {0x01ee39, 0x01ee39, 1}, {0x01ee3a, 0x01ee3a, -1}, 2210 {0x01ee3b, 0x01ee3b, 1}, {0x01ee3c, 0x01ee41, -1}, {0x01ee42, 0x01ee42, 1}, 2211 {0x01ee43, 0x01ee46, -1}, {0x01ee47, 0x01ee47, 1}, {0x01ee48, 0x01ee48, -1}, 2212 {0x01ee49, 0x01ee49, 1}, {0x01ee4a, 0x01ee4a, -1}, {0x01ee4b, 0x01ee4b, 1}, 2213 {0x01ee4c, 0x01ee4c, -1}, {0x01ee4d, 0x01ee4f, 1}, {0x01ee50, 0x01ee50, -1}, 2214 {0x01ee51, 0x01ee52, 1}, {0x01ee53, 0x01ee53, -1}, {0x01ee54, 0x01ee54, 1}, 2215 {0x01ee55, 0x01ee56, -1}, {0x01ee57, 0x01ee57, 1}, {0x01ee58, 0x01ee58, -1}, 2216 {0x01ee59, 0x01ee59, 1}, {0x01ee5a, 0x01ee5a, -1}, {0x01ee5b, 0x01ee5b, 1}, 2217 {0x01ee5c, 0x01ee5c, -1}, {0x01ee5d, 0x01ee5d, 1}, {0x01ee5e, 0x01ee5e, -1}, 2218 {0x01ee5f, 0x01ee5f, 1}, {0x01ee60, 0x01ee60, -1}, {0x01ee61, 0x01ee62, 1}, 2219 {0x01ee63, 0x01ee63, -1}, {0x01ee64, 0x01ee64, 1}, {0x01ee65, 0x01ee66, -1}, 2220 {0x01ee67, 0x01ee6a, 1}, {0x01ee6b, 0x01ee6b, -1}, {0x01ee6c, 0x01ee72, 1}, 2221 {0x01ee73, 0x01ee73, -1}, {0x01ee74, 0x01ee77, 1}, {0x01ee78, 0x01ee78, -1}, 2222 {0x01ee79, 0x01ee7c, 1}, {0x01ee7d, 0x01ee7d, -1}, {0x01ee7e, 0x01ee7e, 1}, 2223 {0x01ee7f, 0x01ee7f, -1}, {0x01ee80, 0x01ee89, 1}, {0x01ee8a, 0x01ee8a, -1}, 2224 {0x01ee8b, 0x01ee9b, 1}, {0x01ee9c, 0x01eea0, -1}, {0x01eea1, 0x01eea3, 1}, 2225 {0x01eea4, 0x01eea4, -1}, {0x01eea5, 0x01eea9, 1}, {0x01eeaa, 0x01eeaa, -1}, 2226 {0x01eeab, 0x01eebb, 1}, {0x01eebc, 0x01eeef, -1}, {0x01eef0, 0x01eef1, 1}, 2227 {0x01eef2, 0x01efff, -1}, {0x01f000, 0x01f003, 1}, {0x01f004, 0x01f004, 2}, 2228 {0x01f005, 0x01f02b, 1}, {0x01f02c, 0x01f02f, -1}, {0x01f030, 0x01f093, 1}, 2229 {0x01f094, 0x01f09f, -1}, {0x01f0a0, 0x01f0ae, 1}, {0x01f0af, 0x01f0b0, -1}, 2230 {0x01f0b1, 0x01f0bf, 1}, {0x01f0c0, 0x01f0c0, -1}, {0x01f0c1, 0x01f0ce, 1}, 2231 {0x01f0cf, 0x01f0cf, 2}, {0x01f0d0, 0x01f0d0, -1}, {0x01f0d1, 0x01f0f5, 1}, 2232 {0x01f0f6, 0x01f0ff, -1}, {0x01f100, 0x01f18d, 1}, {0x01f18e, 0x01f18e, 2}, 2233 {0x01f18f, 0x01f190, 1}, {0x01f191, 0x01f19a, 2}, {0x01f19b, 0x01f1ad, 1}, 2234 {0x01f1ae, 0x01f1e5, -1}, {0x01f1e6, 0x01f1ff, 1}, {0x01f200, 0x01f202, 2}, 2235 {0x01f203, 0x01f20f, -1}, {0x01f210, 0x01f23b, 2}, {0x01f23c, 0x01f23f, -1}, 2236 {0x01f240, 0x01f248, 2}, {0x01f249, 0x01f24f, -1}, {0x01f250, 0x01f251, 2}, 2237 {0x01f252, 0x01f25f, -1}, {0x01f260, 0x01f265, 2}, {0x01f266, 0x01f2ff, -1}, 2238 {0x01f300, 0x01f320, 2}, {0x01f321, 0x01f32c, 1}, {0x01f32d, 0x01f335, 2}, 2239 {0x01f336, 0x01f336, 1}, {0x01f337, 0x01f37c, 2}, {0x01f37d, 0x01f37d, 1}, 2240 {0x01f37e, 0x01f393, 2}, {0x01f394, 0x01f39f, 1}, {0x01f3a0, 0x01f3ca, 2}, 2241 {0x01f3cb, 0x01f3ce, 1}, {0x01f3cf, 0x01f3d3, 2}, {0x01f3d4, 0x01f3df, 1}, 2242 {0x01f3e0, 0x01f3f0, 2}, {0x01f3f1, 0x01f3f3, 1}, {0x01f3f4, 0x01f3f4, 2}, 2243 {0x01f3f5, 0x01f3f7, 1}, {0x01f3f8, 0x01f43e, 2}, {0x01f43f, 0x01f43f, 1}, 2244 {0x01f440, 0x01f440, 2}, {0x01f441, 0x01f441, 1}, {0x01f442, 0x01f4fc, 2}, 2245 {0x01f4fd, 0x01f4fe, 1}, {0x01f4ff, 0x01f53d, 2}, {0x01f53e, 0x01f54a, 1}, 2246 {0x01f54b, 0x01f54e, 2}, {0x01f54f, 0x01f54f, 1}, {0x01f550, 0x01f567, 2}, 2247 {0x01f568, 0x01f579, 1}, {0x01f57a, 0x01f57a, 2}, {0x01f57b, 0x01f594, 1}, 2248 {0x01f595, 0x01f596, 2}, {0x01f597, 0x01f5a3, 1}, {0x01f5a4, 0x01f5a4, 2}, 2249 {0x01f5a5, 0x01f5fa, 1}, {0x01f5fb, 0x01f64f, 2}, {0x01f650, 0x01f67f, 1}, 2250 {0x01f680, 0x01f6c5, 2}, {0x01f6c6, 0x01f6cb, 1}, {0x01f6cc, 0x01f6cc, 2}, 2251 {0x01f6cd, 0x01f6cf, 1}, {0x01f6d0, 0x01f6d2, 2}, {0x01f6d3, 0x01f6d4, 1}, 2252 {0x01f6d5, 0x01f6d7, 2}, {0x01f6d8, 0x01f6db, -1}, {0x01f6dc, 0x01f6df, 2}, 2253 {0x01f6e0, 0x01f6ea, 1}, {0x01f6eb, 0x01f6ec, 2}, {0x01f6ed, 0x01f6ef, -1}, 2254 {0x01f6f0, 0x01f6f3, 1}, {0x01f6f4, 0x01f6fc, 2}, {0x01f6fd, 0x01f6ff, -1}, 2255 {0x01f700, 0x01f776, 1}, {0x01f777, 0x01f77a, -1}, {0x01f77b, 0x01f7d9, 1}, 2256 {0x01f7da, 0x01f7df, -1}, {0x01f7e0, 0x01f7eb, 2}, {0x01f7ec, 0x01f7ef, -1}, 2257 {0x01f7f0, 0x01f7f0, 2}, {0x01f7f1, 0x01f7ff, -1}, {0x01f800, 0x01f80b, 1}, 2258 {0x01f80c, 0x01f80f, -1}, {0x01f810, 0x01f847, 1}, {0x01f848, 0x01f84f, -1}, 2259 {0x01f850, 0x01f859, 1}, {0x01f85a, 0x01f85f, -1}, {0x01f860, 0x01f887, 1}, 2260 {0x01f888, 0x01f88f, -1}, {0x01f890, 0x01f8ad, 1}, {0x01f8ae, 0x01f8af, -1}, 2261 {0x01f8b0, 0x01f8bb, 1}, {0x01f8bc, 0x01f8bf, -1}, {0x01f8c0, 0x01f8c1, 1}, 2262 {0x01f8c2, 0x01f8ff, -1}, {0x01f900, 0x01f90b, 1}, {0x01f90c, 0x01f93a, 2}, 2263 {0x01f93b, 0x01f93b, 1}, {0x01f93c, 0x01f945, 2}, {0x01f946, 0x01f946, 1}, 2264 {0x01f947, 0x01f9ff, 2}, {0x01fa00, 0x01fa53, 1}, {0x01fa54, 0x01fa5f, -1}, 2265 {0x01fa60, 0x01fa6d, 1}, {0x01fa6e, 0x01fa6f, -1}, {0x01fa70, 0x01fa7c, 2}, 2266 {0x01fa7d, 0x01fa7f, -1}, {0x01fa80, 0x01fa89, 2}, {0x01fa8a, 0x01fa8e, -1}, 2267 {0x01fa8f, 0x01fac6, 2}, {0x01fac7, 0x01facd, -1}, {0x01face, 0x01fadc, 2}, 2268 {0x01fadd, 0x01fade, -1}, {0x01fadf, 0x01fae9, 2}, {0x01faea, 0x01faef, -1}, 2269 {0x01faf0, 0x01faf8, 2}, {0x01faf9, 0x01faff, -1}, {0x01fb00, 0x01fb92, 1}, 2270 {0x01fb93, 0x01fb93, -1}, {0x01fb94, 0x01fbf9, 1}, {0x01fbfa, 0x01ffff, -1}, 2271 {0x020000, 0x02a6df, 2}, {0x02a6e0, 0x02a6ff, -1}, {0x02a700, 0x02b739, 2}, 2272 {0x02b73a, 0x02b73f, -1}, {0x02b740, 0x02b81d, 2}, {0x02b81e, 0x02b81f, -1}, 2273 {0x02b820, 0x02cea1, 2}, {0x02cea2, 0x02ceaf, -1}, {0x02ceb0, 0x02ebe0, 2}, 2274 {0x02ebe1, 0x02ebef, -1}, {0x02ebf0, 0x02ee5d, 2}, {0x02ee5e, 0x02f7ff, -1}, 2275 {0x02f800, 0x02fa1d, 2}, {0x02fa1e, 0x02ffff, -1}, {0x030000, 0x03134a, 2}, 2276 {0x03134b, 0x03134f, -1}, {0x031350, 0x0323af, 2}, {0x0323b0, 0x0e0000, -1}, 2277 {0x0e0001, 0x0e0001, 0}, {0x0e0002, 0x0e001f, -1}, {0x0e0020, 0x0e007f, 0}, 2278 {0x0e0080, 0x0e00ff, -1}, {0x0e0100, 0x0e01ef, 0}, {0x0e01f0, 0x0effff, -1}, 2279 {0x0f0000, 0x0ffffd, 1}, {0x0ffffe, 0x0fffff, -1}, {0x100000, 0x10fffd, 1}, 2280 {0x10fffe, 0x10ffff, -1}, 2281 // clang-format on 2282 }; 2283 #define WCWIDTH_TABLE_LENGTH 2143 2284 #endif // ifndef TB_OPT_LIBC_WCHAR 2285 2286 static int tb_reset(void); 2287 static int tb_printf_inner(int x, int y, uintattr_t fg, uintattr_t bg, 2288 size_t *out_w, const char *fmt, va_list vl); 2289 static int init_term_attrs(void); 2290 static int init_term_caps(void); 2291 static int init_cap_trie(void); 2292 static int cap_trie_add(const char *cap, uint16_t key, uint8_t mod); 2293 static int cap_trie_find(const char *buf, size_t nbuf, struct cap_trie **last, 2294 size_t *depth); 2295 static int cap_trie_deinit(struct cap_trie *node); 2296 static int init_resize_handler(void); 2297 static int send_init_escape_codes(void); 2298 static int send_clear(void); 2299 static int update_term_size(void); 2300 static int update_term_size_via_esc(void); 2301 static int init_cellbuf(void); 2302 static int tb_deinit(int deallocate); 2303 static int load_terminfo(void); 2304 static int load_terminfo_from_path(const char *path, const char *term); 2305 static int unveil_terminfo_path(void); 2306 static int read_terminfo_path(const char *path); 2307 static int parse_terminfo_caps(void); 2308 static int load_builtin_caps(void); 2309 static const char *get_terminfo_string(int16_t offsets_pos, int16_t offsets_len, 2310 int16_t table_pos, int16_t table_size, int16_t index); 2311 static int get_terminfo_int16(int offset, int16_t *val); 2312 static int wait_event(struct tb_event *event, int timeout); 2313 static int extract_event(struct tb_event *event); 2314 static int extract_esc(struct tb_event *event); 2315 static int extract_esc_user(struct tb_event *event, int is_post); 2316 static int extract_esc_cap(struct tb_event *event); 2317 static int extract_esc_mouse(struct tb_event *event); 2318 static int resize_cellbufs(void); 2319 static void handle_resize(int sig); 2320 static int send_attr(uintattr_t fg, uintattr_t bg); 2321 static int send_sgr(uint32_t fg, uint32_t bg, int fg_is_default, 2322 int bg_is_default); 2323 static int send_cursor_if(int x, int y); 2324 static int send_char(int x, int y, uint32_t ch); 2325 static int send_cluster(int x, int y, uint32_t *ch, size_t nch); 2326 static int convert_num(uint32_t num, char *buf); 2327 static int cell_cmp(struct tb_cell *a, struct tb_cell *b); 2328 static int cell_copy(struct tb_cell *dst, struct tb_cell *src); 2329 static int cell_set(struct tb_cell *cell, uint32_t *ch, size_t nch, 2330 uintattr_t fg, uintattr_t bg); 2331 static int cell_reserve_ech(struct tb_cell *cell, size_t n); 2332 static int cell_free(struct tb_cell *cell); 2333 static int cellbuf_init(struct cellbuf *c, int w, int h); 2334 static int cellbuf_free(struct cellbuf *c); 2335 static int cellbuf_clear(struct cellbuf *c); 2336 static int cellbuf_get(struct cellbuf *c, int x, int y, struct tb_cell **out); 2337 static int cellbuf_in_bounds(struct cellbuf *c, int x, int y); 2338 static int cellbuf_resize(struct cellbuf *c, int w, int h); 2339 static int bytebuf_puts(struct bytebuf *b, const char *str); 2340 static int bytebuf_nputs(struct bytebuf *b, const char *str, size_t nstr); 2341 static int bytebuf_shift(struct bytebuf *b, size_t n); 2342 static int bytebuf_flush(struct bytebuf *b, int fd); 2343 static int bytebuf_reserve(struct bytebuf *b, size_t sz); 2344 static int bytebuf_free(struct bytebuf *b); 2345 static int tb_iswprint_ex(uint32_t ch, int *width); 2346 static int tb_cluster_width(uint32_t *ch, size_t nch); 2347 2348 int tb_init(void) { 2349 return tb_init_file("/dev/tty"); 2350 } 2351 2352 int tb_init_file(const char *path) { 2353 if (global.initialized) return TB_ERR_INIT_ALREADY; 2354 int ttyfd = open(path, O_RDWR); 2355 if (ttyfd < 0) { 2356 global.last_errno = errno; 2357 return TB_ERR_INIT_OPEN; 2358 } 2359 global.ttyfd_open = 1; 2360 return tb_init_fd(ttyfd); 2361 } 2362 2363 int tb_init_fd(int ttyfd) { 2364 return tb_init_rwfd(ttyfd, ttyfd); 2365 } 2366 2367 int tb_init_rwfd(int rfd, int wfd) { 2368 int rv; 2369 2370 tb_reset(); 2371 global.ttyfd = isatty(rfd) ? rfd : (isatty(wfd) ? wfd : -1); 2372 global.rfd = rfd; 2373 global.wfd = wfd; 2374 2375 do { 2376 if_err_break(rv, init_term_attrs()); 2377 if_err_break(rv, init_term_caps()); 2378 if_err_break(rv, init_cap_trie()); 2379 if_err_break(rv, init_resize_handler()); 2380 if_err_break(rv, send_init_escape_codes()); 2381 if_err_break(rv, send_clear()); 2382 if_err_break(rv, update_term_size()); 2383 if_err_break(rv, init_cellbuf()); 2384 global.initialized = 1; 2385 } while (0); 2386 2387 if (rv != TB_OK) tb_deinit(1); 2388 2389 return rv; 2390 } 2391 2392 /* Change to the original: add deallocate parameter. [SR] */ 2393 int tb_shutdown(int deallocate) { 2394 if_not_init_return(); 2395 tb_deinit(deallocate); 2396 return TB_OK; 2397 } 2398 2399 int tb_width(void) { 2400 if_not_init_return(); 2401 return global.width; 2402 } 2403 2404 int tb_height(void) { 2405 if_not_init_return(); 2406 return global.height; 2407 } 2408 2409 int tb_clear(void) { 2410 if_not_init_return(); 2411 return cellbuf_clear(&global.back); 2412 } 2413 2414 int tb_set_clear_attrs(uintattr_t fg, uintattr_t bg) { 2415 if_not_init_return(); 2416 global.fg = fg; 2417 global.bg = bg; 2418 return TB_OK; 2419 } 2420 2421 int tb_present(void) { 2422 if_not_init_return(); 2423 2424 int rv; 2425 2426 // TODO: Assert global.back.(width,height) == global.front.(width,height) 2427 2428 global.last_x = -1; 2429 global.last_y = -1; 2430 2431 int x, y, i; 2432 for (y = 0; y < global.front.height; y++) { 2433 for (x = 0; x < global.front.width;) { 2434 struct tb_cell *back, *front; 2435 if_err_return(rv, cellbuf_get(&global.back, x, y, &back)); 2436 if_err_return(rv, cellbuf_get(&global.front, x, y, &front)); 2437 2438 int w; 2439 { 2440 #ifdef TB_OPT_EGC 2441 if (back->nech > 0) 2442 w = tb_cluster_width(back->ech, back->nech); 2443 else 2444 #endif 2445 w = tb_wcwidth((wchar_t)back->ch); 2446 } 2447 if (w < 1) w = 1; // wcwidth returns -1 for invalid codepoints 2448 2449 if (cell_cmp(back, front) != 0) { 2450 cell_copy(front, back); 2451 2452 send_attr(back->fg, back->bg); 2453 if (w > 1 && x >= global.front.width - (w - 1)) { 2454 // Not enough room for wide char, send spaces 2455 for (i = x; i < global.front.width; i++) { 2456 send_char(i, y, ' '); 2457 } 2458 } else { 2459 { 2460 #ifdef TB_OPT_EGC 2461 if (back->nech > 0) 2462 send_cluster(x, y, back->ech, back->nech); 2463 else 2464 #endif 2465 send_char(x, y, back->ch); 2466 } 2467 2468 // When wcwidth>1, we need to advance the cursor by more 2469 // than 1, thereby skipping some cells. Set these skipped 2470 // cells to an invalid codepoint in the front buffer, so 2471 // that if this cell is later replaced by a wcwidth==1 char, 2472 // we'll get a cell_cmp diff for the skipped cells and 2473 // properly re-render. 2474 for (i = 1; i < w; i++) { 2475 struct tb_cell *front_wide; 2476 uint32_t invalid = -1; 2477 if_err_return(rv, 2478 cellbuf_get(&global.front, x + i, y, &front_wide)); 2479 if_err_return(rv, 2480 cell_set(front_wide, &invalid, 1, -1, -1)); 2481 } 2482 } 2483 } 2484 x += w; 2485 } 2486 } 2487 2488 if_err_return(rv, send_cursor_if(global.cursor_x, global.cursor_y)); 2489 if_err_return(rv, bytebuf_flush(&global.out, global.wfd)); 2490 2491 return TB_OK; 2492 } 2493 2494 int tb_invalidate(void) { 2495 int rv; 2496 if_not_init_return(); 2497 if_err_return(rv, resize_cellbufs()); 2498 return TB_OK; 2499 } 2500 2501 int tb_set_cursor(int cx, int cy) { 2502 if_not_init_return(); 2503 int rv; 2504 if (cx < 0) cx = 0; 2505 if (cy < 0) cy = 0; 2506 if (global.cursor_x == -1) { 2507 if_err_return(rv, 2508 bytebuf_puts(&global.out, global.caps[TB_CAP_SHOW_CURSOR])); 2509 } 2510 if_err_return(rv, send_cursor_if(cx, cy)); 2511 global.cursor_x = cx; 2512 global.cursor_y = cy; 2513 return TB_OK; 2514 } 2515 2516 int tb_hide_cursor(void) { 2517 if_not_init_return(); 2518 int rv; 2519 if (global.cursor_x >= 0) { 2520 if_err_return(rv, 2521 bytebuf_puts(&global.out, global.caps[TB_CAP_HIDE_CURSOR])); 2522 } 2523 global.cursor_x = -1; 2524 global.cursor_y = -1; 2525 return TB_OK; 2526 } 2527 2528 int tb_set_cell(int x, int y, uint32_t ch, uintattr_t fg, uintattr_t bg) { 2529 return tb_set_cell_ex(x, y, &ch, 1, fg, bg); 2530 } 2531 2532 int tb_set_cell_ex(int x, int y, uint32_t *ch, size_t nch, uintattr_t fg, 2533 uintattr_t bg) { 2534 if_not_init_return(); 2535 int rv; 2536 struct tb_cell *cell; 2537 if_err_return(rv, cellbuf_get(&global.back, x, y, &cell)); 2538 if_err_return(rv, cell_set(cell, ch, nch, fg, bg)); 2539 return TB_OK; 2540 } 2541 2542 int tb_get_cell(int x, int y, int back, struct tb_cell **cell) { 2543 if_not_init_return(); 2544 return cellbuf_get(back ? &global.back : &global.front, x, y, cell); 2545 } 2546 2547 int tb_extend_cell(int x, int y, uint32_t ch) { 2548 if_not_init_return(); 2549 #ifdef TB_OPT_EGC 2550 // TODO: iswprint ch? 2551 int rv; 2552 struct tb_cell *cell; 2553 size_t nech; 2554 if_err_return(rv, cellbuf_get(&global.back, x, y, &cell)); 2555 if (cell->nech > 0) { // append to ech 2556 nech = cell->nech + 1; 2557 if_err_return(rv, cell_reserve_ech(cell, nech + 1)); 2558 cell->ech[nech - 1] = ch; 2559 } else { // make new ech 2560 nech = 2; 2561 if_err_return(rv, cell_reserve_ech(cell, nech + 1)); 2562 cell->ech[0] = cell->ch; 2563 cell->ech[1] = ch; 2564 } 2565 cell->ech[nech] = '\0'; 2566 cell->nech = nech; 2567 return TB_OK; 2568 #else 2569 (void)x; 2570 (void)y; 2571 (void)ch; 2572 return TB_ERR; 2573 #endif 2574 } 2575 2576 int tb_set_input_mode(int mode) { 2577 if_not_init_return(); 2578 2579 if (mode == TB_INPUT_CURRENT) return global.input_mode; 2580 2581 int esc_or_alt = TB_INPUT_ESC | TB_INPUT_ALT; 2582 if ((mode & esc_or_alt) == 0) { 2583 // neither specified; flip on ESC 2584 mode |= TB_INPUT_ESC; 2585 } else if ((mode & esc_or_alt) == esc_or_alt) { 2586 // both specified; flip off ALT 2587 mode &= ~TB_INPUT_ALT; 2588 } 2589 2590 if (mode & TB_INPUT_MOUSE) { 2591 bytebuf_puts(&global.out, TB_HARDCAP_ENTER_MOUSE); 2592 bytebuf_flush(&global.out, global.wfd); 2593 } else { 2594 bytebuf_puts(&global.out, TB_HARDCAP_EXIT_MOUSE); 2595 bytebuf_flush(&global.out, global.wfd); 2596 } 2597 2598 global.input_mode = mode; 2599 return TB_OK; 2600 } 2601 2602 int tb_set_output_mode(int mode) { 2603 if_not_init_return(); 2604 switch (mode) { 2605 case TB_OUTPUT_CURRENT: 2606 return global.output_mode; 2607 case TB_OUTPUT_NORMAL: 2608 case TB_OUTPUT_256: 2609 case TB_OUTPUT_216: 2610 case TB_OUTPUT_GRAYSCALE: 2611 #if TB_OPT_ATTR_W >= 32 2612 case TB_OUTPUT_TRUECOLOR: 2613 #endif 2614 global.last_fg = ~global.fg; 2615 global.last_bg = ~global.bg; 2616 global.output_mode = mode; 2617 return TB_OK; 2618 } 2619 return TB_ERR; 2620 } 2621 2622 int tb_peek_event(struct tb_event *event, int timeout_ms) { 2623 if_not_init_return(); 2624 return wait_event(event, timeout_ms); 2625 } 2626 2627 int tb_poll_event(struct tb_event *event) { 2628 if_not_init_return(); 2629 return wait_event(event, -1); 2630 } 2631 2632 int tb_get_fds(int *ttyfd, int *resizefd) { 2633 if_not_init_return(); 2634 2635 *ttyfd = global.rfd; 2636 *resizefd = global.resize_pipefd[0]; 2637 2638 return TB_OK; 2639 } 2640 2641 int tb_print(int x, int y, uintattr_t fg, uintattr_t bg, const char *str) { 2642 return tb_print_ex(x, y, fg, bg, NULL, str); 2643 } 2644 2645 int tb_print_ex(int x, int y, uintattr_t fg, uintattr_t bg, size_t *out_w, 2646 const char *str) { 2647 int rv, w, ix, x_prev; 2648 uint32_t uni; 2649 2650 if_not_init_return(); 2651 2652 if (!cellbuf_in_bounds(&global.back, x, y)) { 2653 return TB_ERR_OUT_OF_BOUNDS; 2654 } 2655 2656 ix = x; 2657 x_prev = x; 2658 if (out_w) *out_w = 0; 2659 2660 while (*str) { 2661 rv = tb_utf8_char_to_unicode(&uni, str); 2662 2663 if (rv < 0) { 2664 uni = 0xfffd; // replace invalid UTF-8 char with U+FFFD 2665 str += rv * -1; 2666 } else if (rv > 0) { 2667 str += rv; 2668 } else { 2669 break; // shouldn't get here 2670 } 2671 2672 if (uni == '\n') { // TODO: \r, \t, \v, \f, etc? 2673 x = ix; 2674 x_prev = x; 2675 y += 1; 2676 continue; 2677 } else if (!tb_iswprint_ex(uni, &w)) { 2678 uni = 0xfffd; // replace non-printable with U+FFFD 2679 w = 1; 2680 } 2681 2682 if (w < 0) { 2683 return TB_ERR; // shouldn't happen if iswprint 2684 } else if (w == 0) { // combining character 2685 if (cellbuf_in_bounds(&global.back, x_prev, y)) { 2686 if_err_return(rv, tb_extend_cell(x_prev, y, uni)); 2687 } 2688 } else { 2689 if (cellbuf_in_bounds(&global.back, x, y)) { 2690 if_err_return(rv, tb_set_cell(x, y, uni, fg, bg)); 2691 } 2692 x_prev = x; 2693 x += w; 2694 if (out_w) *out_w += w; 2695 } 2696 } 2697 2698 return TB_OK; 2699 } 2700 2701 int tb_printf(int x, int y, uintattr_t fg, uintattr_t bg, const char *fmt, 2702 ...) { 2703 int rv; 2704 va_list vl; 2705 va_start(vl, fmt); 2706 rv = tb_printf_inner(x, y, fg, bg, NULL, fmt, vl); 2707 va_end(vl); 2708 return rv; 2709 } 2710 2711 int tb_printf_ex(int x, int y, uintattr_t fg, uintattr_t bg, size_t *out_w, 2712 const char *fmt, ...) { 2713 int rv; 2714 va_list vl; 2715 va_start(vl, fmt); 2716 rv = tb_printf_inner(x, y, fg, bg, out_w, fmt, vl); 2717 va_end(vl); 2718 return rv; 2719 } 2720 2721 int tb_send(const char *buf, size_t nbuf) { 2722 return bytebuf_nputs(&global.out, buf, nbuf); 2723 } 2724 2725 int tb_sendf(const char *fmt, ...) { 2726 int rv; 2727 char buf[TB_OPT_PRINTF_BUF]; 2728 va_list vl; 2729 va_start(vl, fmt); 2730 rv = vsnprintf(buf, sizeof(buf), fmt, vl); 2731 va_end(vl); 2732 if (rv < 0 || rv >= (int)sizeof(buf)) { 2733 return TB_ERR; 2734 } 2735 return tb_send(buf, (size_t)rv); 2736 } 2737 2738 int tb_set_func(int fn_type, int (*fn)(struct tb_event *, size_t *)) { 2739 switch (fn_type) { 2740 case TB_FUNC_EXTRACT_PRE: 2741 global.fn_extract_esc_pre = fn; 2742 return TB_OK; 2743 case TB_FUNC_EXTRACT_POST: 2744 global.fn_extract_esc_post = fn; 2745 return TB_OK; 2746 } 2747 return TB_ERR; 2748 } 2749 2750 struct tb_cell *tb_cell_buffer(void) { 2751 if (!global.initialized) return NULL; 2752 return global.back.cells; 2753 } 2754 2755 int tb_utf8_char_length(char c) { 2756 return utf8_length[(unsigned char)c]; 2757 } 2758 2759 int tb_utf8_char_to_unicode(uint32_t *out, const char *c) { 2760 if (*c == '\0') return 0; 2761 2762 int i; 2763 unsigned char len = tb_utf8_char_length(*c); 2764 unsigned char mask = utf8_mask[len - 1]; 2765 uint32_t result = c[0] & mask; 2766 for (i = 1; i < len && c[i] != '\0'; ++i) { 2767 result <<= 6; 2768 result |= c[i] & 0x3f; 2769 } 2770 2771 if (i != len) return i * -1; 2772 2773 *out = result; 2774 return (int)len; 2775 } 2776 2777 int tb_utf8_unicode_to_char(char *out, uint32_t c) { 2778 int len = 0; 2779 int first; 2780 int i; 2781 2782 if (c < 0x80) { 2783 first = 0; 2784 len = 1; 2785 } else if (c < 0x800) { 2786 first = 0xc0; 2787 len = 2; 2788 } else if (c < 0x10000) { 2789 first = 0xe0; 2790 len = 3; 2791 } else if (c < 0x200000) { 2792 first = 0xf0; 2793 len = 4; 2794 } else if (c < 0x4000000) { 2795 first = 0xf8; 2796 len = 5; 2797 } else { 2798 first = 0xfc; 2799 len = 6; 2800 } 2801 2802 for (i = len - 1; i > 0; --i) { 2803 out[i] = (c & 0x3f) | 0x80; 2804 c >>= 6; 2805 } 2806 out[0] = c | first; 2807 out[len] = '\0'; 2808 2809 return len; 2810 } 2811 2812 int tb_last_errno(void) { 2813 return global.last_errno; 2814 } 2815 2816 const char *tb_strerror(int err) { 2817 switch (err) { 2818 case TB_OK: 2819 return "Success"; 2820 case TB_ERR_NEED_MORE: 2821 return "Not enough input"; 2822 case TB_ERR_INIT_ALREADY: 2823 return "Termbox initialized already"; 2824 case TB_ERR_MEM: 2825 return "Out of memory"; 2826 case TB_ERR_NO_EVENT: 2827 return "No event"; 2828 case TB_ERR_NO_TERM: 2829 return "No TERM in environment"; 2830 case TB_ERR_NOT_INIT: 2831 return "Termbox not initialized"; 2832 case TB_ERR_OUT_OF_BOUNDS: 2833 return "Out of bounds"; 2834 case TB_ERR_UNSUPPORTED_TERM: 2835 return "Unsupported terminal"; 2836 case TB_ERR_CAP_COLLISION: 2837 return "Termcaps collision"; 2838 case TB_ERR_RESIZE_SSCANF: 2839 return "Terminal width/height not received by sscanf() after " 2840 "resize"; 2841 case TB_ERR: 2842 case TB_ERR_INIT_OPEN: 2843 case TB_ERR_READ: 2844 case TB_ERR_RESIZE_IOCTL: 2845 case TB_ERR_RESIZE_PIPE: 2846 case TB_ERR_RESIZE_SIGACTION: 2847 case TB_ERR_POLL: 2848 case TB_ERR_TCGETATTR: 2849 case TB_ERR_TCSETATTR: 2850 case TB_ERR_RESIZE_WRITE: 2851 case TB_ERR_RESIZE_POLL: 2852 case TB_ERR_RESIZE_READ: 2853 default: 2854 strerror_r(global.last_errno, global.errbuf, sizeof(global.errbuf)); 2855 return (const char *)global.errbuf; 2856 } 2857 } 2858 2859 int tb_has_truecolor(void) { 2860 #if TB_OPT_ATTR_W >= 32 2861 return 1; 2862 #else 2863 return 0; 2864 #endif 2865 } 2866 2867 int tb_has_egc(void) { 2868 #ifdef TB_OPT_EGC 2869 return 1; 2870 #else 2871 return 0; 2872 #endif 2873 } 2874 2875 int tb_attr_width(void) { 2876 return TB_OPT_ATTR_W; 2877 } 2878 2879 const char *tb_version(void) { 2880 return TB_VERSION_STR; 2881 } 2882 2883 static int tb_reset(void) { 2884 int ttyfd_open = global.ttyfd_open; 2885 memset(&global, 0, sizeof(global)); 2886 global.ttyfd = -1; 2887 global.rfd = -1; 2888 global.wfd = -1; 2889 global.ttyfd_open = ttyfd_open; 2890 global.resize_pipefd[0] = -1; 2891 global.resize_pipefd[1] = -1; 2892 global.width = -1; 2893 global.height = -1; 2894 global.cursor_x = -1; 2895 global.cursor_y = -1; 2896 global.last_x = -1; 2897 global.last_y = -1; 2898 global.fg = TB_DEFAULT; 2899 global.bg = TB_DEFAULT; 2900 global.last_fg = ~global.fg; 2901 global.last_bg = ~global.bg; 2902 global.input_mode = TB_INPUT_ESC; 2903 global.output_mode = TB_OUTPUT_NORMAL; 2904 return TB_OK; 2905 } 2906 2907 static int init_term_attrs(void) { 2908 if (global.ttyfd < 0) return TB_OK; 2909 2910 if (tcgetattr(global.ttyfd, &global.orig_tios) != 0) { 2911 global.last_errno = errno; 2912 return TB_ERR_TCGETATTR; 2913 } 2914 2915 struct termios tios; 2916 memcpy(&tios, &global.orig_tios, sizeof(tios)); 2917 global.has_orig_tios = 1; 2918 2919 cfmakeraw(&tios); 2920 tios.c_cc[VMIN] = 1; 2921 tios.c_cc[VTIME] = 0; 2922 2923 if (tcsetattr(global.ttyfd, TCSAFLUSH, &tios) != 0) { 2924 global.last_errno = errno; 2925 return TB_ERR_TCSETATTR; 2926 } 2927 2928 return TB_OK; 2929 } 2930 2931 int tb_printf_inner(int x, int y, uintattr_t fg, uintattr_t bg, size_t *out_w, 2932 const char *fmt, va_list vl) { 2933 int rv; 2934 char buf[TB_OPT_PRINTF_BUF]; 2935 rv = vsnprintf(buf, sizeof(buf), fmt, vl); 2936 if (rv < 0 || rv >= (int)sizeof(buf)) { 2937 return TB_ERR; 2938 } 2939 return tb_print_ex(x, y, fg, bg, out_w, buf); 2940 } 2941 2942 static int init_term_caps(void) { 2943 if (load_terminfo() == TB_OK) { 2944 return parse_terminfo_caps(); 2945 } 2946 return load_builtin_caps(); 2947 } 2948 2949 static int init_cap_trie(void) { 2950 int rv, i; 2951 2952 // Add caps from terminfo or built-in 2953 // 2954 // Collisions are expected as some terminfo entries have dupes. (For 2955 // example, att605-pc collides on TB_CAP_F4 and TB_CAP_DELETE.) First cap 2956 // in TB_CAP_* index order will win. 2957 // 2958 // TODO: Reorder TB_CAP_* so more critical caps come first. 2959 for (i = 0; i < TB_CAP__COUNT_KEYS; i++) { 2960 rv = cap_trie_add(global.caps[i], tb_key_i(i), 0); 2961 if (rv != TB_OK && rv != TB_ERR_CAP_COLLISION) return rv; 2962 } 2963 2964 // Add built-in mod caps 2965 // 2966 // Collisions are OK here as well. This can happen if global.caps collides 2967 // with builtin_mod_caps. It is desirable to give precedence to global.caps 2968 // here. 2969 for (i = 0; builtin_mod_caps[i].cap != NULL; i++) { 2970 rv = cap_trie_add(builtin_mod_caps[i].cap, builtin_mod_caps[i].key, 2971 builtin_mod_caps[i].mod); 2972 if (rv != TB_OK && rv != TB_ERR_CAP_COLLISION) return rv; 2973 } 2974 2975 return TB_OK; 2976 } 2977 2978 static int cap_trie_add(const char *cap, uint16_t key, uint8_t mod) { 2979 struct cap_trie *next, *node = &global.cap_trie; 2980 size_t i, j; 2981 2982 if (!cap || strlen(cap) <= 0) return TB_OK; // Nothing to do for empty caps 2983 2984 for (i = 0; cap[i] != '\0'; i++) { 2985 char c = cap[i]; 2986 next = NULL; 2987 2988 // Check if c is already a child of node 2989 for (j = 0; j < node->nchildren; j++) { 2990 if (node->children[j].c == c) { 2991 next = &node->children[j]; 2992 break; 2993 } 2994 } 2995 if (!next) { 2996 // We need to add a new child to node 2997 node->nchildren += 1; 2998 node->children = (struct cap_trie *)tb_realloc(node->children, 2999 sizeof(*node) * node->nchildren); 3000 if (!node->children) { 3001 return TB_ERR_MEM; 3002 } 3003 next = &node->children[node->nchildren - 1]; 3004 memset(next, 0, sizeof(*next)); 3005 next->c = c; 3006 } 3007 3008 // Continue 3009 node = next; 3010 } 3011 3012 if (node->is_leaf) { 3013 // Already a leaf here 3014 return TB_ERR_CAP_COLLISION; 3015 } 3016 3017 node->is_leaf = 1; 3018 node->key = key; 3019 node->mod = mod; 3020 return TB_OK; 3021 } 3022 3023 static int cap_trie_find(const char *buf, size_t nbuf, struct cap_trie **last, 3024 size_t *depth) { 3025 struct cap_trie *next, *node = &global.cap_trie; 3026 size_t i, j; 3027 *last = node; 3028 *depth = 0; 3029 for (i = 0; i < nbuf; i++) { 3030 char c = buf[i]; 3031 next = NULL; 3032 3033 // Find c in node.children 3034 for (j = 0; j < node->nchildren; j++) { 3035 if (node->children[j].c == c) { 3036 next = &node->children[j]; 3037 break; 3038 } 3039 } 3040 if (!next) { 3041 // Not found 3042 return TB_OK; 3043 } 3044 node = next; 3045 *last = node; 3046 *depth += 1; 3047 if (node->is_leaf && node->nchildren < 1) { 3048 break; 3049 } 3050 } 3051 return TB_OK; 3052 } 3053 3054 static int cap_trie_deinit(struct cap_trie *node) { 3055 size_t j; 3056 for (j = 0; j < node->nchildren; j++) { 3057 cap_trie_deinit(&node->children[j]); 3058 } 3059 if (node->children) tb_free(node->children); 3060 memset(node, 0, sizeof(*node)); 3061 return TB_OK; 3062 } 3063 3064 static int init_resize_handler(void) { 3065 if (pipe(global.resize_pipefd) != 0) { 3066 global.last_errno = errno; 3067 return TB_ERR_RESIZE_PIPE; 3068 } 3069 3070 struct sigaction sa; 3071 memset(&sa, 0, sizeof(sa)); 3072 sa.sa_handler = handle_resize; 3073 if (sigaction(SIGWINCH, &sa, NULL) != 0) { 3074 global.last_errno = errno; 3075 return TB_ERR_RESIZE_SIGACTION; 3076 } 3077 3078 return TB_OK; 3079 } 3080 3081 static int send_init_escape_codes(void) { 3082 int rv; 3083 if_err_return(rv, bytebuf_puts(&global.out, global.caps[TB_CAP_ENTER_CA])); 3084 if_err_return(rv, 3085 bytebuf_puts(&global.out, global.caps[TB_CAP_ENTER_KEYPAD])); 3086 if_err_return(rv, 3087 bytebuf_puts(&global.out, global.caps[TB_CAP_HIDE_CURSOR])); 3088 return TB_OK; 3089 } 3090 3091 static int send_clear(void) { 3092 int rv; 3093 3094 if_err_return(rv, send_attr(global.fg, global.bg)); 3095 if_err_return(rv, 3096 bytebuf_puts(&global.out, global.caps[TB_CAP_CLEAR_SCREEN])); 3097 3098 if_err_return(rv, send_cursor_if(global.cursor_x, global.cursor_y)); 3099 if_err_return(rv, bytebuf_flush(&global.out, global.wfd)); 3100 3101 global.last_x = -1; 3102 global.last_y = -1; 3103 3104 return TB_OK; 3105 } 3106 3107 static int update_term_size(void) { 3108 int rv, ioctl_errno; 3109 3110 if (global.ttyfd < 0) return TB_OK; 3111 3112 struct winsize sz; 3113 memset(&sz, 0, sizeof(sz)); 3114 3115 // Try ioctl TIOCGWINSZ 3116 if (ioctl(global.ttyfd, TIOCGWINSZ, &sz) == 0) { 3117 global.width = sz.ws_col; 3118 global.height = sz.ws_row; 3119 return TB_OK; 3120 } 3121 ioctl_errno = errno; 3122 3123 // Try >cursor(9999,9999), >u7, <u6 3124 if_ok_return(rv, update_term_size_via_esc()); 3125 3126 global.last_errno = ioctl_errno; 3127 return TB_ERR_RESIZE_IOCTL; 3128 } 3129 3130 static int update_term_size_via_esc(void) { 3131 #ifndef TB_RESIZE_FALLBACK_MS 3132 #define TB_RESIZE_FALLBACK_MS 1000 3133 #endif 3134 3135 char move_and_report[] = "\x1b[9999;9999H\x1b[6n"; 3136 ssize_t write_rv = 3137 write(global.wfd, move_and_report, strlen(move_and_report)); 3138 if (write_rv != (ssize_t)strlen(move_and_report)) { 3139 return TB_ERR_RESIZE_WRITE; 3140 } 3141 3142 fd_set fds; 3143 FD_ZERO(&fds); 3144 FD_SET(global.rfd, &fds); 3145 3146 struct timeval timeout; 3147 timeout.tv_sec = 0; 3148 timeout.tv_usec = TB_RESIZE_FALLBACK_MS * 1000; 3149 3150 int select_rv = select(global.rfd + 1, &fds, NULL, NULL, &timeout); 3151 3152 if (select_rv != 1) { 3153 global.last_errno = errno; 3154 return TB_ERR_RESIZE_POLL; 3155 } 3156 3157 char buf[TB_OPT_READ_BUF]; 3158 ssize_t read_rv = read(global.rfd, buf, sizeof(buf) - 1); 3159 if (read_rv < 1) { 3160 global.last_errno = errno; 3161 return TB_ERR_RESIZE_READ; 3162 } 3163 buf[read_rv] = '\0'; 3164 3165 int rw, rh; 3166 if (sscanf(buf, "\x1b[%d;%dR", &rh, &rw) != 2) { 3167 return TB_ERR_RESIZE_SSCANF; 3168 } 3169 3170 global.width = rw; 3171 global.height = rh; 3172 return TB_OK; 3173 } 3174 3175 static int init_cellbuf(void) { 3176 int rv; 3177 if_err_return(rv, cellbuf_init(&global.back, global.width, global.height)); 3178 if_err_return(rv, cellbuf_init(&global.front, global.width, global.height)); 3179 if_err_return(rv, cellbuf_clear(&global.back)); 3180 if_err_return(rv, cellbuf_clear(&global.front)); 3181 return TB_OK; 3182 } 3183 3184 /* Change to the original: add deallocate parameter. [SR] */ 3185 static int tb_deinit(int deallocate) { 3186 if (global.caps[0] != NULL && global.wfd >= 0) { 3187 bytebuf_puts(&global.out, global.caps[TB_CAP_SHOW_CURSOR]); 3188 bytebuf_puts(&global.out, global.caps[TB_CAP_SGR0]); 3189 bytebuf_puts(&global.out, global.caps[TB_CAP_CLEAR_SCREEN]); 3190 bytebuf_puts(&global.out, global.caps[TB_CAP_EXIT_CA]); 3191 bytebuf_puts(&global.out, global.caps[TB_CAP_EXIT_KEYPAD]); 3192 bytebuf_puts(&global.out, TB_HARDCAP_EXIT_MOUSE); 3193 bytebuf_flush(&global.out, global.wfd); 3194 } 3195 if (global.ttyfd >= 0) { 3196 if (global.has_orig_tios) { 3197 tcsetattr(global.ttyfd, TCSAFLUSH, &global.orig_tios); 3198 } 3199 if (global.ttyfd_open) { 3200 close(global.ttyfd); 3201 global.ttyfd_open = 0; 3202 } 3203 } 3204 3205 struct sigaction sa; 3206 memset(&sa, 0, sizeof(sa)); 3207 sa.sa_handler = SIG_DFL; 3208 sigaction(SIGWINCH, &sa, NULL); 3209 if (global.resize_pipefd[0] >= 0) close(global.resize_pipefd[0]); 3210 if (global.resize_pipefd[1] >= 0) close(global.resize_pipefd[1]); 3211 3212 if (deallocate) 3213 { 3214 cellbuf_free(&global.back); 3215 cellbuf_free(&global.front); 3216 bytebuf_free(&global.in); 3217 bytebuf_free(&global.out); 3218 3219 if (global.terminfo) tb_free(global.terminfo); 3220 } 3221 3222 cap_trie_deinit(&global.cap_trie); 3223 3224 tb_reset(); 3225 return TB_OK; 3226 } 3227 3228 static int load_terminfo(void) { 3229 int rv; 3230 char tmp[TB_PATH_MAX]; 3231 3232 // See terminfo(5) "Fetching Compiled Descriptions" for a description of 3233 // this behavior. Some of these paths are compile-time ncurses options, so 3234 // best guesses are used here. 3235 const char *term = getenv("TERM"); 3236 if (!term) return TB_ERR; 3237 3238 // If TERMINFO is set, try that directory first 3239 const char *terminfo = getenv("TERMINFO"); 3240 if (terminfo) if_ok_return(rv, load_terminfo_from_path(terminfo, term)); 3241 3242 // Next try ~/.terminfo 3243 const char *home = getenv("HOME"); 3244 if (home) { 3245 snprintf_or_return(rv, tmp, sizeof(tmp), "%s/.terminfo", home); 3246 if_ok_return(rv, load_terminfo_from_path(tmp, term)); 3247 } 3248 3249 // Next try TERMINFO_DIRS 3250 // 3251 // Note, empty entries are supposed to be interpretted as the "compiled-in 3252 // default", which is of course system-dependent. Previously /etc/terminfo 3253 // was used here. Let's skip empty entries altogether rather than give 3254 // precedence to a guess, and check common paths after this loop. 3255 const char *dirs = getenv("TERMINFO_DIRS"); 3256 if (dirs) { 3257 snprintf_or_return(rv, tmp, sizeof(tmp), "%s", dirs); 3258 char *dir = strtok(tmp, ":"); 3259 while (dir) { 3260 const char *cdir = dir; 3261 if (*cdir != '\0') { 3262 if_ok_return(rv, load_terminfo_from_path(cdir, term)); 3263 } 3264 dir = strtok(NULL, ":"); 3265 } 3266 } 3267 3268 #ifdef TB_TERMINFO_DIR 3269 if_ok_return(rv, load_terminfo_from_path(TB_TERMINFO_DIR, term)); 3270 #endif 3271 if_ok_return(rv, load_terminfo_from_path("/usr/local/etc/terminfo", term)); 3272 if_ok_return(rv, 3273 load_terminfo_from_path("/usr/local/share/terminfo", term)); 3274 if_ok_return(rv, load_terminfo_from_path("/usr/local/lib/terminfo", term)); 3275 if_ok_return(rv, load_terminfo_from_path("/etc/terminfo", term)); 3276 if_ok_return(rv, load_terminfo_from_path("/usr/share/terminfo", term)); 3277 if_ok_return(rv, load_terminfo_from_path("/usr/lib/terminfo", term)); 3278 if_ok_return(rv, load_terminfo_from_path("/usr/share/lib/terminfo", term)); 3279 if_ok_return(rv, load_terminfo_from_path("/lib/terminfo", term)); 3280 3281 return TB_ERR; 3282 } 3283 3284 static int load_terminfo_from_path(const char *path, const char *term) { 3285 int rv; 3286 char tmp[TB_PATH_MAX]; 3287 3288 // Look for term at this terminfo location, e.g., <terminfo>/x/xterm 3289 snprintf_or_return(rv, tmp, sizeof(tmp), "%s/%c/%s", path, term[0], term); 3290 if_ok_return(rv, read_terminfo_path(tmp)); 3291 3292 #ifdef __APPLE__ 3293 // Try the Darwin equivalent path, e.g., <terminfo>/78/xterm 3294 snprintf_or_return(rv, tmp, sizeof(tmp), "%s/%x/%s", path, term[0], term); 3295 return read_terminfo_path(tmp); 3296 #endif 3297 3298 return TB_ERR; 3299 } 3300 3301 #ifdef __OpenBSD__ 3302 static int unveil_single_path(const char* term, const char* path) { 3303 int rv; 3304 char tmp[TB_PATH_MAX]; 3305 snprintf_or_return(rv, tmp, sizeof(tmp), "%s/%c/%s", path, term[0], term); 3306 return unveil(tmp, "r"); 3307 } 3308 3309 static int unveil_terminfo_path(void) { 3310 int rv; 3311 char tmp[TB_PATH_MAX]; 3312 const char *term = NULL; 3313 const char *terminfo = NULL; 3314 const char *home = NULL; 3315 const char *dirs = NULL; 3316 3317 term = getenv("TERM"); 3318 if (!term) return TB_ERR; 3319 terminfo = getenv("TERMINFO"); 3320 if (terminfo) { 3321 rv = unveil_single_path(term, terminfo); 3322 if (!rv) return rv; 3323 } 3324 home = getenv("HOME"); 3325 if (home) { 3326 snprintf_or_return(rv, tmp, sizeof(tmp), "%s/.terminfo", home); 3327 rv = unveil_single_path(term, tmp); 3328 if (!rv) return rv; 3329 } 3330 dirs = getenv("TERMINFO_DIRS"); 3331 if (dirs) { 3332 char *dir = NULL; 3333 snprintf_or_return(rv, tmp, sizeof(tmp), "%s", dirs); 3334 dir = strtok(tmp, ":"); 3335 while (dir) { 3336 const char *cdir = dir; 3337 if (*cdir != '\0') { 3338 rv = unveil_single_path(term, cdir); 3339 if (!rv) return rv; 3340 } 3341 dir = strtok(NULL, ":"); 3342 } 3343 } 3344 #ifdef TB_TERMINFO_DIR 3345 rv = unveil_single_path(term, TB_TERMINFO_DIR); 3346 if (!rv) return rv; 3347 #endif 3348 rv = unveil_single_path(term, "/usr/local/etc/terminfo"); 3349 if (!rv) return rv; 3350 rv = unveil_single_path(term, "/usr/local/share/terminfo"); 3351 if (!rv) return rv; 3352 rv = unveil_single_path(term, "/usr/local/lib/terminfo"); 3353 if (!rv) return rv; 3354 rv = unveil_single_path(term, "/etc/terminfo"); 3355 if (!rv) return rv; 3356 rv = unveil_single_path(term, "/usr/share/terminfo"); 3357 if (!rv) return rv; 3358 rv = unveil_single_path(term, "/usr/lib/terminfo"); 3359 if (!rv) return rv; 3360 rv = unveil_single_path(term, "/usr/share/lib/terminfo"); 3361 if (!rv) return rv; 3362 rv = unveil_single_path(term, "/lib/terminfo"); 3363 if (!rv) return rv; 3364 3365 return -1; 3366 } 3367 #endif 3368 3369 static int read_terminfo_path(const char *path) { 3370 FILE *fp = fopen(path, "rb"); 3371 if (!fp) return TB_ERR; 3372 3373 struct stat st; 3374 if (fstat(fileno(fp), &st) != 0) { 3375 fclose(fp); 3376 return TB_ERR; 3377 } 3378 3379 size_t fsize = st.st_size; 3380 char *data = (char *)tb_malloc(fsize); 3381 if (!data) { 3382 fclose(fp); 3383 return TB_ERR; 3384 } 3385 3386 if (fread(data, 1, fsize, fp) != fsize) { 3387 fclose(fp); 3388 tb_free(data); 3389 return TB_ERR; 3390 } 3391 3392 global.terminfo = data; 3393 global.nterminfo = fsize; 3394 3395 fclose(fp); 3396 return TB_OK; 3397 } 3398 3399 static int parse_terminfo_caps(void) { 3400 // See term(5) "LEGACY STORAGE FORMAT" and "EXTENDED STORAGE FORMAT" for a 3401 // description of this behavior. 3402 3403 // Ensure there's at least a header's worth of data 3404 if (global.nterminfo < 6 * (int)sizeof(int16_t)) return TB_ERR; 3405 3406 int16_t magic_number, nbytes_names, nbytes_bools, num_ints, num_offsets, 3407 nbytes_strings; 3408 size_t nbytes_header = 6 * sizeof(int16_t); 3409 // header[0] the magic number (octal 0432 or 01036) 3410 // header[1] the size, in bytes, of the names section 3411 // header[2] the number of bytes in the boolean section 3412 // header[3] the number of short integers in the numbers section 3413 // header[4] the number of offsets (short integers) in the strings section 3414 // header[5] the size, in bytes, of the string table 3415 get_terminfo_int16(0 * sizeof(int16_t), &magic_number); 3416 get_terminfo_int16(1 * sizeof(int16_t), &nbytes_names); 3417 get_terminfo_int16(2 * sizeof(int16_t), &nbytes_bools); 3418 get_terminfo_int16(3 * sizeof(int16_t), &num_ints); 3419 get_terminfo_int16(4 * sizeof(int16_t), &num_offsets); 3420 get_terminfo_int16(5 * sizeof(int16_t), &nbytes_strings); 3421 3422 // Legacy ints are 16-bit, extended ints are 32-bit 3423 const int bytes_per_int = magic_number == 01036 ? 4 // 32-bit 3424 : 2; // 16-bit 3425 3426 // > Between the boolean section and the number section, a null byte will be 3427 // > inserted, if necessary, to ensure that the number section begins on an 3428 // > even byte 3429 const int align_offset = (nbytes_names + nbytes_bools) % 2 != 0 ? 1 : 0; 3430 3431 const int pos_str_offsets = 3432 nbytes_header // header (12 bytes) 3433 + nbytes_names // length of names section 3434 + nbytes_bools // length of boolean section 3435 + align_offset + 3436 (num_ints * bytes_per_int); // length of numbers section 3437 3438 const int pos_str_table = 3439 pos_str_offsets + 3440 (num_offsets * sizeof(int16_t)); // length of string offsets table 3441 3442 // Load caps 3443 int i; 3444 for (i = 0; i < TB_CAP__COUNT; i++) { 3445 const char *cap = get_terminfo_string(pos_str_offsets, num_offsets, 3446 pos_str_table, nbytes_strings, terminfo_cap_indexes[i]); 3447 if (!cap) { 3448 // Something is not right 3449 return TB_ERR; 3450 } 3451 global.caps[i] = cap; 3452 } 3453 3454 return TB_OK; 3455 } 3456 3457 static int load_builtin_caps(void) { 3458 int i, j; 3459 const char *term = getenv("TERM"); 3460 3461 if (!term) return TB_ERR_NO_TERM; 3462 3463 // Check for exact TERM match 3464 for (i = 0; builtin_terms[i].name != NULL; i++) { 3465 if (strcmp(term, builtin_terms[i].name) == 0) { 3466 for (j = 0; j < TB_CAP__COUNT; j++) { 3467 global.caps[j] = builtin_terms[i].caps[j]; 3468 } 3469 return TB_OK; 3470 } 3471 } 3472 3473 // Check for partial TERM or alias match 3474 for (i = 0; builtin_terms[i].name != NULL; i++) { 3475 if (strstr(term, builtin_terms[i].name) != NULL || 3476 (*(builtin_terms[i].alias) != '\0' && 3477 strstr(term, builtin_terms[i].alias) != NULL)) 3478 { 3479 for (j = 0; j < TB_CAP__COUNT; j++) { 3480 global.caps[j] = builtin_terms[i].caps[j]; 3481 } 3482 return TB_OK; 3483 } 3484 } 3485 3486 return TB_ERR_UNSUPPORTED_TERM; 3487 } 3488 3489 static const char *get_terminfo_string(int16_t offsets_pos, int16_t offsets_len, 3490 int16_t table_pos, int16_t table_size, int16_t index) { 3491 if (index >= offsets_len) { 3492 // An index beyond the offset table indicates absent 3493 // See `convert_strings` in tinfo `read_entry.c` 3494 return ""; 3495 } 3496 3497 int16_t table_offset; 3498 int table_offset_offset = (int)offsets_pos + (index * (int)sizeof(int16_t)); 3499 if (get_terminfo_int16(table_offset_offset, &table_offset) != TB_OK) { 3500 // offset beyond end of terminfo entry 3501 // Truncated/corrupt terminfo entry? 3502 return NULL; 3503 } 3504 3505 if (table_offset < 0 || table_offset >= table_size) { 3506 // A negative offset indicates absent 3507 // An offset beyond the string table indicates absent 3508 // See `convert_strings` in tinfo `read_entry.c` 3509 return ""; 3510 } 3511 3512 int str_offset = (int)table_pos + (int)table_offset; 3513 if (str_offset >= (int)global.nterminfo) { 3514 // string beyond end of terminfo entry 3515 // Truncated/corrupt terminfo entry? 3516 return NULL; 3517 } 3518 3519 return (const char *)(global.terminfo + str_offset); 3520 } 3521 3522 static int get_terminfo_int16(int offset, int16_t *val) { 3523 if (offset < 0 || offset + sizeof(int16_t) > global.nterminfo) { 3524 *val = -1; 3525 return TB_ERR; 3526 } 3527 memcpy(val, global.terminfo + offset, sizeof(int16_t)); 3528 return TB_OK; 3529 } 3530 3531 static int wait_event(struct tb_event *event, int timeout) { 3532 int rv; 3533 char buf[TB_OPT_READ_BUF]; 3534 3535 memset(event, 0, sizeof(*event)); 3536 if_ok_return(rv, extract_event(event)); 3537 3538 fd_set fds; 3539 struct timeval tv; 3540 tv.tv_sec = timeout / 1000; 3541 tv.tv_usec = (timeout - (tv.tv_sec * 1000)) * 1000; 3542 3543 do { 3544 FD_ZERO(&fds); 3545 FD_SET(global.rfd, &fds); 3546 FD_SET(global.resize_pipefd[0], &fds); 3547 3548 int maxfd = global.resize_pipefd[0] > global.rfd 3549 ? global.resize_pipefd[0] 3550 : global.rfd; 3551 3552 int select_rv = 3553 select(maxfd + 1, &fds, NULL, NULL, (timeout < 0) ? NULL : &tv); 3554 3555 if (select_rv < 0) { 3556 // Let EINTR/EAGAIN bubble up 3557 global.last_errno = errno; 3558 return TB_ERR_POLL; 3559 } else if (select_rv == 0) { 3560 return TB_ERR_NO_EVENT; 3561 } 3562 3563 int tty_has_events = (FD_ISSET(global.rfd, &fds)); 3564 int resize_has_events = (FD_ISSET(global.resize_pipefd[0], &fds)); 3565 3566 if (tty_has_events) { 3567 ssize_t read_rv = read(global.rfd, buf, sizeof(buf)); 3568 if (read_rv < 0) { 3569 global.last_errno = errno; 3570 return TB_ERR_READ; 3571 } else if (read_rv > 0) { 3572 bytebuf_nputs(&global.in, buf, read_rv); 3573 } 3574 } 3575 3576 if (resize_has_events) { 3577 int ignore = 0; 3578 read(global.resize_pipefd[0], &ignore, sizeof(ignore)); 3579 // TODO: Harden against errors encountered mid-resize 3580 if_err_return(rv, update_term_size()); 3581 if_err_return(rv, resize_cellbufs()); 3582 event->type = TB_EVENT_RESIZE; 3583 event->w = global.width; 3584 event->h = global.height; 3585 return TB_OK; 3586 } 3587 3588 memset(event, 0, sizeof(*event)); 3589 if_ok_return(rv, extract_event(event)); 3590 } while (timeout == -1); 3591 3592 return rv; 3593 } 3594 3595 static int extract_event(struct tb_event *event) { 3596 int rv; 3597 struct bytebuf *in = &global.in; 3598 3599 if (in->len == 0) return TB_ERR; 3600 3601 if (in->buf[0] == '\x1b') { 3602 // Escape sequence? 3603 // In TB_INPUT_ESC, skip if the buffer is a single escape char 3604 if (!((global.input_mode & TB_INPUT_ESC) && in->len == 1)) { 3605 if_ok_or_need_more_return(rv, extract_esc(event)); 3606 } 3607 3608 // Escape key? 3609 if (global.input_mode & TB_INPUT_ESC) { 3610 event->type = TB_EVENT_KEY; 3611 event->ch = 0; 3612 event->key = TB_KEY_ESC; 3613 event->mod = 0; 3614 bytebuf_shift(in, 1); 3615 return TB_OK; 3616 } 3617 3618 // Recurse for alt key 3619 event->mod |= TB_MOD_ALT; 3620 bytebuf_shift(in, 1); 3621 return extract_event(event); 3622 } 3623 3624 // ASCII control key? 3625 int is_ctrl = 3626 (uint16_t)in->buf[0] < TB_KEY_SPACE || in->buf[0] == TB_KEY_BACKSPACE2; 3627 if (is_ctrl) { 3628 event->type = TB_EVENT_KEY; 3629 event->ch = 0; 3630 event->key = (uint16_t)in->buf[0]; 3631 event->mod |= TB_MOD_CTRL; 3632 bytebuf_shift(in, 1); 3633 return TB_OK; 3634 } 3635 3636 // UTF-8? 3637 if (in->len >= (size_t)tb_utf8_char_length(in->buf[0])) { 3638 event->type = TB_EVENT_KEY; 3639 tb_utf8_char_to_unicode(&event->ch, in->buf); 3640 event->key = 0; 3641 bytebuf_shift(in, tb_utf8_char_length(in->buf[0])); 3642 return TB_OK; 3643 } 3644 3645 // Need more input 3646 return TB_ERR; 3647 } 3648 3649 static int extract_esc(struct tb_event *event) { 3650 int rv; 3651 if_ok_or_need_more_return(rv, extract_esc_user(event, 0)); 3652 if_ok_or_need_more_return(rv, extract_esc_cap(event)); 3653 if_ok_or_need_more_return(rv, extract_esc_mouse(event)); 3654 if_ok_or_need_more_return(rv, extract_esc_user(event, 1)); 3655 return TB_ERR; 3656 } 3657 3658 static int extract_esc_user(struct tb_event *event, int is_post) { 3659 int rv; 3660 size_t consumed = 0; 3661 struct bytebuf *in = &global.in; 3662 int (*fn)(struct tb_event *, size_t *); 3663 3664 fn = is_post ? global.fn_extract_esc_post : global.fn_extract_esc_pre; 3665 3666 if (!fn) return TB_ERR; 3667 3668 rv = fn(event, &consumed); 3669 if (rv == TB_OK) bytebuf_shift(in, consumed); 3670 3671 if_ok_or_need_more_return(rv, rv); 3672 return TB_ERR; 3673 } 3674 3675 static int extract_esc_cap(struct tb_event *event) { 3676 int rv; 3677 struct bytebuf *in = &global.in; 3678 struct cap_trie *node; 3679 size_t depth; 3680 3681 if_err_return(rv, cap_trie_find(in->buf, in->len, &node, &depth)); 3682 if (node->is_leaf) { 3683 // Found a leaf node 3684 event->type = TB_EVENT_KEY; 3685 event->ch = 0; 3686 event->key = node->key; 3687 event->mod = node->mod; 3688 bytebuf_shift(in, depth); 3689 return TB_OK; 3690 } else if (node->nchildren > 0 && in->len <= depth) { 3691 // Found a branch node (not enough input) 3692 return TB_ERR_NEED_MORE; 3693 } 3694 3695 return TB_ERR; 3696 } 3697 3698 static int extract_esc_mouse(struct tb_event *event) { 3699 struct bytebuf *in = &global.in; 3700 size_t buf_shift = 0; 3701 3702 // Bail if not enough to determine type 3703 if (in->len < 2) { 3704 return TB_ERR_NEED_MORE; 3705 } else if (in->buf[1] != '[') { 3706 return TB_ERR; 3707 } else if (in->len < 3) { 3708 return TB_ERR_NEED_MORE; 3709 } 3710 3711 // Discern type of mouse event from 3rd byte 3712 int type = 0; 3713 enum { TYPE_VT200 = 0, TYPE_1006, TYPE_1015, TYPE_MAX }; 3714 if (in->buf[2] == 'M') { 3715 // X10 mouse encoding, the simplest one 3716 // \x1b [ M Cb Cx Cy 3717 type = TYPE_VT200; 3718 } else if (in->buf[2] == '<') { 3719 // xterm 1006 extended mode or urxvt 1015 extended mode 3720 // xterm: \x1b [ < Cb ; Cx ; Cy (M or m) 3721 type = TYPE_1006; 3722 } else { 3723 // urxvt: \x1b [ Cb ; Cx ; Cy M 3724 type = TYPE_1015; 3725 } 3726 3727 switch (type) { 3728 case TYPE_VT200: { 3729 // In this mode, we need 6 bytes 3730 if (in->len < 6) return TB_ERR_NEED_MORE; 3731 3732 int b = in->buf[3] - 0x20; 3733 3734 switch (b & 3) { 3735 case 0: 3736 event->key = ((b & 64) != 0) ? TB_KEY_MOUSE_WHEEL_UP 3737 : TB_KEY_MOUSE_LEFT; 3738 break; 3739 case 1: 3740 event->key = ((b & 64) != 0) ? TB_KEY_MOUSE_WHEEL_DOWN 3741 : TB_KEY_MOUSE_MIDDLE; 3742 break; 3743 case 2: 3744 event->key = TB_KEY_MOUSE_RIGHT; 3745 break; 3746 case 3: 3747 event->key = TB_KEY_MOUSE_RELEASE; 3748 break; 3749 default: 3750 return TB_ERR; 3751 } 3752 3753 if ((b & 32) != 0) event->mod |= TB_MOD_MOTION; 3754 3755 // the coord is 1,1 for upper left 3756 event->x = ((uint8_t)in->buf[4]) - 0x21; 3757 event->y = ((uint8_t)in->buf[5]) - 0x21; 3758 3759 // Eat 6 bytes 3760 buf_shift = 6; 3761 break; 3762 } 3763 3764 case TYPE_1006: 3765 // fallthrough 3766 3767 case TYPE_1015: { 3768 int num[3] = {-1, -1, -1}; 3769 int num_i = 0; 3770 int cur_num = -1; 3771 char trail = ' '; 3772 3773 size_t i = 2; 3774 if (type == TYPE_1006) ++i; // skip '<' 3775 3776 // Parse %d;%d;%d[mM] into `num` 3777 while (i < in->len && num_i < 3) { 3778 char c = in->buf[i]; 3779 if (c >= '0' && c <= '9') { 3780 // Digit 3781 if (cur_num == -1) cur_num = 0; 3782 cur_num *= 10; 3783 cur_num += (int)(c - '0'); 3784 } else if (cur_num != -1 && 3785 ((num_i < 2 && c == ';') || 3786 (num_i == 2 && (c == 'm' || c == 'M')))) 3787 { 3788 // We're at a semi-colon, 'm', or 'M' 3789 // and we have a number 3790 num[num_i] = cur_num; 3791 ++num_i; 3792 cur_num = -1; 3793 trail = c; 3794 } else { 3795 // Something else; not a mouse event 3796 return TB_ERR; 3797 } 3798 ++i; 3799 } 3800 3801 // If we didn't get to the 3rd number, we need more 3802 if (num[2] == -1) return TB_ERR_NEED_MORE; 3803 3804 // We have a valid mouse event, eat `i` bytes from the buffer 3805 buf_shift = i; 3806 3807 if (type == TYPE_1015) num[0] -= 0x20; 3808 3809 switch (num[0] & 3) { 3810 case 0: 3811 event->key = ((num[0] & 64) != 0) ? TB_KEY_MOUSE_WHEEL_UP 3812 : TB_KEY_MOUSE_LEFT; 3813 break; 3814 case 1: 3815 event->key = ((num[0] & 64) != 0) ? TB_KEY_MOUSE_WHEEL_DOWN 3816 : TB_KEY_MOUSE_MIDDLE; 3817 break; 3818 case 2: 3819 event->key = TB_KEY_MOUSE_RIGHT; 3820 break; 3821 case 3: 3822 event->key = TB_KEY_MOUSE_RELEASE; 3823 break; 3824 default: 3825 return TB_ERR; 3826 } 3827 3828 // on xterm mouse release is signaled by lowercase m 3829 if (trail == 'm') event->key = TB_KEY_MOUSE_RELEASE; 3830 3831 if ((num[0] & 32) != 0) event->mod |= TB_MOD_MOTION; 3832 3833 event->x = (num[1] - 1 < 0) ? 0 : num[1] - 1; 3834 event->y = (num[2] - 1 < 0) ? 0 : num[2] - 1; 3835 3836 break; 3837 } 3838 } 3839 3840 if (buf_shift > 0) bytebuf_shift(in, buf_shift); 3841 3842 event->type = TB_EVENT_MOUSE; 3843 3844 return TB_OK; 3845 } 3846 3847 static int resize_cellbufs(void) { 3848 int rv; 3849 if_err_return(rv, 3850 cellbuf_resize(&global.back, global.width, global.height)); 3851 if_err_return(rv, 3852 cellbuf_resize(&global.front, global.width, global.height)); 3853 if_err_return(rv, cellbuf_clear(&global.front)); 3854 if_err_return(rv, send_clear()); 3855 return TB_OK; 3856 } 3857 3858 static void handle_resize(int sig) { 3859 int errno_copy = errno; 3860 write(global.resize_pipefd[1], &sig, sizeof(sig)); 3861 errno = errno_copy; 3862 } 3863 3864 static int send_attr(uintattr_t fg, uintattr_t bg) { 3865 int rv; 3866 3867 if (fg == global.last_fg && bg == global.last_bg) { 3868 return TB_OK; 3869 } 3870 3871 if_err_return(rv, bytebuf_puts(&global.out, global.caps[TB_CAP_SGR0])); 3872 3873 uint32_t cfg, cbg; 3874 switch (global.output_mode) { 3875 default: 3876 case TB_OUTPUT_NORMAL: 3877 // The minus 1 below is because our colors are 1-indexed starting 3878 // from black. Black is represented by a 30, 40, 90, or 100 for fg, 3879 // bg, bright fg, or bright bg respectively. Red is 31, 41, 91, 3880 // 101, etc. 3881 cfg = (fg & TB_BRIGHT ? 90 : 30) + (fg & 0x0f) - 1; 3882 cbg = (bg & TB_BRIGHT ? 100 : 40) + (bg & 0x0f) - 1; 3883 break; 3884 3885 case TB_OUTPUT_256: 3886 cfg = fg & 0xff; 3887 cbg = bg & 0xff; 3888 if (fg & TB_HI_BLACK) cfg = 0; 3889 if (bg & TB_HI_BLACK) cbg = 0; 3890 break; 3891 3892 case TB_OUTPUT_216: 3893 cfg = fg & 0xff; 3894 cbg = bg & 0xff; 3895 if (cfg > 216) cfg = 216; 3896 if (cbg > 216) cbg = 216; 3897 cfg += 0x0f; 3898 cbg += 0x0f; 3899 break; 3900 3901 case TB_OUTPUT_GRAYSCALE: 3902 cfg = fg & 0xff; 3903 cbg = bg & 0xff; 3904 if (cfg > 24) cfg = 24; 3905 if (cbg > 24) cbg = 24; 3906 cfg += 0xe7; 3907 cbg += 0xe7; 3908 break; 3909 3910 #if TB_OPT_ATTR_W >= 32 3911 case TB_OUTPUT_TRUECOLOR: 3912 cfg = fg & 0xffffff; 3913 cbg = bg & 0xffffff; 3914 if (fg & TB_HI_BLACK) cfg = 0; 3915 if (bg & TB_HI_BLACK) cbg = 0; 3916 break; 3917 #endif 3918 } 3919 3920 if (fg & TB_BOLD) 3921 if_err_return(rv, bytebuf_puts(&global.out, global.caps[TB_CAP_BOLD])); 3922 3923 if (fg & TB_BLINK) 3924 if_err_return(rv, bytebuf_puts(&global.out, global.caps[TB_CAP_BLINK])); 3925 3926 if (fg & TB_UNDERLINE) 3927 if_err_return(rv, 3928 bytebuf_puts(&global.out, global.caps[TB_CAP_UNDERLINE])); 3929 3930 if (fg & TB_ITALIC) 3931 if_err_return(rv, 3932 bytebuf_puts(&global.out, global.caps[TB_CAP_ITALIC])); 3933 3934 if (fg & TB_DIM) 3935 if_err_return(rv, bytebuf_puts(&global.out, global.caps[TB_CAP_DIM])); 3936 3937 #if TB_OPT_ATTR_W == 64 3938 if (fg & TB_STRIKEOUT) 3939 if_err_return(rv, bytebuf_puts(&global.out, TB_HARDCAP_STRIKEOUT)); 3940 3941 if (fg & TB_UNDERLINE_2) 3942 if_err_return(rv, bytebuf_puts(&global.out, TB_HARDCAP_UNDERLINE_2)); 3943 3944 if (fg & TB_OVERLINE) 3945 if_err_return(rv, bytebuf_puts(&global.out, TB_HARDCAP_OVERLINE)); 3946 3947 if (fg & TB_INVISIBLE) 3948 if_err_return(rv, 3949 bytebuf_puts(&global.out, global.caps[TB_CAP_INVISIBLE])); 3950 #endif 3951 3952 if ((fg & TB_REVERSE) || (bg & TB_REVERSE)) 3953 if_err_return(rv, 3954 bytebuf_puts(&global.out, global.caps[TB_CAP_REVERSE])); 3955 3956 int fg_is_default = (fg & 0xff) == 0; 3957 int bg_is_default = (bg & 0xff) == 0; 3958 if (global.output_mode == TB_OUTPUT_256) { 3959 if (fg & TB_HI_BLACK) fg_is_default = 0; 3960 if (bg & TB_HI_BLACK) bg_is_default = 0; 3961 } 3962 #if TB_OPT_ATTR_W >= 32 3963 if (global.output_mode == TB_OUTPUT_TRUECOLOR) { 3964 fg_is_default = ((fg & 0xffffff) == 0) && ((fg & TB_HI_BLACK) == 0); 3965 bg_is_default = ((bg & 0xffffff) == 0) && ((bg & TB_HI_BLACK) == 0); 3966 } 3967 #endif 3968 3969 if_err_return(rv, send_sgr(cfg, cbg, fg_is_default, bg_is_default)); 3970 3971 global.last_fg = fg; 3972 global.last_bg = bg; 3973 3974 return TB_OK; 3975 } 3976 3977 static int send_sgr(uint32_t cfg, uint32_t cbg, int fg_is_default, 3978 int bg_is_default) { 3979 int rv; 3980 char nbuf[32]; 3981 3982 if (fg_is_default && bg_is_default) { 3983 return TB_OK; 3984 } 3985 3986 switch (global.output_mode) { 3987 default: 3988 case TB_OUTPUT_NORMAL: 3989 send_literal(rv, "\x1b["); 3990 if (!fg_is_default) { 3991 send_num(rv, nbuf, cfg); 3992 if (!bg_is_default) { 3993 send_literal(rv, ";"); 3994 } 3995 } 3996 if (!bg_is_default) { 3997 send_num(rv, nbuf, cbg); 3998 } 3999 send_literal(rv, "m"); 4000 break; 4001 4002 case TB_OUTPUT_256: 4003 case TB_OUTPUT_216: 4004 case TB_OUTPUT_GRAYSCALE: 4005 send_literal(rv, "\x1b["); 4006 if (!fg_is_default) { 4007 send_literal(rv, "38;5;"); 4008 send_num(rv, nbuf, cfg); 4009 if (!bg_is_default) { 4010 send_literal(rv, ";"); 4011 } 4012 } 4013 if (!bg_is_default) { 4014 send_literal(rv, "48;5;"); 4015 send_num(rv, nbuf, cbg); 4016 } 4017 send_literal(rv, "m"); 4018 break; 4019 4020 #if TB_OPT_ATTR_W >= 32 4021 case TB_OUTPUT_TRUECOLOR: 4022 send_literal(rv, "\x1b["); 4023 if (!fg_is_default) { 4024 send_literal(rv, "38;2;"); 4025 send_num(rv, nbuf, (cfg >> 16) & 0xff); 4026 send_literal(rv, ";"); 4027 send_num(rv, nbuf, (cfg >> 8) & 0xff); 4028 send_literal(rv, ";"); 4029 send_num(rv, nbuf, cfg & 0xff); 4030 if (!bg_is_default) { 4031 send_literal(rv, ";"); 4032 } 4033 } 4034 if (!bg_is_default) { 4035 send_literal(rv, "48;2;"); 4036 send_num(rv, nbuf, (cbg >> 16) & 0xff); 4037 send_literal(rv, ";"); 4038 send_num(rv, nbuf, (cbg >> 8) & 0xff); 4039 send_literal(rv, ";"); 4040 send_num(rv, nbuf, cbg & 0xff); 4041 } 4042 send_literal(rv, "m"); 4043 break; 4044 #endif 4045 } 4046 return TB_OK; 4047 } 4048 4049 static int send_cursor_if(int x, int y) { 4050 int rv; 4051 char nbuf[32]; 4052 if (x < 0 || y < 0) { 4053 return TB_OK; 4054 } 4055 send_literal(rv, "\x1b["); 4056 send_num(rv, nbuf, y + 1); 4057 send_literal(rv, ";"); 4058 send_num(rv, nbuf, x + 1); 4059 send_literal(rv, "H"); 4060 return TB_OK; 4061 } 4062 4063 static int send_char(int x, int y, uint32_t ch) { 4064 return send_cluster(x, y, &ch, 1); 4065 } 4066 4067 static int send_cluster(int x, int y, uint32_t *ch, size_t nch) { 4068 int rv; 4069 char chu8[8]; 4070 4071 if (global.last_x != x - 1 || global.last_y != y) { 4072 if_err_return(rv, send_cursor_if(x, y)); 4073 } 4074 global.last_x = x; 4075 global.last_y = y; 4076 4077 int i; 4078 for (i = 0; i < (int)nch; i++) { 4079 uint32_t ch32 = *(ch + i); 4080 if (!tb_iswprint(ch32)) { 4081 ch32 = 0xfffd; // replace non-printable codepoints with U+FFFD 4082 } 4083 int chu8_len = tb_utf8_unicode_to_char(chu8, ch32); 4084 if_err_return(rv, bytebuf_nputs(&global.out, chu8, (size_t)chu8_len)); 4085 } 4086 4087 return TB_OK; 4088 } 4089 4090 static int convert_num(uint32_t num, char *buf) { 4091 int i, l = 0; 4092 char ch; 4093 do { 4094 buf[l++] = (char)('0' + (num % 10)); 4095 num /= 10; 4096 } while (num); 4097 for (i = 0; i < l / 2; i++) { 4098 ch = buf[i]; 4099 buf[i] = buf[l - 1 - i]; 4100 buf[l - 1 - i] = ch; 4101 } 4102 return l; 4103 } 4104 4105 static int cell_cmp(struct tb_cell *a, struct tb_cell *b) { 4106 if (a->ch != b->ch || a->fg != b->fg || a->bg != b->bg) { 4107 return 1; 4108 } 4109 #ifdef TB_OPT_EGC 4110 if (a->nech != b->nech) { 4111 return 1; 4112 } else if (a->nech > 0) { // a->nech == b->nech 4113 return memcmp(a->ech, b->ech, a->nech); 4114 } 4115 #endif 4116 return 0; 4117 } 4118 4119 static int cell_copy(struct tb_cell *dst, struct tb_cell *src) { 4120 #ifdef TB_OPT_EGC 4121 if (src->nech > 0) { 4122 return cell_set(dst, src->ech, src->nech, src->fg, src->bg); 4123 } 4124 #endif 4125 return cell_set(dst, &src->ch, 1, src->fg, src->bg); 4126 } 4127 4128 static int cell_set(struct tb_cell *cell, uint32_t *ch, size_t nch, 4129 uintattr_t fg, uintattr_t bg) { 4130 // TODO: iswprint ch? 4131 cell->ch = ch ? *ch : 0; 4132 cell->fg = fg; 4133 cell->bg = bg; 4134 #ifdef TB_OPT_EGC 4135 if (nch <= 1) { 4136 cell->nech = 0; 4137 } else { 4138 int rv; 4139 if_err_return(rv, cell_reserve_ech(cell, nch + 1)); 4140 memcpy(cell->ech, ch, sizeof(*ch) * nch); 4141 cell->ech[nch] = '\0'; 4142 cell->nech = nch; 4143 } 4144 #else 4145 (void)nch; 4146 (void)cell_reserve_ech; 4147 #endif 4148 return TB_OK; 4149 } 4150 4151 static int cell_reserve_ech(struct tb_cell *cell, size_t n) { 4152 #ifdef TB_OPT_EGC 4153 if (cell->cech >= n) return TB_OK; 4154 cell->ech = (uint32_t *)tb_realloc(cell->ech, n * sizeof(cell->ch)); 4155 if (!cell->ech) return TB_ERR_MEM; 4156 cell->cech = n; 4157 return TB_OK; 4158 #else 4159 (void)cell; 4160 (void)n; 4161 return TB_ERR; 4162 #endif 4163 } 4164 4165 static int cell_free(struct tb_cell *cell) { 4166 #ifdef TB_OPT_EGC 4167 if (cell->ech) tb_free(cell->ech); 4168 #endif 4169 memset(cell, 0, sizeof(*cell)); 4170 return TB_OK; 4171 } 4172 4173 static int cellbuf_init(struct cellbuf *c, int w, int h) { 4174 c->cells = (struct tb_cell *)tb_malloc(sizeof(struct tb_cell) * w * h); 4175 if (!c->cells) return TB_ERR_MEM; 4176 memset(c->cells, 0, sizeof(struct tb_cell) * w * h); 4177 c->width = w; 4178 c->height = h; 4179 return TB_OK; 4180 } 4181 4182 static int cellbuf_free(struct cellbuf *c) { 4183 if (c->cells) { 4184 int i; 4185 for (i = 0; i < c->width * c->height; i++) { 4186 cell_free(&c->cells[i]); 4187 } 4188 tb_free(c->cells); 4189 } 4190 memset(c, 0, sizeof(*c)); 4191 return TB_OK; 4192 } 4193 4194 static int cellbuf_clear(struct cellbuf *c) { 4195 int rv, i; 4196 uint32_t space = (uint32_t)' '; 4197 for (i = 0; i < c->width * c->height; i++) { 4198 if_err_return(rv, 4199 cell_set(&c->cells[i], &space, 1, global.fg, global.bg)); 4200 } 4201 return TB_OK; 4202 } 4203 4204 static int cellbuf_get(struct cellbuf *c, int x, int y, 4205 struct tb_cell **out) { 4206 if (!cellbuf_in_bounds(c, x, y)) { 4207 *out = NULL; 4208 return TB_ERR_OUT_OF_BOUNDS; 4209 } 4210 *out = &c->cells[(y * c->width) + x]; 4211 return TB_OK; 4212 } 4213 4214 static int cellbuf_in_bounds(struct cellbuf *c, int x, int y) { 4215 if (x < 0 || x >= c->width || y < 0 || y >= c->height) { 4216 return 0; 4217 } 4218 return 1; 4219 } 4220 4221 static int cellbuf_resize(struct cellbuf *c, int w, int h) { 4222 int rv; 4223 4224 int ow = c->width; 4225 int oh = c->height; 4226 4227 if (ow == w && oh == h) { 4228 return TB_OK; 4229 } 4230 4231 w = w < 1 ? 1 : w; 4232 h = h < 1 ? 1 : h; 4233 4234 int minw = (w < ow) ? w : ow; 4235 int minh = (h < oh) ? h : oh; 4236 4237 struct tb_cell *prev = c->cells; 4238 4239 if_err_return(rv, cellbuf_init(c, w, h)); 4240 if_err_return(rv, cellbuf_clear(c)); 4241 4242 int x, y; 4243 for (x = 0; x < minw; x++) { 4244 for (y = 0; y < minh; y++) { 4245 struct tb_cell *src, *dst; 4246 src = &prev[(y * ow) + x]; 4247 if_err_return(rv, cellbuf_get(c, x, y, &dst)); 4248 if_err_return(rv, cell_copy(dst, src)); 4249 } 4250 } 4251 4252 tb_free(prev); 4253 4254 return TB_OK; 4255 } 4256 4257 static int bytebuf_puts(struct bytebuf *b, const char *str) { 4258 if (!str || strlen(str) <= 0) return TB_OK; // Nothing to do for empty caps 4259 return bytebuf_nputs(b, str, (size_t)strlen(str)); 4260 } 4261 4262 static int bytebuf_nputs(struct bytebuf *b, const char *str, size_t nstr) { 4263 int rv; 4264 if_err_return(rv, bytebuf_reserve(b, b->len + nstr + 1)); 4265 memcpy(b->buf + b->len, str, nstr); 4266 b->len += nstr; 4267 b->buf[b->len] = '\0'; 4268 return TB_OK; 4269 } 4270 4271 static int bytebuf_shift(struct bytebuf *b, size_t n) { 4272 if (n > b->len) n = b->len; 4273 size_t nmove = b->len - n; 4274 memmove(b->buf, b->buf + n, nmove); 4275 b->len -= n; 4276 return TB_OK; 4277 } 4278 4279 static int bytebuf_flush(struct bytebuf *b, int fd) { 4280 if (b->len <= 0) return TB_OK; 4281 ssize_t write_rv = write(fd, b->buf, b->len); 4282 if (write_rv < 0 || (size_t)write_rv != b->len) { 4283 // Note, errno will be 0 on partial write 4284 global.last_errno = errno; 4285 return TB_ERR; 4286 } 4287 b->len = 0; 4288 return TB_OK; 4289 } 4290 4291 static int bytebuf_reserve(struct bytebuf *b, size_t sz) { 4292 if (b->cap >= sz) return TB_OK; 4293 4294 size_t newcap = b->cap > 0 ? b->cap : 1; 4295 while (newcap < sz) { 4296 newcap *= 2; 4297 } 4298 4299 char *newbuf; 4300 if (b->buf) { 4301 newbuf = (char *)tb_realloc(b->buf, newcap); 4302 } else { 4303 newbuf = (char *)tb_malloc(newcap); 4304 } 4305 if (!newbuf) return TB_ERR_MEM; 4306 4307 b->buf = newbuf; 4308 b->cap = newcap; 4309 return TB_OK; 4310 } 4311 4312 static int bytebuf_free(struct bytebuf *b) { 4313 if (b->buf) tb_free(b->buf); 4314 memset(b, 0, sizeof(*b)); 4315 return TB_OK; 4316 } 4317 4318 int tb_iswprint(uint32_t ch) { 4319 #ifdef TB_OPT_LIBC_WCHAR 4320 return iswprint((wint_t)ch); 4321 #else 4322 return tb_iswprint_ex(ch, NULL); 4323 #endif 4324 } 4325 4326 int tb_wcwidth(uint32_t ch) { 4327 int w; 4328 #ifdef TB_OPT_LIBC_WCHAR 4329 w = wcwidth((wchar_t)ch); 4330 #else 4331 tb_iswprint_ex(ch, &w); 4332 #endif 4333 return w; 4334 } 4335 4336 static int tb_cluster_width(uint32_t *ch, size_t nch) { 4337 int wmax = -1; 4338 int vs15 = 0, vs16 = 0, ri = 0, zwj = 0; 4339 size_t i = 0; 4340 for (i = 0; i < nch; i++) { 4341 uint32_t c = ch[i]; 4342 switch (c) { 4343 case 0xfe0e: ++vs15; break; 4344 case 0xfe0f: ++vs16; break; 4345 case 0x200d: ++zwj; break; 4346 default: if (c >= 0x1f1e6 && c <= 0x1f1ff) ++ri; 4347 } 4348 int w = tb_wcwidth(c); 4349 if (w > wmax) wmax = w; 4350 } 4351 if (wmax >= 1) { 4352 if (vs15) return 1; 4353 else if (vs16 || zwj || ri >= 2) return 2; 4354 } 4355 return wmax; 4356 } 4357 4358 static int tb_iswprint_ex(uint32_t ch, int *w) { 4359 #ifdef TB_OPT_LIBC_WCHAR 4360 if (w) *w = wcwidth((wint_t)ch); 4361 return iswprint(ch); 4362 #else 4363 // Fast path for 1-byte codepoints 4364 if ((ch >= 0x20 && ch <= 0x7e) || (ch >= 0xa0 && ch <= 0xff)) { 4365 if (w) *w = 1; 4366 return 1; 4367 } else if (ch <= 0xff) { 4368 if (w) *w = ch == 0 ? 0 : -1; 4369 return 0; 4370 } 4371 4372 int lo = 0, hi = WCWIDTH_TABLE_LENGTH - 1; 4373 while (lo <= hi) { 4374 int i = (lo + hi) / 2; 4375 if (ch < wcwidth_table[i].range_start) { 4376 hi = i - 1; 4377 } else if (ch > wcwidth_table[i].range_end) { 4378 lo = i + 1; 4379 } else { 4380 if (w) *w = wcwidth_table[i].width; 4381 return wcwidth_table[i].width >= 0 ? 1 : 0; 4382 } 4383 } 4384 if (w) *w = -1; // Invalid codepoint 4385 return 0; 4386 #endif 4387 } 4388 4389 #endif // TB_IMPL