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