chiark / gitweb /
*** empty log message ***
[sympathy.git] / src / vt102.c
index 8e495e4862aa74151e737904c193497932ba753a..a879999359a729720987ca7921296d094df93929 100644 (file)
@@ -10,6 +10,24 @@ static char rcsid[] = "$Id$";
 
 /*
  * $Log$
+ * Revision 1.45  2008/02/27 01:31:14  james
+ * *** empty log message ***
+ *
+ * Revision 1.44  2008/02/27 00:54:16  james
+ * *** empty log message ***
+ *
+ * Revision 1.43  2008/02/27 00:27:22  james
+ * *** empty log message ***
+ *
+ * Revision 1.42  2008/02/26 23:56:12  james
+ * *** empty log message ***
+ *
+ * Revision 1.41  2008/02/26 23:23:17  james
+ * *** empty log message ***
+ *
+ * Revision 1.40  2008/02/26 19:00:59  james
+ * *** empty log message ***
+ *
  * Revision 1.39  2008/02/26 16:54:06  james
  * *** empty log message ***
  *
@@ -288,10 +306,11 @@ 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' };
-
 #define TABLE_LENGTH 128
+#undef DEBUG
+
+
+static char terminal_id[] = "vt102";
 
 /* number of aditional chars after \033 ... to complete the escape if it's fixed length*/
 int vt102_cmd_length[TABLE_LENGTH] = {
@@ -337,14 +356,19 @@ csi_ender (int c)
   return 0;
 }
 
-
-
-/*Stay or enter command acquision and exit after n more chars*/
-void
-redispatch_with_more (VT102_parser * p, int n)
+static inline int
+ctrl_chr (int ch, int term)
 {
+  if ((term > 0) && (ch == term))
+    return 0;
+  if (ch == 033)
+    return 0;
+  if ((ch > 0) && (ch < 040))
+    return 1;
+  return 0;
 }
 
+
 static inline int
 in_margins (VT102 * v, CRT_Pos p)
 {
@@ -364,9 +388,9 @@ in_margins (VT102 * v, CRT_Pos p)
 void
 vt102_log_line (Context * c, int line)
 {
-  CRT_Pos e = { VT102_COLS - 1, line };
+  CRT_Pos e = { c->v->current_width - 1, line };
   CRT_Pos p = { 0, line };
-  char logbuf[VT102_COLS + 1];
+  char logbuf[4 * (VT102_MAX_COLS + 1)], *logptr = logbuf;
 
   if (!c->l)
     return;
@@ -383,11 +407,9 @@ vt102_log_line (Context * c, int line)
       int ch = c->v->crt.screen[CRT_ADDR_POS (&p)].chr;
       if (ch < 32)
         ch = ' ';
-      if (ch > 126)
-        ch = ' ';
-      logbuf[p.x] = ch;
+      logptr += utf8_encode (logptr, ch);
     }
-  logbuf[p.x] = 0;
+  *logptr = 0;
 
   c->l->log (c->l, logbuf);
 }
@@ -548,7 +570,9 @@ void
 vt102_cursor_retreat (VT102 * v)
 {
   if (v->pos.x != v->top_margin.x)
-    v->pos.x--;
+    {
+      v->pos.x--;
+    }
 
   v->pending_wrap = 0;
 }
@@ -560,7 +584,7 @@ vt102_reset_tabs (VT102 * v)
 
   memset (v->tabs, 0, sizeof (v->tabs));
 
-  for (i = 0; i < VT102_COLS; i += 8)
+  for (i = 0; i < VT102_MAX_COLS; i += 8)
     {
       v->tabs[i]++;
     }
@@ -606,7 +630,7 @@ 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;
+      v->pos.y = y + v->top_margin.y;
     }
   else
     {
@@ -661,9 +685,9 @@ vt102_insert_into_line (VT102 * v, CRT_Pos p)
                &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;
+  v->crt.screen[CRT_ADDR_POS (&p)].chr = ' ';
+  v->crt.screen[CRT_ADDR_POS (&p)].attr = CRT_ATTR_NORMAL;
+  v->crt.screen[CRT_ADDR_POS (&p)].color = CRT_COLOR_NORMAL;
 }
 
 
@@ -703,6 +727,23 @@ vt102_change_mode (VT102 * v, int private, char *ns, int set)
           break;
         case VT102_PRIVATE_MODE_ORIGIN_MODE:
           vt102_cursor_home (v);
