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