X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Fvt102.c;h=f378c166c407c1292efbd67c33beb352213a0dd7;hb=7e2a4c6ceec2f4a204faf416ca150742f7d5f364;hp=80b636c0570333a49d0784cf2334248079a49d9c;hpb=c36d5e9da077b09450d3c21a5bf777fb2972bd64;p=sympathy.git diff --git a/src/vt102.c b/src/vt102.c index 80b636c..f378c16 100644 --- a/src/vt102.c +++ b/src/vt102.c @@ -10,6 +10,114 @@ static char rcsid[] = "$Id$"; /* * $Log$ + * Revision 1.37 2008/02/24 12:22:53 james + * *** empty log message *** + * + * Revision 1.36 2008/02/24 12:22:42 james + * *** empty log message *** + * + * Revision 1.35 2008/02/24 00:42:53 james + * *** empty log message *** + * + * Revision 1.34 2008/02/23 11:48:37 james + * *** empty log message *** + * + * Revision 1.33 2008/02/22 23:39:27 james + * *** empty log message *** + * + * Revision 1.32 2008/02/22 19:12:05 james + * *** empty log message *** + * + * Revision 1.31 2008/02/22 17:07:00 james + * *** empty log message *** + * + * Revision 1.30 2008/02/22 14:51:54 james + * *** empty log message *** + * + * Revision 1.29 2008/02/15 03:32:07 james + * *** empty log message *** + * + * Revision 1.28 2008/02/14 10:34:30 james + * *** empty log message *** + * + * Revision 1.27 2008/02/14 02:46:45 james + * *** empty log message *** + * + * Revision 1.26 2008/02/14 01:55:57 james + * *** empty log message *** + * + * Revision 1.25 2008/02/13 16:57:29 james + * *** empty log message *** + * + * Revision 1.24 2008/02/13 09:12:21 james + * *** empty log message *** + * + * Revision 1.23 2008/02/07 13:26:35 james + * *** empty log message *** + * + * Revision 1.22 2008/02/07 13:22:51 james + * *** empty log message *** + * + * Revision 1.21 2008/02/07 12:21:16 james + * *** empty log message *** + * + * Revision 1.20 2008/02/07 12:16:04 james + * *** empty log message *** + * + * Revision 1.19 2008/02/07 11:27:02 james + * *** empty log message *** + * + * Revision 1.18 2008/02/07 01:59:25 james + * *** empty log message *** + * + * Revision 1.17 2008/02/07 01:58:28 james + * *** empty log message *** + * + * Revision 1.16 2008/02/07 01:57:46 james + * *** empty log message *** + * + * Revision 1.15 2008/02/07 00:43:27 james + * *** empty log message *** + * + * Revision 1.14 2008/02/07 00:40:23 james + * *** empty log message *** + * + * Revision 1.13 2008/02/07 00:39:59 james + * *** empty log message *** + * + * Revision 1.12 2008/02/07 00:39:13 james + * *** empty log message *** + * + * Revision 1.11 2008/02/06 20:26:58 james + * *** empty log message *** + * + * Revision 1.10 2008/02/06 17:53:28 james + * *** empty log message *** + * + * Revision 1.9 2008/02/06 15:53:22 james + * *** empty log message *** + * + * Revision 1.8 2008/02/06 11:49:47 james + * *** empty log message *** + * + * Revision 1.7 2008/02/06 11:30:37 james + * *** empty log message *** + * + * Revision 1.6 2008/02/05 01:11:46 james + * *** empty log message *** + * + * Revision 1.5 2008/02/04 20:23:55 james + * *** empty log message *** + * + * Revision 1.4 2008/02/04 05:45:55 james + * :: + * + * Revision 1.3 2008/02/04 02:05:06 james + * *** empty log message *** + * + * Revision 1.2 2008/02/04 01:32:39 james + * *** empty log message *** + * * Revision 1.1 2008/02/03 23:36:41 james * *** empty log message *** * @@ -18,6 +126,8 @@ static char rcsid[] = "$Id$"; /* Termcap he say: +VT102: + vt102|dec vt102:\ :mi:\ :al=\E[L:dc=\E[P:dl=\E[M:ei=\E[4l:im=\E[4h:tc=vt100: @@ -51,51 +161,139 @@ vt100+keypad|dec vt100 numeric keypad no fkeys:\ /* so the parser needs to be able to at least do +CTRL-G CTRL-H +CTRL-I +CTRL-J +CTRL-M +CTRL-N + +CTRL-O +ESC7 +ESC8 +ESCH +ESCM +ESC> + ESC[%dA ESC[%dB ESC[%dC ESC[%dD -ESC[?7l -ESC[?7h -CTRL-O -CTRL-N -CTRL-G -ESC[1K -ESC[J -ESC[K ESC[H +ESC[%d;%dH ESC[J -ESC[%d;%dh -CTRL-M -ESC[%d;%dr +ESC[K +ESC[1K +ESC[L +ESC[M +ESC[P + ESC[3g -CTRL-J -ESC(B -ESC)0 -ESC[5m +ESC[4h +ESC[4l +ESC[m ESC[1m -ESC[m CTRL-O +ESC[4m +ESC[5m ESC[7m -ESC8 -ESC> +ESC[%d;%dr + + ESC[?3l ESC[?4l ESC[?5l ESC[?7h +ESC[?7h +ESC[?7l ESC[?8h -ESC7 -ESCM -ESCH -CTRL-I -ESC[4m -ESC[L -ESC[P -ESC[M -ESC[4l -ESC[4h + +ESC(B +ESC)0 + + +TODO: + +ESC(B +ESC)0 + +CTRL-O + +ANSI: + + + +ansi|ansi/pc-term compatible with color:\ + :u6=\E[%i%d;%dR:u7=\E[6n:u9=\E[c:tc=ecma+color:\ + :tc=klone+sgr:tc=ansi-m: +ansi-m|ansi-mono|ANSI X3.64-1979 terminal with ANSI.SYS compatible attributes:\ + :5i:\ + :AL=\E[%dL:DC=\E[%dP:DL=\E[%dM:DO=\E[%dB:IC=\E[%d@:\ + :LE=\E[%dD:RI=\E[%dC:SF=\E[%dS:SR=\E[%dT:UP=\E[%dA:\ + :cb=\E[1K:ch=\E[%i%dG:ct=\E[2g:cv=\E[%i%dd:ec=\E[%dX:ei=:\ + :im=:kB=\E[Z:kI=\E[L:kb=^H:kd=\E[B:kl=\E[D:kr=\E[C:ku=\E[A:\ + :nw=\r\E[S:pf=\E[4i:po=\E[5i:s0=\E(B:s1=\E)B:s2=\E*B:\ + :s3=\E+B:ta=\E[I:tc=pcansi-m: +pcansi-m|pcansi-mono|ibm-pc terminal programs claiming to be ansi (mono mode):\ + :am:bs:mi:ms:\ + :co#80:it#8:li#24:\ + :al=\E[L:bl=^G:bt=\E[Z:cd=\E[J:ce=\E[K:cl=\E[H\E[J:\ + :cm=\E[%i%d;%dH:cr=^M:ct=\E[2g:dc=\E[P:dl=\E[M:do=\E[B:\ + :ho=\E[H:kb=^H:kd=\E[B:kh=\E[H:kl=\E[D:kr=\E[C:ku=\E[A:\ + :le=\E[D:nd=\E[C:sf=^J:st=\EH:ta=^I:up=\E[A:\ + :tc=klone+sgr-dumb: +klone+sgr-dumb|attribute control for ansi.sys displays (no ESC [ 11 m):\ + :as=\E[12m:mb=\E[5m:md=\E[1m:me=\E[0;10m:mk=\E[8m:\ + :mr=\E[7m:se=\E[m:so=\E[7m:ue=\E[m:us=\E[4m:tc=klone+acs: +klone+acs|alternate character set for ansi.sys displays:\ + :ac=+\020,\021-\030.^Y0\333`\004a\261f\370g\361h\260j\331k\277l\332m\300n\305o~p\304q\304r\304s_t\303u\264v\301w\302x\263y\363z\362{\343|\330}\234~\376:\ + :ae=\E[10m:as=\E[11m: +ecma+color|color control for ECMA-48-compatible terminals:\ + :Co#8:NC#3:pa#64:\ + :AB=\E[4%dm:AF=\E[3%dm:op=\E[39;49m: + + +Ignoreing ones in the VT102 spec + +ESC[%d@ +ESC[I +ESC[....R +ESC[%dS +ESC[%dT +ESC[X +ESC[Z + +ESC[c +*ESC[%db +ESC[....d +ESC[....f +ESC[2g +ESC[4i +ESC[5i +ESC[6n + +ESC(B +ESC)B +ESC*B +ESC+B + + */ +#include "project.h" +#include "syslog.h" + +//static char terminal_reply[]={033,0133,077,066,0143}; +static char terminal_reply[] = { 'v', 't', '1', '0', '2' }; + +static inline int +safe_ch (int c) +{ + if (c < 32) + return ' '; + if (c > 126) + return ' '; + return c; +} static inline int csi_ender (int c) @@ -104,138 +302,1204 @@ csi_ender (int c) return 1; if ((c >= 'A') && (c <= 'Z')) return 1; + if ((c == '@')) + return 1; return 0; } static inline int -csi_starter (int c) +scs_starter (int c) { switch (c) { - case '[': case '(': case ')': + case '+': + case '*': + case '%': return 1; } return 0; } -void vt102_cursor_normalize(VT102 *v,int wrap,int scroll) +static inline int +csi_starter (int c) { - if (v->pos.x<-1) /*don't wrap backwards*/ - c->pos.x=0; + switch (c) + { + case '[': + return 1; + } + return 0; +} - if (v->pos.x>=CRT_COLS) { - if (wrap) { - c->pos.x=0; - c->pos.y++; - } else { - c->pos.x=CRT_COLS-1; - } - } +static inline int +in_margins (VT102 * v, CRT_Pos p) +{ + if (v->pos.x < v->top_margin.x) + return 0; + if (v->pos.y < v->top_margin.y) + return 0; - if (v->pos.y<0) - c->pos.y=0 + if (v->pos.x > v->bottom_margin.x) + return 0; + if (v->pos.y > v->bottom_margin.y) + return 0; - if (v->pos.y>=CRT_ROWS) { - if (scroll) - vt102_scroll(v,0,CRT_ROWS-1); - c->pos.y=CRT_ROWS-1; - } + return 1; } - -void vt102_cursor_motion(VT102 *v,int x,int y,int wrap,scroll) +void +vt102_log_line (Context * c, int line) { -while (x>0) { - x--; - v->pos.x++; - vt102_cursor_normalize(v,wrap,scroll); + CRT_Pos e = { VT102_COLS - 1, line }; + CRT_Pos p = { 0, line }; + char logbuf[VT102_COLS + 1]; + + if (!c->l) + return; + + + for (; e.x > 0; --e.x) + { + if (c->v->crt.screen[CRT_ADDR_POS (&e)].chr != ' ') + break; + } + + for (; p.x <= e.x; ++p.x) + { + int ch = c->v->crt.screen[CRT_ADDR_POS (&p)].chr; + if (ch < 32) + ch = ' '; + if (ch > 126) + ch = ' '; + logbuf[p.x] = ch; + } + logbuf[p.x] = 0; + + c->l->log (c->l, logbuf); } - -while (x<0) { - x++; - v->pos.x--; - vt102_cursor_normalize(v,wrap,scroll); + +/*Called for every upward scroll with same args*/ +void +vt102_history (Context * c, CRT_Pos t, CRT_Pos b) +{ +/*Only log if it scrolls off the top*/ + if (t.y) + return; + + t.x = 0; + history_add (c->h, &(c->v->crt.screen[CRT_ADDR_POS (&t)])); } - -while (y>0) { - y--; - v->pos.y++; - vt102_cursor_normalize(v,wrap,scroll); + +void +vt102_clip_cursor (VT102 * v, CRT_Pos tl, CRT_Pos br) +{ + if (v->pos.x < tl.x) + v->pos.x = tl.x; + if (v->pos.y < tl.y) + v->pos.y = tl.y; + + if (v->pos.x > br.x) + v->pos.x = br.x; + if (v->pos.y > br.y) + v->pos.y = br.y; } - -while (y<0) { - y++; - v->pos.y--; - vt102_cursor_normalize(v,wrap,scroll); + + +void +vt102_cursor_normalize (VT102 * v) +{ + CRT_Pos *top, *bottom; + + if (v->private_modes[VT102_PRIVATE_MODE_ORIGIN_MODE]) + { + vt102_clip_cursor (v, v->top_margin, v->bottom_margin); + } + else + { + vt102_clip_cursor (v, v->screen_start, v->screen_end); + } } -} void -vt102_parse_char (VT102 * v, int c) +vt102_cursor_carriage_return (VT102 * v) { - VT102_parser *p = &v->p; + /*FISH*/ v->pos.x = v->top_margin.x; + v->pending_wrap = 0; +} +void +vt102_cursor_advance_line (Context * c) +{ + VT102 *v = c->v; + int couldscroll = in_margins (v, v->pos); - if (p->in_csi) +/*have wraped off end of last line in scrolling region */ +/* (|| not necessary, but shuts compiler up */ + if (((v->pos.y == v->bottom_margin.y) || (v->pos.y == v->screen_end.y)) && + (couldscroll)) { - p->csi_buf[p->csi_ptr++] = c; - if (csi_ender (c) || (p->csi_ptr == VT102_CSI_LEN)) - { - vt102_parse_csi (v, p->csi_buf, p->csi_ptr); - p->in_csi = 0; - } + vt102_log_line (c, v->pos.y); + + vt102_history (c, v->top_margin, v->bottom_margin); + + crt_scroll_up (&v->crt, v->top_margin, v->bottom_margin, 1, v->color); + return; } - else if (p->in_escape) + + if (v->pos.y != v->screen_end.y) + v->pos.y++; + v->pending_wrap = 0; +} + + +void +vt102_cursor_retreat_line (Context * c) +{ + VT102 *v = c->v; + int couldscroll = in_margins (v, v->pos); + +/*have wraped off end of last line in scrolling region */ +/* (|| not necessary, but shuts compiler up */ + if (((v->pos.y == v->top_margin.y) || (v->pos.y == v->screen_start.y)) && + (couldscroll)) { - if (csi_starter (c)) - { - p->csi_ptr = 0; - p->csi_buf[p->csi_ptr++] = c; - p->in_csi++; - p->in_escape = 0; - } - else - { - p->in_escape = 0; - vt102_parse_esc (v, c); - } + vt102_log_line (c, v->pos.y); + + crt_scroll_down (&v->crt, v->top_margin, v->bottom_margin, 1, v->color); + return; + } + + if (v->pos.y != v->screen_start.y) + v->pos.y--; + v->pending_wrap = 0; +} + + +void +vt102_do_pending_wrap (Context * c) +{ + VT102 *v = c->v; + int couldscroll = in_margins (v, v->pos); + int autowrap = v->private_modes[VT102_PRIVATE_MODE_AUTO_WRAP]; + + if (!v->pending_wrap) + return; + +#if 0 + fprintf (stderr, "ca: (%d,%d) autowrap %d couldscroll %d\n", v->pos.x, + v->pos.y, autowrap, couldscroll); +#endif + +/*End of line but no autowrap, nothing to do*/ + if (!autowrap) + return; + +/*End of screen and not allowed to scroll, nothing to do*/ + if ((v->pos.y == v->screen_end.y) && (!couldscroll)) + return; + + if (couldscroll) + { + v->pos.x = v->top_margin.x; } else { + v->pos.x = 0; + } - switch (c) - { - /*NUL*/ case 0: - /*SOH*/ case 1: - /*STX*/ case 2: - /*ETX*/ case 3: - /*EOT*/ case 4: - /*ENQ*/ case 5: - /*ACK*/ case 6: - /*BEL*/ case 7: - /*BS*/ case 8: - vt102_cursor_motion(v,-1,0,0,0); - break; - /*HT*/ case 9: - break; - /*LF*/ case 10: - break; - /*VT*/ case 11: - break; - /*FF*/ case 12: - break; - /*CR*/ case 13: - break; + vt102_cursor_advance_line (c); +} + +void +vt102_cursor_advance (Context * c) +{ + VT102 *v = c->v; + + if (v->pos.x < v->bottom_margin.x) + { +/*Normal advance*/ + v->pos.x++; + v->pending_wrap = 0; + return; + } + v->pending_wrap++; + if (!c->v->xn_glitch) + vt102_do_pending_wrap (c); +} + + + +void +vt102_cursor_retreat (VT102 * v) +{ + if (v->pos.x != v->top_margin.x) + v->pos.x--; + + v->pending_wrap = 0; +} + +void +vt102_reset_tabs (VT102 * v) +{ + int i; + + memset (v->tabs, 0, sizeof (v->tabs)); + + for (i = 0; i < VT102_COLS; i += 8) + { + v->tabs[i]++; + } +} +void +vt102_cursor_advance_tab (VT102 * v) +{ + if (v->pos.x == v->bottom_margin.x) + return; + while (v->pos.x < v->bottom_margin.x) + { + v->pos.x++; + if (v->tabs[v->pos.x]) + break; + } + v->pending_wrap = 0; +} + +void +vt102_cursor_retreat_tab (VT102 * v) +{ + if (v->pos.x == v->top_margin.x) + return; + while (v->pos.x > v->top_margin.x) + { + v->pos.x--; + if (v->tabs[v->pos.x]) + break; + } + v->pending_wrap = 0; +} + +vt102_cursor_home (VT102 * v) +{ + v->pos = v->top_margin; + vt102_cursor_normalize (v); + v->pending_wrap = 0; + +} + +vt102_cursor_absolute (VT102 * v, int x, int y) +{ + if (v->private_modes[VT102_PRIVATE_MODE_ORIGIN_MODE]) + { + v->pos.x = x + v->top_margin.x; + v->pos.y = y + v->top_margin.x; + } + else + { + v->pos.x = x; + v->pos.y = y; + } + vt102_cursor_normalize (v); + v->pending_wrap = 0; +} + +vt102_cursor_relative (VT102 * v, int x, int y) +{ + v->pos.x += x; + v->pos.y += y; + vt102_cursor_normalize (v); + v->pending_wrap = 0; +} + + + +void +vt102_delete_from_line (VT102 * v, CRT_Pos p) +{ + int n = v->bottom_margin.x - p.x; + + if (n < 0) + return; + + if (n) + { + + memmove (&v->crt.screen[CRT_ADDR_POS (&p)], + &v->crt.screen[CRT_ADDR_POS (&p) + 1], sizeof (CRT_CA) * n); + } + + v->crt.screen[CRT_ADDR (p.y, v->bottom_margin.x)].chr = ' '; +/*But not attr due to vt102 bug*/ +} + +void +vt102_insert_into_line (VT102 * v, CRT_Pos p) +{ + int n = v->bottom_margin.x - p.x; + + if (n < 0) + return; + + if (n) + { + + memmove (&v->crt.screen[CRT_ADDR_POS (&p) + 1], + &v->crt.screen[CRT_ADDR_POS (&p)], sizeof (CRT_CA) * n); + } + + v->crt.screen[CRT_ADDR (p.y, v->bottom_margin.x)].chr = ' '; + v->crt.screen[CRT_ADDR (p.y, v->bottom_margin.x)].attr = CRT_ATTR_NORMAL; + v->crt.screen[CRT_ADDR (p.y, v->bottom_margin.x)].color = CRT_COLOR_NORMAL; +} + + + +void +vt102_change_mode (VT102 * v, int private, char *ns, int set) +{ + int m; + + + if (*ns) + { + m = atoi (ns); + } + else + { + m = 1; + } + + if (m < 0) + return; + if (m >= VT102_NMODES) + return; + + if (private) + { + v->private_modes[m] = set; + switch (m) + { + case VT102_PRIVATE_MODE_CURSOR_MODE: + if (v->application_keypad_mode) + v->private_modes[m] = 0; +#if 0 + fprintf (stderr, "APPLICATION CURSOR MODE %d wanted %d\n", + v->private_modes[m], set); +#endif + break; + case VT102_PRIVATE_MODE_ORIGIN_MODE: + vt102_cursor_home (v); + break; + } + + } + else + v->modes[m] = set; + +#if 0 + fprintf (stderr, "mode set=%d private=%d num=%d\n", set, private, m); +#endif +} + +void +vt102_parse_mode_string (VT102 * v, char *buf, int len) +{ + int private = 0; + char last = buf[len - 1]; + char num[4]; + int o; + + memset (num, 0, sizeof (num)); + o = sizeof (num) - 1; + + len--; + + if (*buf == '?') + { + private++; + buf++; + len--; + } + + if (len < 0) + return; + + while (len--) + { + if (*buf == ';') + { + vt102_change_mode (v, private, &num[o], last == 'h'); + memset (num, 0, sizeof (num)); + o = sizeof (num) - 1; + buf++; + continue; + } + + num[0] = num[1]; + num[1] = num[2]; + num[2] = *buf; + + if (o) + o--; + + buf++; + } + + vt102_change_mode (v, private, &num[o], last == 'h'); + +} + + +void +vt102_change_attr (VT102 * v, char *na) +{ + int a; + + + if (*na) + { + a = atoi (na); + } + else + { + a = 0; + } + + switch (a) + { + case 0: + v->attr = CRT_ATTR_NORMAL; + v->color = CRT_COLOR_NORMAL; + break; + case 1: + v->attr |= CRT_ATTR_BOLD; + break; + case 21: + case 22: + v->attr &= ~CRT_ATTR_BOLD; + break; + case 4: + v->attr |= CRT_ATTR_UNDERLINE; + break; + case 24: + v->attr &= ~CRT_ATTR_UNDERLINE; + break; + case 5: + v->attr |= CRT_ATTR_BLINK; + break; + case 25: + v->attr &= ~CRT_ATTR_BLINK; + break; + case 7: + v->attr |= CRT_ATTR_REVERSE; + break; + case 27: + v->attr &= ~CRT_ATTR_REVERSE; + break; + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + case 36: + case 37: + v->color &= ~CRT_COLOR_FG_MASK; + v->color |= ((a - 30) << CRT_COLOR_FG_SHIFT) & CRT_COLOR_FG_MASK; + break; + case 90: + case 91: + case 92: + case 93: + case 94: + case 95: + case 96: + case 97: + v->color &= ~CRT_COLOR_FG_MASK; + v->color |= + (((a - + 90) | CRT_COLOR_INTENSITY) << CRT_COLOR_FG_SHIFT) & + CRT_COLOR_FG_MASK; + break; + case 39: + case 99: + v->color &= ~CRT_COLOR_FG_MASK; + v->color |= + (CRT_FGCOLOR_NORMAL << CRT_COLOR_FG_SHIFT) & CRT_COLOR_FG_MASK; + break; + case 40: + case 41: + case 42: + case 43: + case 44: + case 45: + case 46: + case 47: + v->color &= ~CRT_COLOR_BG_MASK; + v->color |= ((a - 40) << CRT_COLOR_BG_SHIFT) & CRT_COLOR_BG_MASK; + break; + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + v->color &= ~CRT_COLOR_BG_MASK; + v->color |= + (((a - + 100) | CRT_COLOR_INTENSITY) << CRT_COLOR_BG_SHIFT) & + CRT_COLOR_BG_MASK; + break; + case 49: + case 109: + v->color &= ~CRT_COLOR_BG_MASK; + v->color |= + (CRT_BGCOLOR_NORMAL << CRT_COLOR_BG_SHIFT) & CRT_COLOR_BG_MASK; + break; + + default: + ; +#if 0 + fprintf (stderr, "unhandled SGR %d\n", a); +#endif + } + +} + + +void +vt102_parse_attr_string (VT102 * v, char *buf, int len) +{ + int private = 0; + char last = buf[len - 1]; + char num[4]; + int o; + + memset (num, 0, sizeof (num)); + o = sizeof (num) - 1; + + len--; + + if (len < 0) + return; + + while (len--) + { + if (*buf == ';') + { + vt102_change_attr (v, &num[o]); + memset (num, 0, sizeof (num)); + o = sizeof (num) - 1; + buf++; + continue; + } + + num[0] = num[1]; + num[1] = num[2]; + num[2] = *buf; + + if (o) + o--; + + buf++; + } + vt102_change_attr (v, &num[o]); +} + +void +vt102_save_state (VT102 * v) +{ + v->saved.pos = v->pos; + v->saved.attr = v->attr; + v->saved.color = v->color; + v->saved.origin_mode = v->private_modes[VT102_PRIVATE_MODE_ORIGIN_MODE]; +} + +void +vt102_restore_state (VT102 * v) +{ + v->pos = v->saved.pos; + v->attr = v->saved.attr; + v->color = v->saved.color; + v->private_modes[VT102_PRIVATE_MODE_ORIGIN_MODE] = v->saved.origin_mode; + vt102_cursor_normalize (v); + v->pending_wrap = 0; +} + +void +vt102_regular_char (Context * c, VT102 * v, int ch) +{ + + vt102_do_pending_wrap (c); + + if (v->modes[VT102_MODE_INSERT]) + vt102_insert_into_line (v, v->pos); + + v->crt.screen[CRT_ADDR_POS (&v->pos)].chr = ch; + v->crt.screen[CRT_ADDR_POS (&v->pos)].attr = v->attr; + v->crt.screen[CRT_ADDR_POS (&v->pos)].color = v->color; + vt102_cursor_advance (c); + + v->last_reg_char = ch; +} + +void +vt102_scs (Context * c, int g, int s) +{ +/*Ignoring charsets*/ +} + +void +vt102_parse_esc (Context * c, int ch) +{ + VT102 *v = c->v; + switch (ch) + { + case 'A': + vt102_cursor_relative (v, 0, -1); + break; + case 'B': + vt102_cursor_relative (v, 0, 1); + break; + case 'C': + vt102_cursor_relative (v, 1, 0); + break; + case 'D': + vt102_cursor_relative (v, -1, 0); + break; + case 'E': + if (v->pos.y == v->bottom_margin.y) + { + vt102_log_line (c, v->pos.y); + vt102_history (c, v->top_margin, v->bottom_margin); + crt_scroll_up (&v->crt, v->top_margin, v->bottom_margin, 1, + v->color); + } + else + { + vt102_cursor_relative (v, 0, 1); + } + break; + case 'H': + v->tabs[v->pos.x]++; + break; + case 'I': + vt102_cursor_retreat_line (c); + break; + case 'J': + crt_erase (&v->crt, v->pos, v->screen_end, 1, v->color); + break; + case 'K': + { + CRT_Pos le = { VT102_COLS - 1, v->pos.y }; + crt_erase (&v->crt, v->pos, le, 1, v->color); + } + break; + case 'M': + if (v->pos.y == v->top_margin.y) + { + crt_scroll_down (&v->crt, v->top_margin, v->bottom_margin, 1, + v->color); + } + else + { + vt102_cursor_relative (v, 0, -1); + } + break; + case 'Y': + v->parser.in_dca++; + v->parser.dca_ptr = 0; + break; + case 'Z': + if (c->t) + { + c->t->xmit (c->t, terminal_reply, sizeof (terminal_reply)); + } + break; + case '<': + /*Set ansi mode - ignored */ + break; + + case '7': + vt102_save_state (v); + break; + case '8': + vt102_restore_state (v); + break; + case '=': + v->application_keypad_mode = 1; + break; + case '>': + v->application_keypad_mode = 0; + break; + case ']': + v->parser.ignore_until_bell++; + break; + default: + log_f (c->l, "<%s:%d unhandled ESC: \\033 \\%03o (ESC %c)>", __FILE__, + __LINE__, ch, safe_ch (ch)); + + ; + } +} +void +vt102_parse_csi (Context * c, char *buf, int len) +{ + char last; + char *ptr; + char *arg = buf + 1; + int narg; + + VT102 *v = c->v; + + buf[len] = 0; + + last = buf[len - 1]; +#if 0 + buf[len - 1] = 0; +#endif + + if (len > 2) + { + narg = atoi (arg); + } + else + { + narg = 1; + } + + switch (buf[0]) + { + case '[': + switch (last) + { + case '@': + while (narg--) + vt102_insert_into_line (v, v->pos); + break; + case 'A': + vt102_cursor_relative (v, 0, -narg); + break; + case 'e': + case 'B': + vt102_cursor_relative (v, 0, narg); + break; + case 'a': + case 'C': + vt102_cursor_relative (v, narg, 0); + break; + case 'D': + vt102_cursor_relative (v, -narg, 0); + break; + case 'E': + vt102_cursor_relative (v, 0, narg); + vt102_cursor_carriage_return (v); + break; + case 'F': + vt102_cursor_relative (v, 0, -narg); + vt102_cursor_carriage_return (v); + break; + case 'G': + vt102_cursor_absolute (v, narg - 1, v->pos.y); + break; + case 'H': + case 'f': + { + int x, y; + + y = narg - 1; + + ptr = index (arg, ';'); + if (ptr) + x = atoi (ptr + 1) - 1; + else + x = 0; + + vt102_cursor_absolute (v, x, y); + } + break; + case 'I': + while (narg--) + vt102_cursor_advance_tab (c->v); + break; + case 'J': + if (len == 2) + narg = 0; /*Different default */ + switch (narg) + { + case 0: + crt_erase (&v->crt, v->pos, v->screen_end, 1, v->color); + break; + case 1: + crt_erase (&v->crt, v->screen_start, v->pos, 1, v->color); + break; + case 2: + crt_erase (&v->crt, v->screen_start, v->screen_end, 1, + v->color); + break; + } + break; + case 'K': + { + CRT_Pos ls = { 0, v->pos.y }; + CRT_Pos le = { VT102_COLS - 1, v->pos.y }; + if (len == 2) + narg = 0; /*Different default */ + + switch (narg) + { + case 0: + crt_erase (&v->crt, v->pos, le, 1, v->color); + break; + case 1: + crt_erase (&v->crt, ls, v->pos, 1, v->color); + break; + case 2: + crt_erase (&v->crt, ls, le, 1, v->color); + break; + } + } + break; + + case 'L': + if ((v->pos.y >= v->top_margin.y) + && (v->pos.y <= v->bottom_margin.y)) + { + while (narg--) + crt_scroll_down (&v->crt, v->pos, v->bottom_margin, 1, + v->color); + } + break; + + case 'M': + if ((v->pos.y >= v->top_margin.y) + && (v->pos.y <= v->bottom_margin.y)) + { + while (narg--) + { + vt102_history (c, v->pos, v->bottom_margin); + crt_scroll_up (&v->crt, v->pos, v->bottom_margin, 1, + v->color); + } + } + break; + case 'P': + while (narg--) + vt102_delete_from_line (v, v->pos); + break; + case 'R': + //FIXME: cursor position report - does anything use that? + break; + case 'S': + while (narg--) + { + vt102_history (c, v->top_margin, v->bottom_margin); + crt_scroll_up (&v->crt, v->top_margin, v->bottom_margin, 1, + v->color); + } + break; + case 'T': + while (narg--) + crt_scroll_down (&v->crt, v->top_margin, v->bottom_margin, 1, + v->color); + break; + case 'X': + { + CRT_Pos end = v->pos; + if (!narg) + narg++; + + end.x += narg - 1; + if (end.x > v->bottom_margin.x) + end.x = v->bottom_margin.x; + + crt_erase (&v->crt, v->pos, end, 1, v->color); + } + break; + case 'Z': + while (narg--) + vt102_cursor_retreat_tab (c->v); + break; + case '`': + vt102_cursor_absolute (v, narg - 1, v->pos.y); + break; + case 'b': + while (narg--) + vt102_regular_char (c, v, v->last_reg_char); + break; + case 'c': + //FIXME: + break; + case 'd': + vt102_cursor_absolute (v, v->pos.x, narg - 1); + break; + case 'g': + if (len == 2) + narg = 0; /*Different default */ + + switch (narg) + { + case 0: + v->tabs[v->pos.x] = 0; + break; + case 2: //FIXME: - LA120 says current line only WTF? + case 3: + memset (v->tabs, 0, sizeof (v->tabs)); + break; + } + break; + + case 'i': //4,5 Turn printer on and off WTF? + //FIXME + break; + case 'h': + case 'l': + vt102_parse_mode_string (v, &buf[1], len - 1); + break; + + + case 'm': + vt102_parse_attr_string (v, &buf[1], len - 1); + break; + case 'n': // 6 request cursor position + //FIXME + break; + case 'r': + v->top_margin = v->screen_start; + v->bottom_margin = v->screen_end; + + if ((len > 2) && (ptr = index (arg, ';'))) + { + ptr++; + v->top_margin.y = narg - 1; + v->bottom_margin.y = atoi (ptr) - 1; + } + + if (v->top_margin.y < v->screen_start.y) + v->top_margin.y = v->screen_start.y; + if (v->top_margin.y > v->screen_end.y) + v->top_margin.y = v->screen_end.y; + if (v->bottom_margin.y < v->screen_start.y) + v->bottom_margin.y = v->screen_start.y; + if (v->bottom_margin.y > v->screen_end.y) + v->bottom_margin.y = v->screen_end.y; + + vt102_cursor_home (v); + break; + case 's': + v->saved.pos = v->pos; + break; + case 'u': + v->pos = v->saved.pos; + vt102_cursor_normalize (v); + v->pending_wrap = 0; + break; + + default: + log_f (c->l, "<%s:%d unhandled CSI: \\033%s>", __FILE__, __LINE__, + buf); + + ; + } + break; + default: + log_f (c->l, "<%s:%d unhandled sequence: \\033%s>", __FILE__, __LINE__, + buf); + ; + } + + + +} + +void +vt102_status_line (VT102 * v, char *str) +{ + int i = VT102_COLS; + CRT_CA *ca = &v->crt.screen[CRT_ADDR (VT102_STATUS_ROW, 0)]; + + while (i--) + { + ca->attr = CRT_ATTR_REVERSE; + ca->color = CRT_COLOR_NORMAL; + ca->chr = *str; + if (*str) + str++; + ca++; + } + +} + + +void +vt102_parser_reset (VT102_parser * p) +{ + p->in_csi = 0; + p->in_escape = 0; + p->ignore_until_bell = 0; +} + + +void +vt102_reset_state (VT102 * v) +{ + vt102_parser_reset (&v->parser); + + v->attr = CRT_ATTR_NORMAL; + v->color = CRT_COLOR_NORMAL; + + v->application_keypad_mode = 0; + + v->top_margin = v->screen_start; + v->bottom_margin = v->screen_end; + + memset (v->modes, 0, VT102_NMODES); + memset (v->private_modes, 0, VT102_NMODES); + + v->private_modes[VT102_PRIVATE_MODE_AUTO_WRAP] = 1; + v->private_modes[VT102_PRIVATE_MODE_AUTO_REPEAT] = 1; + v->private_modes[VT102_PRIVATE_MODE_SHOW_CURSOR] = 1; + v->modes[VT102_MODE_LOCAL_ECHO_OFF] = 1; + + vt102_reset_tabs (v); +} + + +void +vt102_parse_char (Context * c, int ch) +{ + VT102 *v = c->v; + VT102_parser *p = &v->parser; + +#if 0 + log_f (c->l, "char %3d %c pc %d %d %d %2d %2d %d", ch, safe_ch (ch), + p->ignore_until_bell, p->in_escape, p->in_csi, v->pos.x, v->pos.y, + v->pending_wrap); +#endif + +/* Turn anything non-ascii into '?' */ +#if 0 + if ((ch != SYM_CHAR_RESET) && (ch != 0xb9) && (ch > 127)) + { + ch = '?'; + } +#endif + + + if (ch == SYM_CHAR_RESET) + { + vt102_reset_state (v); + } + else if (p->in_dca) + { + p->dca_buf[p->dca_ptr++] = ch; + if (p->dca_ptr == 2) + { + vt102_cursor_absolute (v, p->dca_buf[0] - 040, p->dca_buf[1] - 040); + p->in_dca = 0; + } + } + else if (p->ignore_until_bell) + { + if (ch == 7) + p->ignore_until_bell = 0; + } + else if (p->in_csi) + { + p->csi_buf[p->csi_ptr++] = ch; + if (csi_ender (ch) || (p->csi_ptr == VT102_CSI_LEN)) + { + if (csi_starter (p->csi_buf[0])) + { + vt102_parse_csi (c, p->csi_buf, p->csi_ptr); + } + else if (scs_starter (p->csi_buf[0])) + { + vt102_scs (c, p->csi_buf[0], p->csi_buf[1]); + } + else + { + log_f (c->l, + "<%s:%d no dispatcher for sequence starting \\033 \\%03o (ESC %c)>", + __FILE__, __LINE__, p->csi_buf[0], + safe_ch (p->csi_buf[0])); + } + p->in_csi = 0; + } + } + else if (p->in_escape) + { + if (csi_starter (ch) || scs_starter (ch)) + { + p->csi_ptr = 0; + p->csi_buf[p->csi_ptr++] = ch; + p->in_csi++; + p->in_escape = 0; + } + else + { + p->in_escape = 0; + vt102_parse_esc (c, ch); + } + } + else if (ch == 0x9b) /*One byte CSI */ + { + p->csi_ptr = 0; + p->csi_buf[p->csi_ptr++] = '['; + p->in_csi++; + } + else + { + + switch (ch) + { + /*NUL*/ case 0: + /*SOH*/ case 1: + /*STX*/ case 2: + /*ETX*/ case 3: + /*EOT*/ case 4: + break; + /*ENQ*/ case 5: + if (c->t) + { + c->t->xmit (c->t, "vt102", 5); + } + break; + /*ACK*/ case 6: + /*BEL*/ case 7: + break; + /*BS*/ case 8: + vt102_cursor_retreat (c->v); + break; + /*HT*/ case 9: + vt102_cursor_advance_tab (c->v); + break; + /*LF*/ case 10: + /*VT*/ case 11: + /*FF*/ case 12: + vt102_cursor_advance_line (c); + if (!v->modes[VT102_MODE_NEWLINE_MODE]) + break; + /*CR*/ case 13: + vt102_cursor_carriage_return (v); + break; /*SO*/ case 14: + /*select G1 */ + /*Ignoring charsets */ + break; /*SI*/ case 15: + /*select G0 */ + /*Ignoring charsets */ + break; /*DLE*/ case 16: - /*DC1*/ case 17: - /*DC2*/ case 18: - /*DC3*/ case 19: - /*DC4*/ case 20: + /*DC1 */ case 17: + /*DC2 */ case 18: + /*DC3 */ case 19: + /*DC4 */ case 20: /*NAK*/ case 21: /*SYN*/ case 22: /*ETB*/ case 23: @@ -252,10 +1516,245 @@ vt102_parse_char (VT102 * v, int c) /*US*/ case 31: /*DEL*/ case 127: break; - /*regular character*/ default: - v->crt->screen[CRT_ADDR_POS(&v->pos)].chr=c; - v->crt->screen[CRT_ADDR_POS(&v->pos)].attr=v->attr; - vt102_cursor_motion(v,1,0); + /*regular character */ default: + vt102_regular_char (c, v, ch); + } + } + + v->crt.pos = v->pos; + v->crt.hide_cursor = + v->private_modes[VT102_PRIVATE_MODE_SHOW_CURSOR] ? 0 : 1; + + if (v->current_line.y != v->pos.y) + { + vt102_log_line (c, v->current_line.y); + v->current_line = v->pos; + } + + if (c->d) + cmd_show_status (c->d, c); +} + +void +vt102_send (Context * c, uint8_t key) +{ + uint8_t ch; + + if (!c->t) + return; + +#if 0 + fprintf (stderr, "vts: %d(%c)\n", key, (key > 31) ? key : ' '); +#endif + if ((key > 31) && (key < 127)) + { + c->t->xmit (c->t, &key, 1); + return; + } + + switch (key) + { + /*NUL*/ case 0: + /*SOH*/ case 1: + /*STX*/ case 2: + /*ETX*/ case 3: + /*EOT*/ case 4: + /*ENQ*/ case 5: + /*ACK*/ case 6: + /*BEL*/ case 7: + /*BS*/ case 8: + /*HT*/ case 9: + /*LF*/ case 10: + /*VT*/ case 11: + /*FF*/ case 12: + c->t->xmit (c->t, &key, 1); + break; + /*CR*/ case 13: + c->t->xmit (c->t, &key, 1); + if (c->v->modes[VT102_MODE_NEWLINE_MODE]) + { + ch = 10; + c->t->xmit (c->t, &ch, 1); + } + break; + /*SO*/ case 14: + /*SI*/ case 15: + /*DLE*/ case 16: + /*DC1 */ case 17: + /*DC2 */ case 18: + /*DC3 */ case 19: + /*DC4 */ case 20: + /*NAK*/ case 21: + /*SYN*/ case 22: + /*ETB*/ case 23: + /*CAN*/ case 24: + /*EM*/ case 25: + /*SUB*/ case 26: + c->t->xmit (c->t, &key, 1); + break; + /*ESC*/ case 27: + /*FS*/ case 28: + /*GS*/ case 29: + /*RS*/ case 30: + /*US*/ case 31: + /*DEL*/ case 127: + c->t->xmit (c->t, &key, 1); + break; + + case KEY_UP: + case KEY_DOWN: + case KEY_RIGHT: + case KEY_LEFT: + case KEY_HOME: + case KEY_MIDDLE: + case KEY_END: + + if (c->v->private_modes[VT102_PRIVATE_MODE_CURSOR_MODE]) + { + uint8_t buf[] = { 033, 'O', 'A' + (key - KEY_UP) }; + c->t->xmit (c->t, &buf, sizeof (buf)); + } + else + { + uint8_t buf[] = { 033, '[', 'A' + (key - KEY_UP) }; + c->t->xmit (c->t, &buf, sizeof (buf)); + } + break; + case KEY_STAR: + case KEY_PLUS: + case KEY_COMMA: + case KEY_PERIOD: + case KEY_DIVIDE: + case KEY_0: + case KEY_1: + case KEY_2: + case KEY_3: + case KEY_4: + case KEY_5: + case KEY_6: + case KEY_7: + case KEY_8: + case KEY_9: + if (c->v->application_keypad_mode) + { + uint8_t buf[] = { 033, 'O', 'a' + (key - KEY_154) }; + c->t->xmit (c->t, &buf, sizeof (buf)); } + else + { + static char kpoff[KEY_NUM] = { + [KEY_STAR] = '*', + [KEY_PLUS] = '+', + [KEY_COMMA] = ',', + [KEY_MINUS] = '-', + [KEY_PERIOD] = '.', + [KEY_DIVIDE] = '/', + [KEY_0] = '0', + [KEY_1] = '1', + [KEY_2] = '2', + [KEY_3] = '3', + [KEY_4] = '4', + [KEY_5] = '5', + [KEY_6] = '6', + [KEY_7] = '7', + [KEY_8] = '8', + [KEY_9] = '9' + }; + + c->t->xmit (c->t, &kpoff[key], 1); + } + break; + case KEY_ENTER: + if (c->v->application_keypad_mode) + { + uint8_t buf[] = { 033, 'O', 'M' }; + c->t->xmit (c->t, &buf, sizeof (buf)); + } + else + { + ch = 13; + c->t->xmit (c->t, &ch, 1); + if (c->v->modes[VT102_MODE_NEWLINE_MODE]) + { + ch = 10; + c->t->xmit (c->t, &ch, 1); + } + } + break; + case KEY_PF1: + case KEY_PF2: + case KEY_PF3: + case KEY_PF4: + { + uint8_t buf[] = { 033, 'O', 'P' + (key - KEY_PF1) }; + c->t->xmit (c->t, &buf, sizeof (buf)); + } + break; + case KEY_INSERT: + case KEY_DELETE: + case KEY_PGUP: + case KEY_PGDN: + { + uint8_t buf[] = { 033, '[', '0' + (key - KEY_180), '~' }; + c->t->xmit (c->t, &buf, sizeof (buf)); + } + break; } + +} + +void +vt102_reset (VT102 * v) +{ + VT102_parser *p = &v->parser; + + + crt_cls (&v->crt); + v->current_line = v->pos; + v->pending_wrap = 0; + + v->screen_start.x = 0; + v->screen_start.y = 0; + v->screen_end.x = VT102_COLS - 1; + v->screen_end.y = VT102_ROWS - 1; + + vt102_cursor_home (v); + vt102_status_line (v, ""); + + vt102_reset_tabs (v); + v->current_line = v->pos; + + vt102_parser_reset (p); + vt102_reset_state (v); + + vt102_save_state (v); + + v->last_reg_char = ' '; +} + +VT102 * +vt102_new (void) +{ + VT102 *v; + + v = (VT102 *) malloc (sizeof (VT102)); + + v->xn_glitch = 1; + + vt102_reset (v); + + + return v; +} + +void +vt102_set_ansi (VT102 * v, int ansi) +{ + v->xn_glitch = ansi ? 0 : 1; +} + +void +vt102_free (VT102 * v) +{ + free (v); }