+          break;
+        case VT102_PRIVATE_MODE_132COLS:
+          /* We don't implement 132 col mode - yet */
+
+          v->current_width =
+            v->
+            private_modes[VT102_PRIVATE_MODE_132COLS] ? VT102_COLS_132 :
+            VT102_COLS_80;
+
+          v->crt.width = v->current_width;
+          v->screen_end.x = v->current_width - 1;
+          v->top_margin = v->screen_start;
+          v->bottom_margin = v->screen_end;
+          vt102_cursor_home (v);
+          crt_cls (&v->crt);
+
+
           break;
         }
 
@@ -943,877 +984,1074 @@ vt102_restore_state (VT102 * v)
 }
 
 void
-vt102_regular_char (Context * c, VT102 * v, int ch)
+vt102_regular_char (Context * c, VT102 * v, uint32_t ch)
 {
 
+
   vt102_do_pending_wrap (c);
 
+
   if (v->modes[VT102_MODE_INSERT])
     vt102_insert_into_line (v, v->pos);
 
+  v->last_reg_char = ch;
+
+
+  if (ch < VT102_CHARSET_SIZE)
+    {
+      int cs;
+      if ((cs = vt102_charset_c0[ch]))
+        {
+          ch = cs;
+        }
+      else if ((cs = charset_from_csid[v->g[v->cs]][ch]))
+        {
+          ch = cs;
+        }
+    }
   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)
+vt102_send_id (Context * c, char *buf)
 {
-/*Ignoring charsets*/
+
+  if (c->t)
+    {
+      int l = strlen (buf);
+      c->t->xmit (c->t, buf, l);
+    }
 }
 
 void
-vt102_parse_esc (Context * c)
+vt102_scs (Context * c, int g, int s)
 {
   VT102 *v = c->v;
-  VT102_parser *p = &v->parser;
+  int cs = VT102_CSID_US;
 
-/*If you edit this switch don't forget to edit the length and termination tables*/
-  switch (p->cmd_buf[0])
+
+  switch (s)
     {
     case 'A':
-      vt102_cursor_relative (v, 0, -1);
+      cs = VT102_CSID_UK;
       break;
+    case '1':
+    case '2':
     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);
-      }
+      cs = VT102_CSID_US;
       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);
-        }
+    case '0':
+      cs = VT102_CSID_GL;
       break;
+    }
 
-    case 'Y':
-      vt102_cursor_absolute (v, p->cmd_buf[2] - 040, p->cmd_buf[1] - 040);
+  switch (g)
+    {
+    case '(':
+      v->g[0] = cs;
       break;
-    case 'Z':
-      if (c->t)
-        {
-          c->t->xmit (c->t, terminal_reply, sizeof (terminal_reply));
-        }
+    case ')':
+      v->g[1] = cs;
       break;
-    case '#':
-        switch (p->cmd_buf[1])
-          {
-          case '8':
-            /*DECALN*/
-            {
-              int i;
-              crt_erase (&v->crt, v->screen_start, v->screen_end, 1,
-                         CRT_NORMAL_COLOR);
-              for (i = 0; i < CRT_ADDR_POS (&v->screen_end); ++i)
-                v->crt.screen[i].chr = 'E';
-            }
-          default:
-
-            log_f (c->l,
-                   "<%s:%d unhandled ESC: \\033 \\043 \\%03o (ESC # %c)>",
-                   __FILE__, __LINE__, p->cmd_buf[1],
-                   safe_ch (p->cmd_buf[1]));
-
-          }
-        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 ']':                  /*Set various titles */
-        //FIXME:
-        break;
-    case '[':
-        vt102_parse_csi (c, p->cmd_buf, p->cmd_ptr);
-        break;
-    case '(':                  /*Charsets */
-    case ')':
-    case '+':
-    case '*':
-    case '%':
-        vt102_scs (c, p->cmd_buf[0], p->cmd_buf[1]);
-        break;
-    default:
-        log_f (c->l, "<%s:%d unhandled ESC: \\033 \\%03o (ESC %c)>", __FILE__,
-               __LINE__, p->cmd_buf[0], safe_ch (p->cmd_buf[0]));
+}
 
