dcef4b38f4469969d3e459ce7e44650b4d32603c
15 #define MODE_CURSOR 0x01
16 #define MODE_WRAP 0x02
17 #define MODE_ORIGIN 0x04
18 #define MODE_AUTOCR 0x08
19 #define MODE_DEFAULT (MODE_CURSOR | MODE_WRAP)
20 #define ATTR_BOLD 0x10
21 #define ATTR_ITALIC 0x20
23 #define ATTR_ALL (ATTR_BOLD | ATTR_ITALIC | ATTR_REV)
24 #define MODE_INSERT 0x100
25 #define MODE_WRAPREADY 0x200
27 #define LIMIT(n, a, b) ((n) < (a) ? (a) : ((n) > (b) ? (b) : (n)))
28 #define BIT_SET(i, b, val) ((val) ? ((i) | (b)) : ((i) & ~(b)))
29 #define OFFSET(r, c) ((r) * pad_cols() + (c))
31 static struct term
*term
;
33 static short *fgs
, *bgs
;
42 /* low level drawing and lazy updating */
44 static int fgcolor(void)
46 int c
= mode
& ATTR_REV
? bg
: fg
;
49 if (mode
& ATTR_ITALIC
)
54 static int bgcolor(void)
56 return mode
& ATTR_REV
? fg
: bg
;
59 /* assumes visible && !lazy */
60 static void _draw_pos(int r
, int c
, int cursor
)
62 int rev
= cursor
&& mode
& MODE_CURSOR
;
64 int fg
= rev
? bgs
[i
] : fgs
[i
];
65 int bg
= rev
? fgs
[i
] : bgs
[i
];
66 pad_put(screen
[i
], r
, c
, fg
, bg
);
69 /* assumes visible && !lazy */
70 static void _draw_row(int r
)
72 int cbg
, cch
; /* current background and character */
73 int fbg
, fsc
= -1; /* filling background and start column */
75 /* call pad_fill() only once for blank columns with identical backgrounds */
76 for (i
= 0; i
< pad_cols(); i
++) {
77 cbg
= bgs
[OFFSET(r
, i
)];
78 cch
= screen
[OFFSET(r
, i
)] ? screen
[OFFSET(r
, i
)] : ' ';
79 if (fsc
>= 0 && (cbg
!= fbg
|| (cch
!= ' '))) {
80 pad_fill(r
, r
+ 1, fsc
, i
, fbg
& FN_C
);
90 pad_fill(r
, r
+ 1, fsc
>= 0 ? fsc
: pad_cols(), -1, cbg
& FN_C
);
93 static int candraw(int sr
, int er
)
97 for (i
= sr
; i
< er
; i
++)
99 return visible
&& !lazy
;
102 static void draw_rows(int sr
, int er
)
106 for (i
= sr
; i
< er
; i
++)
110 static void draw_cols(int r
, int sc
, int ec
)
113 if (candraw(r
, r
+ 1))
114 for (i
= sc
; i
< ec
; i
++)
118 static void draw_char(int ch
, int r
, int c
)
120 int i
= OFFSET(r
, c
);
124 if (candraw(r
, r
+ 1))
128 static void draw_cursor(int put
)
130 if (candraw(row
, row
+ 1))
131 _draw_pos(row
, col
, put
);
134 static void lazy_start(void)
136 memset(dirty
, 0, pad_rows() * sizeof(*dirty
));
140 static void lazy_flush(void)
143 if (!visible
|| !lazy
)
145 for (i
= 0; i
< pad_rows(); i
++)
149 _draw_pos(row
, col
, 1);
154 static void screen_reset(int i
, int n
)
157 candraw(i
/ pad_cols(), (i
+ n
) / pad_cols() + 1);
158 memset(screen
+ i
, 0, n
* sizeof(*screen
));
159 for (c
= 0; c
< n
; c
++)
161 for (c
= 0; c
< n
; c
++)
165 static void screen_move(int dst
, int src
, int n
)
168 candraw(MIN(src
, dst
) / pad_cols(), (MAX(src
, dst
) + n
) / pad_cols() + 1);
170 candraw((MIN(src
, dst
) + n
) / pad_cols(), MAX(src
, dst
) / pad_cols() + 1);
171 memmove(screen
+ dst
, screen
+ src
, n
* sizeof(*screen
));
172 memmove(fgs
+ dst
, fgs
+ src
, n
* sizeof(*fgs
));
173 memmove(bgs
+ dst
, bgs
+ src
, n
* sizeof(*bgs
));
176 /* terminal input buffering */
178 #define PTYLEN (1 << 16)
180 static char ptybuf
[PTYLEN
]; /* always emptied in term_read() */
181 static int ptylen
; /* buffer length */
182 static int ptycur
; /* current offset */
184 static int waitpty(int us
)
186 struct pollfd ufds
[1];
187 ufds
[0].fd
= term
->fd
;
188 ufds
[0].events
= POLLIN
;
189 return poll(ufds
, 1, us
) <= 0;
192 static int readpty(void)
196 return (unsigned char) ptybuf
[ptycur
++];
200 while ((nr
= read(term
->fd
, ptybuf
+ ptylen
, PTYLEN
- ptylen
)) > 0)
202 if (!ptylen
&& errno
== EAGAIN
&& !waitpty(100))
203 ptylen
= read(term
->fd
, ptybuf
, PTYLEN
);
205 return ptylen
> 0 ? (unsigned char) ptybuf
[0] : -1;
208 /* term interface functions */
210 void term_send(int c
)
214 write(term
->fd
, &b
, 1);
217 static void term_sendstr(char *s
)
220 write(term
->fd
, s
, strlen(s
));
223 static void term_blank(void)
225 screen_reset(0, pad_rows() * pad_cols());
227 pad_fill(0, -1, 0, -1, bgcolor() & FN_C
);
230 static void ctlseq(void);
234 while (ptycur
< ptylen
) {
235 if (visible
&& !lazy
&& ptylen
- ptycur
> 15)
242 static void term_reset(void)
253 static int _openpty(int *master
, int *slave
)
258 if ((*master
= open("/dev/ptmx", O_RDWR
)) == -1)
260 if (ioctl(*master
, TIOCSPTLCK
, &unlock
) == -1)
262 if (ioctl(*master
, TIOCGPTN
, &ptyno
) == -1)
264 sprintf(name
, "/dev/pts/%d", ptyno
);
265 *slave
= open(name
, O_RDWR
| O_NOCTTY
);
269 static void _login(int fd
)
272 winp
.ws_col
= pad_cols();
273 winp
.ws_row
= pad_rows();
277 ioctl(fd
, TIOCSCTTY
, NULL
);
278 ioctl(fd
, TIOCSWINSZ
, &winp
);
286 #define MAXENV (1 << 8)
288 static void envcpy(char **d
, char **s
)
295 static void execvep(char *cmd
, char **argv
, char **envp
)
298 char *p
= getenv("PATH");
299 execve(cmd
, argv
, envp
);
302 while (*p
&& *p
!= ':')
306 execve(path
, argv
, envp
);
312 extern char **environ
;
313 void term_exec(char **args
)
316 memset(term
, 0, sizeof(*term
));
317 if (_openpty(&master
, &slave
) == -1)
319 if ((term
->pid
= fork()) == -1)
322 char *envp
[MAXENV
] = {"TERM=linux"};
323 envcpy(envp
+ 1, environ
);
326 execvep(args
[0], args
, envp
);
331 fcntl(term
->fd
, F_SETFD
, fcntl(term
->fd
, F_GETFD
) | FD_CLOEXEC
);
332 fcntl(term
->fd
, F_SETFL
, fcntl(term
->fd
, F_GETFL
) | O_NONBLOCK
);
334 memset(term
->hist
, 0, sizeof(term
->hist
));
337 static void misc_save(struct term_state
*state
)
346 static void misc_load(struct term_state
*state
)
355 void term_save(struct term
*term
)
360 misc_save(&term
->cur
);
366 /* redraw the screen; if all is zero, update changed lines only */
367 void term_redraw(int all
)
371 pad_fill(pad_rows(), -1, 0, -1, BGCOLOR
);
373 memset(dirty
, 1, pad_rows() * sizeof(*dirty
));
375 if (all
|| !term
->hpos
)
379 pad_fill(0, -1, 0, -1, 0);
383 void term_load(struct term
*t
, int flags
)
386 misc_load(&term
->cur
);
387 screen
= term
->screen
;
401 memset(term
, 0, sizeof(*term
));
402 term_load(term
, visible
);
407 static int writeutf8(char *dst
, int c
)
412 *d
++ = 0xf0 | (c
>> 18);
414 } else if (c
> 0x7ff) {
415 *d
++ = 0xe0 | (c
>> 12);
417 } else if (c
> 0x7f) {
418 *d
++ = 0xc0 | (c
>> 6);
421 *d
++ = c
> 0 ? c
: ' ';
425 *d
++ = 0x80 | ((c
>> (l
* 6)) & 0x3f);
429 void term_screenshot(void)
432 int fd
= open(SCRSHOT
, O_CREAT
| O_TRUNC
| O_WRONLY
, 0600);
434 for (i
= 0; i
< pad_rows(); i
++) {
436 for (j
= 0; j
< pad_cols(); j
++)
437 if (~screen
[OFFSET(i
, j
)] & DWCHAR
)
438 s
+= writeutf8(s
, screen
[OFFSET(i
, j
)]);
440 write(fd
, buf
, s
- buf
);
445 /* high-level drawing functions */
447 static void empty_rows(int sr
, int er
)
449 screen_reset(OFFSET(sr
, 0), (er
- sr
) * pad_cols());
452 static void blank_rows(int sr
, int er
)
459 #define HISTROW(pos) (term->hist + ((term->hrow + NHIST - (pos)) % NHIST) * pad_cols())
461 static void scrl_rows(int nr
)
464 for (i
= 0; i
< nr
; i
++) {
465 memcpy(HISTROW(0), screen
+ i
* pad_cols(),
466 pad_cols() * sizeof(screen
[0]));
467 term
->hrow
= (term
->hrow
+ 1) % NHIST
;
471 void term_scrl(int scrl
)
474 int hpos
= LIMIT(term
->hpos
+ scrl
, 0, NHIST
);
481 memset(dirty
, 1, pad_rows() * sizeof(*dirty
));
482 for (i
= 0; i
< pad_rows(); i
++) {
483 int off
= (i
- hpos
) * pad_cols();
484 int *_scr
= i
< hpos
? HISTROW(hpos
- i
) : term
->screen
+ off
;
485 short *_fgs
= i
< hpos
? NULL
: term
->fgs
+ off
;
486 short *_bgs
= i
< hpos
? NULL
: term
->bgs
+ off
;
487 for (j
= 0; j
< pad_cols(); j
++)
488 pad_put(_scr
[j
], i
, j
, _fgs
? _fgs
[j
] : BGCOLOR
,
489 _bgs
? _bgs
[j
] : FGCOLOR
);
493 static void scroll_screen(int sr
, int nr
, int n
)
498 screen_move(OFFSET(sr
+ n
, 0), OFFSET(sr
, 0), nr
* pad_cols());
500 empty_rows(sr
, sr
+ n
);
502 empty_rows(sr
+ nr
+ n
, sr
+ nr
);
503 draw_rows(MIN(sr
, sr
+ n
), MAX(sr
+ nr
, sr
+ nr
+ n
));
507 static void insert_lines(int n
)
509 int sr
= MAX(top
, row
);
510 int nr
= bot
- row
- n
;
512 scroll_screen(sr
, nr
, n
);
515 static void delete_lines(int n
)
517 int r
= MAX(top
, row
);
519 int nr
= bot
- r
- n
;
521 scroll_screen(sr
, nr
, -n
);
524 static int origin(void)
526 return mode
& MODE_ORIGIN
;
529 static void move_cursor(int r
, int c
)
533 t
= origin() ? top
: 0;
534 b
= origin() ? bot
: pad_rows();
535 row
= LIMIT(r
, t
, b
- 1);
536 col
= LIMIT(c
, 0, pad_cols() - 1);
538 mode
= BIT_SET(mode
, MODE_WRAPREADY
, 0);
541 static void set_region(int t
, int b
)
543 top
= LIMIT(t
- 1, 0, pad_rows() - 1);
544 bot
= LIMIT(b
? b
: pad_rows(), top
+ 1, pad_rows());
549 static void setattr(int m
)
570 mode
&= ~ATTR_ITALIC
;
577 fg
= m
> 37 ? FGCOLOR
: m
- 30;
579 bg
= m
> 47 ? BGCOLOR
: m
- 40;
587 static void kill_chars(int sc
, int ec
)
590 for (i
= sc
; i
< ec
; i
++)
591 draw_char(0, row
, i
);
595 static void move_chars(int sc
, int nc
, int n
)
598 screen_move(OFFSET(row
, sc
+ n
), OFFSET(row
, sc
), nc
);
600 screen_reset(OFFSET(row
, sc
), n
);
602 screen_reset(OFFSET(row
, pad_cols() + n
), -n
);
603 draw_cols(row
, MIN(sc
, sc
+ n
), pad_cols());
607 static void delete_chars(int n
)
610 int nc
= pad_cols() - sc
;
611 move_chars(sc
, nc
, -n
);
614 static void insert_chars(int n
)
616 int nc
= pad_cols() - col
- n
;
617 move_chars(col
, nc
, n
);
620 static void advance(int dr
, int dc
, int scrl
)
624 if (dr
&& r
>= bot
&& scrl
) {
626 int nr
= (bot
- top
) + n
;
627 scroll_screen(top
+ -n
, nr
, n
);
629 if (dr
&& r
< top
&& scrl
) {
631 int nr
= (bot
- top
) - n
;
632 scroll_screen(top
, nr
, n
);
634 r
= dr
? LIMIT(r
, top
, bot
- 1) : r
;
635 c
= LIMIT(c
, 0, pad_cols() - 1);
639 static void insertchar(int c
)
641 if (mode
& MODE_WRAPREADY
)
643 if (mode
& MODE_INSERT
)
645 draw_char(c
, row
, col
);
646 if (col
== pad_cols() - 1)
647 mode
= BIT_SET(mode
, MODE_WRAPREADY
, 1);
653 /* partial vt102 implementation */
655 static void escseq(void);
656 static void escseq_cs(void);
657 static void escseq_g0(void);
658 static void escseq_g1(void);
659 static void escseq_g2(void);
660 static void escseq_g3(void);
661 static void csiseq(void);
662 static void csiseq_da(int c
);
663 static void csiseq_dsr(int c
);
664 static void modeseq(int c
, int set
);
666 /* comments taken from: http://www.ivarch.com/programs/termvt102.shtml */
668 static int readutf8(int c
)
674 while (l
< 6 && c
& (0x40 >> l
))
676 result
= (0x3f >> l
) & c
;
678 result
= (result
<< 6) | (readpty() & 0x3f);
682 #define unknown(ctl, c)
684 /* control sequences */
685 static void ctlseq(void)
689 case 0x09: /* HT horizontal tab to next tab stop */
690 advance(0, 8 - col
% 8, 0);
692 case 0x0a: /* LF line feed */
693 case 0x0b: /* VT line feed */
694 case 0x0c: /* FF line feed */
695 advance(1, (mode
& MODE_AUTOCR
) ? -col
: 0, 1);
697 case 0x08: /* BS backspace one column */
700 case 0x1b: /* ESC start escape sequence */
703 case 0x0d: /* CR carriage return */
706 case 0x00: /* NUL ignored */
707 case 0x07: /* BEL beep */
708 case 0x7f: /* DEL ignored */
710 case 0x05: /* ENQ trigger answerback message */
711 case 0x0e: /* SO activate G1 character set & newline */
712 case 0x0f: /* SI activate G0 character set */
713 case 0x11: /* XON resume transmission */
714 case 0x13: /* XOFF stop transmission, ignore characters */
715 case 0x18: /* CAN interrupt escape sequence */
716 case 0x1a: /* SUB interrupt escape sequence */
717 case 0x9b: /* CSI equivalent to ESC [ */
718 unknown("ctlseq", c
);
722 if (isdw(c
) && col
+ 1 == pad_cols() && ~mode
& MODE_WRAPREADY
)
727 insertchar(c
| DWCHAR
);
732 #define ESCM(c) (((c) & 0xf0) == 0x20)
733 #define ESCF(c) ((c) > 0x30 && (c) < 0x7f)
735 /* escape sequences */
736 static void escseq(void)
742 case '[': /* CSI control sequence introducer */
745 case '%': /* CS... escseq_cs table */
748 case '(': /* G0... escseq_g0 table */
751 case ')': /* G1... escseq_g1 table */
754 case '*': /* G2... escseq_g2 table */
757 case '+': /* G3... escseq_g3 table */
760 case '7': /* DECSC save state (position, charset, attributes) */
761 misc_save(&term
->sav
);
763 case '8': /* DECRC restore most recently saved state */
764 misc_load(&term
->sav
);
766 case 'M': /* RI reverse line feed */
769 case 'D': /* IND line feed */
772 case 'E': /* NEL newline */
775 case 'c': /* RIS reset */
778 case 'H': /* HTS set tab stop at current column */
779 case 'Z': /* DECID DEC private ID; return ESC [ ? 6 c (VT102) */
780 case '#': /* DECALN ("#8") DEC alignment test - fill screen with E's */
781 case '>': /* DECPNM set numeric keypad mode */
782 case '=': /* DECPAM set application keypad mode */
783 case 'N': /* SS2 select G2 charset for next char only */
784 case 'O': /* SS3 select G3 charset for next char only */
785 case 'P': /* DCS device control string (ended by ST) */
786 case 'X': /* SOS start of string */
787 case '^': /* PM privacy message (ended by ST) */
788 case '_': /* APC application program command (ended by ST) */
789 case '\\': /* ST string terminator */
790 case 'n': /* LS2 invoke G2 charset */
791 case 'o': /* LS3 invoke G3 charset */
792 case '|': /* LS3R invoke G3 charset as GR */
793 case '}': /* LS2R invoke G2 charset as GR */
794 case '~': /* LS1R invoke G1 charset as GR */
795 case ']': /* OSC operating system command */
796 case 'g': /* BEL alternate BEL */
798 unknown("escseq", c
);
803 static void escseq_cs(void)
807 case '@': /* CSDFL select default charset (ISO646/8859-1) */
808 case 'G': /* CSUTF8 select UTF-8 */
809 case '8': /* CSUTF8 select UTF-8 (obsolete) */
811 unknown("escseq_cs", c
);
816 static void escseq_g0(void)
820 case '8': /* G0DFL G0 charset = default mapping (ISO8859-1) */
821 case '0': /* G0GFX G0 charset = VT100 graphics mapping */
822 case 'U': /* G0ROM G0 charset = null mapping (straight to ROM) */
823 case 'K': /* G0USR G0 charset = user defined mapping */
824 case 'B': /* G0TXT G0 charset = ASCII mapping */
826 unknown("escseq_g0", c
);
831 static void escseq_g1(void)
835 case '8': /* G1DFL G1 charset = default mapping (ISO8859-1) */
836 case '0': /* G1GFX G1 charset = VT100 graphics mapping */
837 case 'U': /* G1ROM G1 charset = null mapping (straight to ROM) */
838 case 'K': /* G1USR G1 charset = user defined mapping */
839 case 'B': /* G1TXT G1 charset = ASCII mapping */
841 unknown("escseq_g1", c
);
846 static void escseq_g2(void)
850 case '8': /* G2DFL G2 charset = default mapping (ISO8859-1) */
851 case '0': /* G2GFX G2 charset = VT100 graphics mapping */
852 case 'U': /* G2ROM G2 charset = null mapping (straight to ROM) */
853 case 'K': /* G2USR G2 charset = user defined mapping */
855 unknown("escseq_g2", c
);
860 static void escseq_g3(void)
864 case '8': /* G3DFL G3 charset = default mapping (ISO8859-1) */
865 case '0': /* G3GFX G3 charset = VT100 graphics mapping */
866 case 'U': /* G3ROM G3 charset = null mapping (straight to ROM) */
867 case 'K': /* G3USR G3 charset = user defined mapping */
869 unknown("escseq_g3", c
);
874 static int absrow(int r
)
876 return origin() ? top
+ r
: r
;
879 #define CSIP(c) (((c) & 0xf0) == 0x30)
880 #define CSII(c) (((c) & 0xf0) == 0x20)
881 #define CSIF(c) ((c) >= 0x40 && (c) < 0x80)
883 #define MAXCSIARGS 32
884 /* ECMA-48 CSI sequences */
885 static void csiseq(void)
887 int args
[MAXCSIARGS
] = {0};
893 if (strchr("<=>?", c
)) {
900 arg
= arg
* 10 + (c
- '0');
911 case 'H': /* CUP move cursor to row, column */
912 case 'f': /* HVP move cursor to row, column */
913 move_cursor(absrow(MAX(0, args
[0] - 1)), MAX(0, args
[1] - 1));
915 case 'J': /* ED erase display */
918 kill_chars(col
, pad_cols());
919 blank_rows(row
+ 1, pad_rows());
922 kill_chars(0, col
+ 1);
923 blank_rows(0, row
- 1);
930 case 'A': /* CUU move cursor up */
931 advance(-MAX(1, args
[0]), 0, 0);
933 case 'e': /* VPR move cursor down */
934 case 'B': /* CUD move cursor down */
935 advance(MAX(1, args
[0]), 0, 0);
937 case 'a': /* HPR move cursor right */
938 case 'C': /* CUF move cursor right */
939 advance(0, MAX(1, args
[0]), 0);
941 case 'D': /* CUB move cursor left */
942 advance(0, -MAX(1, args
[0]), 0);
944 case 'K': /* EL erase line */
947 kill_chars(col
, pad_cols());
950 kill_chars(0, col
+ 1);
953 kill_chars(0, pad_cols());
957 case 'L': /* IL insert blank lines */
958 if (row
>= top
&& row
< bot
)
959 insert_lines(MAX(1, args
[0]));
961 case 'M': /* DL delete lines */
962 if (row
>= top
&& row
< bot
)
963 delete_lines(MAX(1, args
[0]));
965 case 'd': /* VPA move to row (current column) */
966 move_cursor(absrow(MAX(1, args
[0]) - 1), col
);
968 case 'm': /* SGR set graphic rendition */
971 for (i
= 0; i
< n
; i
++) {
985 case 'r': /* DECSTBM set scrolling region to (top, bottom) rows */
986 set_region(args
[0], args
[1]);
988 case 'c': /* DA return ESC [ ? 6 c (VT102) */
989 csiseq_da(priv
== '?' ? args
[0] | 0x80 : args
[0]);
991 case 'h': /* SM set mode */
992 for (i
= 0; i
< n
; i
++)
993 modeseq(priv
== '?' ? args
[i
] | 0x80 : args
[i
], 1);
995 case 'l': /* RM reset mode */
996 for (i
= 0; i
< n
; i
++)
997 modeseq(priv
== '?' ? args
[i
] | 0x80 : args
[i
], 0);
999 case 'P': /* DCH delete characters on current line */
1000 delete_chars(LIMIT(args
[0], 1, pad_cols() - col
));
1002 case '@': /* ICH insert blank characters */
1003 insert_chars(LIMIT(args
[0], 1, pad_cols() - col
));
1005 case 'n': /* DSR device status report */
1006 csiseq_dsr(args
[0]);
1008 case 'G': /* CHA move cursor to column in current row */
1009 advance(0, MAX(0, args
[0] - 1) - col
, 0);
1011 case 'X': /* ECH erase characters on current line */
1012 kill_chars(col
, MIN(col
+ MAX(1, args
[0]), pad_cols()));
1014 case '[': /* IGN ignored control sequence */
1015 case 'E': /* CNL move cursor down and to column 1 */
1016 case 'F': /* CPL move cursor up and to column 1 */
1017 case 'g': /* TBC clear tab stop (CSI 3 g = clear all stops) */
1018 case 'q': /* DECLL set keyboard LEDs */
1019 case 's': /* CUPSV save cursor position */
1020 case 'u': /* CUPRS restore cursor position */
1021 case '`': /* HPA move cursor to column in current row */
1023 unknown("csiseq", c
);
1028 static void csiseq_da(int c
)
1032 term_sendstr("\x1b[?6c");
1035 /* we don't care much about cursor shape */
1036 /* printf("csiseq_da <0x%x>\n", c); */
1041 static void csiseq_dsr(int c
)
1043 char status
[1 << 5];
1046 term_sendstr("\x1b[0n");
1049 sprintf(status
, "\x1b[%d;%dR",
1050 (origin() ? row
- top
: row
) + 1, col
+ 1);
1051 term_sendstr(status
);
1054 unknown("csiseq_dsr", c
);
1059 /* ANSI/DEC specified modes for SM/RM ANSI Specified Modes */
1060 static void modeseq(int c
, int set
)
1063 case 0x87: /* DECAWM Auto Wrap */
1064 mode
= BIT_SET(mode
, MODE_WRAP
, set
);
1066 case 0x99: /* DECTCEM Cursor on (set); Cursor off (reset) */
1067 mode
= BIT_SET(mode
, MODE_CURSOR
, set
);
1069 case 0x86: /* DECOM Sets relative coordinates (set); Sets absolute coordinates (reset) */
1070 mode
= BIT_SET(mode
, MODE_ORIGIN
, set
);
1072 case 0x14: /* LNM Line Feed / New Line Mode */
1073 mode
= BIT_SET(mode
, MODE_AUTOCR
, set
);
1075 case 0x04: /* IRM insertion/replacement mode (always reset) */
1076 mode
= BIT_SET(mode
, MODE_INSERT
, set
);
1078 case 0x00: /* IGN Error (Ignored) */
1079 case 0x01: /* GATM guarded-area transfer mode (ignored) */
1080 case 0x02: /* KAM keyboard action mode (always reset) */
1081 case 0x03: /* CRM control representation mode (always reset) */
1082 case 0x05: /* SRTM status-reporting transfer mode */
1083 case 0x06: /* ERM erasure mode (always set) */
1084 case 0x07: /* VEM vertical editing mode (ignored) */
1085 case 0x0a: /* HEM horizontal editing mode */
1086 case 0x0b: /* PUM positioning unit mode */
1087 case 0x0c: /* SRM send/receive mode (echo on/off) */
1088 case 0x0d: /* FEAM format effector action mode */
1089 case 0x0e: /* FETM format effector transfer mode */
1090 case 0x0f: /* MATM multiple area transfer mode */
1091 case 0x10: /* TTM transfer termination mode */
1092 case 0x11: /* SATM selected area transfer mode */
1093 case 0x12: /* TSM tabulation stop mode */
1094 case 0x13: /* EBM editing boundary mode */
1095 /* DEC Private Modes: "?NUM" -> (NUM | 0x80) */
1096 case 0x80: /* IGN Error (Ignored) */
1097 case 0x81: /* DECCKM Cursorkeys application (set); Cursorkeys normal (reset) */
1098 case 0x82: /* DECANM ANSI (set); VT52 (reset) */
1099 case 0x83: /* DECCOLM 132 columns (set); 80 columns (reset) */
1100 case 0x84: /* DECSCLM Jump scroll (set); Smooth scroll (reset) */
1101 case 0x85: /* DECSCNM Reverse screen (set); Normal screen (reset) */
1102 case 0x88: /* DECARM Auto Repeat */
1103 case 0x89: /* DECINLM Interlace */
1104 case 0x92: /* DECPFF Send FF to printer after print screen (set); No char after PS (reset) */
1105 case 0x93: /* DECPEX Print screen: prints full screen (set); prints scroll region (reset) */
1107 unknown("modeseq", c
);