sys/teken/teken.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * $FreeBSD$
  29  */
  30
  31 #include <sys/cdefs.h>
  32 #if defined(__FreeBSD__) && defined(_KERNEL)
  33 #include <sys/param.h>
  34 #include <sys/limits.h>
  35 #include <sys/lock.h>
  36 #include <sys/systm.h>
  37 #define teken_assert(x)         MPASS(x)
  38 #else /* !(__FreeBSD__ && _KERNEL) */
  39 #include <sys/types.h>
  40 #include <assert.h>
  41 #include <limits.h>
  42 #include <stdint.h>
  43 #include <stdio.h>
  44 #include <string.h>
  45 #define teken_assert(x)         assert(x)
  46 #endif /* __FreeBSD__ && _KERNEL */
  47
  48 /* debug messages */
  49 #define teken_printf(x,...)
  50
  51 /* Private flags for t_stateflags. */
  52 #define TS_FIRSTDIGIT   0x0001  /* First numeric digit in escape sequence. */
  53 #define TS_INSERT       0x0002  /* Insert mode. */
  54 #define TS_AUTOWRAP     0x0004  /* Autowrap. */
  55 #define TS_ORIGIN       0x0008  /* Origin mode. */
  56 #define TS_WRAPPED      0x0010  /* Next character should be printed on col 0. */
  57 #define TS_8BIT         0x0020  /* UTF-8 disabled. */
  58 #define TS_CONS25       0x0040  /* cons25 emulation. */
  59 #define TS_INSTRING     0x0080  /* Inside string. */
  60 #define TS_CURSORKEYS   0x0100  /* Cursor keys mode. */
  61 #define TS_CONS25KEYS   0x0400  /* Fuller cons25 emul (fix function keys). */
  62
  63 /* Character that blanks a cell. */
  64 #define BLANK   ' '
  65
  66 #include "teken.h"
  67 #include "teken_wcwidth.h"
  68 #include "teken_scs.h"
  69
  70 static teken_state_t    teken_state_init;
  71
  72 /*
  73  * Wrappers for hooks.
  74  */
  75
  76 static inline void
  77 teken_funcs_bell(const teken_t *t)
  78 {
  79
  80         teken_assert(t->t_funcs->tf_bell != NULL);
  81         t->t_funcs->tf_bell(t->t_softc);
  82 }
  83
  84 static inline void
  85 teken_funcs_cursor(const teken_t *t)
  86 {
  87
  88         teken_assert(t->t_cursor.tp_row < t->t_winsize.tp_row);
  89         teken_assert(t->t_cursor.tp_col < t->t_winsize.tp_col);
  90
  91         teken_assert(t->t_funcs->tf_cursor != NULL);
  92         t->t_funcs->tf_cursor(t->t_softc, &t->t_cursor);
  93 }
  94
  95 static inline void
  96 teken_funcs_putchar(const teken_t *t, const teken_pos_t *p, teken_char_t c,
  97     const teken_attr_t *a)
  98 {
  99
 100         teken_assert(p->tp_row < t->t_winsize.tp_row);
 101         teken_assert(p->tp_col < t->t_winsize.tp_col);
 102
 103         teken_assert(t->t_funcs->tf_putchar != NULL);
 104         t->t_funcs->tf_putchar(t->t_softc, p, c, a);
 105 }
 106
 107 static inline void
 108 teken_funcs_fill(const teken_t *t, const teken_rect_t *r,
 109     const teken_char_t c, const teken_attr_t *a)
 110 {
 111
 112         teken_assert(r->tr_end.tp_row > r->tr_begin.tp_row);
 113         teken_assert(r->tr_end.tp_row <= t->t_winsize.tp_row);
 114         teken_assert(r->tr_end.tp_col > r->tr_begin.tp_col);
 115         teken_assert(r->tr_end.tp_col <= t->t_winsize.tp_col);
 116
 117         teken_assert(t->t_funcs->tf_fill != NULL);
 118         t->t_funcs->tf_fill(t->t_softc, r, c, a);
 119 }
 120
 121 static inline void
 122 teken_funcs_copy(const teken_t *t, const teken_rect_t *r, const teken_pos_t *p)
 123 {
 124
 125         teken_assert(r->tr_end.tp_row > r->tr_begin.tp_row);
 126         teken_assert(r->tr_end.tp_row <= t->t_winsize.tp_row);
 127         teken_assert(r->tr_end.tp_col > r->tr_begin.tp_col);
 128         teken_assert(r->tr_end.tp_col <= t->t_winsize.tp_col);
 129         teken_assert(p->tp_row + (r->tr_end.tp_row - r->tr_begin.tp_row) <= t->t_winsize.tp_row);
 130         teken_assert(p->tp_col + (r->tr_end.tp_col - r->tr_begin.tp_col) <= t->t_winsize.tp_col);
 131
 132         teken_assert(t->t_funcs->tf_copy != NULL);
 133         t->t_funcs->tf_copy(t->t_softc, r, p);
 134 }
 135
 136 static inline void
 137 teken_funcs_pre_input(const teken_t *t)
 138 {
 139
 140         if (t->t_funcs->tf_pre_input != NULL)
 141                 t->t_funcs->tf_pre_input(t->t_softc);
 142 }
 143
 144 static inline void
 145 teken_funcs_post_input(const teken_t *t)
 146 {
 147
 148         if (t->t_funcs->tf_post_input != NULL)
 149                 t->t_funcs->tf_post_input(t->t_softc);
 150 }
 151
 152 static inline void
 153 teken_funcs_param(const teken_t *t, int cmd, unsigned int value)
 154 {
 155
 156         teken_assert(t->t_funcs->tf_param != NULL);
 157         t->t_funcs->tf_param(t->t_softc, cmd, value);
 158 }
 159
 160 static inline void
 161 teken_funcs_respond(const teken_t *t, const void *buf, size_t len)
 162 {
 163
 164         teken_assert(t->t_funcs->tf_respond != NULL);
 165         t->t_funcs->tf_respond(t->t_softc, buf, len);
 166 }
 167
 168 #include "teken_subr.h"
 169 #include "teken_subr_compat.h"
 170
 171 /*
 172  * Programming interface.
 173  */
 174
 175 void
 176 teken_init(teken_t *t, const teken_funcs_t *tf, void *softc)
 177 {
 178         teken_pos_t tp = { .tp_row = 24, .tp_col = 80 };
 179
 180         t->t_funcs = tf;
 181         t->t_softc = softc;
 182
 183         t->t_nextstate = teken_state_init;
 184         t->t_stateflags = 0;
 185         t->t_utf8_left = 0;
 186
 187         t->t_defattr.ta_format = 0;
 188         t->t_defattr.ta_fgcolor = TC_WHITE;
 189         t->t_defattr.ta_bgcolor = TC_BLACK;
 190         teken_subr_do_reset(t);
 191
 192         teken_set_winsize(t, &tp);
 193 }
 194
 195 static void
 196 teken_input_char(teken_t *t, teken_char_t c)
 197 {
 198
 199         /*
 200          * There is no support for DCS and OSC.  Just discard strings
 201          * until we receive characters that may indicate string
 202          * termination.
 203          */
 204         if (t->t_stateflags & TS_INSTRING) {
 205                 switch (c) {
 206                 case '\x1B':
 207                         t->t_stateflags &= ~TS_INSTRING;
 208                         break;
 209                 case '\a':
 210                         t->t_stateflags &= ~TS_INSTRING;
 211                         return;
 212                 default:
 213                         return;
 214                 }
 215         }
 216
 217         switch (c) {
 218         case '\0':
 219                 break;
 220         case '\a':
 221                 teken_subr_bell(t);
 222                 break;
 223         case '\b':
 224                 teken_subr_backspace(t);
 225                 break;
 226         case '\n':
 227         case '\x0B':
 228                 teken_subr_newline(t);
 229                 break;
 230         case '\x0C':
 231                 teken_subr_newpage(t);
 232                 break;
 233         case '\x0E':
 234                 if (t->t_stateflags & TS_CONS25)
 235                         t->t_nextstate(t, c);
 236                 else
 237                         t->t_curscs = 1;
 238                 break;
 239         case '\x0F':
 240                 if (t->t_stateflags & TS_CONS25)
 241                         t->t_nextstate(t, c);
 242                 else
 243                         t->t_curscs = 0;
 244                 break;
 245         case '\r':
 246                 teken_subr_carriage_return(t);
 247                 break;
 248         case '\t':
 249                 teken_subr_horizontal_tab(t);
 250                 break;
 251         default:
 252                 t->t_nextstate(t, c);
 253                 break;
 254         }
 255
 256         /* Post-processing assertions. */
 257         teken_assert(t->t_cursor.tp_row >= t->t_originreg.ts_begin);
 258         teken_assert(t->t_cursor.tp_row < t->t_originreg.ts_end);
 259         teken_assert(t->t_cursor.tp_row < t->t_winsize.tp_row);
 260         teken_assert(t->t_cursor.tp_col < t->t_winsize.tp_col);
 261         teken_assert(t->t_saved_cursor.tp_row < t->t_winsize.tp_row);
 262         teken_assert(t->t_saved_cursor.tp_col < t->t_winsize.tp_col);
 263         teken_assert(t->t_scrollreg.ts_end <= t->t_winsize.tp_row);
 264         teken_assert(t->t_scrollreg.ts_begin < t->t_scrollreg.ts_end);
 265         /* Origin region has to be window size or the same as scrollreg. */
 266         teken_assert((t->t_originreg.ts_begin == t->t_scrollreg.ts_begin &&
 267             t->t_originreg.ts_end == t->t_scrollreg.ts_end) ||
 268             (t->t_originreg.ts_begin == 0 &&
 269             t->t_originreg.ts_end == t->t_winsize.tp_row));
 270 }
 271
 272 static void
 273 teken_input_byte(teken_t *t, unsigned char c)
 274 {
 275
 276         /*
 277          * UTF-8 handling.
 278          */
 279         if ((c & 0x80) == 0x00 || t->t_stateflags & TS_8BIT) {
 280                 /* One-byte sequence. */
 281                 t->t_utf8_left = 0;
 282                 teken_input_char(t, c);
 283         } else if ((c & 0xe0) == 0xc0) {
 284                 /* Two-byte sequence. */
 285                 t->t_utf8_left = 1;
 286                 t->t_utf8_partial = c & 0x1f;
 287         } else if ((c & 0xf0) == 0xe0) {
 288                 /* Three-byte sequence. */
 289                 t->t_utf8_left = 2;
 290                 t->t_utf8_partial = c & 0x0f;
 291         } else if ((c & 0xf8) == 0xf0) {
 292                 /* Four-byte sequence. */
 293                 t->t_utf8_left = 3;
 294                 t->t_utf8_partial = c & 0x07;
 295         } else if ((c & 0xc0) == 0x80) {
 296                 if (t->t_utf8_left == 0)
 297                         return;
 298                 t->t_utf8_left--;
 299                 t->t_utf8_partial = (t->t_utf8_partial << 6) | (c & 0x3f);
 300                 if (t->t_utf8_left == 0) {
 301                         teken_printf("Got UTF-8 char %x\n", t->t_utf8_partial);
 302                         teken_input_char(t, t->t_utf8_partial);
 303                 }
 304         }
 305 }
 306
 307 void
 308 teken_input(teken_t *t, const void *buf, size_t len)
 309 {
 310         const char *c = buf;
 311
 312         teken_funcs_pre_input(t);
 313         while (len-- > 0)
 314                 teken_input_byte(t, *c++);
 315         teken_funcs_post_input(t);
 316 }
 317
 318 const teken_pos_t *
 319 teken_get_cursor(const teken_t *t)
 320 {
 321
 322         return (&t->t_cursor);
 323 }
 324
 325 void
 326 teken_set_cursor(teken_t *t, const teken_pos_t *p)
 327 {
 328
 329         /* XXX: bounds checking with originreg! */
 330         teken_assert(p->tp_row < t->t_winsize.tp_row);
 331         teken_assert(p->tp_col < t->t_winsize.tp_col);
 332
 333         t->t_cursor = *p;
 334 }
 335
 336 const teken_attr_t *
 337 teken_get_curattr(const teken_t *t)
 338 {
 339
 340         return (&t->t_curattr);
 341 }
 342
 343 void
 344 teken_set_curattr(teken_t *t, const teken_attr_t *a)
 345 {
 346
 347         t->t_curattr = *a;
 348 }
 349
 350 const teken_attr_t *
 351 teken_get_defattr(const teken_t *t)
 352 {
 353
 354         return (&t->t_defattr);
 355 }
 356
 357 void
 358 teken_set_defattr(teken_t *t, const teken_attr_t *a)
 359 {
 360
 361         t->t_curattr = t->t_saved_curattr = t->t_defattr = *a;
 362 }
 363
 364 const teken_pos_t *
 365 teken_get_winsize(const teken_t *t)
 366 {
 367
 368         return (&t->t_winsize);
 369 }
 370
 371 static void
 372 teken_trim_cursor_pos(teken_t *t, const teken_pos_t *new)
 373 {
 374         const teken_pos_t *cur;
 375
 376         cur = &t->t_winsize;
 377
 378         if (cur->tp_row < new->tp_row || cur->tp_col < new->tp_col)
 379                 return;
 380         if (t->t_cursor.tp_row >= new->tp_row)
 381                 t->t_cursor.tp_row = new->tp_row - 1;
 382         if (t->t_cursor.tp_col >= new->tp_col)
 383                 t->t_cursor.tp_col = new->tp_col - 1;
 384 }
 385
 386 void
 387 teken_set_winsize(teken_t *t, const teken_pos_t *p)
 388 {
 389
 390         teken_trim_cursor_pos(t, p);
 391         t->t_winsize = *p;
 392         teken_subr_do_reset(t);
 393 }
 394
 395 void
 396 teken_set_winsize_noreset(teken_t *t, const teken_pos_t *p)
 397 {
 398
 399         teken_trim_cursor_pos(t, p);
 400         t->t_winsize = *p;
 401         teken_subr_do_resize(t);
 402 }
 403
 404 void
 405 teken_set_8bit(teken_t *t)
 406 {
 407
 408         t->t_stateflags |= TS_8BIT;
 409 }
 410
 411 void
 412 teken_set_cons25(teken_t *t)
 413 {
 414
 415         t->t_stateflags |= TS_CONS25;
 416 }
 417
 418 void
 419 teken_set_cons25keys(teken_t *t)
 420 {
 421
 422         t->t_stateflags |= TS_CONS25KEYS;
 423 }
 424
 425 /*
 426  * State machine.
 427  */
 428
 429 static void
 430 teken_state_switch(teken_t *t, teken_state_t *s)
 431 {
 432
 433         t->t_nextstate = s;
 434         t->t_curnum = 0;
 435         t->t_stateflags |= TS_FIRSTDIGIT;
 436 }
 437
 438 static int
 439 teken_state_numbers(teken_t *t, teken_char_t c)
 440 {
 441
 442         teken_assert(t->t_curnum < T_NUMSIZE);
 443
 444         if (c >= '0' && c <= '9') {
 445                 if (t->t_stateflags & TS_FIRSTDIGIT) {
 446                         /* First digit. */
 447                         t->t_stateflags &= ~TS_FIRSTDIGIT;
 448                         t->t_nums[t->t_curnum] = c - '0';
 449                 } else if (t->t_nums[t->t_curnum] < UINT_MAX / 100) {
 450                         /*
 451                          * There is no need to continue parsing input
 452                          * once the value exceeds the size of the
 453                          * terminal. It would only allow for integer
 454                          * overflows when performing arithmetic on the
 455                          * cursor position.
 456                          *
 457                          * Ignore any further digits if the value is
 458                          * already UINT_MAX / 100.
 459                          */
 460                         t->t_nums[t->t_curnum] =
 461                             t->t_nums[t->t_curnum] * 10 + c - '0';
 462                 }
 463                 return (1);
 464         } else if (c == ';') {
 465                 if (t->t_stateflags & TS_FIRSTDIGIT)
 466                         t->t_nums[t->t_curnum] = 0;
 467
 468                 /* Only allow a limited set of arguments. */
 469                 if (++t->t_curnum == T_NUMSIZE) {
 470                         teken_state_switch(t, teken_state_init);
 471                         return (1);
 472                 }
 473
 474                 t->t_stateflags |= TS_FIRSTDIGIT;
 475                 return (1);
 476         } else {
 477                 if (t->t_stateflags & TS_FIRSTDIGIT && t->t_curnum > 0) {
 478                         /* Finish off the last empty argument. */
 479                         t->t_nums[t->t_curnum] = 0;
 480                         t->t_curnum++;
 481                 } else if ((t->t_stateflags & TS_FIRSTDIGIT) == 0) {
 482                         /* Also count the last argument. */
 483                         t->t_curnum++;
 484                 }
 485         }
 486
 487         return (0);
 488 }
 489
 490 #define k       TC_BLACK
 491 #define b       TC_BLUE
 492 #define y       TC_BROWN
 493 #define c       TC_CYAN
 494 #define g       TC_GREEN
 495 #define m       TC_MAGENTA
 496 #define r       TC_RED
 497 #define w       TC_WHITE
 498 #define K       (TC_BLACK | TC_LIGHT)
 499 #define B       (TC_BLUE | TC_LIGHT)
 500 #define Y       (TC_BROWN | TC_LIGHT)
 501 #define C       (TC_CYAN | TC_LIGHT)
 502 #define G       (TC_GREEN | TC_LIGHT)
 503 #define M       (TC_MAGENTA | TC_LIGHT)
 504 #define R       (TC_RED | TC_LIGHT)
 505 #define W       (TC_WHITE | TC_LIGHT)
 506
 507 /**
 508  * The xterm-256 color map has steps of 0x28 (in the range 0-0xff), except
 509  * for the first step which is 0x5f.  Scale to the range 0-6 by dividing
 510  * by 0x28 and rounding down.  The range of 0-5 cannot represent the
 511  * larger first step.
 512  *
 513  * This table is generated by the follow rules:
 514  * - if all components are equal, the result is black for (0, 0, 0) and
 515  *   (2, 2, 2), else white; otherwise:
 516  * - subtract the smallest component from all components
 517  * - if this gives only one nonzero component, then that is the color
 518  * - else if one component is 2 or more larger than the other nonzero one,
 519  *   then that component gives the color
 520  * - else there are 2 nonzero components.  The color is that of a small
 521  *   equal mixture of these components (cyan, yellow or magenta).  E.g.,
 522  *   (0, 5, 6) (Turquoise2) is a much purer cyan than (0, 2, 3)
 523  *   (DeepSkyBlue4), but we map both to cyan since we can't represent
 524  *   delicate shades of either blue or cyan and blue would be worse.
 525  *   Here it is important that components of 1 never occur.  Blue would
 526  *   be twice as large as green in (0, 1, 2).
 527  */
 528 static const teken_color_t teken_256to8tab[] = {
 529         /* xterm normal colors: */
 530         k, r, g, y, b, m, c, w,
 531
 532         /* xterm bright colors: */
 533         k, r, g, y, b, m, c, w,
 534
 535         /* Red0 submap. */
 536         k, b, b, b, b, b,
 537         g, c, c, b, b, b,
 538         g, c, c, c, b, b,
 539         g, g, c, c, c, b,
 540         g, g, g, c, c, c,
 541         g, g, g, g, c, c,
 542
 543         /* Red2 submap. */
 544         r, m, m, b, b, b,
 545         y, k, b, b, b, b,
 546         y, g, c, c, b, b,
 547         g, g, c, c, c, b,
 548         g, g, g, c, c, c,
 549         g, g, g, g, c, c,
 550
 551         /* Red3 submap. */
 552         r, m, m, m, b, b,
 553         y, r, m, m, b, b,
 554         y, y, w, b, b, b,
 555         y, y, g, c, c, b,
 556         g, g, g, c, c, c,
 557         g, g, g, g, c, c,
 558
 559         /* Red4 submap. */
 560         r, r, m, m, m, b,
 561         r, r, m, m, m, b,
 562         y, y, r, m, m, b,
 563         y, y, y, w, b, b,
 564         y, y, y, g, c, c,
 565         g, g, g, g, c, c,
 566
 567         /* Red5 submap. */
 568         r, r, r, m, m, m,
 569         r, r, r, m, m, m,
 570         r, r, r, m, m, m,
 571         y, y, y, r, m, m,
 572         y, y, y, y, w, b,
 573         y, y, y, y, g, c,
 574
 575         /* Red6 submap. */
 576         r, r, r, r, m, m,
 577         r, r, r, r, m, m,
 578         r, r, r, r, m, m,
 579         r, r, r, r, m, m,
 580         y, y, y, y, r, m,
 581         y, y, y, y, y, w,
 582
 583         /* Grey submap. */
 584         k, k, k, k, k, k,
 585         k, k, k, k, k, k,
 586         w, w, w, w, w, w,
 587         w, w, w, w, w, w,
 588 };
 589
 590 /*
 591  * This table is generated from the previous one by setting TC_LIGHT for
 592  * entries whose luminosity in the xterm256 color map is 60% or larger.
 593  * Thus the previous table is currently not really needed.  It will be
 594  * used for different fine tuning of the tables.
 595  */
 596 static const teken_color_t teken_256to16tab[] = {
 597         /* xterm normal colors: */
 598         k, r, g, y, b, m, c, w,
 599
 600         /* xterm bright colors: */
 601         K, R, G, Y, B, M, C, W,
 602
 603         /* Red0 submap. */
 604         k, b, b, b, b, b,
 605         g, c, c, b, b, b,
 606         g, c, c, c, b, b,
 607         g, g, c, c, c, b,
 608         g, g, g, c, c, c,
 609         g, g, g, g, c, c,
 610
 611         /* Red2 submap. */
 612         r, m, m, b, b, b,
 613         y, K, b, b, B, B,
 614         y, g, c, c, B, B,
 615         g, g, c, c, C, B,
 616         g, G, G, C, C, C,
 617         g, G, G, G, C, C,
 618
 619         /* Red3 submap. */
 620         r, m, m, m, b, b,
 621         y, r, m, m, B, B,
 622         y, y, w, B, B, B,
 623         y, y, G, C, C, B,
 624         g, G, G, C, C, C,
 625         g, G, G, G, C, C,
 626
 627         /* Red4 submap. */
 628         r, r, m, m, m, b,
 629         r, r, m, m, M, B,
 630         y, y, R, M, M, B,
 631         y, y, Y, W, B, B,
 632         y, Y, Y, G, C, C,
 633         g, G, G, G, C, C,
 634
 635         /* Red5 submap. */
 636         r, r, r, m, m, m,
 637         r, R, R, M, M, M,
 638         r, R, R, M, M, M,
 639         y, Y, Y, R, M, M,
 640         y, Y, Y, Y, W, B,
 641         y, Y, Y, Y, G, C,
 642
 643         /* Red6 submap. */
 644         r, r, r, r, m, m,
 645         r, R, R, R, M, M,
 646         r, R, R, R, M, M,
 647         r, R, R, R, M, M,
 648         y, Y, Y, Y, R, M,
 649         y, Y, Y, Y, Y, W,
 650
 651         /* Grey submap. */
 652         k, k, k, k, k, k,
 653         K, K, K, K, K, K,
 654         w, w, w, w, w, w,
 655         W, W, W, W, W, W,
 656 };
 657
 658 #undef  k
 659 #undef  b
 660 #undef  y
 661 #undef  c
 662 #undef  g
 663 #undef  m
 664 #undef  r
 665 #undef  w
 666 #undef  K
 667 #undef  B
 668 #undef  Y
 669 #undef  C
 670 #undef  G
 671 #undef  M
 672 #undef  R
 673 #undef  W
 674
 675 teken_color_t
 676 teken_256to8(teken_color_t c)
 677 {
 678
 679         return (teken_256to8tab[c % 256]);
 680 }
 681
 682 teken_color_t
 683 teken_256to16(teken_color_t c)
 684 {
 685
 686         return (teken_256to16tab[c % 256]);
 687 }
 688
 689 static const char * const special_strings_cons25[] = {
 690         [TKEY_UP] = "\x1B[A",           [TKEY_DOWN] = "\x1B[B",
 691         [TKEY_LEFT] = "\x1B[D",         [TKEY_RIGHT] = "\x1B[C",
 692
 693         [TKEY_HOME] = "\x1B[H",         [TKEY_END] = "\x1B[F",
 694         [TKEY_INSERT] = "\x1B[L",       [TKEY_DELETE] = "\x7F",
 695         [TKEY_PAGE_UP] = "\x1B[I",      [TKEY_PAGE_DOWN] = "\x1B[G",
 696
 697         [TKEY_F1] = "\x1B[M",           [TKEY_F2] = "\x1B[N",
 698         [TKEY_F3] = "\x1B[O",           [TKEY_F4] = "\x1B[P",
 699         [TKEY_F5] = "\x1B[Q",           [TKEY_F6] = "\x1B[R",
 700         [TKEY_F7] = "\x1B[S",           [TKEY_F8] = "\x1B[T",
 701         [TKEY_F9] = "\x1B[U",           [TKEY_F10] = "\x1B[V",
 702         [TKEY_F11] = "\x1B[W",          [TKEY_F12] = "\x1B[X",
 703 };
 704
 705 static const char * const special_strings_ckeys[] = {
 706         [TKEY_UP] = "\x1BOA",           [TKEY_DOWN] = "\x1BOB",
 707         [TKEY_LEFT] = "\x1BOD",         [TKEY_RIGHT] = "\x1BOC",
 708
 709         [TKEY_HOME] = "\x1BOH",         [TKEY_END] = "\x1BOF",
 710 };
 711
 712 static const char * const special_strings_normal[] = {
 713         [TKEY_UP] = "\x1B[A",           [TKEY_DOWN] = "\x1B[B",
 714         [TKEY_LEFT] = "\x1B[D",         [TKEY_RIGHT] = "\x1B[C",
 715
 716         [TKEY_HOME] = "\x1B[H",         [TKEY_END] = "\x1B[F",
 717         [TKEY_INSERT] = "\x1B[2~",      [TKEY_DELETE] = "\x1B[3~",
 718         [TKEY_PAGE_UP] = "\x1B[5~",     [TKEY_PAGE_DOWN] = "\x1B[6~",
 719
 720         [TKEY_F1] = "\x1BOP",           [TKEY_F2] = "\x1BOQ",
 721         [TKEY_F3] = "\x1BOR",           [TKEY_F4] = "\x1BOS",
 722         [TKEY_F5] = "\x1B[15~",         [TKEY_F6] = "\x1B[17~",
 723         [TKEY_F7] = "\x1B[18~",         [TKEY_F8] = "\x1B[19~",
 724         [TKEY_F9] = "\x1B[20~",         [TKEY_F10] = "\x1B[21~",
 725         [TKEY_F11] = "\x1B[23~",        [TKEY_F12] = "\x1B[24~",
 726 };
 727
 728 const char *
 729 teken_get_sequence(const teken_t *t, unsigned int k)
 730 {
 731
 732         /* Cons25 mode. */
 733         if ((t->t_stateflags & (TS_CONS25 | TS_CONS25KEYS)) ==
 734             (TS_CONS25 | TS_CONS25KEYS))
 735                 return (NULL);  /* Don't override good kbd(4) strings. */
 736         if (t->t_stateflags & TS_CONS25 &&
 737             k < sizeof special_strings_cons25 / sizeof(char *))
 738                 return (special_strings_cons25[k]);
 739
 740         /* Cursor keys mode. */
 741         if (t->t_stateflags & TS_CURSORKEYS &&
 742             k < sizeof special_strings_ckeys / sizeof(char *))
 743                 return (special_strings_ckeys[k]);
 744
 745         /* Default xterm sequences. */
 746         if (k < sizeof special_strings_normal / sizeof(char *))
 747                 return (special_strings_normal[k]);
 748
 749         return (NULL);
 750 }
 751
 752 #include "teken_state.h"