-        ;
-      }
-    }
-  void vt102_parse_csi (Context * c, char *buf, int len)
-  {
-    char last;
-    char *ptr;
-    char *arg = buf + 1;
-    int narg;
+void
+vt102_parse_csi (Context * c, char *buf, int len)
+{
+  char last;
+  char *ptr;
+  char *arg = buf + 1;
+  int narg;
 
-    VT102 *v = c->v;
+  VT102 *v = c->v;
 
-    buf[len] = 0;
+  buf[len] = 0;
 
-    last = buf[len - 1];
+  last = buf[len - 1];
 #if 0
-    buf[len - 1] = 0;
+  buf[len - 1] = 0;
 #endif
 
-    if (len > 2)
-      {
-        narg = atoi (arg);
-      }
-    else
-      {
-        narg = 1;
-      }
+  if (len > 2)
+    {
+      narg = atoi (arg);
+    }
+  else
+    {
+      narg = 1;
+    }
 
-    switch (buf[0])
-      {
-      case '[':
-        switch (last)
+  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':
           {
-          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;
+            int x, y;
 
-              y = narg - 1;
+            y = narg - 1;
 
-              ptr = index (arg, ';');
-              if (ptr)
-                x = atoi (ptr + 1) - 1;
-              else
-                x = 0;
+            ptr = index (arg, ';');
+            if (ptr)
+              x = atoi (ptr + 1) - 1;
+            else
+              x = 0;
 
-              vt102_cursor_absolute (v, x, y);
+            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 'I':
-            while (narg--)
-              vt102_cursor_advance_tab (c->v);
-            break;
-          case 'J':
+          break;
+        case 'K':
+          {
+            CRT_Pos ls = { 0, v->pos.y };
+            CRT_Pos le = { v->current_width - 1, v->pos.y };
             if (len == 2)
               narg = 0;         /*Different default */
+
             switch (narg)
               {
               case 0:
-                crt_erase (&v->crt, v->pos, v->screen_end, 1, v->color);
+                crt_erase (&v->crt, v->pos, le, 1, v->color);
                 break;
               case 1:
-                crt_erase (&v->crt, v->screen_start, v->pos, 1, v->color);
+                crt_erase (&v->crt, ls, v->pos, 1, v->color);
                 break;
               case 2:
-                crt_erase (&v->crt, v->screen_start, v->screen_end, 1,
-                           v->color);
+                crt_erase (&v->crt, ls, le, 1, v->color);
                 break;
               }
-            break;
-          case 'K':
+          }
+          break;
+
+        case 'L':
+          if ((v->pos.y >= v->top_margin.y)
+              && (v->pos.y <= v->bottom_margin.y))
             {
-              CRT_Pos ls = { 0, v->pos.y };
-              CRT_Pos le = { VT102_COLS - 1, v->pos.y };
-              if (len == 2)
-                narg = 0;       /*Different default */
+              while (narg--)
+                crt_scroll_down (&v->crt, v->pos, v->bottom_margin, 1,
+                                 v->color);
+            }
+          break;
 
-              switch (narg)
+        case 'M':
+          if ((v->pos.y >= v->top_margin.y)
+              && (v->pos.y <= v->bottom_margin.y))
+            {
+              while (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;
+                  vt102_history (c, v->pos, v->bottom_margin);
+                  crt_scroll_up (&v->crt, v->pos, v->bottom_margin, 1,
+                                 v->color);
                 }
             }
-            break;
+          break;
+        case 'P':
+          while (narg--)
+            vt102_delete_from_line (v, v->pos);
+          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++;
 
-          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;
+            end.x += narg - 1;
+            if (end.x > v->bottom_margin.x)
+              end.x = v->bottom_margin.x;
 
-          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_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':
+          vt102_send_id (c, "\033[?2c");
+          break;
+        case 'd':
+          vt102_cursor_absolute (v, v->pos.x, narg - 1);
+          break;
+        case 'g':
+          if (len == 2)
+            narg = 0;           /*Different default */
+
+          switch (narg)
             {
-              CRT_Pos end = v->pos;
-              if (!narg)
-                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':              //Printer commands
+          //FIXME
+          break;
+        case 'h':
+        case 'l':
+          vt102_parse_mode_string (v, &buf[1], len - 1);
+          break;
 
-              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);
+        case 'm':
+          vt102_parse_attr_string (v, &buf[1], len - 1);
+          break;
+        case 'n':              //Device status report
+          switch (buf[1])
+            {
+            case '5':
+              vt102_send_id (c, "\033[0n");
+              break;
+            case '6':
+              if (c->t)
+                {
+                  char buf[16];
+                  int i;
+                  i =
+                    sprintf (buf, "\033[%d;%dR", v->pos.y + 1, v->pos.x + 1);
+                  c->t->xmit (c->t, buf, i);
+                }
+              break;
+            default:
+              //?15n printer status
+              log_f (c->l, "<%s:%d unhandled DSR: \\033%s>", __FILE__,
+                     __LINE__, buf);
             }
-            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 */
+          break;
+        case 'q':              //Load LED on off 
+          break;
+        case 'r':
+          v->top_margin = v->screen_start;
+          v->bottom_margin = v->screen_end;
 
-            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;
+          if ((len > 2) && (ptr = index (arg, ';')))
+            {
+              ptr++;
+              v->top_margin.y = narg - 1;
+              v->bottom_margin.y = atoi (ptr) - 1;
+            }
 
-          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;
+          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;
+        case 'y':              //Invoke confidence test
+          break;
+        case 'z':              //request terminal parameters
+          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;
+        default:
+          log_f (c->l, "<%s:%d unhandled CSI: \\033%s>", __FILE__, __LINE__,
+                 buf);
 
-            if ((len > 2) && (ptr = index (arg, ';')))
-              {
-                ptr++;
-                v->top_margin.y = narg - 1;
-                v->bottom_margin.y = atoi (ptr) - 1;
-              }
+          ;
+        }
+      break;
+    default:
+      log_f (c->l, "<%s:%d unhandled sequence: \\033%s>", __FILE__,
+             __LINE__, buf);
+      ;
+    }
 
-            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);
+}
 
