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