teken_subr.h

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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 static void teken_subr_cursor_up(teken_t *, unsigned int);
   32 static void teken_subr_erase_line(const teken_t *, unsigned int);
   33 static void teken_subr_regular_character(teken_t *, teken_char_t);
   34 static void teken_subr_reset_to_initial_state(teken_t *);
   35 static void teken_subr_save_cursor(teken_t *);
   36 
   37 static inline int
   38 teken_tab_isset(const teken_t *t, unsigned int col)
   39 {
   40         unsigned int b, o;
   41 
   42         if (col >= T_NUMCOL)
   43                 return ((col % 8) == 0);
   44 
   45         b = col / (sizeof(unsigned int) * 8);
   46         o = col % (sizeof(unsigned int) * 8);
   47 
   48         return (t->t_tabstops[b] & (1U << o));
   49 }
   50 
   51 static inline void
   52 teken_tab_clear(teken_t *t, unsigned int col)
   53 {
   54         unsigned int b, o;
   55 
   56         if (col >= T_NUMCOL)
   57                 return;
   58 
   59         b = col / (sizeof(unsigned int) * 8);
   60         o = col % (sizeof(unsigned int) * 8);
   61 
   62         t->t_tabstops[b] &= ~(1U << o);
   63 }
   64 
   65 static inline void
   66 teken_tab_set(teken_t *t, unsigned int col)
   67 {
   68         unsigned int b, o;
   69 
   70         if (col >= T_NUMCOL)
   71                 return;
   72 
   73         b = col / (sizeof(unsigned int) * 8);
   74         o = col % (sizeof(unsigned int) * 8);
   75 
   76         t->t_tabstops[b] |= 1U << o;
   77 }
   78 
   79 static void
   80 teken_tab_default(teken_t *t)
   81 {
   82         unsigned int i;
   83 
   84         memset(t->t_tabstops, 0, T_NUMCOL / 8);
   85 
   86         for (i = 8; i < T_NUMCOL; i += 8)
   87                 teken_tab_set(t, i);
   88 }
   89 
   90 static void
   91 teken_subr_do_scroll(const teken_t *t, int amount)
   92 {
   93         teken_rect_t tr;
   94         teken_pos_t tp;
   95 
   96         teken_assert(t->t_cursor.tp_row <= t->t_winsize.tp_row);
   97         teken_assert(t->t_scrollreg.ts_end <= t->t_winsize.tp_row);
   98         teken_assert(amount != 0);
   99 
  100         /* Copy existing data 1 line up. */
  101         if (amount > 0) {
  102                 /* Scroll down. */
  103 
  104                 /* Copy existing data up. */
  105                 if (t->t_scrollreg.ts_begin + amount < t->t_scrollreg.ts_end) {
  106                         tr.tr_begin.tp_row = t->t_scrollreg.ts_begin + amount;
  107                         tr.tr_begin.tp_col = 0;
  108                         tr.tr_end.tp_row = t->t_scrollreg.ts_end;
  109                         tr.tr_end.tp_col = t->t_winsize.tp_col;
  110                         tp.tp_row = t->t_scrollreg.ts_begin;
  111                         tp.tp_col = 0;
  112                         teken_funcs_copy(t, &tr, &tp);
  113 
  114                         tr.tr_begin.tp_row = t->t_scrollreg.ts_end - amount;
  115                 } else {
  116                         tr.tr_begin.tp_row = t->t_scrollreg.ts_begin;
  117                 }
  118 
  119                 /* Clear the last lines. */
  120                 tr.tr_begin.tp_col = 0;
  121                 tr.tr_end.tp_row = t->t_scrollreg.ts_end;
  122                 tr.tr_end.tp_col = t->t_winsize.tp_col;
  123                 teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
  124         } else {
  125                 /* Scroll up. */
  126                 amount = -amount;
  127 
  128                 /* Copy existing data down. */
  129                 if (t->t_scrollreg.ts_begin + amount < t->t_scrollreg.ts_end) {
  130                         tr.tr_begin.tp_row = t->t_scrollreg.ts_begin;
  131                         tr.tr_begin.tp_col = 0;
  132                         tr.tr_end.tp_row = t->t_scrollreg.ts_end - amount;
  133                         tr.tr_end.tp_col = t->t_winsize.tp_col;
  134                         tp.tp_row = t->t_scrollreg.ts_begin + amount;
  135                         tp.tp_col = 0;
  136                         teken_funcs_copy(t, &tr, &tp);
  137 
  138                         tr.tr_end.tp_row = t->t_scrollreg.ts_begin + amount;
  139                 } else {
  140                         tr.tr_end.tp_row = t->t_scrollreg.ts_end;
  141                 }
  142 
  143                 /* Clear the first lines. */
  144                 tr.tr_begin.tp_row = t->t_scrollreg.ts_begin;
  145                 tr.tr_begin.tp_col = 0;
  146                 tr.tr_end.tp_col = t->t_winsize.tp_col;
  147                 teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
  148         }
  149 }
  150 
  151 static ssize_t
  152 teken_subr_do_cpr(const teken_t *t, unsigned int cmd, char response[16])
  153 {
  154 
  155         switch (cmd) {
  156         case 5: /* Operating status. */
  157                 strcpy(response, "0n");
  158                 return (2);
  159         case 6: { /* Cursor position. */
  160                 int len;
  161 
  162                 len = snprintf(response, 16, "%u;%uR",
  163                     (t->t_cursor.tp_row - t->t_originreg.ts_begin) + 1,
  164                     t->t_cursor.tp_col + 1);
  165 
  166                 if (len >= 16)
  167                         return (-1);
  168                 return (len);
  169         }
  170         case 15: /* Printer status. */
  171                 strcpy(response, "13n");
  172                 return (3);
  173         case 25: /* UDK status. */
  174                 strcpy(response, "20n");
  175                 return (3);
  176         case 26: /* Keyboard status. */
  177                 strcpy(response, "27;1n");
  178                 return (5);
  179         default:
  180                 teken_printf("Unknown DSR\n");
  181                 return (-1);
  182         }
  183 }
  184 
  185 static void
  186 teken_subr_alignment_test(teken_t *t)
  187 {
  188         teken_rect_t tr;
  189 
  190         t->t_cursor.tp_row = t->t_cursor.tp_col = 0;
  191         t->t_scrollreg.ts_begin = 0;
  192         t->t_scrollreg.ts_end = t->t_winsize.tp_row;
  193         t->t_originreg = t->t_scrollreg;
  194         t->t_stateflags &= ~(TS_WRAPPED|TS_ORIGIN);
  195         teken_funcs_cursor(t);
  196 
  197         tr.tr_begin.tp_row = 0;
  198         tr.tr_begin.tp_col = 0;
  199         tr.tr_end = t->t_winsize;
  200         teken_funcs_fill(t, &tr, 'E', &t->t_defattr);
  201 }
  202 
  203 static void
  204 teken_subr_backspace(teken_t *t)
  205 {
  206 
  207         if (t->t_stateflags & TS_CONS25) {
  208                 if (t->t_cursor.tp_col == 0) {
  209                         if (t->t_cursor.tp_row == t->t_originreg.ts_begin)
  210                                 return;
  211                         t->t_cursor.tp_row--;
  212                         t->t_cursor.tp_col = t->t_winsize.tp_col - 1;
  213                 } else {
  214                         t->t_cursor.tp_col--;
  215                 }
  216         } else {
  217                 if (t->t_cursor.tp_col == 0)
  218                         return;
  219 
  220                 t->t_cursor.tp_col--;
  221                 t->t_stateflags &= ~TS_WRAPPED;
  222         }
  223 
  224         teken_funcs_cursor(t);
  225 }
  226 
  227 static void
  228 teken_subr_bell(const teken_t *t)
  229 {
  230 
  231         teken_funcs_bell(t);
  232 }
  233 
  234 static void
  235 teken_subr_carriage_return(teken_t *t)
  236 {
  237 
  238         t->t_cursor.tp_col = 0;
  239         t->t_stateflags &= ~TS_WRAPPED;
  240         teken_funcs_cursor(t);
  241 }
  242 
  243 static void
  244 teken_subr_cursor_backward(teken_t *t, unsigned int ncols)
  245 {
  246 
  247         if (ncols > t->t_cursor.tp_col)
  248                 t->t_cursor.tp_col = 0;
  249         else
  250                 t->t_cursor.tp_col -= ncols;
  251         t->t_stateflags &= ~TS_WRAPPED;
  252         teken_funcs_cursor(t);
  253 }
  254 
  255 static void
  256 teken_subr_cursor_backward_tabulation(teken_t *t, unsigned int ntabs)
  257 {
  258 
  259         do {
  260                 /* Stop when we've reached the beginning of the line. */
  261                 if (t->t_cursor.tp_col == 0)
  262                         break;
  263 
  264                 t->t_cursor.tp_col--;
  265 
  266                 /* Tab marker set. */
  267                 if (teken_tab_isset(t, t->t_cursor.tp_col))
  268                         ntabs--;
  269         } while (ntabs > 0);
  270 
  271         teken_funcs_cursor(t);
  272 }
  273 
  274 static void
  275 teken_subr_cursor_down(teken_t *t, unsigned int nrows)
  276 {
  277 
  278         if (t->t_cursor.tp_row + nrows >= t->t_scrollreg.ts_end)
  279                 t->t_cursor.tp_row = t->t_scrollreg.ts_end - 1;
  280         else
  281                 t->t_cursor.tp_row += nrows;
  282         t->t_stateflags &= ~TS_WRAPPED;
  283         teken_funcs_cursor(t);
  284 }
  285 
  286 static void
  287 teken_subr_cursor_forward(teken_t *t, unsigned int ncols)
  288 {
  289 
  290         if (t->t_cursor.tp_col + ncols >= t->t_winsize.tp_col)
  291                 t->t_cursor.tp_col = t->t_winsize.tp_col - 1;
  292         else
  293                 t->t_cursor.tp_col += ncols;
  294         t->t_stateflags &= ~TS_WRAPPED;
  295         teken_funcs_cursor(t);
  296 }
  297 
  298 static void
  299 teken_subr_cursor_forward_tabulation(teken_t *t, unsigned int ntabs)
  300 {
  301 
  302         do {
  303                 /* Stop when we've reached the end of the line. */
  304                 if (t->t_cursor.tp_col == t->t_winsize.tp_col - 1)
  305                         break;
  306 
  307                 t->t_cursor.tp_col++;
  308 
  309                 /* Tab marker set. */
  310                 if (teken_tab_isset(t, t->t_cursor.tp_col))
  311                         ntabs--;
  312         } while (ntabs > 0);
  313 
  314         teken_funcs_cursor(t);
  315 }
  316 
  317 static void
  318 teken_subr_cursor_next_line(teken_t *t, unsigned int ncols)
  319 {
  320 
  321         t->t_cursor.tp_col = 0;
  322         teken_subr_cursor_down(t, ncols);
  323 }
  324 
  325 static void
  326 teken_subr_cursor_position(teken_t *t, unsigned int row, unsigned int col)
  327 {
  328 
  329         row = (row - 1) + t->t_originreg.ts_begin;
  330         t->t_cursor.tp_row = row < t->t_originreg.ts_end ?
  331             row : t->t_originreg.ts_end - 1;
  332 
  333         col--;
  334         t->t_cursor.tp_col = col < t->t_winsize.tp_col ?
  335             col : t->t_winsize.tp_col - 1;
  336 
  337         t->t_stateflags &= ~TS_WRAPPED;
  338         teken_funcs_cursor(t);
  339 }
  340 
  341 static void
  342 teken_subr_cursor_position_report(const teken_t *t, unsigned int cmd)
  343 {
  344         char response[18] = "\x1B[";
  345         ssize_t len;
  346 
  347         len = teken_subr_do_cpr(t, cmd, response + 2);
  348         if (len < 0)
  349                 return;
  350 
  351         teken_funcs_respond(t, response, len + 2);
  352 }
  353 
  354 static void
  355 teken_subr_cursor_previous_line(teken_t *t, unsigned int ncols)
  356 {
  357 
  358         t->t_cursor.tp_col = 0;
  359         teken_subr_cursor_up(t, ncols);
  360 }
  361 
  362 static void
  363 teken_subr_cursor_up(teken_t *t, unsigned int nrows)
  364 {
  365 
  366         if (t->t_scrollreg.ts_begin + nrows >= t->t_cursor.tp_row)
  367                 t->t_cursor.tp_row = t->t_scrollreg.ts_begin;
  368         else
  369                 t->t_cursor.tp_row -= nrows;
  370         t->t_stateflags &= ~TS_WRAPPED;
  371         teken_funcs_cursor(t);
  372 }
  373 
  374 static void
  375 teken_subr_set_cursor_style(teken_t *t __unused, unsigned int style __unused)
  376 {
  377 
  378         /* TODO */
  379 
  380         /*
  381          * CSI Ps SP q
  382          *   Set cursor style (DECSCUSR), VT520.
  383          *     Ps = 0  -> blinking block.
  384          *     Ps = 1  -> blinking block (default).
  385          *     Ps = 2  -> steady block.
  386          *     Ps = 3  -> blinking underline.
  387          *     Ps = 4  -> steady underline.
  388          *     Ps = 5  -> blinking bar (xterm).
  389          *     Ps = 6  -> steady bar (xterm).
  390          */
  391 }
  392 
  393 static void
  394 teken_subr_delete_character(const teken_t *t, unsigned int ncols)
  395 {
  396         teken_rect_t tr;
  397 
  398         tr.tr_begin.tp_row = t->t_cursor.tp_row;
  399         tr.tr_end.tp_row = t->t_cursor.tp_row + 1;
  400         tr.tr_end.tp_col = t->t_winsize.tp_col;
  401 
  402         if (t->t_cursor.tp_col + ncols >= t->t_winsize.tp_col) {
  403                 tr.tr_begin.tp_col = t->t_cursor.tp_col;
  404         } else {
  405                 /* Copy characters to the left. */
  406                 tr.tr_begin.tp_col = t->t_cursor.tp_col + ncols;
  407                 teken_funcs_copy(t, &tr, &t->t_cursor);
  408 
  409                 tr.tr_begin.tp_col = t->t_winsize.tp_col - ncols;
  410         }
  411 
  412         /* Blank trailing columns. */
  413         teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
  414 }
  415 
  416 static void
  417 teken_subr_delete_line(const teken_t *t, unsigned int nrows)
  418 {
  419         teken_rect_t tr;
  420 
  421         /* Ignore if outside scrolling region. */
  422         if (t->t_cursor.tp_row < t->t_scrollreg.ts_begin ||
  423             t->t_cursor.tp_row >= t->t_scrollreg.ts_end)
  424                 return;
  425 
  426         tr.tr_begin.tp_col = 0;
  427         tr.tr_end.tp_row = t->t_scrollreg.ts_end;
  428         tr.tr_end.tp_col = t->t_winsize.tp_col;
  429 
  430         if (t->t_cursor.tp_row + nrows >= t->t_scrollreg.ts_end) {
  431                 tr.tr_begin.tp_row = t->t_cursor.tp_row;
  432         } else {
  433                 teken_pos_t tp;
  434 
  435                 /* Copy rows up. */
  436                 tr.tr_begin.tp_row = t->t_cursor.tp_row + nrows;
  437                 tp.tp_row = t->t_cursor.tp_row;
  438                 tp.tp_col = 0;
  439                 teken_funcs_copy(t, &tr, &tp);
  440 
  441                 tr.tr_begin.tp_row = t->t_scrollreg.ts_end - nrows;
  442         }
  443 
  444         /* Blank trailing rows. */
  445         teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
  446 }
  447 
  448 static void
  449 teken_subr_device_control_string(teken_t *t)
  450 {
  451 
  452         teken_printf("Unsupported device control string\n");
  453         t->t_stateflags |= TS_INSTRING;
  454 }
  455 
  456 static void
  457 teken_subr_device_status_report(const teken_t *t, unsigned int cmd)
  458 {
  459         char response[19] = "\x1B[?";
  460         ssize_t len;
  461 
  462         len = teken_subr_do_cpr(t, cmd, response + 3);
  463         if (len < 0)
  464                 return;
  465 
  466         teken_funcs_respond(t, response, len + 3);
  467 }
  468 
  469 static void
  470 teken_subr_double_height_double_width_line_top(const teken_t *t)
  471 {
  472 
  473         (void)t;
  474         teken_printf("double height double width top\n");
  475 }
  476 
  477 static void
  478 teken_subr_double_height_double_width_line_bottom(const teken_t *t)
  479 {
  480 
  481         (void)t;
  482         teken_printf("double height double width bottom\n");
  483 }
  484 
  485 static void
  486 teken_subr_erase_character(const teken_t *t, unsigned int ncols)
  487 {
  488         teken_rect_t tr;
  489 
  490         tr.tr_begin = t->t_cursor;
  491         tr.tr_end.tp_row = t->t_cursor.tp_row + 1;
  492 
  493         if (t->t_cursor.tp_col + ncols >= t->t_winsize.tp_col)
  494                 tr.tr_end.tp_col = t->t_winsize.tp_col;
  495         else
  496                 tr.tr_end.tp_col = t->t_cursor.tp_col + ncols;
  497 
  498         teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
  499 }
  500 
  501 static void
  502 teken_subr_erase_display(const teken_t *t, unsigned int mode)
  503 {
  504         teken_rect_t r;
  505 
  506         r.tr_begin.tp_col = 0;
  507         r.tr_end.tp_col = t->t_winsize.tp_col;
  508 
  509         switch (mode) {
  510         case 1: /* Erase from the top to the cursor. */
  511                 teken_subr_erase_line(t, 1);
  512 
  513                 /* Erase lines above. */
  514                 if (t->t_cursor.tp_row == 0)
  515                         return;
  516                 r.tr_begin.tp_row = 0;
  517                 r.tr_end.tp_row = t->t_cursor.tp_row;
  518                 break;
  519         case 2: /* Erase entire display. */
  520                 r.tr_begin.tp_row = 0;
  521                 r.tr_end.tp_row = t->t_winsize.tp_row;
  522                 break;
  523         default: /* Erase from cursor to the bottom. */
  524                 teken_subr_erase_line(t, 0);
  525 
  526                 /* Erase lines below. */
  527                 if (t->t_cursor.tp_row == t->t_winsize.tp_row - 1)
  528                         return;
  529                 r.tr_begin.tp_row = t->t_cursor.tp_row + 1;
  530                 r.tr_end.tp_row = t->t_winsize.tp_row;
  531                 break;
  532         }
  533 
  534         teken_funcs_fill(t, &r, BLANK, &t->t_curattr);
  535 }
  536 
  537 static void
  538 teken_subr_erase_line(const teken_t *t, unsigned int mode)
  539 {
  540         teken_rect_t r;
  541 
  542         r.tr_begin.tp_row = t->t_cursor.tp_row;
  543         r.tr_end.tp_row = t->t_cursor.tp_row + 1;
  544 
  545         switch (mode) {
  546         case 1: /* Erase from the beginning of the line to the cursor. */
  547                 r.tr_begin.tp_col = 0;
  548                 r.tr_end.tp_col = t->t_cursor.tp_col + 1;
  549                 break;
  550         case 2: /* Erase entire line. */
  551                 r.tr_begin.tp_col = 0;
  552                 r.tr_end.tp_col = t->t_winsize.tp_col;
  553                 break;
  554         default: /* Erase from cursor to the end of the line. */
  555                 r.tr_begin.tp_col = t->t_cursor.tp_col;
  556                 r.tr_end.tp_col = t->t_winsize.tp_col;
  557                 break;
  558         }
  559 
  560         teken_funcs_fill(t, &r, BLANK, &t->t_curattr);
  561 }
  562 
  563 static void
  564 teken_subr_g0_scs_special_graphics(teken_t *t)
  565 {
  566 
  567         t->t_scs[0] = teken_scs_special_graphics;
  568 }
  569 
  570 static void
  571 teken_subr_g0_scs_uk_national(teken_t *t)
  572 {
  573 
  574         t->t_scs[0] = teken_scs_uk_national;
  575 }
  576 
  577 static void
  578 teken_subr_g0_scs_us_ascii(teken_t *t)
  579 {
  580 
  581         t->t_scs[0] = teken_scs_us_ascii;
  582 }
  583 
  584 static void
  585 teken_subr_g1_scs_special_graphics(teken_t *t)
  586 {
  587 
  588         t->t_scs[1] = teken_scs_special_graphics;
  589 }
  590 
  591 static void
  592 teken_subr_g1_scs_uk_national(teken_t *t)
  593 {
  594 
  595         t->t_scs[1] = teken_scs_uk_national;
  596 }
  597 
  598 static void
  599 teken_subr_g1_scs_us_ascii(teken_t *t)
  600 {
  601 
  602         t->t_scs[1] = teken_scs_us_ascii;
  603 }
  604 
  605 static void
  606 teken_subr_horizontal_position_absolute(teken_t *t, unsigned int col)
  607 {
  608 
  609         col--;
  610         t->t_cursor.tp_col = col < t->t_winsize.tp_col ?
  611             col : t->t_winsize.tp_col - 1;
  612 
  613         t->t_stateflags &= ~TS_WRAPPED;
  614         teken_funcs_cursor(t);
  615 }
  616 
  617 static void
  618 teken_subr_horizontal_tab(teken_t *t)
  619 {
  620 
  621         teken_subr_cursor_forward_tabulation(t, 1);
  622 }
  623 
  624 static void
  625 teken_subr_horizontal_tab_set(teken_t *t)
  626 {
  627 
  628         teken_tab_set(t, t->t_cursor.tp_col);
  629 }
  630 
  631 static void
  632 teken_subr_index(teken_t *t)
  633 {
  634 
  635         if (t->t_cursor.tp_row < t->t_scrollreg.ts_end - 1) {
  636                 t->t_cursor.tp_row++;
  637                 t->t_stateflags &= ~TS_WRAPPED;
  638                 teken_funcs_cursor(t);
  639         } else {
  640                 teken_subr_do_scroll(t, 1);
  641         }
  642 }
  643 
  644 static void
  645 teken_subr_insert_character(const teken_t *t, unsigned int ncols)
  646 {
  647         teken_rect_t tr;
  648 
  649         tr.tr_begin = t->t_cursor;
  650         tr.tr_end.tp_row = t->t_cursor.tp_row + 1;
  651 
  652         if (t->t_cursor.tp_col + ncols >= t->t_winsize.tp_col) {
  653                 tr.tr_end.tp_col = t->t_winsize.tp_col;
  654         } else {
  655                 teken_pos_t tp;
  656 
  657                 /* Copy characters to the right. */
  658                 tr.tr_end.tp_col = t->t_winsize.tp_col - ncols;
  659                 tp.tp_row = t->t_cursor.tp_row;
  660                 tp.tp_col = t->t_cursor.tp_col + ncols;
  661                 teken_funcs_copy(t, &tr, &tp);
  662 
  663                 tr.tr_end.tp_col = t->t_cursor.tp_col + ncols;
  664         }
  665 
  666         /* Blank current location. */
  667         teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
  668 }
  669 
  670 static void
  671 teken_subr_insert_line(const teken_t *t, unsigned int nrows)
  672 {
  673         teken_rect_t tr;
  674 
  675         /* Ignore if outside scrolling region. */
  676         if (t->t_cursor.tp_row < t->t_scrollreg.ts_begin ||
  677             t->t_cursor.tp_row >= t->t_scrollreg.ts_end)
  678                 return;
  679 
  680         tr.tr_begin.tp_row = t->t_cursor.tp_row;
  681         tr.tr_begin.tp_col = 0;
  682         tr.tr_end.tp_col = t->t_winsize.tp_col;
  683 
  684         if (t->t_cursor.tp_row + nrows >= t->t_scrollreg.ts_end) {
  685                 tr.tr_end.tp_row = t->t_scrollreg.ts_end;
  686         } else {
  687                 teken_pos_t tp;
  688 
  689                 /* Copy lines down. */
  690                 tr.tr_end.tp_row = t->t_scrollreg.ts_end - nrows;
  691                 tp.tp_row = t->t_cursor.tp_row + nrows;
  692                 tp.tp_col = 0;
  693                 teken_funcs_copy(t, &tr, &tp);
  694 
  695                 tr.tr_end.tp_row = t->t_cursor.tp_row + nrows;
  696         }
  697 
  698         /* Blank current location. */
  699         teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
  700 }
  701 
  702 static void
  703 teken_subr_keypad_application_mode(const teken_t *t)
  704 {
  705 
  706         teken_funcs_param(t, TP_KEYPADAPP, 1);
  707 }
  708 
  709 static void
  710 teken_subr_keypad_numeric_mode(const teken_t *t)
  711 {
  712 
  713         teken_funcs_param(t, TP_KEYPADAPP, 0);
  714 }
  715 
  716 static void
  717 teken_subr_newline(teken_t *t)
  718 {
  719 
  720         t->t_cursor.tp_row++;
  721 
  722         if (t->t_cursor.tp_row >= t->t_scrollreg.ts_end) {
  723                 teken_subr_do_scroll(t, 1);
  724                 t->t_cursor.tp_row = t->t_scrollreg.ts_end - 1;
  725         }
  726 
  727         t->t_stateflags &= ~TS_WRAPPED;
  728         teken_funcs_cursor(t);
  729 }
  730 
  731 static void
  732 teken_subr_newpage(teken_t *t)
  733 {
  734 
  735         if (t->t_stateflags & TS_CONS25) {
  736                 teken_rect_t tr;
  737 
  738                 /* Clear screen. */
  739                 tr.tr_begin.tp_row = t->t_originreg.ts_begin;
  740                 tr.tr_begin.tp_col = 0;
  741                 tr.tr_end.tp_row = t->t_originreg.ts_end;
  742                 tr.tr_end.tp_col = t->t_winsize.tp_col;
  743                 teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
  744 
  745                 /* Cursor at top left. */
  746                 t->t_cursor.tp_row = t->t_originreg.ts_begin;
  747                 t->t_cursor.tp_col = 0;
  748                 t->t_stateflags &= ~TS_WRAPPED;
  749                 teken_funcs_cursor(t);
  750         } else {
  751                 teken_subr_newline(t);
  752         }
  753 }
  754 
  755 static void
  756 teken_subr_next_line(teken_t *t)
  757 {
  758 
  759         t->t_cursor.tp_col = 0;
  760         teken_subr_newline(t);
  761 }
  762 
  763 static void
  764 teken_subr_operating_system_command(teken_t *t)
  765 {
  766 
  767         teken_printf("Unsupported operating system command\n");
  768         t->t_stateflags |= TS_INSTRING;
  769 }
  770 
  771 static void
  772 teken_subr_pan_down(const teken_t *t, unsigned int nrows)
  773 {
  774 
  775         teken_subr_do_scroll(t, (int)nrows);
  776 }
  777 
  778 static void
  779 teken_subr_pan_up(const teken_t *t, unsigned int nrows)
  780 {
  781 
  782         teken_subr_do_scroll(t, -(int)nrows);
  783 }
  784 
  785 static void
  786 teken_subr_primary_device_attributes(const teken_t *t, unsigned int request)
  787 {
  788 
  789         if (request == 0) {
  790                 const char response[] = "\x1B[?1;2c";
  791 
  792                 teken_funcs_respond(t, response, sizeof response - 1);
  793         } else {
  794                 teken_printf("Unknown DA1\n");
  795         }
  796 }
  797 
  798 static void
  799 teken_subr_do_putchar(teken_t *t, const teken_pos_t *tp, teken_char_t c,
  800     int width)
  801 {
  802 
  803         t->t_last = c;
  804         if (t->t_stateflags & TS_INSERT &&
  805             tp->tp_col < t->t_winsize.tp_col - width) {
  806                 teken_rect_t ctr;
  807                 teken_pos_t ctp;
  808 
  809                 /* Insert mode. Move existing characters to the right. */
  810                 ctr.tr_begin = *tp;
  811                 ctr.tr_end.tp_row = tp->tp_row + 1;
  812                 ctr.tr_end.tp_col = t->t_winsize.tp_col - width;
  813                 ctp.tp_row = tp->tp_row;
  814                 ctp.tp_col = tp->tp_col + width;
  815                 teken_funcs_copy(t, &ctr, &ctp);
  816         }
  817 
  818         teken_funcs_putchar(t, tp, c, &t->t_curattr);
  819 
  820         if (width == 2 && tp->tp_col + 1 < t->t_winsize.tp_col) {
  821                 teken_pos_t tp2;
  822                 teken_attr_t attr;
  823 
  824                 /* Print second half of CJK fullwidth character. */
  825                 tp2.tp_row = tp->tp_row;
  826                 tp2.tp_col = tp->tp_col + 1;
  827                 attr = t->t_curattr;
  828                 attr.ta_format |= TF_CJK_RIGHT;
  829                 teken_funcs_putchar(t, &tp2, c, &attr);
  830         }
  831 }
  832 
  833 static void
  834 teken_subr_regular_character(teken_t *t, teken_char_t c)
  835 {
  836         int width;
  837 
  838         if (t->t_stateflags & TS_8BIT) {
  839                 if (!(t->t_stateflags & TS_CONS25) && (c <= 0x1b || c == 0x7f))
  840                         return;
  841                 c = teken_scs_process(t, c);
  842                 width = 1;
  843         } else {
  844                 c = teken_scs_process(t, c);
  845                 width = teken_wcwidth(c);
  846                 /* XXX: Don't process zero-width characters yet. */
  847                 if (width <= 0)
  848                         return;
  849         }
  850 
  851         if (t->t_stateflags & TS_CONS25) {
  852                 teken_subr_do_putchar(t, &t->t_cursor, c, width);
  853                 t->t_cursor.tp_col += width;
  854 
  855                 if (t->t_cursor.tp_col >= t->t_winsize.tp_col) {
  856                         if (t->t_cursor.tp_row == t->t_scrollreg.ts_end - 1) {
  857                                 /* Perform scrolling. */
  858                                 teken_subr_do_scroll(t, 1);
  859                         } else {
  860                                 /* No scrolling needed. */
  861                                 if (t->t_cursor.tp_row <
  862                                     t->t_winsize.tp_row - 1)
  863                                         t->t_cursor.tp_row++;
  864                         }
  865                         t->t_cursor.tp_col = 0;
  866                 }
  867         } else if (t->t_stateflags & TS_AUTOWRAP &&
  868             ((t->t_stateflags & TS_WRAPPED &&
  869             t->t_cursor.tp_col + 1 == t->t_winsize.tp_col) ||
  870             t->t_cursor.tp_col + width > t->t_winsize.tp_col)) {
  871                 teken_pos_t tp;
  872 
  873                 /*
  874                  * Perform line wrapping, if:
  875                  * - Autowrapping is enabled, and
  876                  *   - We're in the wrapped state at the last column, or
  877                  *   - The character to be printed does not fit anymore.
  878                  */
  879                 if (t->t_cursor.tp_row == t->t_scrollreg.ts_end - 1) {
  880                         /* Perform scrolling. */
  881                         teken_subr_do_scroll(t, 1);
  882                         tp.tp_row = t->t_scrollreg.ts_end - 1;
  883                 } else {
  884                         /* No scrolling needed. */
  885                         tp.tp_row = t->t_cursor.tp_row + 1;
  886                         if (tp.tp_row == t->t_winsize.tp_row) {
  887                                 /*
  888                                  * Corner case: regular character
  889                                  * outside scrolling region, but at the
  890                                  * bottom of the screen.
  891                                  */
  892                                 teken_subr_do_putchar(t, &t->t_cursor,
  893                                     c, width);
  894                                 return;
  895                         }
  896                 }
  897 
  898                 tp.tp_col = 0;
  899                 teken_subr_do_putchar(t, &tp, c, width);
  900 
  901                 t->t_cursor.tp_row = tp.tp_row;
  902                 t->t_cursor.tp_col = width;
  903                 t->t_stateflags &= ~TS_WRAPPED;
  904         } else {
  905                 /* No line wrapping needed. */
  906                 teken_subr_do_putchar(t, &t->t_cursor, c, width);
  907                 t->t_cursor.tp_col += width;
  908 
  909                 if (t->t_cursor.tp_col >= t->t_winsize.tp_col) {
  910                         t->t_stateflags |= TS_WRAPPED;
  911                         t->t_cursor.tp_col = t->t_winsize.tp_col - 1;
  912                 } else {
  913                         t->t_stateflags &= ~TS_WRAPPED;
  914                 }
  915         }
  916 
  917         teken_funcs_cursor(t);
  918 }
  919 
  920 static void
  921 teken_subr_reset_dec_mode(teken_t *t, unsigned int cmd)
  922 {
  923 
  924         switch (cmd) {
  925         case 1: /* Cursor keys mode. */
  926                 t->t_stateflags &= ~TS_CURSORKEYS;
  927                 break;
  928         case 2: /* DECANM: ANSI/VT52 mode. */
  929                 teken_printf("DECRST VT52\n");
  930                 break;
  931         case 3: /* 132 column mode. */
  932                 teken_funcs_param(t, TP_132COLS, 0);
  933                 teken_subr_reset_to_initial_state(t);
  934                 break;
  935         case 5: /* Inverse video. */
  936                 teken_printf("DECRST inverse video\n");
  937                 break;
  938         case 6: /* Origin mode. */
  939                 t->t_stateflags &= ~TS_ORIGIN;
  940                 t->t_originreg.ts_begin = 0;
  941                 t->t_originreg.ts_end = t->t_winsize.tp_row;
  942                 t->t_cursor.tp_row = t->t_cursor.tp_col = 0;
  943                 t->t_stateflags &= ~TS_WRAPPED;
  944                 teken_funcs_cursor(t);
  945                 break;
  946         case 7: /* Autowrap mode. */
  947                 t->t_stateflags &= ~TS_AUTOWRAP;
  948                 break;
  949         case 8: /* Autorepeat mode. */
  950                 teken_funcs_param(t, TP_AUTOREPEAT, 0);
  951                 break;
  952         case 25: /* Hide cursor. */
  953                 teken_funcs_param(t, TP_SHOWCURSOR, 0);
  954                 break;
  955         case 40: /* Disallow 132 columns. */
  956                 teken_printf("DECRST allow 132\n");
  957                 break;
  958         case 45: /* Disable reverse wraparound. */
  959                 teken_printf("DECRST reverse wraparound\n");
  960                 break;
  961         case 47: /* Switch to alternate buffer. */
  962                 teken_printf("Switch to alternate buffer\n");
  963                 break;
  964         case 1000: /* Mouse input. */
  965                 teken_funcs_param(t, TP_MOUSE, 0);
  966                 break;
  967         default:
  968                 teken_printf("Unknown DECRST: %u\n", cmd);
  969         }
  970 }
  971 
  972 static void
  973 teken_subr_reset_mode(teken_t *t, unsigned int cmd)
  974 {
  975 
  976         switch (cmd) {
  977         case 4:
  978                 t->t_stateflags &= ~TS_INSERT;
  979                 break;
  980         default:
  981                 teken_printf("Unknown reset mode: %u\n", cmd);
  982         }
  983 }
  984 
  985 static void
  986 teken_subr_do_resize(teken_t *t)
  987 {
  988 
  989         t->t_scrollreg.ts_begin = 0;
  990         t->t_scrollreg.ts_end = t->t_winsize.tp_row;
  991         t->t_originreg = t->t_scrollreg;
  992 }
  993 
  994 static void
  995 teken_subr_do_reset(teken_t *t)
  996 {
  997 
  998         t->t_curattr = t->t_defattr;
  999         t->t_cursor.tp_row = t->t_cursor.tp_col = 0;
 1000         t->t_scrollreg.ts_begin = 0;
 1001         t->t_scrollreg.ts_end = t->t_winsize.tp_row;
 1002         t->t_originreg = t->t_scrollreg;
 1003         t->t_stateflags &= TS_8BIT | TS_CONS25 | TS_CONS25KEYS;
 1004         t->t_stateflags |= TS_AUTOWRAP;
 1005 
 1006         t->t_scs[0] = teken_scs_us_ascii;
 1007         t->t_scs[1] = teken_scs_us_ascii;
 1008         t->t_curscs = 0;
 1009 
 1010         teken_subr_save_cursor(t);
 1011         teken_tab_default(t);
 1012 }
 1013 
 1014 static void
 1015 teken_subr_reset_to_initial_state(teken_t *t)
 1016 {
 1017 
 1018         teken_subr_do_reset(t);
 1019         teken_subr_erase_display(t, 2);
 1020         teken_funcs_param(t, TP_SHOWCURSOR, 1);
 1021         teken_funcs_cursor(t);
 1022 }
 1023 
 1024 static void
 1025 teken_subr_restore_cursor(teken_t *t)
 1026 {
 1027 
 1028         t->t_cursor = t->t_saved_cursor;
 1029         t->t_curattr = t->t_saved_curattr;
 1030         t->t_scs[t->t_curscs] = t->t_saved_curscs;
 1031         t->t_stateflags &= ~TS_WRAPPED;
 1032 
 1033         /* Get out of origin mode when the cursor is moved outside. */
 1034         if (t->t_cursor.tp_row < t->t_originreg.ts_begin ||
 1035             t->t_cursor.tp_row >= t->t_originreg.ts_end) {
 1036                 t->t_stateflags &= ~TS_ORIGIN;
 1037                 t->t_originreg.ts_begin = 0;
 1038                 t->t_originreg.ts_end = t->t_winsize.tp_row;
 1039         }
 1040 
 1041         teken_funcs_cursor(t);
 1042 }
 1043 
 1044 static void
 1045 teken_subr_reverse_index(teken_t *t)
 1046 {
 1047 
 1048         if (t->t_cursor.tp_row > t->t_scrollreg.ts_begin) {
 1049                 t->t_cursor.tp_row--;
 1050                 t->t_stateflags &= ~TS_WRAPPED;
 1051                 teken_funcs_cursor(t);
 1052         } else {
 1053                 teken_subr_do_scroll(t, -1);
 1054         }
 1055 }
 1056 
 1057 static void
 1058 teken_subr_save_cursor(teken_t *t)
 1059 {
 1060 
 1061         t->t_saved_cursor = t->t_cursor;
 1062         t->t_saved_curattr = t->t_curattr;
 1063         t->t_saved_curscs = t->t_scs[t->t_curscs];
 1064 }
 1065 
 1066 static void
 1067 teken_subr_secondary_device_attributes(const teken_t *t, unsigned int request)
 1068 {
 1069 
 1070         if (request == 0) {
 1071                 const char response[] = "\x1B[>0;10;0c";
 1072                 teken_funcs_respond(t, response, sizeof response - 1);
 1073         } else {
 1074                 teken_printf("Unknown DA2\n");
 1075         }
 1076 }
 1077 
 1078 static void
 1079 teken_subr_set_dec_mode(teken_t *t, unsigned int cmd)
 1080 {
 1081 
 1082         switch (cmd) {
 1083         case 1: /* Cursor keys mode. */
 1084                 t->t_stateflags |= TS_CURSORKEYS;
 1085                 break;
 1086         case 2: /* DECANM: ANSI/VT52 mode. */
 1087                 teken_printf("DECSET VT52\n");
 1088                 break;
 1089         case 3: /* 132 column mode. */
 1090                 teken_funcs_param(t, TP_132COLS, 1);
 1091                 teken_subr_reset_to_initial_state(t);
 1092                 break;
 1093         case 5: /* Inverse video. */
 1094                 teken_printf("DECSET inverse video\n");
 1095                 break;
 1096         case 6: /* Origin mode. */
 1097                 t->t_stateflags |= TS_ORIGIN;
 1098                 t->t_originreg = t->t_scrollreg;
 1099                 t->t_cursor.tp_row = t->t_scrollreg.ts_begin;
 1100                 t->t_cursor.tp_col = 0;
 1101                 t->t_stateflags &= ~TS_WRAPPED;
 1102                 teken_funcs_cursor(t);
 1103                 break;
 1104         case 7: /* Autowrap mode. */
 1105                 t->t_stateflags |= TS_AUTOWRAP;
 1106                 break;
 1107         case 8: /* Autorepeat mode. */
 1108                 teken_funcs_param(t, TP_AUTOREPEAT, 1);
 1109                 break;
 1110         case 25: /* Display cursor. */
 1111                 teken_funcs_param(t, TP_SHOWCURSOR, 1);
 1112                 break;
 1113         case 40: /* Allow 132 columns. */
 1114                 teken_printf("DECSET allow 132\n");
 1115                 break;
 1116         case 45: /* Enable reverse wraparound. */
 1117                 teken_printf("DECSET reverse wraparound\n");
 1118                 break;
 1119         case 47: /* Switch to alternate buffer. */
 1120                 teken_printf("Switch away from alternate buffer\n");
 1121                 break;
 1122         case 1000: /* Mouse input. */
 1123                 teken_funcs_param(t, TP_MOUSE, 1);
 1124                 break;
 1125         default:
 1126                 teken_printf("Unknown DECSET: %u\n", cmd);
 1127         }
 1128 }
 1129 
 1130 static void
 1131 teken_subr_set_mode(teken_t *t, unsigned int cmd)
 1132 {
 1133 
 1134         switch (cmd) {
 1135         case 4:
 1136                 teken_printf("Insert mode\n");
 1137                 t->t_stateflags |= TS_INSERT;
 1138                 break;
 1139         default:
 1140                 teken_printf("Unknown set mode: %u\n", cmd);
 1141         }
 1142 }
 1143 
 1144 static void
 1145 teken_subr_set_graphic_rendition(teken_t *t, unsigned int ncmds,
 1146     const unsigned int cmds[])
 1147 {
 1148         unsigned int i, n;
 1149 
 1150         /* No attributes means reset. */
 1151         if (ncmds == 0) {
 1152                 t->t_curattr = t->t_defattr;
 1153                 return;
 1154         }
 1155 
 1156         for (i = 0; i < ncmds; i++) {
 1157                 n = cmds[i];
 1158 
 1159                 switch (n) {
 1160                 case 0: /* Reset. */
 1161                         t->t_curattr = t->t_defattr;
 1162                         break;
 1163                 case 1: /* Bold. */
 1164                         t->t_curattr.ta_format |= TF_BOLD;
 1165                         break;
 1166                 case 4: /* Underline. */
 1167                         t->t_curattr.ta_format |= TF_UNDERLINE;
 1168                         break;
 1169                 case 5: /* Blink. */
 1170                         t->t_curattr.ta_format |= TF_BLINK;
 1171                         break;
 1172                 case 7: /* Reverse. */
 1173                         t->t_curattr.ta_format |= TF_REVERSE;
 1174                         break;
 1175                 case 22: /* Remove bold. */
 1176                         t->t_curattr.ta_format &= ~TF_BOLD;
 1177                         break;
 1178                 case 24: /* Remove underline. */
 1179                         t->t_curattr.ta_format &= ~TF_UNDERLINE;
 1180                         break;
 1181                 case 25: /* Remove blink. */
 1182                         t->t_curattr.ta_format &= ~TF_BLINK;
 1183                         break;
 1184                 case 27: /* Remove reverse. */
 1185                         t->t_curattr.ta_format &= ~TF_REVERSE;
 1186                         break;
 1187                 case 30: /* Set foreground color: black */
 1188                 case 31: /* Set foreground color: red */
 1189                 case 32: /* Set foreground color: green */
 1190                 case 33: /* Set foreground color: brown */
 1191                 case 34: /* Set foreground color: blue */
 1192                 case 35: /* Set foreground color: magenta */
 1193                 case 36: /* Set foreground color: cyan */
 1194                 case 37: /* Set foreground color: white */
 1195                         t->t_curattr.ta_fgcolor = n - 30;
 1196                         break;
 1197                 case 38: /* Set foreground color: 256 color mode */
 1198                         if (i + 2 >= ncmds || cmds[i + 1] != 5)
 1199                                 continue;
 1200                         t->t_curattr.ta_fgcolor = cmds[i + 2];
 1201                         i += 2;
 1202                         break;
 1203                 case 39: /* Set default foreground color. */
 1204                         t->t_curattr.ta_fgcolor = t->t_defattr.ta_fgcolor;
 1205                         break;
 1206                 case 40: /* Set background color: black */
 1207                 case 41: /* Set background color: red */
 1208                 case 42: /* Set background color: green */
 1209                 case 43: /* Set background color: brown */
 1210                 case 44: /* Set background color: blue */
 1211                 case 45: /* Set background color: magenta */
 1212                 case 46: /* Set background color: cyan */
 1213                 case 47: /* Set background color: white */
 1214                         t->t_curattr.ta_bgcolor = n - 40;
 1215                         break;
 1216                 case 48: /* Set background color: 256 color mode */
 1217                         if (i + 2 >= ncmds || cmds[i + 1] != 5)
 1218                                 continue;
 1219                         t->t_curattr.ta_bgcolor = cmds[i + 2];
 1220                         i += 2;
 1221                         break;
 1222                 case 49: /* Set default background color. */
 1223                         t->t_curattr.ta_bgcolor = t->t_defattr.ta_bgcolor;
 1224                         break;
 1225                 case 90: /* Set bright foreground color: black */
 1226                 case 91: /* Set bright foreground color: red */
 1227                 case 92: /* Set bright foreground color: green */
 1228                 case 93: /* Set bright foreground color: brown */
 1229                 case 94: /* Set bright foreground color: blue */
 1230                 case 95: /* Set bright foreground color: magenta */
 1231                 case 96: /* Set bright foreground color: cyan */
 1232                 case 97: /* Set bright foreground color: white */
 1233                         t->t_curattr.ta_fgcolor = (n - 90) + 8;
 1234                         break;
 1235                 case 100: /* Set bright background color: black */
 1236                 case 101: /* Set bright background color: red */
 1237                 case 102: /* Set bright background color: green */
 1238                 case 103: /* Set bright background color: brown */
 1239                 case 104: /* Set bright background color: blue */
 1240                 case 105: /* Set bright background color: magenta */
 1241                 case 106: /* Set bright background color: cyan */
 1242                 case 107: /* Set bright background color: white */
 1243                         t->t_curattr.ta_bgcolor = (n - 100) + 8;
 1244                         break;
 1245                 default:
 1246                         teken_printf("unsupported attribute %u\n", n);
 1247                 }
 1248         }
 1249 }
 1250 
 1251 static void
 1252 teken_subr_set_top_and_bottom_margins(teken_t *t, unsigned int top,
 1253     unsigned int bottom)
 1254 {
 1255 
 1256         /* Adjust top row number. */
 1257         if (top > 0)
 1258                 top--;
 1259         /* Adjust bottom row number. */
 1260         if (bottom == 0 || bottom > t->t_winsize.tp_row)
 1261                 bottom = t->t_winsize.tp_row;
 1262 
 1263         /* Invalid arguments. */
 1264         if (top >= bottom - 1) {
 1265                 top = 0;
 1266                 bottom = t->t_winsize.tp_row;
 1267         }
 1268 
 1269         /* Apply scrolling region. */
 1270         t->t_scrollreg.ts_begin = top;
 1271         t->t_scrollreg.ts_end = bottom;
 1272         if (t->t_stateflags & TS_ORIGIN)
 1273                 t->t_originreg = t->t_scrollreg;
 1274 
 1275         /* Home cursor to the top left of the scrolling region. */
 1276         t->t_cursor.tp_row = t->t_originreg.ts_begin;
 1277         t->t_cursor.tp_col = 0;
 1278         t->t_stateflags &= ~TS_WRAPPED;
 1279         teken_funcs_cursor(t);
 1280 }
 1281 
 1282 static void
 1283 teken_subr_single_height_double_width_line(const teken_t *t)
 1284 {
 1285 
 1286         (void)t;
 1287         teken_printf("single height double width???\n");
 1288 }
 1289 
 1290 static void
 1291 teken_subr_single_height_single_width_line(const teken_t *t)
 1292 {
 1293 
 1294         (void)t;
 1295         teken_printf("single height single width???\n");
 1296 }
 1297 
 1298 static void
 1299 teken_subr_string_terminator(const teken_t *t)
 1300 {
 1301 
 1302         (void)t;
 1303         /*
 1304          * Strings are already terminated in teken_input_char() when ^[
 1305          * is inserted.
 1306          */
 1307 }
 1308 
 1309 static void
 1310 teken_subr_tab_clear(teken_t *t, unsigned int cmd)
 1311 {
 1312 
 1313         switch (cmd) {
 1314         case 0:
 1315                 teken_tab_clear(t, t->t_cursor.tp_col);
 1316                 break;
 1317         case 3:
 1318                 memset(t->t_tabstops, 0, T_NUMCOL / 8);
 1319                 break;
 1320         default:
 1321                 break;
 1322         }
 1323 }
 1324 
 1325 static void
 1326 teken_subr_vertical_position_absolute(teken_t *t, unsigned int row)
 1327 {
 1328 
 1329         row = (row - 1) + t->t_originreg.ts_begin;
 1330         t->t_cursor.tp_row = row < t->t_originreg.ts_end ?
 1331             row : t->t_originreg.ts_end - 1;
 1332 
 1333         t->t_stateflags &= ~TS_WRAPPED;
 1334         teken_funcs_cursor(t);
 1335 }
 1336 
 1337 static void
 1338 teken_subr_repeat_last_graphic_char(teken_t *t, unsigned int rpts)
 1339 {
 1340         unsigned int max_repetitions;
 1341 
 1342         max_repetitions = t->t_winsize.tp_row * t->t_winsize.tp_col;
 1343         if (rpts > max_repetitions)
 1344                 rpts = max_repetitions;
 1345         for (; t->t_last != 0 && rpts > 0; rpts--)
 1346                 teken_subr_regular_character(t, t->t_last);
 1347 }
Cache object: ab6235772e4976307d7d2beb29f476d6
[ 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.
FreeBSD/Linux Kernel Cross Reference sys/teken/teken_subr.h

FreeBSD/Linux Kernel Cross Reference
sys/teken/teken_subr.h