-            ;
+void
+vt102_parse_esc (Context * c)
+{
+  VT102 *v = c->v;
+  VT102_parser *p = &v->parser;
+
+#ifdef DEBUG
+  p->cmd_buf[p->cmd_ptr] = 0;
+  log_f (c->l, "<cmd in  x=%3d y=%2d aw=%d vt=%d <ESC>%s >", v->pos.x,
+         v->pos.y, v->pending_wrap,
+         !v->private_modes[VT102_PRIVATE_MODE_VT52], p->cmd_buf);
+#endif
+
+  if (!v->private_modes[VT102_PRIVATE_MODE_VT52])
+    {
+      int ate = 1;
+
+      switch (p->cmd_buf[0])
+        {
+        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 'F':
+          v->cs = 1;
+          v->g[1] = VT102_CSID_VT52;
+          break;
+        case 'G':
+          v->cs = 0;
+          v->g[0] = VT102_CSID_US;
+          break;
+        case 'H':
+          vt102_cursor_absolute (v, 0, 0);
+          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 = { v->current_width - 1, v->pos.y };
+            crt_erase (&v->crt, v->pos, le, 1, v->color);
           }
-        break;
-      default:
-        log_f (c->l, "<%s:%d unhandled sequence: \\033%s>", __FILE__,
-               __LINE__, buf);
-        ;
-      }
+          break;
+        case 'Y':
+          vt102_cursor_absolute (v, p->cmd_buf[2] - 040, p->cmd_buf[1] - 040);
+          break;
+        case 'V':              //Print current line
+          break;
+        case 'W':              //Printer on
+          break;
+        case 'X':              //printer off
+          break;
+        case ']':              //print screen
+          break;
+        case 'Z':              //ID
+          vt102_send_id (c, "\033/K");
+          break;
+        case '^':              //Autoprint on
+          break;
+        case '_':              //Autoprint off
+          break;
+        case '=':
+          v->application_keypad_mode = 1;
+          break;
+        case '>':
+          v->application_keypad_mode = 0;
+          break;
+        default:
+          ate = 0;
+        }
+      if (ate)
+        return;
+    }
 
 
+/*If you edit this switch don't forget to edit the length and termination tables*/
+  switch (p->cmd_buf[0])
+    {
+    case 'D':
+      vt102_cursor_advance_line (c);
+      break;
 
-  }
+    case 'E':
+      vt102_cursor_advance_line (c);
+      v->pos.x = v->top_margin.x;
+      vt102_cursor_normalize (v);
+      v->pending_wrap = 0;
+      break;
+    case 'H':
+      v->tabs[v->pos.x]++;
+      break;
+    case 'M':
+      vt102_cursor_retreat_line (c);
+      break;
+    case 'N':                  //select G2 for one char
+      break;
+    case 'O':                  //select G3 for one char
+      break;
+    case 'Z':
+      vt102_send_id (c, terminal_id);
+      break;
+    case 'c':
+      vt102_reset (v);
 
