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