X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=sympathy.git;a=blobdiff_plain;f=src%2Fvt102.c;h=d33d3092d33369156ef424075c9a030b86cf8dc1;hp=8b6192971f645704c7bc4d6faf98324701e46c02;hb=d20265fbf33e22b30b5c2879cff7ae5c22d3fc29;hpb=5175425f563e29f4698d2941ba1825b09965aaa5

diff --git a/src/vt102.c b/src/vt102.c
index 8b61929..d33d309 100644
--- a/src/vt102.c
+++ b/src/vt102.c
@@ -10,6 +10,66 @@ static char rcsid[] = "$Id$";
 
 /*
  * $Log$
+ * 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 ***
  *
@@ -75,8 +135,8 @@ CTRL-I
 CTRL-J
 CTRL-M
 CTRL-N
-CTRL-O
 
+CTRL-O
 ESC7
 ESC8
 ESCH
@@ -106,8 +166,6 @@ ESC[5m
 ESC[7m
 ESC[%d;%dr
 
-ESC(B
-ESC)0
 
 ESC[?3l 
 ESC[?4l 
@@ -117,11 +175,24 @@ ESC[?7h
 ESC[?7l
 ESC[?8h
 
+ESC(B
+ESC)0
+
+
+TODO:
+
+ESC(B
+ESC)0
+
+CTRL-O
+
+
 */
 
 #include "project.h"
 
 
+
 static inline int
 csi_ender (int c)
 {
@@ -133,11 +204,10 @@ csi_ender (int c)
 }
 
 static inline int
-csi_starter (int c)
+scs_starter (int c)
 {
   switch (c)
     {
-    case '[':
     case '(':
     case ')':
       return 1;
@@ -145,85 +215,259 @@ csi_starter (int c)
   return 0;
 }
 
+static inline int
+csi_starter (int c)
+{
+  switch (c)
+    {
+    case '[':
+      return 1;
+    }
+  return 0;
+}
+
+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.x > v->bottom_margin.x)
+    return 0;
+  if (v->pos.y > v->bottom_margin.y)
+    return 0;
+
+  return 1;
+}
 
 void
-vt102_cursor_normalize (VT102 * v, int do_wrapscroll, int use_margins)
+vt102_log_line (Context * c, int line)
 {
-  int wrap = do_wrapscroll ? 1 : 0;
-  int scroll = do_wrapscroll ? 1 : 0;
-  CRT_Pos *top, *bottom;
+  CRT_Pos e = { VT102_COLS - 1, line };
+  CRT_Pos p = { 0, line };
+  char logbuf[VT102_COLS + 1];
+
+  if (!c->l)
+    return;
 
-  if (use_margins)
+
+  for (; e.x > 0; --e.x)
     {
-      top = &v->top_margin;
-      bottom = &v->bottom_margin;
+      if (c->v->crt.screen[CRT_ADDR_POS (&e)].chr != ' ')
+        break;
     }
-  else
+
+  for (; p.x <= e.x; ++p.x)
     {
-      top = &v->screen_start;
-      bottom = &v->screen_end;
+      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;
 
-  if (v->pos.x < top->x)        /*don't wrap backwards */
-    v->pos.x = top->x;
+  c->l->log (c->l, logbuf);
+}
+
+/*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)]));
+}
+
+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;
+}
+
+
+void
+vt102_cursor_normalize (VT102 * v)
+{
+  CRT_Pos *top, *bottom;
 
-  if (v->pos.x > bottom->x)
+  if (v->private_modes[VT102_PRIVATE_MODE_ORIGIN_MODE])
     {
-      if (wrap)
-        {
-          v->pos.x = top->x;
-          v->pos.y++;
-        }
-      else
-        {
-          v->pos.x = bottom->x;
-        }
+      vt102_clip_cursor (v, v->top_margin, v->bottom_margin);
+    }
+  else
+    {
+      vt102_clip_cursor (v, v->screen_start, v->screen_end);
     }
+}
 
-  if (v->pos.y < top->y)
-    v->pos.y = top->y;
 
-  if (v->pos.y > bottom->y)
+void
+vt102_cursor_carriage_return (VT102 * v)
+{
+   /*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);
+
+/*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))
     {
-      if (scroll)
-        crt_scroll_up (&v->crt, *top, *bottom, 1);
-      v->pos.y = bottom->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);
+      return;
     }
+
+  v->pos.y++;
+  v->pending_wrap = 0;
 }
 
 
 void
-vt102_cursor_motion (VT102 * v, int x, int y, int wrapscroll)
+vt102_cursor_advance (Context * c)
 {
-  while (x > 0)
+  VT102 *v = c->v;
+
+  if (v->pos.x < v->bottom_margin.x)
     {
-      x--;
+/*Normal advance*/
       v->pos.x++;
-      vt102_cursor_normalize (v, wrapscroll, 1);
+      v->pending_wrap = 0;
+      return;
     }