-  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++;
-      }
+      break;
+    case '=':
+      v->application_keypad_mode = 1;
+      break;
+    case '>':
+      v->application_keypad_mode = 0;
+      break;
 
-  }
+    case '#':
+      switch (p->cmd_buf[1])
+        {
+        case '3':              //top of double height line
+        case '4':              //bottom of double height line
+        case '5':              //single width line
+        case '6':              //double width line
+          break;
+        case '8':
+           /*DECALN*/
+          {
+            int i;
+            crt_erase (&v->crt, v->screen_start, v->screen_end, 1,
+                       CRT_COLOR_NORMAL);
+            for (i = 0; i < CRT_ADDR_POS (&v->screen_end); ++i)
+              v->crt.screen[i].chr = 'E';
+          }
+          break;
+        default:
 
+          log_f (c->l,
+                 "<%s:%d unhandled ESC: \\033 \\043 \\%03o (ESC # %c)>",
+                 __FILE__, __LINE__, p->cmd_buf[1], safe_ch (p->cmd_buf[1]));
 
-  void vt102_parser_reset (VT102_parser * p)
-  {
-    p->in_cmd = 0;
-    p->cmd_more_bytes = 0;
-    p->cmd_termination = 0;
-    p->in_escape = 0;
-  }
+        }
+      break;
+    case '<':
+      /*Set ansi mode - ignored */
+      break;
 
+    case '7':
+      vt102_save_state (v);
+      break;
+    case '8':
+      vt102_restore_state (v);
+      break;
+    case ']':                  /*Set various titles */
+      //FIXME:
+      break;
+    case '[':
+      vt102_parse_csi (c, p->cmd_buf, p->cmd_ptr);
+      break;
+    case '(':                  /*Charsets */
+    case ')':
+    case '+':
+    case '*':
+    case '%':
+      vt102_scs (c, p->cmd_buf[0], p->cmd_buf[1]);
+      break;
+    default:
+      log_f (c->l, "<%s:%d unhandled ESC: \\033 \\%03o (ESC %c)>", __FILE__,
+             __LINE__, p->cmd_buf[0], safe_ch (p->cmd_buf[0]));
 
-  void vt102_reset_state (VT102 * v)
-  {
-    vt102_parser_reset (&v->parser);
+      ;
+    }
 
-    v->attr = CRT_ATTR_NORMAL;
-    v->color = CRT_COLOR_NORMAL;
+  p->cmd_buf[p->cmd_ptr] = 0;
+#ifdef DEBUG
+  log_f (c->l, "<cmd out x=%3d y=%2d aw=%d>", v->pos.x, v->pos.y,
+         v->pending_wrap);
+#endif
+}
 
-    v->application_keypad_mode = 0;
+void
+vt102_status_line (VT102 * v, char *str)
+{
+  int i = v->current_width - 1;
+  CRT_CA *ca = &v->crt.screen[CRT_ADDR (VT102_STATUS_ROW, 0)];
 
-    v->top_margin = v->screen_start;
-    v->bottom_margin = v->screen_end;
+  for (i = 0; i < v->current_width; ++i)
+    {
+      ca->attr = CRT_ATTR_REVERSE;
+      ca->color = CRT_COLOR_NORMAL;
+      ca->chr = *str ? *str : ' ';
+      if (*str)
+        str++;
+      ca++;
+    }
 
-    memset (v->modes, 0, VT102_NMODES);
-    memset (v->private_modes, 0, VT102_NMODES);
+  for (; i < VT102_MAX_COLS; ++i)
+    {
+      ca->attr = CRT_ATTR_NORMAL;
+      ca->color = CRT_COLOR_NORMAL;
+      ca->chr = ' ';
+      ca++;
+    }
 
-    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);
-  }
 
