vt102.c

   1 static void escseq(void);
   2 static void escseq_cs(void);
   3 static void escseq_g0(void);
   4 static void escseq_g1(void);
   5 static void escseq_g2(void);
   6 static void escseq_g3(void);
   7 static void csiseq(void);
   8 static void csiseq_da(int c);
   9 static void csiseq_dsr(int c);
  10 static void modeseq(int c, int set);
  11
  12 /* comments taken from: http://www.ivarch.com/programs/termvt102.shtml */
  13
  14 static int readutf8(int c)
  15 {
  16         int result;
  17         int l = 1;
  18         if (~c & 0xc0)
  19                 return c;
  20         while (l < 6 && c & (0x40 >> l))
  21                 l++;
  22         result = (0x3f >> l) & c;
  23         while (l--)
  24                 result = (result << 6) | (readpty() & 0x3f);
  25         return result;
  26 }
  27
  28 static void unknown(char *ctl, int c)
  29 {
  30 #ifdef DEBUG
  31         fprintf(stderr, "%s: <%d:%c>\r\n", ctl, c, c);
  32 #endif
  33 }
  34
  35 /* control sequences */
  36 static void ctlseq(void)
  37 {
  38         int c = readpty();
  39         switch (c) {
  40         case 0x09:      /* HT           horizontal tab to next tab stop */
  41                 advance(0, 8 - col % 8, 0);
  42                 break;
  43         case 0x0a:      /* LF           line feed */
  44         case 0x0b:      /* VT           line feed */
  45         case 0x0c:      /* FF           line feed */
  46                 advance(1, (mode & MODE_AUTOCR) ? -col : 0, 1);
  47                 break;
  48         case 0x08:      /* BS           backspace one column */
  49                 advance(0, -1, 0);
  50                 break;
  51         case 0x1b:      /* ESC          start escape sequence */
  52                 escseq();
  53                 break;
  54         case 0x0d:      /* CR           carriage return */
  55                 advance(0, -col, 0);
  56                 break;
  57         case 0x00:      /* NUL          ignored */
  58         case 0x07:      /* BEL          beep */
  59         case 0x7f:      /* DEL          ignored */
  60                 break;
  61         case 0x05:      /* ENQ          trigger answerback message */
  62         case 0x0e:      /* SO           activate G1 character set & newline */
  63         case 0x0f:      /* SI           activate G0 character set */
  64         case 0x11:      /* XON          resume transmission */
  65         case 0x13:      /* XOFF         stop transmission, ignore characters */
  66         case 0x18:      /* CAN          interrupt escape sequence */
  67         case 0x1a:      /* SUB          interrupt escape sequence */
  68         case 0x9b:      /* CSI          equivalent to ESC [ */
  69                 unknown("ctlseq", c);
  70                 break;
  71         default:
  72                 insertchar(readutf8(c));
  73                 break;
  74         }
  75 }
  76
  77 #define ESCM(c)         (((c) & 0xf0) == 0x20)
  78 #define ESCF(c)         ((c) > 0x30 && (c) < 0x7f)
  79
  80 /* escape sequences */
  81 static void escseq(void)
  82 {
  83         int c = readpty();
  84         while (ESCM(c))
  85                 c = readpty();
  86         switch(c) {
  87         case '[':       /* CSI          control sequence introducer */
  88                 csiseq();
  89                 break;
  90         case '%':       /* CS...        escseq_cs table */
  91                 escseq_cs();
  92                 break;
  93         case '(':       /* G0...        escseq_g0 table */
  94                 escseq_g0();
  95                 break;
  96         case ')':       /* G1...        escseq_g1 table */
  97                 escseq_g1();
  98                 break;
  99         case '*':       /* G2...        escseq_g2 table */
 100                 escseq_g2();
 101                 break;
 102         case '+':       /* G3...        escseq_g3 table */
 103                 escseq_g3();
 104                 break;
 105         case '7':       /* DECSC        save state (position, charset, attributes) */
 106                 misc_save(&term->sav);
 107                 break;
 108         case '8':       /* DECRC        restore most recently saved state */
 109                 misc_load(&term->sav);
 110                 break;
 111         case 'M':       /* RI           reverse line feed */
 112                 advance(-1, 0, 1);
 113                 break;
 114         case 'D':       /* IND          line feed */
 115                 advance(1, 0, 1);
 116                 break;
 117         case 'E':       /* NEL          newline */
 118                 advance(1, -col, 1);
 119                 break;
 120         case 'c':       /* RIS          reset */
 121                 term_reset();
 122                 break;
 123         case 'H':       /* HTS          set tab stop at current column */
 124         case 'Z':       /* DECID        DEC private ID; return ESC [ ? 6 c (VT102) */
 125         case '#':       /* DECALN       ("#8") DEC alignment test - fill screen with E's */
 126         case '>':       /* DECPNM       set numeric keypad mode */
 127         case '=':       /* DECPAM       set application keypad mode */
 128         case 'N':       /* SS2          select G2 charset for next char only */
 129         case 'O':       /* SS3          select G3 charset for next char only */
 130         case 'P':       /* DCS          device control string (ended by ST) */
 131         case 'X':       /* SOS          start of string */
 132         case '^':       /* PM           privacy message (ended by ST) */
 133         case '_':       /* APC          application program command (ended by ST) */
 134         case '\\':      /* ST           string terminator */
 135         case 'n':       /* LS2          invoke G2 charset */
 136         case 'o':       /* LS3          invoke G3 charset */
 137         case '|':       /* LS3R         invoke G3 charset as GR */
 138         case '}':       /* LS2R         invoke G2 charset as GR */
 139         case '~':       /* LS1R         invoke G1 charset as GR */
 140         case ']':       /* OSC          operating system command */
 141         case 'g':       /* BEL          alternate BEL */
 142         default:
 143                 unknown("escseq", c);
 144                 break;
 145         }
 146 }
 147
 148 static void escseq_cs(void)
 149 {
 150         int c = readpty();
 151         switch(c) {
 152         case '@':       /* CSDFL        select default charset (ISO646/8859-1) */
 153         case 'G':       /* CSUTF8       select UTF-8 */
 154         case '8':       /* CSUTF8       select UTF-8 (obsolete) */
 155         default:
 156                 unknown("escseq_cs", c);
 157                 break;
 158         }
 159 }
 160
 161 static void escseq_g0(void)
 162 {
 163         int c = readpty();
 164         switch(c) {
 165         case '8':       /* G0DFL        G0 charset = default mapping (ISO8859-1) */
 166         case '0':       /* G0GFX        G0 charset = VT100 graphics mapping */
 167         case 'U':       /* G0ROM        G0 charset = null mapping (straight to ROM) */
 168         case 'K':       /* G0USR        G0 charset = user defined mapping */
 169         case 'B':       /* G0TXT        G0 charset = ASCII mapping */
 170         default:
 171                 unknown("escseq_g0", c);
 172                 break;
 173         }
 174 }
 175
 176 static void escseq_g1(void)
 177 {
 178         int c = readpty();
 179         switch(c) {
 180         case '8':       /* G1DFL        G1 charset = default mapping (ISO8859-1) */
 181         case '0':       /* G1GFX        G1 charset = VT100 graphics mapping */
 182         case 'U':       /* G1ROM        G1 charset = null mapping (straight to ROM) */
 183         case 'K':       /* G1USR        G1 charset = user defined mapping */
 184         case 'B':       /* G1TXT        G1 charset = ASCII mapping */
 185         default:
 186                 unknown("escseq_g1", c);
 187                 break;
 188         }
 189 }
 190
 191 static void escseq_g2(void)
 192 {
 193         int c = readpty();
 194         switch(c) {
 195         case '8':       /* G2DFL        G2 charset = default mapping (ISO8859-1) */
 196         case '0':       /* G2GFX        G2 charset = VT100 graphics mapping */
 197         case 'U':       /* G2ROM        G2 charset = null mapping (straight to ROM) */
 198         case 'K':       /* G2USR        G2 charset = user defined mapping */
 199         default:
 200                 unknown("escseq_g2", c);
 201                 break;
 202         }
 203 }
 204
 205 static void escseq_g3(void)
 206 {
 207         int c = readpty();
 208         switch(c) {
 209         case '8':       /* G3DFL        G3 charset = default mapping (ISO8859-1) */
 210         case '0':       /* G3GFX        G3 charset = VT100 graphics mapping */
 211         case 'U':       /* G3ROM        G3 charset = null mapping (straight to ROM) */
 212         case 'K':       /* G3USR        G3 charset = user defined mapping */
 213         default:
 214                 unknown("escseq_g3", c);
 215                 break;
 216         }
 217 }
 218
 219 static int absrow(int r)
 220 {
 221         return origin() ? top + r : r;
 222 }
 223
 224 #define CSIP(c)                 (((c) & 0xf0) == 0x30)
 225 #define CSII(c)                 (((c) & 0xf0) == 0x20)
 226 #define CSIF(c)                 ((c) >= 0x40 && (c) < 0x80)
 227
 228 #define MAXCSIARGS      32
 229 /* ECMA-48 CSI sequences */
 230 static void csiseq(void)
 231 {
 232         int args[MAXCSIARGS] = {0};
 233         int i;
 234         int n = 0;
 235         int c = readpty();
 236         int inter = 0;
 237         int priv = 0;
 238
 239         if (strchr("<=>?", c)) {
 240                 priv = c;
 241                 c = readpty();
 242         }
 243         while (CSIP(c)) {
 244                 int arg = 0;
 245                 while (isdigit(c)) {
 246                         arg = arg * 10 + (c - '0');
 247                         c = readpty();
 248                 }
 249                 if (c == ';')
 250                         c = readpty();
 251                 args[n] = arg;
 252                 n = n < ARRAY_SIZE(args) ? n + 1 : 0;
 253         }
 254         while (CSII(c)) {
 255                 inter = c;
 256                 c = readpty();
 257         }
 258         switch(c) {
 259         case 'H':       /* CUP          move cursor to row, column */
 260         case 'f':       /* HVP          move cursor to row, column */
 261                 move_cursor(absrow(MAX(0, args[0] - 1)), MAX(0, args[1] - 1));
 262                 break;
 263         case 'J':       /* ED           erase display */
 264                 switch(args[0]) {
 265                 case 0:
 266                         kill_chars(col, pad_cols());
 267                         blank_rows(row + 1, pad_rows());
 268                         break;
 269                 case 1:
 270                         kill_chars(0, col + 1);
 271                         blank_rows(0, row - 1);
 272                         break;
 273                 case 2:
 274                         term_blank();
 275                         break;
 276                 }
 277                 break;
 278         case 'A':       /* CUU          move cursor up */
 279                 advance(-MAX(1, args[0]), 0, 0);
 280                 break;
 281         case 'e':       /* VPR          move cursor down */
 282         case 'B':       /* CUD          move cursor down */
 283                 advance(MAX(1, args[0]), 0, 0);
 284                 break;
 285         case 'a':       /* HPR          move cursor right */
 286         case 'C':       /* CUF          move cursor right */
 287                 advance(0, MAX(1, args[0]), 0);
 288                 break;
 289         case 'D':       /* CUB          move cursor left */
 290                 advance(0, -MAX(1, args[0]), 0);
 291                 break;
 292         case 'K':       /* EL           erase line */
 293                 switch (args[0]) {
 294                 case 0:
 295                         kill_chars(col, pad_cols());
 296                         break;
 297                 case 1:
 298                         kill_chars(0, col + 1);
 299                         break;
 300                 case 2:
 301                         kill_chars(0, pad_cols());
 302                         break;
 303                 }
 304                 break;
 305         case 'L':       /* IL           insert blank lines */
 306                 if (row >= top && row < bot)
 307                         insert_lines(MAX(1, args[0]));
 308                 break;
 309         case 'M':       /* DL           delete lines */
 310                 if (row >= top && row < bot)
 311                         delete_lines(MAX(1, args[0]));
 312                 break;
 313         case 'd':       /* VPA          move to row (current column) */
 314                 move_cursor(absrow(MAX(1, args[0]) - 1), col);
 315                 break;
 316         case 'm':       /* SGR          set graphic rendition */
 317                 if (!n)
 318                         setattr(0);
 319                 for (i = 0; i < n; i++)
 320                         setattr(args[i]);
 321                 break;
 322         case 'r':       /* DECSTBM      set scrolling region to (top, bottom) rows
 323  */
 324                 set_region(args[0], args[1]);
 325                 break;
 326         case 'c':       /* DA           return ESC [ ? 6 c (VT102) */
 327                 csiseq_da(priv == '?' ? args[0] | 0x80 : args[0]);
 328                 break;
 329         case 'h':       /* SM           set mode */
 330                 for (i = 0; i < n; i++)
 331                         modeseq(priv == '?' ? args[i] | 0x80 : args[i], 1);
 332                 break;
 333         case 'l':       /* RM           reset mode */
 334                 for (i = 0; i < n; i++)
 335                         modeseq(priv == '?' ? args[i] | 0x80 : args[i], 0);
 336                 break;
 337         case 'P':       /* DCH          delete characters on current line */
 338                 delete_chars(MIN(MAX(1, args[0]), pad_cols() - col));
 339                 break;
 340         case '@':       /* ICH          insert blank characters */
 341                 insert_chars(MAX(1, args[0]));
 342                 break;
 343         case 'n':       /* DSR          device status report */
 344                 csiseq_dsr(args[0]);
 345                 break;
 346         case 'G':       /* CHA          move cursor to column in current row */
 347                 advance(0, MAX(0, args[0] - 1) - col, 0);
 348                 break;
 349         case 'X':       /* ECH          erase characters on current line */
 350                 kill_chars(col, MIN(col + MAX(1, args[0]), pad_cols()));
 351                 break;
 352         case '[':       /* IGN          ignored control sequence */
 353         case 'E':       /* CNL          move cursor down and to column 1 */
 354         case 'F':       /* CPL          move cursor up and to column 1 */
 355         case 'g':       /* TBC          clear tab stop (CSI 3 g = clear all stops) */
 356         case 'q':       /* DECLL        set keyboard LEDs */
 357         case 's':       /* CUPSV        save cursor position */
 358         case 'u':       /* CUPRS        restore cursor position */
 359         case '`':       /* HPA          move cursor to column in current row */
 360         default:
 361                 unknown("csiseq", c);
 362                 break;
 363         }
 364 }
 365
 366 static void csiseq_da(int c)
 367 {
 368         switch(c) {
 369         case 0x00:
 370                 term_sendstr("\x1b[?6c");
 371                 break;
 372         default:
 373                 /* we don't care much about cursor shape */
 374                 /* printf("csiseq_da <0x%x>\n", c); */
 375                 break;
 376         }
 377 }
 378
 379 static void csiseq_dsr(int c)
 380 {
 381         char status[1 << 5];
 382         switch(c) {
 383         case 0x05:
 384                 term_sendstr("\x1b[0n");
 385                 break;
 386         case 0x06:
 387                 snprintf(status, sizeof(status), "\x1b[%d;%dR",
 388                          (origin() ? row - top : row) + 1, col + 1);
 389                 term_sendstr(status);
 390                 break;
 391         default:
 392                 unknown("csiseq_dsr", c);
 393                 break;
 394         }
 395 }
 396
 397 /* ANSI/DEC specified modes for SM/RM ANSI Specified Modes */
 398 static void modeseq(int c, int set)
 399 {
 400         switch(c) {
 401         case 0x87:      /* DECAWM       Auto Wrap */
 402                 mode = BIT_SET(mode, MODE_WRAP, set);
 403                 break;
 404         case 0x99:      /* DECTCEM      Cursor on (set); Cursor off (reset) */
 405                 mode = BIT_SET(mode, MODE_CURSOR, set);
 406                 break;
 407         case 0x86:      /* DECOM        Sets relative coordinates (set); Sets absolute coordinates (reset) */
 408                 mode = BIT_SET(mode, MODE_ORIGIN, set);
 409                 break;
 410         case 0x14:      /* LNM          Line Feed / New Line Mode */
 411                 mode = BIT_SET(mode, MODE_AUTOCR, set);
 412                 break;
 413         case 0x04:      /* IRM          insertion/replacement mode (always reset) */
 414                 break;
 415         case 0x00:      /* IGN          Error (Ignored) */
 416         case 0x01:      /* GATM         guarded-area transfer mode (ignored) */
 417         case 0x02:      /* KAM          keyboard action mode (always reset) */
 418         case 0x03:      /* CRM          control representation mode (always reset) */
 419         case 0x05:      /* SRTM         status-reporting transfer mode */
 420         case 0x06:      /* ERM          erasure mode (always set) */
 421         case 0x07:      /* VEM          vertical editing mode (ignored) */
 422         case 0x0a:      /* HEM          horizontal editing mode */
 423         case 0x0b:      /* PUM          positioning unit mode */
 424         case 0x0c:      /* SRM          send/receive mode (echo on/off) */
 425         case 0x0d:      /* FEAM         format effector action mode */
 426         case 0x0e:      /* FETM         format effector transfer mode */
 427         case 0x0f:      /* MATM         multiple area transfer mode */
 428         case 0x10:      /* TTM          transfer termination mode */
 429         case 0x11:      /* SATM         selected area transfer mode */
 430         case 0x12:      /* TSM          tabulation stop mode */
 431         case 0x13:      /* EBM          editing boundary mode */
 432 /* DEC Private Modes: "?NUM" -> (NUM | 0x80) */
 433         case 0x80:      /* IGN          Error (Ignored) */
 434         case 0x81:      /* DECCKM       Cursorkeys application (set); Cursorkeys normal (reset) */
 435         case 0x82:      /* DECANM       ANSI (set); VT52 (reset) */
 436         case 0x83:      /* DECCOLM      132 columns (set); 80 columns (reset) */
 437         case 0x84:      /* DECSCLM      Jump scroll (set); Smooth scroll (reset) */
 438         case 0x85:      /* DECSCNM      Reverse screen (set); Normal screen (reset) */
 439         case 0x88:      /* DECARM       Auto Repeat */
 440         case 0x89:      /* DECINLM      Interlace */
 441         case 0x92:      /* DECPFF       Send FF to printer after print screen (set); No char after PS (reset) */
 442         case 0x93:      /* DECPEX       Print screen: prints full screen (set); prints scroll region (reset) */
 443         default:
 444                 unknown("modeseq", c);
 445                 break;
 446         }
 447 }