The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/teken/teken.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  *
   14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   24  * SUCH DAMAGE.
   25  *
   26  * $FreeBSD: releng/11.0/sys/teken/teken.c 286827 2015-08-16 13:59:11Z ed $
   27  */
   28 
   29 #include <sys/cdefs.h>
   30 #if defined(__FreeBSD__) && defined(_KERNEL)
   31 #include <sys/param.h>
   32 #include <sys/limits.h>
   33 #include <sys/lock.h>
   34 #include <sys/systm.h>
   35 #define teken_assert(x)         MPASS(x)
   36 #else /* !(__FreeBSD__ && _KERNEL) */
   37 #include <sys/types.h>
   38 #include <assert.h>
   39 #include <limits.h>
   40 #include <stdint.h>
   41 #include <stdio.h>
   42 #include <string.h>
   43 #define teken_assert(x)         assert(x)
   44 #endif /* __FreeBSD__ && _KERNEL */
   45 
   46 /* debug messages */
   47 #define teken_printf(x,...)
   48 
   49 /* Private flags for t_stateflags. */
   50 #define TS_FIRSTDIGIT   0x0001  /* First numeric digit in escape sequence. */
   51 #define TS_INSERT       0x0002  /* Insert mode. */
   52 #define TS_AUTOWRAP     0x0004  /* Autowrap. */
   53 #define TS_ORIGIN       0x0008  /* Origin mode. */
   54 #define TS_WRAPPED      0x0010  /* Next character should be printed on col 0. */
   55 #define TS_8BIT         0x0020  /* UTF-8 disabled. */
   56 #define TS_CONS25       0x0040  /* cons25 emulation. */
   57 #define TS_INSTRING     0x0080  /* Inside string. */
   58 #define TS_CURSORKEYS   0x0100  /* Cursor keys mode. */
   59 
   60 /* Character that blanks a cell. */
   61 #define BLANK   ' '
   62 
   63 #include "teken.h"
   64 #include "teken_wcwidth.h"
   65 #include "teken_scs.h"
   66 
   67 static teken_state_t    teken_state_init;
   68 
   69 /*
   70  * Wrappers for hooks.
   71  */
   72 
   73 static inline void
   74 teken_funcs_bell(teken_t *t)
   75 {
   76 
   77         t->t_funcs->tf_bell(t->t_softc);
   78 }
   79 
   80 static inline void
   81 teken_funcs_cursor(teken_t *t)
   82 {
   83 
   84         teken_assert(t->t_cursor.tp_row < t->t_winsize.tp_row);
   85         teken_assert(t->t_cursor.tp_col < t->t_winsize.tp_col);
   86 
   87         t->t_funcs->tf_cursor(t->t_softc, &t->t_cursor);
   88 }
   89 
   90 static inline void
   91 teken_funcs_putchar(teken_t *t, const teken_pos_t *p, teken_char_t c,
   92     const teken_attr_t *a)
   93 {
   94 
   95         teken_assert(p->tp_row < t->t_winsize.tp_row);
   96         teken_assert(p->tp_col < t->t_winsize.tp_col);
   97 
   98         t->t_funcs->tf_putchar(t->t_softc, p, c, a);
   99 }
  100 
  101 static inline void
  102 teken_funcs_fill(teken_t *t, const teken_rect_t *r,
  103     const teken_char_t c, const teken_attr_t *a)
  104 {
  105 
  106         teken_assert(r->tr_end.tp_row > r->tr_begin.tp_row);
  107         teken_assert(r->tr_end.tp_row <= t->t_winsize.tp_row);
  108         teken_assert(r->tr_end.tp_col > r->tr_begin.tp_col);
  109         teken_assert(r->tr_end.tp_col <= t->t_winsize.tp_col);
  110 
  111         t->t_funcs->tf_fill(t->t_softc, r, c, a);
  112 }
  113 
  114 static inline void
  115 teken_funcs_copy(teken_t *t, const teken_rect_t *r, const teken_pos_t *p)
  116 {
  117 
  118         teken_assert(r->tr_end.tp_row > r->tr_begin.tp_row);
  119         teken_assert(r->tr_end.tp_row <= t->t_winsize.tp_row);
  120         teken_assert(r->tr_end.tp_col > r->tr_begin.tp_col);
  121         teken_assert(r->tr_end.tp_col <= t->t_winsize.tp_col);
  122         teken_assert(p->tp_row + (r->tr_end.tp_row - r->tr_begin.tp_row) <= t->t_winsize.tp_row);
  123         teken_assert(p->tp_col + (r->tr_end.tp_col - r->tr_begin.tp_col) <= t->t_winsize.tp_col);
  124 
  125         t->t_funcs->tf_copy(t->t_softc, r, p);
  126 }
  127 
  128 static inline void
  129 teken_funcs_param(teken_t *t, int cmd, unsigned int value)
  130 {
  131 
  132         t->t_funcs->tf_param(t->t_softc, cmd, value);
  133 }
  134 
  135 static inline void
  136 teken_funcs_respond(teken_t *t, const void *buf, size_t len)
  137 {
  138 
  139         t->t_funcs->tf_respond(t->t_softc, buf, len);
  140 }
  141 
  142 #include "teken_subr.h"
  143 #include "teken_subr_compat.h"
  144 
  145 /*
  146  * Programming interface.
  147  */
  148 
  149 void
  150 teken_init(teken_t *t, const teken_funcs_t *tf, void *softc)
  151 {
  152         teken_pos_t tp = { .tp_row = 24, .tp_col = 80 };
  153 
  154         t->t_funcs = tf;
  155         t->t_softc = softc;
  156 
  157         t->t_nextstate = teken_state_init;
  158         t->t_stateflags = 0;
  159         t->t_utf8_left = 0;
  160 
  161         t->t_defattr.ta_format = 0;
  162         t->t_defattr.ta_fgcolor = TC_WHITE;
  163         t->t_defattr.ta_bgcolor = TC_BLACK;
  164         teken_subr_do_reset(t);
  165 
  166         teken_set_winsize(t, &tp);
  167 }
  168 
  169 static void
  170 teken_input_char(teken_t *t, teken_char_t c)
  171 {
  172 
  173         /*
  174          * There is no support for DCS and OSC.  Just discard strings
  175          * until we receive characters that may indicate string
  176          * termination.
  177          */
  178         if (t->t_stateflags & TS_INSTRING) {
  179                 switch (c) {
  180                 case '\x1B':
  181                         t->t_stateflags &= ~TS_INSTRING;
  182                         break;
  183                 case '\a':
  184                         t->t_stateflags &= ~TS_INSTRING;
  185                         return;
  186                 default:
  187                         return;
  188                 }
  189         }
  190 
  191         switch (c) {
  192         case '\0':
  193                 break;
  194         case '\a':
  195                 teken_subr_bell(t);
  196                 break;
  197         case '\b':
  198                 teken_subr_backspace(t);
  199                 break;
  200         case '\n':
  201         case '\x0B':
  202                 teken_subr_newline(t);
  203                 break;
  204         case '\x0C':
  205                 teken_subr_newpage(t);
  206                 break;
  207         case '\x0E':
  208                 if (t->t_stateflags & TS_CONS25)
  209                         t->t_nextstate(t, c);
  210                 else
  211                         t->t_curscs = 1;
  212                 break;
  213         case '\x0F':
  214                 if (t->t_stateflags & TS_CONS25)
  215                         t->t_nextstate(t, c);
  216                 else
  217                         t->t_curscs = 0;
  218                 break;
  219         case '\r':
  220                 teken_subr_carriage_return(t);
  221                 break;
  222         case '\t':
  223                 teken_subr_horizontal_tab(t);
  224                 break;
  225         default:
  226                 t->t_nextstate(t, c);
  227                 break;
  228         }
  229 
  230         /* Post-processing assertions. */
  231         teken_assert(t->t_cursor.tp_row >= t->t_originreg.ts_begin);
  232         teken_assert(t->t_cursor.tp_row < t->t_originreg.ts_end);
  233         teken_assert(t->t_cursor.tp_row < t->t_winsize.tp_row);
  234         teken_assert(t->t_cursor.tp_col < t->t_winsize.tp_col);
  235         teken_assert(t->t_saved_cursor.tp_row < t->t_winsize.tp_row);
  236         teken_assert(t->t_saved_cursor.tp_col < t->t_winsize.tp_col);
  237         teken_assert(t->t_scrollreg.ts_end <= t->t_winsize.tp_row);
  238         teken_assert(t->t_scrollreg.ts_begin < t->t_scrollreg.ts_end);
  239         /* Origin region has to be window size or the same as scrollreg. */
  240         teken_assert((t->t_originreg.ts_begin == t->t_scrollreg.ts_begin &&
  241             t->t_originreg.ts_end == t->t_scrollreg.ts_end) ||
  242             (t->t_originreg.ts_begin == 0 &&
  243             t->t_originreg.ts_end == t->t_winsize.tp_row));
  244 }
  245 
  246 static void
  247 teken_input_byte(teken_t *t, unsigned char c)
  248 {
  249 
  250         /*
  251          * UTF-8 handling.
  252          */
  253         if ((c & 0x80) == 0x00 || t->t_stateflags & TS_8BIT) {
  254                 /* One-byte sequence. */
  255                 t->t_utf8_left = 0;
  256                 teken_input_char(t, c);
  257         } else if ((c & 0xe0) == 0xc0) {
  258                 /* Two-byte sequence. */
  259                 t->t_utf8_left = 1;
  260                 t->t_utf8_partial = c & 0x1f;
  261         } else if ((c & 0xf0) == 0xe0) {
  262                 /* Three-byte sequence. */
  263                 t->t_utf8_left = 2;
  264                 t->t_utf8_partial = c & 0x0f;
  265         } else if ((c & 0xf8) == 0xf0) {
  266                 /* Four-byte sequence. */
  267                 t->t_utf8_left = 3;
  268                 t->t_utf8_partial = c & 0x07;
  269         } else if ((c & 0xc0) == 0x80) {
  270                 if (t->t_utf8_left == 0)
  271                         return;
  272                 t->t_utf8_left--;
  273                 t->t_utf8_partial = (t->t_utf8_partial << 6) | (c & 0x3f);
  274                 if (t->t_utf8_left == 0) {
  275                         teken_printf("Got UTF-8 char %x\n", t->t_utf8_partial);
  276                         teken_input_char(t, t->t_utf8_partial);
  277                 }
  278         }
  279 }
  280 
  281 void
  282 teken_input(teken_t *t, const void *buf, size_t len)
  283 {
  284         const char *c = buf;
  285 
  286         while (len-- > 0)
  287                 teken_input_byte(t, *c++);
  288 }
  289 
  290 const teken_pos_t *
  291 teken_get_cursor(teken_t *t)
  292 {
  293 
  294         return (&t->t_cursor);
  295 }
  296 
  297 void
  298 teken_set_cursor(teken_t *t, const teken_pos_t *p)
  299 {
  300 
  301         /* XXX: bounds checking with originreg! */
  302         teken_assert(p->tp_row < t->t_winsize.tp_row);
  303         teken_assert(p->tp_col < t->t_winsize.tp_col);
  304 
  305         t->t_cursor = *p;
  306 }
  307 
  308 const teken_attr_t *
  309 teken_get_curattr(teken_t *t)
  310 {
  311 
  312         return (&t->t_curattr);
  313 }
  314 
  315 void
  316 teken_set_curattr(teken_t *t, const teken_attr_t *a)
  317 {
  318 
  319         t->t_curattr = *a;
  320 }
  321 
  322 const teken_attr_t *
  323 teken_get_defattr(teken_t *t)
  324 {
  325 
  326         return (&t->t_defattr);
  327 }
  328 
  329 void
  330 teken_set_defattr(teken_t *t, const teken_attr_t *a)
  331 {
  332 
  333         t->t_curattr = t->t_saved_curattr = t->t_defattr = *a;
  334 }
  335 
  336 const teken_pos_t *
  337 teken_get_winsize(teken_t *t)
  338 {
  339 
  340         return (&t->t_winsize);
  341 }
  342 
  343 static void
  344 teken_trim_cursor_pos(teken_t *t, const teken_pos_t *new)
  345 {
  346         const teken_pos_t *cur;
  347 
  348         cur = &t->t_winsize;
  349 
  350         if (cur->tp_row < new->tp_row || cur->tp_col < new->tp_col)
  351                 return;
  352         if (t->t_cursor.tp_row >= new->tp_row)
  353                 t->t_cursor.tp_row = new->tp_row - 1;
  354         if (t->t_cursor.tp_col >= new->tp_col)
  355                 t->t_cursor.tp_col = new->tp_col - 1;
  356 }
  357 
  358 void
  359 teken_set_winsize(teken_t *t, const teken_pos_t *p)
  360 {
  361 
  362         teken_trim_cursor_pos(t, p);
  363         t->t_winsize = *p;
  364         teken_subr_do_reset(t);
  365 }
  366 
  367 void
  368 teken_set_winsize_noreset(teken_t *t, const teken_pos_t *p)
  369 {
  370 
  371         teken_trim_cursor_pos(t, p);
  372         t->t_winsize = *p;
  373         teken_subr_do_resize(t);
  374 }
  375 
  376 void
  377 teken_set_8bit(teken_t *t)
  378 {
  379 
  380         t->t_stateflags |= TS_8BIT;
  381 }
  382 
  383 void
  384 teken_set_cons25(teken_t *t)
  385 {
  386 
  387         t->t_stateflags |= TS_CONS25;
  388 }
  389 
  390 /*
  391  * State machine.
  392  */
  393 
  394 static void
  395 teken_state_switch(teken_t *t, teken_state_t *s)
  396 {
  397 
  398         t->t_nextstate = s;
  399         t->t_curnum = 0;
  400         t->t_stateflags |= TS_FIRSTDIGIT;
  401 }
  402 
  403 static int
  404 teken_state_numbers(teken_t *t, teken_char_t c)
  405 {
  406 
  407         teken_assert(t->t_curnum < T_NUMSIZE);
  408 
  409         if (c >= '' && c <= '9') {
  410                 if (t->t_stateflags & TS_FIRSTDIGIT) {
  411                         /* First digit. */
  412                         t->t_stateflags &= ~TS_FIRSTDIGIT;
  413                         t->t_nums[t->t_curnum] = c - '';
  414                 } else if (t->t_nums[t->t_curnum] < UINT_MAX / 100) {
  415                         /*
  416                          * There is no need to continue parsing input
  417                          * once the value exceeds the size of the
  418                          * terminal. It would only allow for integer
  419                          * overflows when performing arithmetic on the
  420                          * cursor position.
  421                          *
  422                          * Ignore any further digits if the value is
  423                          * already UINT_MAX / 100.
  424                          */
  425                         t->t_nums[t->t_curnum] =
  426                             t->t_nums[t->t_curnum] * 10 + c - '';
  427                 }
  428                 return (1);
  429         } else if (c == ';') {
  430                 if (t->t_stateflags & TS_FIRSTDIGIT)
  431                         t->t_nums[t->t_curnum] = 0;
  432 
  433                 /* Only allow a limited set of arguments. */
  434                 if (++t->t_curnum == T_NUMSIZE) {
  435                         teken_state_switch(t, teken_state_init);
  436                         return (1);
  437                 }
  438 
  439                 t->t_stateflags |= TS_FIRSTDIGIT;
  440                 return (1);
  441         } else {
  442                 if (t->t_stateflags & TS_FIRSTDIGIT && t->t_curnum > 0) {
  443                         /* Finish off the last empty argument. */
  444                         t->t_nums[t->t_curnum] = 0;
  445                         t->t_curnum++;
  446                 } else if ((t->t_stateflags & TS_FIRSTDIGIT) == 0) {
  447                         /* Also count the last argument. */
  448                         t->t_curnum++;
  449                 }
  450         }
  451 
  452         return (0);
  453 }
  454 
  455 teken_color_t
  456 teken_256to8(teken_color_t c)
  457 {
  458         unsigned int r, g, b;
  459 
  460         if (c < 16) {
  461                 /* Traditional color indices. */
  462                 return (c % 8);
  463         } else if (c >= 244) {
  464                 /* Upper grayscale colors. */
  465                 return (TC_WHITE);
  466         } else if (c >= 232) {
  467                 /* Lower grayscale colors. */
  468                 return (TC_BLACK);
  469         }
  470 
  471         /* Convert to RGB. */
  472         c -= 16;
  473         b = c % 6;
  474         g = (c / 6) % 6;
  475         r = c / 36;
  476 
  477         if (r < g) {
  478                 /* Possibly green. */
  479                 if (g < b)
  480                         return (TC_BLUE);
  481                 else if (g > b)
  482                         return (TC_GREEN);
  483                 else
  484                         return (TC_CYAN);
  485         } else if (r > g) {
  486                 /* Possibly red. */
  487                 if (r < b)
  488                         return (TC_BLUE);
  489                 else if (r > b)
  490                         return (TC_RED);
  491                 else
  492                         return (TC_MAGENTA);
  493         } else {
  494                 /* Possibly brown. */
  495                 if (g < b)
  496                         return (TC_BLUE);
  497                 else if (g > b)
  498                         return (TC_BROWN);
  499                 else if (r < 3)
  500                         return (TC_BLACK);
  501                 else
  502                         return (TC_WHITE);
  503         }
  504 }
  505 
  506 static const char * const special_strings_cons25[] = {
  507         [TKEY_UP] = "\x1B[A",           [TKEY_DOWN] = "\x1B[B",
  508         [TKEY_LEFT] = "\x1B[D",         [TKEY_RIGHT] = "\x1B[C",
  509 
  510         [TKEY_HOME] = "\x1B[H",         [TKEY_END] = "\x1B[F",
  511         [TKEY_INSERT] = "\x1B[L",       [TKEY_DELETE] = "\x7F",
  512         [TKEY_PAGE_UP] = "\x1B[I",      [TKEY_PAGE_DOWN] = "\x1B[G",
  513 
  514         [TKEY_F1] = "\x1B[M",           [TKEY_F2] = "\x1B[N",
  515         [TKEY_F3] = "\x1B[O",           [TKEY_F4] = "\x1B[P",
  516         [TKEY_F5] = "\x1B[Q",           [TKEY_F6] = "\x1B[R",
  517         [TKEY_F7] = "\x1B[S",           [TKEY_F8] = "\x1B[T",
  518         [TKEY_F9] = "\x1B[U",           [TKEY_F10] = "\x1B[V",
  519         [TKEY_F11] = "\x1B[W",          [TKEY_F12] = "\x1B[X",
  520 };
  521 
  522 static const char * const special_strings_ckeys[] = {
  523         [TKEY_UP] = "\x1BOA",           [TKEY_DOWN] = "\x1BOB",
  524         [TKEY_LEFT] = "\x1BOD",         [TKEY_RIGHT] = "\x1BOC",
  525 
  526         [TKEY_HOME] = "\x1BOH",         [TKEY_END] = "\x1BOF",
  527 };
  528 
  529 static const char * const special_strings_normal[] = {
  530         [TKEY_UP] = "\x1B[A",           [TKEY_DOWN] = "\x1B[B",
  531         [TKEY_LEFT] = "\x1B[D",         [TKEY_RIGHT] = "\x1B[C",
  532 
  533         [TKEY_HOME] = "\x1B[H",         [TKEY_END] = "\x1B[F",
  534         [TKEY_INSERT] = "\x1B[2~",      [TKEY_DELETE] = "\x1B[3~",
  535         [TKEY_PAGE_UP] = "\x1B[5~",     [TKEY_PAGE_DOWN] = "\x1B[6~",
  536 
  537         [TKEY_F1] = "\x1BOP",           [TKEY_F2] = "\x1BOQ",
  538         [TKEY_F3] = "\x1BOR",           [TKEY_F4] = "\x1BOS",
  539         [TKEY_F5] = "\x1B[15~",         [TKEY_F6] = "\x1B[17~",
  540         [TKEY_F7] = "\x1B[18~",         [TKEY_F8] = "\x1B[19~",
  541         [TKEY_F9] = "\x1B[20~",         [TKEY_F10] = "\x1B[21~",
  542         [TKEY_F11] = "\x1B[23~",        [TKEY_F12] = "\x1B[24~",
  543 };
  544 
  545 const char *
  546 teken_get_sequence(teken_t *t, unsigned int k)
  547 {
  548 
  549         /* Cons25 mode. */
  550         if (t->t_stateflags & TS_CONS25 &&
  551             k < sizeof special_strings_cons25 / sizeof(char *))
  552                 return (special_strings_cons25[k]);
  553 
  554         /* Cursor keys mode. */
  555         if (t->t_stateflags & TS_CURSORKEYS &&
  556             k < sizeof special_strings_ckeys / sizeof(char *))
  557                 return (special_strings_ckeys[k]);
  558 
  559         /* Default xterm sequences. */
  560         if (k < sizeof special_strings_normal / sizeof(char *))
  561                 return (special_strings_normal[k]);
  562 
  563         return (NULL);
  564 }
  565 
  566 #include "teken_state.h"

Cache object: bd7fb9f2462b6f6f64c5c861df8e0b31


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.