-  static void pre_parse_cmd (int ch, VT102_parser * p)
-  {
-    if (ch > TABLE_LENGTH)
-      return;
-    if (ch < 0)
-      return;
+void
+vt102_parser_reset (VT102_parser * p)
+{
+  p->in_cmd = 0;
+  p->cmd_more_bytes = 0;
+  p->cmd_termination = 0;
+  p->in_escape = 0;
+}
 
-    p->cmd_more_bytes = 0;
-    p->in_cmd = 0;
 
-    p->cmd_termination = vt102_cmd_termination[ch];
-    if (p->cmd_termination)
-      {
-        p->in_cmd++;
-        return;
-      }
+void
+vt102_reset_state (VT102 * v)
+{
+  vt102_parser_reset (&v->parser);
 
-    p->cmd_more_bytes = vt102_cmd_length[ch];
+  v->attr = CRT_ATTR_NORMAL;
+  v->color = CRT_COLOR_NORMAL;
 
-    if (p->cmd_more_bytes)
-      {
-        p->in_cmd++;
-        return;
-      }
-  }
+  v->application_keypad_mode = 0;
+
+  v->current_width = VT102_COLS_80;
+  v->crt.width = v->current_width;
+  v->screen_end.x = v->current_width - 1;
 
-  void vt102_parse_char (Context * c, int ch)
-  {
-    VT102 *v = c->v;
-    VT102_parser *p = &v->parser;
+  v->top_margin = v->screen_start;
+  v->bottom_margin = v->screen_end;
 
-#if 1
-    log_f (c->l, "char %3d %c   ie=%d ic=%d cmb=%d ct=%d    %2d %2d %d", ch,
-           safe_ch (ch), p->in_escape, p->in_cmd, p->cmd_more_bytes,
-           p->cmd_termination, v->pos.x, v->pos.y, v->pending_wrap);
+  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->private_modes[VT102_PRIVATE_MODE_VT52] = 1;
+  v->modes[VT102_MODE_LOCAL_ECHO_OFF] = 1;
+
+  vt102_reset_tabs (v);
+
+  v->g[0] = v->g[1] = VT102_CSID_US;
+  v->cs = 0;
+}
+
+static void
+pre_parse_cmd (int ch, VT102_parser * p)
+{
+  if (ch > TABLE_LENGTH)
+    return;
+  if (ch < 0)
+    return;
+
+  p->cmd_more_bytes = 0;
+  p->in_cmd = 0;
+
+  p->cmd_termination = vt102_cmd_termination[ch];
+  if (p->cmd_termination)
+    {
+      p->in_cmd++;
+      return;
+    }
+
+  p->cmd_more_bytes = vt102_cmd_length[ch];
+
+  if (p->cmd_more_bytes)
+    {
+      p->in_cmd++;
+      return;
+    }
+}
+
+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   ie=%d ic=%d cmb=%d ct=%3d    %2d %2d %d", ch,
+         safe_ch (ch), p->in_escape, p->in_cmd, p->cmd_more_bytes,
+         p->cmd_termination, 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 = '?';
-      }
+  if ((ch != SYM_CHAR_RESET) && (ch != 0xb9) && (ch > 127))
+    {
+      ch = '?';
+    }
 #endif
 
 
 #if 0
-    if (p->dca_ptr == 2)
-      {
-        p->in_dca = 0;
-      }
+  if (p->dca_ptr == 2)
+    {
+      p->in_dca = 0;
+    }
 #endif