+  v->pending_wrap++;
+}
 
-  while (x < 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
     {
-      x++;
-      v->pos.x--;
-      vt102_cursor_normalize (v, wrapscroll, 1);
+      v->pos.x = 0;
     }
 
-  while (y > 0)
+  vt102_cursor_advance_line (c);
+}
+
+
+void
+vt102_cursor_retard (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)
     {
-      y--;
-      v->pos.y++;
-      vt102_cursor_normalize (v, wrapscroll, 1);
+      v->pos.x++;
+      if (v->tabs[v->pos.x])
+        break;
     }
+  v->pending_wrap = 0;
+}
 
-  while (y < 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])
     {
-      y++;
-      v->pos.y--;
-      vt102_cursor_normalize (v, wrapscroll, 1);
+      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)
 {
@@ -243,6 +487,28 @@ vt102_delete_from_line (VT102 * v, CRT_Pos p)
 /*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)
 {
@@ -264,11 +530,30 @@ vt102_change_mode (VT102 * v, int private, char *ns, int set)
     return;
 
   if (private)
-    v->private_modes[m] = set;
+    {
+      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
@@ -319,20 +604,252 @@ vt102_parse_mode_string (VT102 * v, char *buf, int len)
 
 }
 
+
 void
-vt102_parse_esc (VT102 * v, int c)
+vt102_change_attr (VT102 * v, char *na)
 {
-  fprintf (stderr, "ESC 0%o(%c)\n", c, c);
+  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_csi (VT102 * v, char *buf, int len)
+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_scs (Context * c, int g, int s)
+{
+/*Ignoring charsets*/
+}
+
+void
+vt102_parse_esc (Context * c, int ch)
+{
+  VT102 *v = c->v;
+  switch (ch)
+    {
+    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);
+        }
+      else
+        {
+          vt102_cursor_relative (v, 0, 1);
+        }
+      break;
+    case 'H':
+      v->tabs[v->pos.x]++;
+      break;
+    case 'M':
+      if (v->pos.y == v->top_margin.y)
+        {
+          crt_scroll_down (&v->crt, v->top_margin, v->bottom_margin, 1);
+        }
+      else
+        {
+          vt102_cursor_relative (v, 0, -1);
+        }
+      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;
+    default:
+#if 0
+      fprintf (stderr, "unhandled ESC \\033 \\%03o (ESC %c)\n", ch,
+               (ch < 32) ? '?' : ch);
+#endif
+      ;
+    }
+}
+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];
@@ -355,30 +872,45 @@ vt102_parse_csi (VT102 * v, char *buf, int len)
       switch (last)
         {
         case 'A':
-          vt102_cursor_motion (v, 0, -narg, 0);
+          vt102_cursor_relative (v, 0, -narg);
           break;
         case 'B':
-          vt102_cursor_motion (v, 0, narg, 0);
+          vt102_cursor_relative (v, 0, narg);
           break;
         case 'C':
-          vt102_cursor_motion (v, narg, 0, 0);
+          vt102_cursor_relative (v, narg, 0);
           break;
         case 'D':
-          vt102_cursor_motion (v, -narg, 0, 0);
+          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':
-          v->pos.y = narg - 1;
+        case 'f':
+          {
+            int x, y;
+
+            y = narg - 1;
 
-          ptr = index (arg, ';');
-          if (ptr)
-            v->pos.x = atoi (ptr + 1) - 1;
-          else
-            v->pos.x = 0;
+            ptr = index (arg, ';');
+            if (ptr)
+              x = atoi (ptr + 1) - 1;
+            else
+              x = 0;
 
-          vt102_cursor_normalize (v, 0, 0);
+            vt102_cursor_absolute (v, x, y);
+          }
           break;
         case 'J':
-          fprintf (stderr, "OCTOPUS %d\n", narg);
           switch (narg)
             {
             case 1:
@@ -399,18 +931,12 @@ vt102_parse_csi (VT102 * v, char *buf, int len)
             switch (narg)
               {
               case 0:
-                fprintf (stderr, "FISH %d %d -> %d %d\n",
-                         v->pos.x, v->pos.y, le.x, le.y);
                 crt_erase (&v->crt, v->pos, le, 1);
                 break;
               case 1:
-                fprintf (stderr, "SOUP %d %d -> %d %d\n",
-                         ls.x, ls.y, v->pos.x, v->pos.y);
                 crt_erase (&v->crt, ls, v->pos, 1);
                 break;
               case 2:
-                fprintf (stderr, "TREE %d %d -> %d %d\n",
-                         ls.x, ls.y, le.x, le.y);
                 crt_erase (&v->crt, ls, le, 1);
                 break;
               }
@@ -435,22 +961,35 @@ vt102_parse_csi (VT102 * v, char *buf, int len)
               && (v->pos.y <= v->bottom_margin.y))
             {
               while (narg--)
-                crt_scroll_up (&v->crt, v->pos, v->bottom_margin, 0);
+                {
+                  vt102_history (c, v->pos, v->bottom_margin);
+                  crt_scroll_up (&v->crt, v->pos, v->bottom_margin, 1);
+                }
             }
           break;
 
         case 'g':
-          fprintf (stderr, "C: CSI %s buf[0]=%c\n", buf, buf[0]);
+          if (len == 2)
+            narg = 0;           /*Different default */
+
+          switch (narg)
+            {
+            case 0:
+              v->tabs[v->pos.x] = 0;
+              break;
+            case 3:
+              memset (v->tabs, 0, sizeof (v->tabs));
+              break;
+            }
           break;
 
         case 'h':
         case 'l':
-          fprintf (stderr, "D: CSI %s buf[0]=%c\n", buf, buf[0]);
           vt102_parse_mode_string (v, &buf[1], len - 1);
           break;
 
         case 'm':
-          //horror of horrors parsing the ;
+          vt102_parse_attr_string (v, &buf[1], len - 1);
           break;
         case 'r':
           v->top_margin = v->screen_start;
@@ -472,17 +1011,29 @@ vt102_parse_csi (VT102 * v, char *buf, int len)
           if (v->bottom_margin.y > v->screen_end.y)
             v->bottom_margin.y = v->screen_end.y;
 
-          fprintf (stderr, "D: %d %d\n", v->top_margin.y, v->bottom_margin.y);
-
-          v->pos = v->top_margin;
+          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:
-          fprintf (stderr, "A: CSI %s buf[0]=%c\n", buf, buf[0]);
+#if 0
+          fprintf (stderr, "unhandled CSI  \\033%s\n", buf, buf[0]);
+#endif
+          ;
         }
       break;
     default:
-      fprintf (stderr, "B: CSI %s buf[0]=%c\n", buf, buf[0]);
+#if 0
+      fprintf (stderr, "unhandled CSI  \\033%s\n", buf, buf[0]);
+#endif
+      ;
     }
 
 
@@ -498,6 +1049,7 @@ vt102_status_line (VT102 * v, char *str)
   while (i--)
     {
       ca->attr = CRT_ATTR_REVERSE;
+      ca->color = CRT_COLOR_NORMAL;
       ca->chr = *str;
       if (*str)
         str++;
@@ -508,70 +1060,89 @@ vt102_status_line (VT102 * v, char *str)
 
 
 void
-vt102_parse_char (VT102 * v, int c)
+vt102_parse_char (Context * c, int ch)
 {
+  VT102 *v = c->v;
   VT102_parser *p = &v->parser;
 
 #if 0
-  fprintf (stderr, "%c pc %d %d %d   %d %d\n", (c > 31) ? 32 : c, c,
+  fprintf (stderr, "char %c pc %d %d %d   %d %d\n", (c < 32) ? 32 : c, c,
            p->in_csi, p->in_escape, v->pos.x, v->pos.y);
 #endif
   if (p->in_csi)
     {
-      p->csi_buf[p->csi_ptr++] = c;
-      if (csi_ender (c) || (p->csi_ptr == VT102_CSI_LEN))
+      p->csi_buf[p->csi_ptr++] = ch;
+      if (csi_ender (ch) || (p->csi_ptr == VT102_CSI_LEN))
         {
-          vt102_parse_csi (v, p->csi_buf, p->csi_ptr);
+          vt102_parse_csi (c, p->csi_buf, p->csi_ptr);
           p->in_csi = 0;
         }
     }
   else if (p->in_escape)
     {
-      if (csi_starter (c))
+      if (csi_starter (ch))
         {
           p->csi_ptr = 0;
-          p->csi_buf[p->csi_ptr++] = c;
+          p->csi_buf[p->csi_ptr++] = ch;
           p->in_csi++;
           p->in_escape = 0;
         }
+      else if (scs_starter (ch))
+        {
+          p->in_scs = ch;
+          p->in_escape = 0;
+        }
       else
         {
           p->in_escape = 0;
-          vt102_parse_esc (v, c);
+          vt102_parse_esc (c, ch);
         }
     }
+  else if (p->in_scs)
+    {
+      vt102_scs (c, p->in_scs, ch);
+      p->in_scs = 0;
+    }
   else
     {
 
-      switch (c)
+      switch (ch)
         {
          /*NUL*/ case 0:
          /*SOH*/ case 1:
          /*STX*/ case 2:
          /*ETX*/ case 3:
          /*EOT*/ case 4:
+          break;
          /*ENQ*/ case 5:
+          c->t->xmit (c->t, "vt102", 5);
+          break;
          /*ACK*/ case 6:
          /*BEL*/ case 7:
           break;
          /*BS*/ case 8:
-          vt102_cursor_motion (v, -1, 0, 1);
+          vt102_cursor_retard (c->v);
           break;
          /*HT*/ case 9:
-          v->pos.x += 8;
-          v->pos.x &= ~7;
-          vt102_cursor_normalize (v, 1, 1);
+          vt102_cursor_advance_tab (c->v);
           break;
          /*LF*/ case 10:
          /*VT*/ case 11:
          /*FF*/ case 12:
-          vt102_cursor_motion (v, 0, 1, 1);
-          break;
+          vt102_cursor_advance_line (c);
+          if (!v->modes[VT102_MODE_NEWLINE_MODE])
+            break;
          /*CR*/ case 13:
-          v->pos.x = v->top_margin.x;
+          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:
@@ -594,23 +1165,214 @@ vt102_parse_char (VT102 * v, int c)
          /*DEL*/ case 127:
           break;
         /*regular character */ default:
-          v->crt.screen[CRT_ADDR_POS (&v->pos)].chr = c;
+          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;
-          vt102_cursor_motion (v, 1, 0, 1);
+          v->crt.screen[CRT_ADDR_POS (&v->pos)].color = v->color;
+          vt102_cursor_advance (c);
         }
     }
 
   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;
+    }
 
   vt102_status_line (v, "VT102 foo bar baz I'm the urban spaceman baby");
 }
 
+vt102_parse (Context * c, char *buf, int len)
+{
+  while (len--)
+    vt102_parse_char (c, *(buf++));
+}
+
+
 void
 vt102_parser_reset (VT102_parser * p)
 {
   p->in_csi = 0;
   p->in_escape = 0;
   p->csi_ptr = 0;
+  p->in_scs = 0;
+}
+
+
+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
@@ -621,6 +1383,13 @@ vt102_reset (VT102 * v)
   vt102_parser_reset (p);
   crt_cls (&v->crt);
 
+  v->attr = CRT_ATTR_NORMAL;
+  v->color = CRT_COLOR_NORMAL;
+
+  v->application_keypad_mode = 0;
+
+  v->current_line = v->pos;
+  v->pending_wrap = 0;
 
   v->screen_start.x = 0;
   v->screen_start.y = 0;
@@ -630,6 +1399,77 @@ vt102_reset (VT102 * v)
   v->top_margin = v->screen_start;
   v->bottom_margin = v->screen_end;
 
-  v->pos = v->screen_start;
+  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_cursor_home (v);
+  vt102_reset_tabs (v);
+  v->current_line = v->pos;
+
+  vt102_save_state (v);
+
+  vt102_status_line (v, "VT102 foo bar baz I'm the urban spaceman baby");
+
+}
+
+int
+vt102_dispatch (Context * c)
+{
+  char buf[1024];
+  int red;
+
+  red = c->t->recv (c->t, buf, sizeof (buf));
+
+  if (red < 0)
+    return -1;
+  if (!red)
+    return 0;
+
+
+  vt102_parse (c, buf, red);
+
+  return 0;
+}
+
+
+int
+vt102_dispatch_one (Context * c)
+{
+  char buf;
+  int red;
+
+  red = c->t->recv (c->t, &buf, sizeof (buf));
+
+  if (red < 0)
+    return -1;
+  if (!red)
+    return 0;
 
+  vt102_parse_char (c, buf);
+
+  return 0;
+}
+
+VT102 *
+vt102_new (void)
+{
+  VT102 *v;
+
+  v = (VT102 *) malloc (sizeof (VT102));
+
+  vt102_reset (v);
+
+
+  return v;
+}
+
+void
+vt102_free (VT102 * v)
+{
+  free (v);
 }