teken_subr.h revision 197114 
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 197114 2009-09-12 08:19:24Z 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_scrollreg.ts_begin = 0;
189	t->t_scrollreg.ts_end = t->t_winsize.tp_row;
190
191	t->t_cursor.tp_row = t->t_cursor.tp_col = 0;
192	t->t_stateflags &= ~TS_WRAPPED;
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#ifdef TEKEN_XTERM
206	if (t->t_cursor.tp_col == 0)
207		return;
208
209	t->t_cursor.tp_col--;
210	t->t_stateflags &= ~TS_WRAPPED;
211#else /* !TEKEN_XTERM */
212	if (t->t_cursor.tp_col == 0) {
213		if (t->t_cursor.tp_row == t->t_originreg.ts_begin)
214			return;
215		t->t_cursor.tp_row--;
216		t->t_cursor.tp_col = t->t_winsize.tp_col - 1;
217	} else {
218		t->t_cursor.tp_col--;
219	}
220#endif /* TEKEN_XTERM */
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 (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	tr.tr_begin.tp_col = 0;
401	tr.tr_end.tp_row = t->t_scrollreg.ts_end;
402	tr.tr_end.tp_col = t->t_winsize.tp_col;
403
404	if (t->t_cursor.tp_row + nrows >= t->t_scrollreg.ts_end) {
405		tr.tr_begin.tp_row = t->t_cursor.tp_row;
406	} else {
407		teken_pos_t tp;
408
409		/* Copy rows up. */
410		tr.tr_begin.tp_row = t->t_cursor.tp_row + nrows;
411		tp.tp_row = t->t_cursor.tp_row;
412		tp.tp_col = 0;
413		teken_funcs_copy(t, &tr, &tp);
414
415		tr.tr_begin.tp_row = t->t_scrollreg.ts_end - nrows;
416	}
417
418	/* Blank trailing rows. */
419	teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
420}
421
422static void
423teken_subr_device_control_string(teken_t *t __unused)
424{
425
426	teken_printf("device control string???\n");
427}
428
429static void
430teken_subr_device_status_report(teken_t *t, unsigned int cmd)
431{
432	char response[19] = "\x1B[?";
433	ssize_t len;
434
435	len = teken_subr_do_cpr(t, cmd, response + 3);
436	if (len < 0)
437		return;
438
439	teken_funcs_respond(t, response, len + 3);
440}
441
442static void
443teken_subr_double_height_double_width_line_top(teken_t *t __unused)
444{
445
446	teken_printf("double height double width top\n");
447}
448
449static void
450teken_subr_double_height_double_width_line_bottom(teken_t *t __unused)
451{
452
453	teken_printf("double height double width bottom\n");
454}
455
456static void
457teken_subr_erase_character(teken_t *t, unsigned int ncols)
458{
459	teken_rect_t tr;
460
461	tr.tr_begin = t->t_cursor;
462	tr.tr_end.tp_row = t->t_cursor.tp_row + 1;
463
464	if (t->t_cursor.tp_col + ncols >= t->t_winsize.tp_col)
465		tr.tr_end.tp_col = t->t_winsize.tp_col;
466	else
467		tr.tr_end.tp_col = t->t_cursor.tp_col + ncols;
468
469	teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
470}
471
472static void
473teken_subr_erase_display(teken_t *t, unsigned int mode)
474{
475	teken_rect_t r;
476
477	r.tr_begin.tp_col = 0;
478	r.tr_end.tp_col = t->t_winsize.tp_col;
479
480	switch (mode) {
481	case 1: /* Erase from the top to the cursor. */
482		teken_subr_erase_line(t, 1);
483
484		/* Erase lines above. */
485		if (t->t_cursor.tp_row == 0)
486			return;
487		r.tr_begin.tp_row = 0;
488		r.tr_end.tp_row = t->t_cursor.tp_row;
489		break;
490	case 2: /* Erase entire display. */
491		r.tr_begin.tp_row = 0;
492		r.tr_end.tp_row = t->t_winsize.tp_row;
493		break;
494	default: /* Erase from cursor to the bottom. */
495		teken_subr_erase_line(t, 0);
496
497		/* Erase lines below. */
498		if (t->t_cursor.tp_row == t->t_winsize.tp_row - 1)
499			return;
500		r.tr_begin.tp_row = t->t_cursor.tp_row + 1;
501		r.tr_end.tp_row = t->t_winsize.tp_row;
502		break;
503	}
504
505	teken_funcs_fill(t, &r, BLANK, &t->t_curattr);
506}
507
508static void
509teken_subr_erase_line(teken_t *t, unsigned int mode)
510{
511	teken_rect_t r;
512
513	r.tr_begin.tp_row = t->t_cursor.tp_row;
514	r.tr_end.tp_row = t->t_cursor.tp_row + 1;
515
516	switch (mode) {
517	case 1: /* Erase from the beginning of the line to the cursor. */
518		r.tr_begin.tp_col = 0;
519		r.tr_end.tp_col = t->t_cursor.tp_col + 1;
520		break;
521	case 2: /* Erase entire line. */
522		r.tr_begin.tp_col = 0;
523		r.tr_end.tp_col = t->t_winsize.tp_col;
524		break;
525	default: /* Erase from cursor to the end of the line. */
526		r.tr_begin.tp_col = t->t_cursor.tp_col;
527		r.tr_end.tp_col = t->t_winsize.tp_col;
528		break;
529	}
530
531	teken_funcs_fill(t, &r, BLANK, &t->t_curattr);
532}
533
534static void
535teken_subr_g0_scs_special_graphics(teken_t *t __unused)
536{
537
538	teken_scs_set(t, 0, teken_scs_special_graphics);
539}
540
541static void
542teken_subr_g0_scs_uk_national(teken_t *t __unused)
543{
544
545	teken_scs_set(t, 0, teken_scs_uk_national);
546}
547
548static void
549teken_subr_g0_scs_us_ascii(teken_t *t __unused)
550{
551
552	teken_scs_set(t, 0, teken_scs_us_ascii);
553}
554
555static void
556teken_subr_g1_scs_special_graphics(teken_t *t __unused)
557{
558
559	teken_scs_set(t, 1, teken_scs_special_graphics);
560}
561
562static void
563teken_subr_g1_scs_uk_national(teken_t *t __unused)
564{
565
566	teken_scs_set(t, 1, teken_scs_uk_national);
567}
568
569static void
570teken_subr_g1_scs_us_ascii(teken_t *t __unused)
571{
572
573	teken_scs_set(t, 1, teken_scs_us_ascii);
574}
575
576static void
577teken_subr_horizontal_position_absolute(teken_t *t, unsigned int col)
578{
579
580	t->t_cursor.tp_col = col - 1;
581	if (t->t_cursor.tp_col >= t->t_winsize.tp_col)
582		t->t_cursor.tp_col = t->t_winsize.tp_col - 1;
583
584	t->t_stateflags &= ~TS_WRAPPED;
585	teken_funcs_cursor(t);
586}
587
588static void
589teken_subr_horizontal_tab(teken_t *t)
590{
591#ifdef TEKEN_XTERM
592	teken_rect_t tr;
593
594	tr.tr_begin = t->t_cursor;
595	teken_subr_cursor_forward_tabulation(t, 1);
596	tr.tr_end.tp_row = tr.tr_begin.tp_row + 1;
597	tr.tr_end.tp_col = t->t_cursor.tp_col;
598
599	/* Blank region that we skipped. */
600	if (tr.tr_end.tp_col > tr.tr_begin.tp_col)
601		teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
602#else /* !TEKEN_XTERM */
603
604	teken_subr_cursor_forward_tabulation(t, 1);
605#endif /* TEKEN_XTERM */
606}
607
608static void
609teken_subr_horizontal_tab_set(teken_t *t)
610{
611
612	teken_tab_set(t, t->t_cursor.tp_col);
613}
614
615static void
616teken_subr_index(teken_t *t)
617{
618
619	if (t->t_cursor.tp_row < t->t_scrollreg.ts_end - 1) {
620		t->t_cursor.tp_row++;
621		t->t_stateflags &= ~TS_WRAPPED;
622		teken_funcs_cursor(t);
623	} else {
624		teken_subr_do_scroll(t, 1);
625	}
626}
627
628static void
629teken_subr_insert_character(teken_t *t, unsigned int ncols)
630{
631	teken_rect_t tr;
632
633	tr.tr_begin = t->t_cursor;
634	tr.tr_end.tp_row = t->t_cursor.tp_row + 1;
635
636	if (t->t_cursor.tp_col + ncols >= t->t_winsize.tp_col) {
637		tr.tr_end.tp_col = t->t_winsize.tp_col;
638	} else {
639		teken_pos_t tp;
640
641		/* Copy characters to the right. */
642		tr.tr_end.tp_col = t->t_winsize.tp_col - ncols;
643		tp.tp_row = t->t_cursor.tp_row;
644		tp.tp_col = t->t_cursor.tp_col + ncols;
645		teken_funcs_copy(t, &tr, &tp);
646
647		tr.tr_end.tp_col = t->t_cursor.tp_col + ncols;
648	}
649
650	/* Blank current location. */
651	teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
652}
653
654static void
655teken_subr_insert_line(teken_t *t, unsigned int nrows)
656{
657	teken_rect_t tr;
658
659	tr.tr_begin.tp_row = t->t_cursor.tp_row;
660	tr.tr_begin.tp_col = 0;
661	tr.tr_end.tp_col = t->t_winsize.tp_col;
662
663	if (t->t_cursor.tp_row + nrows >= t->t_scrollreg.ts_end) {
664		tr.tr_end.tp_row = t->t_scrollreg.ts_end;
665	} else {
666		teken_pos_t tp;
667
668		/* Copy lines down. */
669		tr.tr_end.tp_row = t->t_scrollreg.ts_end - nrows;
670		tp.tp_row = t->t_cursor.tp_row + nrows;
671		tp.tp_col = 0;
672		teken_funcs_copy(t, &tr, &tp);
673
674		tr.tr_end.tp_row = t->t_cursor.tp_row + nrows;
675	}
676
677	/* Blank current location. */
678	teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
679}
680
681static void
682teken_subr_keypad_application_mode(teken_t *t)
683{
684
685	teken_funcs_param(t, TP_KEYPADAPP, 1);
686}
687
688static void
689teken_subr_keypad_numeric_mode(teken_t *t)
690{
691
692	teken_funcs_param(t, TP_KEYPADAPP, 0);
693}
694
695static void
696teken_subr_newline(teken_t *t)
697{
698
699	t->t_cursor.tp_row++;
700
701	if (t->t_cursor.tp_row >= t->t_scrollreg.ts_end) {
702		teken_subr_do_scroll(t, 1);
703		t->t_cursor.tp_row = t->t_scrollreg.ts_end - 1;
704	}
705
706	t->t_stateflags &= ~TS_WRAPPED;
707	teken_funcs_cursor(t);
708}
709
710static void
711teken_subr_newpage(teken_t *t)
712{
713#ifdef TEKEN_XTERM
714
715	teken_subr_newline(t);
716#else /* !TEKEN_XTERM */
717	teken_rect_t tr;
718
719	tr.tr_begin.tp_row = tr.tr_begin.tp_col = 0;
720	tr.tr_end = t->t_winsize;
721	teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
722
723	t->t_cursor.tp_row = t->t_cursor.tp_col = 0;
724	teken_funcs_cursor(t);
725#endif /* TEKEN_XTERM */
726}
727
728static void
729teken_subr_next_line(teken_t *t)
730{
731
732	t->t_cursor.tp_col = 0;
733	teken_subr_newline(t);
734}
735
736static void
737teken_subr_pan_down(teken_t *t, unsigned int nrows)
738{
739
740	teken_subr_do_scroll(t, (int)nrows);
741}
742
743static void
744teken_subr_pan_up(teken_t *t, unsigned int nrows)
745{
746
747	teken_subr_do_scroll(t, -(int)nrows);
748}
749
750static void
751teken_subr_primary_device_attributes(teken_t *t, unsigned int request)
752{
753
754	if (request == 0) {
755		const char response[] = "\x1B[?1;2c";
756
757		teken_funcs_respond(t, response, sizeof response - 1);
758	} else {
759		teken_printf("Unknown DA1\n");
760	}
761}
762
763static void
764teken_subr_do_putchar(teken_t *t, const teken_pos_t *tp, teken_char_t c,
765    int width)
766{
767
768	if (t->t_stateflags & TS_INSERT &&
769	    tp->tp_col < t->t_winsize.tp_col - width) {
770		teken_rect_t ctr;
771		teken_pos_t ctp;
772
773		/* Insert mode. Move existing characters to the right. */
774		ctr.tr_begin = *tp;
775		ctr.tr_end.tp_row = tp->tp_row + 1;
776		ctr.tr_end.tp_col = t->t_winsize.tp_col - width;
777		ctp.tp_row = tp->tp_row;
778		ctp.tp_col = tp->tp_col + width;
779		teken_funcs_copy(t, &ctr, &ctp);
780	}
781
782	teken_funcs_putchar(t, tp, c, &t->t_curattr);
783}
784
785static void
786teken_subr_regular_character(teken_t *t, teken_char_t c)
787{
788	int width;
789
790	c = teken_scs_process(t, c);
791
792	/* XXX: Don't process zero-width characters yet. */
793	width = teken_wcwidth(c);
794	if (width <= 0)
795		return;
796
797#ifdef TEKEN_XTERM
798	if (t->t_cursor.tp_col == t->t_winsize.tp_col - 1 &&
799	    (t->t_stateflags & (TS_WRAPPED|TS_AUTOWRAP)) ==
800	    (TS_WRAPPED|TS_AUTOWRAP)) {
801		teken_pos_t tp;
802
803		/* Perform line wrapping. */
804
805		if (t->t_cursor.tp_row == t->t_scrollreg.ts_end - 1) {
806			/* Perform scrolling. */
807			teken_subr_do_scroll(t, 1);
808			tp.tp_row = t->t_scrollreg.ts_end - 1;
809		} else {
810			/* No scrolling needed. */
811			tp.tp_row = t->t_cursor.tp_row + 1;
812			if (tp.tp_row == t->t_winsize.tp_row) {
813				/*
814				 * Corner case: regular character
815				 * outside scrolling region, but at the
816				 * bottom of the screen.
817				 */
818				teken_subr_do_putchar(t, &t->t_cursor,
819				    c, width);
820				return;
821			}
822		}
823
824		tp.tp_col = 0;
825		teken_subr_do_putchar(t, &tp, c, width);
826
827		t->t_cursor.tp_row = tp.tp_row;
828		t->t_cursor.tp_col = width;
829		t->t_stateflags &= ~TS_WRAPPED;
830	} else {
831		/* No line wrapping needed. */
832		teken_subr_do_putchar(t, &t->t_cursor, c, width);
833		t->t_cursor.tp_col += width;
834
835		if (t->t_cursor.tp_col >= t->t_winsize.tp_col) {
836			t->t_stateflags |= TS_WRAPPED;
837			t->t_cursor.tp_col = t->t_winsize.tp_col - 1;
838		} else {
839			t->t_stateflags &= ~TS_WRAPPED;
840		}
841	}
842#else /* !TEKEN_XTERM */
843	teken_subr_do_putchar(t, &t->t_cursor, c, width);
844	t->t_cursor.tp_col += width;
845
846	if (t->t_cursor.tp_col >= t->t_winsize.tp_col) {
847		if (t->t_cursor.tp_row == t->t_scrollreg.ts_end - 1) {
848			/* Perform scrolling. */
849			teken_subr_do_scroll(t, 1);
850		} else {
851			/* No scrolling needed. */
852			if (t->t_cursor.tp_row < t->t_winsize.tp_row - 1)
853				t->t_cursor.tp_row++;
854		}
855		t->t_cursor.tp_col = 0;
856	}
857#endif /* TEKEN_XTERM */
858
859	teken_funcs_cursor(t);
860}
861
862static void
863teken_subr_reset_dec_mode(teken_t *t, unsigned int cmd)
864{
865
866	switch (cmd) {
867	case 1: /* Cursor keys mode. */
868		teken_funcs_param(t, TP_CURSORKEYS, 0);
869		break;
870	case 2: /* DECANM: ANSI/VT52 mode. */
871		teken_printf("DECRST VT52\n");
872		break;
873	case 3: /* 132 column mode. */
874		teken_funcs_param(t, TP_132COLS, 0);
875		teken_subr_reset_to_initial_state(t);
876		break;
877	case 5: /* Inverse video. */
878		teken_printf("DECRST inverse video\n");
879		break;
880	case 6: /* Origin mode. */
881		t->t_stateflags &= ~TS_ORIGIN;
882		t->t_originreg.ts_begin = 0;
883		t->t_originreg.ts_end = t->t_winsize.tp_row;
884		t->t_cursor.tp_row = t->t_cursor.tp_col = 0;
885		t->t_stateflags &= ~TS_WRAPPED;
886		teken_funcs_cursor(t);
887		break;
888	case 7: /* Autowrap mode. */
889		t->t_stateflags &= ~TS_AUTOWRAP;
890		break;
891	case 8: /* Autorepeat mode. */
892		teken_funcs_param(t, TP_AUTOREPEAT, 0);
893		break;
894	case 25: /* Hide cursor. */
895		teken_funcs_param(t, TP_SHOWCURSOR, 0);
896		break;
897	case 40: /* Disallow 132 columns. */
898		teken_printf("DECRST allow 132\n");
899		break;
900	case 45: /* Disable reverse wraparound. */
901		teken_printf("DECRST reverse wraparound\n");
902		break;
903	case 47: /* Switch to alternate buffer. */
904		teken_printf("Switch to alternate buffer\n");
905		break;
906	default:
907		teken_printf("Unknown DECRST: %u\n", cmd);
908	}
909}
910
911static void
912teken_subr_reset_mode(teken_t *t, unsigned int cmd)
913{
914
915	switch (cmd) {
916	case 4:
917		t->t_stateflags &= ~TS_INSERT;
918		break;
919	default:
920		teken_printf("Unknown reset mode: %u\n", cmd);
921	}
922}
923
924static void
925teken_subr_do_reset(teken_t *t)
926{
927
928	t->t_curattr = t->t_defattr;
929	t->t_cursor.tp_row = t->t_cursor.tp_col = 0;
930	t->t_scrollreg.ts_begin = 0;
931	t->t_scrollreg.ts_end = t->t_winsize.tp_row;
932	t->t_originreg = t->t_scrollreg;
933	t->t_stateflags = TS_AUTOWRAP;
934
935	teken_scs_set(t, 0, teken_scs_us_ascii);
936	teken_scs_set(t, 1, teken_scs_us_ascii);
937	teken_scs_switch(t, 0);
938
939	teken_subr_save_cursor(t);
940	teken_tab_default(t);
941}
942
943static void
944teken_subr_reset_to_initial_state(teken_t *t)
945{
946
947	teken_subr_do_reset(t);
948	teken_subr_erase_display(t, 2);
949	teken_funcs_param(t, TP_SHOWCURSOR, 1);
950	teken_funcs_cursor(t);
951}
952
953static void
954teken_subr_restore_cursor(teken_t *t)
955{
956
957	t->t_cursor = t->t_saved_cursor;
958	t->t_curattr = t->t_saved_curattr;
959	t->t_stateflags &= ~TS_WRAPPED;
960	teken_scs_restore(t);
961	teken_funcs_cursor(t);
962}
963
964static void
965teken_subr_reverse_index(teken_t *t)
966{
967
968	if (t->t_cursor.tp_row > t->t_scrollreg.ts_begin) {
969		t->t_cursor.tp_row--;
970		t->t_stateflags &= ~TS_WRAPPED;
971		teken_funcs_cursor(t);
972	} else {
973		teken_subr_do_scroll(t, -1);
974	}
975}
976
977static void
978teken_subr_save_cursor(teken_t *t)
979{
980
981	t->t_saved_cursor = t->t_cursor;
982	t->t_saved_curattr = t->t_curattr;
983	teken_scs_save(t);
984}
985
986static void
987teken_subr_secondary_device_attributes(teken_t *t, unsigned int request)
988{
989
990	if (request == 0) {
991		const char response[] = "\x1B[>0;10;0c";
992		teken_funcs_respond(t, response, sizeof response - 1);
993	} else {
994		teken_printf("Unknown DA2\n");
995	}
996}
997
998static void
999teken_subr_set_dec_mode(teken_t *t, unsigned int cmd)
1000{
1001
1002	switch (cmd) {
1003	case 1: /* Cursor keys mode. */
1004		teken_funcs_param(t, TP_CURSORKEYS, 1);
1005		break;
1006	case 2: /* DECANM: ANSI/VT52 mode. */
1007		teken_printf("DECSET VT52\n");
1008		break;
1009	case 3: /* 132 column mode. */
1010		teken_funcs_param(t, TP_132COLS, 1);
1011		teken_subr_reset_to_initial_state(t);
1012		break;
1013	case 5: /* Inverse video. */
1014		teken_printf("DECSET inverse video\n");
1015		break;
1016	case 6: /* Origin mode. */
1017		t->t_stateflags |= TS_ORIGIN;
1018		t->t_originreg = t->t_scrollreg;
1019		t->t_cursor.tp_row = t->t_scrollreg.ts_begin;
1020		t->t_cursor.tp_col = 0;
1021		t->t_stateflags &= ~TS_WRAPPED;
1022		teken_funcs_cursor(t);
1023		break;
1024	case 7: /* Autowrap mode. */
1025		t->t_stateflags |= TS_AUTOWRAP;
1026		break;
1027	case 8: /* Autorepeat mode. */
1028		teken_funcs_param(t, TP_AUTOREPEAT, 1);
1029		break;
1030	case 25: /* Display cursor. */
1031		teken_funcs_param(t, TP_SHOWCURSOR, 1);
1032		break;
1033	case 40: /* Allow 132 columns. */
1034		teken_printf("DECSET allow 132\n");
1035		break;
1036	case 45: /* Enable reverse wraparound. */
1037		teken_printf("DECSET reverse wraparound\n");
1038		break;
1039	case 47: /* Switch to alternate buffer. */
1040		teken_printf("Switch away from alternate buffer\n");
1041		break;
1042	default:
1043		teken_printf("Unknown DECSET: %u\n", cmd);
1044	}
1045}
1046
1047static void
1048teken_subr_set_mode(teken_t *t, unsigned int cmd)
1049{
1050
1051	switch (cmd) {
1052	case 4:
1053		teken_printf("Insert mode\n");
1054		t->t_stateflags |= TS_INSERT;
1055		break;
1056	default:
1057		teken_printf("Unknown set mode: %u\n", cmd);
1058	}
1059}
1060
1061static void
1062teken_subr_set_graphic_rendition(teken_t *t, unsigned int ncmds,
1063    unsigned int cmds[])
1064{
1065	unsigned int i, n;
1066
1067	/* No attributes means reset. */
1068	if (ncmds == 0) {
1069		t->t_curattr = t->t_defattr;
1070		return;
1071	}
1072
1073	for (i = 0; i < ncmds; i++) {
1074		n = cmds[i];
1075
1076		switch (n) {
1077		case 0: /* Reset. */
1078			t->t_curattr = t->t_defattr;
1079			break;
1080		case 1: /* Bold. */
1081			t->t_curattr.ta_format |= TF_BOLD;
1082			break;
1083		case 4: /* Underline. */
1084			t->t_curattr.ta_format |= TF_UNDERLINE;
1085			break;
1086		case 5: /* Blink. */
1087			t->t_curattr.ta_format |= TF_BLINK;
1088			break;
1089		case 7: /* Reverse. */
1090			t->t_curattr.ta_format |= TF_REVERSE;
1091			break;
1092		case 22: /* Remove bold. */
1093			t->t_curattr.ta_format &= ~TF_BOLD;
1094			break;
1095		case 24: /* Remove underline. */
1096			t->t_curattr.ta_format &= ~TF_UNDERLINE;
1097			break;
1098		case 25: /* Remove blink. */
1099			t->t_curattr.ta_format &= ~TF_BLINK;
1100			break;
1101		case 27: /* Remove reverse. */
1102			t->t_curattr.ta_format &= ~TF_REVERSE;
1103			break;
1104		case 30: /* Set foreground color: black */
1105		case 31: /* Set foreground color: red */
1106		case 32: /* Set foreground color: green */
1107		case 33: /* Set foreground color: brown */
1108		case 34: /* Set foreground color: blue */
1109		case 35: /* Set foreground color: magenta */
1110		case 36: /* Set foreground color: cyan */
1111		case 37: /* Set foreground color: white */
1112			t->t_curattr.ta_fgcolor = n - 30;
1113			break;
1114		case 39: /* Set default foreground color. */
1115			t->t_curattr.ta_fgcolor = t->t_defattr.ta_fgcolor;
1116			break;
1117		case 40: /* Set background color: black */
1118		case 41: /* Set background color: red */
1119		case 42: /* Set background color: green */
1120		case 43: /* Set background color: brown */
1121		case 44: /* Set background color: blue */
1122		case 45: /* Set background color: magenta */
1123		case 46: /* Set background color: cyan */
1124		case 47: /* Set background color: white */
1125			t->t_curattr.ta_bgcolor = n - 40;
1126			break;
1127		case 49: /* Set default background color. */
1128			t->t_curattr.ta_bgcolor = t->t_defattr.ta_bgcolor;
1129			break;
1130		default:
1131			teken_printf("unsupported attribute %u\n", n);
1132		}
1133	}
1134}
1135
1136static void
1137teken_subr_set_top_and_bottom_margins(teken_t *t, unsigned int top,
1138    unsigned int bottom)
1139{
1140
1141	/* Adjust top row number. */
1142	if (top > 0)
1143		top--;
1144	/* Adjust bottom row number. */
1145	if (bottom == 0 || bottom > t->t_winsize.tp_row)
1146		bottom = t->t_winsize.tp_row;
1147
1148	/* Invalid arguments. */
1149	if (top >= bottom - 1) {
1150		top = 0;
1151		bottom = t->t_winsize.tp_row;
1152	}
1153
1154	t->t_scrollreg.ts_begin = top;
1155	t->t_scrollreg.ts_end = bottom;
1156	if (t->t_stateflags & TS_ORIGIN) {
1157		/* XXX: home cursor? */
1158		t->t_originreg = t->t_scrollreg;
1159		t->t_cursor.tp_row = t->t_originreg.ts_begin;
1160		t->t_cursor.tp_col = 0;
1161		t->t_stateflags &= ~TS_WRAPPED;
1162		teken_funcs_cursor(t);
1163	}
1164}
1165
1166static void
1167teken_subr_single_height_double_width_line(teken_t *t __unused)
1168{
1169
1170	teken_printf("single height double width???\n");
1171}
1172
1173static void
1174teken_subr_single_height_single_width_line(teken_t *t __unused)
1175{
1176
1177	teken_printf("single height single width???\n");
1178}
1179
1180static void
1181teken_subr_string_terminator(teken_t *t __unused)
1182{
1183
1184	teken_printf("string terminator???\n");
1185}
1186
1187static void
1188teken_subr_tab_clear(teken_t *t, unsigned int cmd)
1189{
1190
1191	switch (cmd) {
1192	case 0:
1193		teken_tab_clear(t, t->t_cursor.tp_col);
1194		break;
1195	case 3:
1196		memset(&t->t_tabstops, 0, T_NUMCOL / 8);
1197		break;
1198	}
1199}
1200
1201static void
1202teken_subr_vertical_position_absolute(teken_t *t, unsigned int row)
1203{
1204
1205	t->t_cursor.tp_row = t->t_originreg.ts_begin + row - 1;
1206	if (row >= t->t_originreg.ts_end)
1207		t->t_cursor.tp_row = t->t_originreg.ts_end - 1;
1208
1209
1210	t->t_stateflags &= ~TS_WRAPPED;
1211	teken_funcs_cursor(t);
1212}
1213