-    if (ch == SYM_CHAR_RESET)
-      {
-        vt102_reset_state (v);
-      }
-    else if (p->in_cmd)
-      {
-        p->cmd_buf[p->cmd_ptr++] = ch;
-        if (p->cmd_more_bytes)
+  if (ch == SYM_CHAR_RESET)
+    {
+      vt102_reset_state (v);
+    }
+  else if (p->in_cmd && !ctrl_chr (ch, p->cmd_termination))
+    {
+      p->cmd_buf[p->cmd_ptr++] = ch;
+      if (p->cmd_ptr == VT102_CMD_LEN)
+        p->in_cmd = 0;
+      if (p->cmd_more_bytes)
+        {
           p->cmd_more_bytes--;
 
 
-        if (p->cmd_more_bytes == 1)
-          p->in_cmd = 0;
+          if (!p->cmd_more_bytes == 1)
+            p->in_cmd = 0;
+        }
 
-        switch (p->cmd_termination)
-          {
-          case 0:
-            break;
-          default:
-            if (p->cmd_termination == ch)
-              p->in_cmd = 0;
-            break;
-          case CSI_ENDER:
-            if (csi_ender (ch))
-              p->in_cmd = 0;
-            break;
-          }
+      switch (p->cmd_termination)
+        {
+        case 0:
+          break;
+        default:
+          if (p->cmd_termination == ch)
+            p->in_cmd = 0;
+          break;
+        case CSI_ENDER:
+          if (csi_ender (ch))
+            p->in_cmd = 0;
+          break;
+        }
 
-        if (!p->in_cmd)
-          {
-            vt102_parse_esc (c);
-            p->cmd_more_bytes = 0;
-          }
-      }
-    else if (p->in_escape)
-      {
+      if (!p->in_cmd)
+        {
+          vt102_parse_esc (c);
+          p->cmd_more_bytes = 0;
+          p->cmd_termination = 0;
+        }
+    }
+  else if (p->in_escape && !ctrl_chr (ch, 0))
+    {
+      p->cmd_ptr = 0;
+      p->cmd_buf[p->cmd_ptr++] = ch;
+      p->in_escape = 0;
 
-        p->cmd_ptr = 0;
-        p->cmd_buf[p->cmd_ptr++] = ch;
-        p->in_escape = 0;
+      pre_parse_cmd (ch, p);
 
-        pre_parse_cmd (ch, p);
+      if (!p->in_cmd)
+        vt102_parse_esc (c);
+    }
+  else if (ch == 0x9b)          /*One byte CSI */
+    {
+      p->cmd_ptr = 0;
+      p->cmd_buf[p->cmd_ptr++] = '[';
 
-        if (!p->in_cmd)
-          vt102_parse_esc (c);
-      }
-    else if (ch == 0x9b)        /*One byte CSI */
-      {
-        p->cmd_ptr = 0;
-        p->cmd_buf[p->cmd_ptr++] = '[';
+      pre_parse_cmd (ch, p);
+    }
+  else
+    {
+#ifdef DEBUG
+      if (ch != 27)
+        log_f (c->l,
+               "<chr in  x=%3d y=%2d aw=%d  \\%03o %3d %c",
+               v->pos.x, v->pos.y, v->pending_wrap, ch, ch, safe_ch (ch));
 
-        pre_parse_cmd (ch, p);
-      }
-    else
-      {
+#endif
 
-        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:
-           /*NAK*/ case 21:
-           /*SYN*/ case 22:
-           /*ETB*/ case 23:
-           /*CAN*/ case 24:
-           /*EM*/ case 25:
-           /*SUB*/ case 26:
-            break;
-           /*ESC*/ case 27:
-            p->in_escape++;
-            return;
-           /*FS*/ case 28:
-           /*GS*/ case 29:
-           /*RS*/ case 30:
-           /*US*/ case 31:
-           /*DEL*/ case 127:
+      switch (ch)
+        {
+#if 0
+         /*NUL*/ case 0:
+         /*SOH*/ case 1:
+         /*STX*/ case 2:
+         /*ETX*/ case 3:
+         /*EOT*/ case 4:
+          break;
+#endif
+         /*ENQ*/ case 5:
+          vt102_send_id (c, terminal_id);
+          break;
+#if 0
+         /*ACK*/ case 6:
+          break;
+#endif
+         /*BEL*/ case 7:
+          //FIXME beep
+          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;
-          /*regular character */ default:
-            vt102_regular_char (c, v, ch);
-          }
-      }
+         /*CR*/ case 13:
+          vt102_cursor_carriage_return (v);
+          break;
+         /*SO*/ case 14:
+          /*select G1 */
+          v->cs = 1;
+          break;
+         /*SI*/ case 15:
+          /*select G0 */
+          v->cs = 0;
+          break;
+#if 0
+         /*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:
+          break;
+#endif
+         /*ESC*/ case 27:
+          p->in_escape++;
+          return;
+#if 0
+         /*FS*/ case 28:
+         /*GS*/ case 29:
+         /*RS*/ case 30:
+         /*US*/ case 31:
+         /*DEL*/ case 127:
+          break;
+#endif
+        /*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;
+#ifdef DEBUG
+      if (ch != 27)
+        log_f (c->l, "<chr out x=%3d y=%2d aw=%d>", v->pos.x, v->pos.y,
+               v->pending_wrap);
+#endif
+    }
 
-    if (v->current_line.y != v->pos.y)
-      {
-        vt102_log_line (c, v->current_line.y);
-        v->current_line = v->pos;
-      }
+  v->crt.pos = v->pos;
+  v->crt.hide_cursor =
+    v->private_modes[VT102_PRIVATE_MODE_SHOW_CURSOR] ? 0 : 1;
 
-    if (c->d)
-      cmd_show_status (c->d, c);
-  }
+  if (v->current_line.y != v->pos.y)
+    {
+      vt102_log_line (c, v->current_line.y);
+      v->current_line = v->pos;
+    }
 
-  void vt102_send (Context * c, uint8_t key)
-  {
-    uint8_t ch;
+  if (c->d)
+    cmd_show_status (c->d, c);
+}
 
-    if (!c->t)
-      return;
+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 : ' ');
+  fprintf (stderr, "vts: %d(%c)\n", key, (key > 31) ? key : ' ');
 #endif
-    if ((key > 31) && (key < 127))
-      {
-        c->t->xmit (c->t, &key, 1);
-        return;
-      }
+  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;
+  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:
+    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:
+      if (c->v->private_modes[VT102_PRIVATE_MODE_CURSOR_MODE])
         {
-          uint8_t buf[] = { 033, 'O', 'P' + (key - KEY_PF1) };
+          uint8_t buf[] = { 033, 'O', 'A' + (key - KEY_UP) };
           c->t->xmit (c->t, &buf, sizeof (buf));
         }
-        break;
-      case KEY_INSERT:
-      case KEY_DELETE:
-      case KEY_PGUP:
-      case KEY_PGDN:
+      else
         {
-          uint8_t buf[] = { 033, '[', '0' + (key - KEY_180), '~' };
+          uint8_t buf[] = { 033, '[', 'A' + (key - KEY_UP) };
           c->t->xmit (c->t, &buf, sizeof (buf));
         }
-        break;
+      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;
+}
 
+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;
+  crt_cls (&v->crt);
+  v->current_line = v->pos;
+  v->pending_wrap = 0;
 
-    vt102_cursor_home (v);
-    vt102_status_line (v, "");
+  v->screen_start.x = 0;
+  v->screen_start.y = 0;
+  v->current_width = VT102_COLS_80;
+  v->crt.width = v->current_width;
+  v->screen_end.x = v->current_width - 1;
+  v->screen_end.y = VT102_ROWS - 1;
 
-    vt102_reset_tabs (v);
-    v->current_line = v->pos;
+  vt102_cursor_home (v);
+  vt102_status_line (v, "");
 
-    vt102_parser_reset (p);
-    vt102_reset_state (v);
+  vt102_reset_tabs (v);
+  v->current_line = v->pos;
 
-    vt102_save_state (v);
+  vt102_parser_reset (p);
+  vt102_reset_state (v);
 
-    v->last_reg_char = ' ';
-  }
+  vt102_save_state (v);
 
-  VT102 *vt102_new (void)
-  {
-    VT102 *v;
+  v->last_reg_char = ' ';
+}
 
-    v = (VT102 *) malloc (sizeof (VT102));
+VT102 *
+vt102_new (int width)
+{
+  VT102 *v;
 
-    v->xn_glitch = 1;
+  v = (VT102 *) malloc (sizeof (VT102));
 
-    vt102_reset (v);
+  v->xn_glitch = 1;
 
+  vt102_reset (v);
 
-    return v;
+  if (width) {
+          v->current_width =width;
+          v->crt.width = v->current_width;
+          v->screen_end.x = v->current_width - 1;
+          v->top_margin = v->screen_start;
+          v->bottom_margin = v->screen_end;
+          vt102_cursor_home (v);
   }
 
-  void vt102_set_ansi (VT102 * v, int ansi)
-  {
-    v->xn_glitch = ansi ? 0 : 1;
-  }
+  return v;
+}
 
-  void vt102_free (VT102 * v)
-  {
-    free (v);
-  }
+void
+vt102_set_ansi (VT102 * v, int ansi)
+{
+  v->xn_glitch = ansi ? 0 : 1;
+}
+
+void
+vt102_free (VT102 * v)
+{
+  free (v);
+}