vt100.c

   1 #include <stdio.h>
   2 #include <ctype.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <unistd.h>
   6 #include "log.h"
   7 #include "vt100.h"
   8
   9
  10
  11 vt100* init_term (int width, int height)
  12 {
  13         vt100 *term = malloc(sizeof(vt100) + 3 * width * height);
  14         if (term == NULL)
  15         {
  16                 write_log (LOG_ERROR, "unable to allocate memory to create terminal %dx%d", width, height);
  17                 return NULL;
  18         }
  19
  20         term->wid = width;
  21         term->hgt = height;
  22         term->cx = term->cy = 0;
  23         term->cmode = CM_NORM;
  24         term->att = 0;
  25         term->col = 7;
  26         term->esc_len = 0;
  27         term->prev_char = ' ';
  28
  29         term->screen = ((uint8_t*)term) + sizeof(vt100);
  30         term->colour = term->screen + width * height;
  31         term->attrib = term->colour + width * height;
  32         memset (term->screen, ' ', width * height);
  33         memset (term->attrib, 0, width * height);
  34         memset (term->colour, 0, width * height);
  35
  36         return term;
  37 }
  38
  39
  40
  41 vt100* resize_term (vt100 *term, int width, int height)
  42 {
  43         // XXX
  44         return term;
  45 }
  46
  47
  48
  49 // we can't use strtol() because the string doesn't have to be 0-terminated
  50 static int get_num (const uint8_t *data, int len, int *pos)
  51 {
  52         int i, n = 0;
  53
  54
  55         for (i = 0; i < len; i++)
  56         {
  57                 if (!isdigit(data[i])) break;
  58                 n = n * 10 + data[i] - '0';
  59         }
  60
  61         *pos = i;
  62         return n;
  63 }
  64
  65
  66
  67 static void process_attr (vt100 *term, int attr)
  68 {
  69         // attribute
  70         if (attr <= 10) term->att = attr;
  71
  72         // foreground colour
  73         if (attr >= 30 && attr <= 37) term->col = (term->col & 0xF0) | (attr - 30);
  74
  75         // background colour
  76         if (attr >= 40 && attr <= 47) term->col = (term->col & 0x0F) | ((attr - 40) << 4);
  77 }
  78
  79
  80
  81 static void erase_screen (vt100 *term, int n1)
  82 {
  83         memset (term->screen, ' ', term->wid * term->hgt);
  84         memset (term->attrib, 0, term->wid * term->hgt);
  85         memset (term->colour, 0, term->wid * term->hgt);
  86         if (n1 != 2) term->cx = term->cy = 0;
  87 }
  88
  89
  90
  91 static void erase_line (vt100 *term, int n1)
  92 {
  93         int ofs = term->wid * term->cy;
  94         int l = term->wid;
  95
  96         // [ 0 K or [ K - to the end of line
  97         if (n1 <= 0)
  98         {
  99                 ofs += term->cx;
 100                 l -= term->cx;
 101         }
 102
 103         // [ 1 K - to the beginning of line
 104         if (n1 == 1)
 105         {
 106                 l = term->cx;
 107         }
 108
 109         memset (&term->screen[ofs], ' ', l);
 110         memset (&term->attrib[ofs], 0, l);
 111         memset (&term->colour[ofs], 0, l);
 112 }
 113
 114
 115
 116 static void erase_characters (vt100 *term, int n1)
 117 {
 118         int ofs = term->wid * term->cy + term->cx;
 119         int l = term->wid - term->cx;
 120
 121         if (n1 < l) l = n1;
 122         memset (&term->screen[ofs], ' ', l);
 123         memset (&term->attrib[ofs], 0, l);
 124         memset (&term->colour[ofs], 0, l);
 125 }
 126
 127
 128
 129 // process single non-esc character
 130 static void process_char (vt100 *term, char c)
 131 {
 132         if (c == '\r')
 133         {
 134                 term->cx = 0;
 135         }
 136         else if (c == '\n')
 137         {
 138                 // XXX no scrolling
 139                 if (term->cy < term->hgt - 1) term->cy++;
 140         }
 141         // backspace
 142         else if (c == 8)
 143         {
 144                 if (term->cx > 0) term->cx--;
 145                 return;
 146         }
 147         else
 148         {
 149                 int ofs = term->cy * term->wid + term->cx;
 150                 term->screen[ofs] = c;
 151                 term->attrib[ofs] = term->att;
 152                 term->colour[ofs] = term->col;
 153                 if (++term->cx >= term->wid)
 154                 {
 155                         term->cx = 0;
 156                         // XXX no scrolling
 157                         if (term->cy < term->hgt - 1) term->cy++;
 158                 }
 159
 160                 term->prev_char = c;
 161         }
 162 }
 163
 164
 165
 166 #define MAX_ARGS        3
 167
 168 static int parse_dec (vt100 *term, int args, int arg[MAX_ARGS])
 169 {
 170         int i;
 171
 172
 173         switch (term->esc[term->esc_len - 1])
 174         {
 175                 // [ Y ; X H - goto Y,X
 176                 case 'H':
 177                 case 'f':
 178                         if (args == 0)
 179                         {
 180                                 term->cx = term->cy = 0;
 181                                 break;
 182                         }
 183
 184                         if (args != 2) return -1;
 185
 186                         if (arg[0] != 0) arg[0]--;
 187                         if (arg[0] >= 0 && arg[0] < term->hgt) term->cy = arg[0];
 188                         if (arg[1] != 0) arg[1]--;
 189                         if (arg[1] >= 0 && arg[1] < term->wid) term->cx = arg[1];
 190                         break;
 191
 192                 // [ nn J or [ J - clear screen
 193                 case 'J':
 194                         if (args == 0) arg[0] = 0;
 195                         erase_screen (term, arg[0]);
 196                         break;
 197
 198                 // [ nn K or [ K - erase line
 199                 case 'K':
 200                         if (args == 0) arg[0] = 0;
 201                         erase_line (term, arg[0]);
 202                         break;
 203
 204                 // [ N1 m or [ N1 ; N2 m or [ N1 ; N2 ; N3 m - set colour and/or attribute (SGR mode)
 205                 case 'm':
 206                         if (args == 0) args = 1, arg[0] = 0;
 207
 208                         for (i = 0; i < args; i++)
 209                         {
 210                                 process_attr (term, arg[i]);
 211                         }
 212                         break;
 213
 214                 // [ nn @ or [ @ - insert blank characters
 215                 case '@':
 216                         if (args == 0) arg[0] = 1;
 217                         for (i = 0; i < arg[0]; i++)
 218                         {
 219                                 process_char (term, ' ');
 220                         }
 221                         break;
 222
 223                 case 'b':
 224                         if (args != 1) return -1;
 225                         for (i = 0; i < arg[0]; i++)
 226                         {
 227                                 process_char (term, term->prev_char);
 228                         }
 229                         break;
 230
 231                 // [ nn A or [ A - move cursor up
 232                 case 'A':
 233                         if (args == 0 || arg[0] < 1) arg[0] = 1;
 234                         term->cy -= arg[0];
 235                         if (term->cy < 0) term->cy = 0;
 236                         break;
 237
 238                 // [ nn B or [ B - move cursor down
 239                 case 'B':
 240                         if (args == 0 || arg[0] < 1) arg[0] = 1;
 241                         term->cy += arg[0];
 242                         if (term->cy >= term->hgt) term->cy = term->hgt - 1;
 243                         break;
 244
 245                 // [ nn C or [ C - move cursor right
 246                 case 'C':
 247                         if (args == 0 || arg[0] < 1) arg[0] = 1;
 248                         term->cx += arg[0];
 249                         if (term->cx >= term->wid) term->cx = term->wid - 1;
 250                         break;
 251
 252                 // [ nn D or [ D - move cursor left
 253                 case 'D':
 254                         if (args == 0 || arg[0] < 1) arg[0] = 1;
 255                         term->cx -= arg[0];
 256                         if (term->cx < 0) term->cx = 0;
 257                         break;
 258
 259                 // [ nn X - delete characters
 260                 case 'X':
 261                         if (args != 1) return -1;
 262
 263                         if (arg[0] == 0) arg[0] = 1;
 264                         erase_characters (term, arg[0]);
 265                         break;
 266
 267                 // [ nn d - move to specified row
 268                 case 'd':
 269                         if (args != 1) return -1;
 270
 271                         if (arg[0] != 0) arg[0]--;
 272                         term->cy = arg[0];
 273                         if (term->cy >= term->hgt) term->cy = term->hgt - 1;
 274                         break;
 275
 276                 // [ nn G - move to specified column
 277                 case 'G':
 278                         if (args != 1) return -1;
 279
 280                         if (arg[0] != 0) arg[0]--;
 281                         term->cx = arg[0];
 282                         if (term->cx >= term->wid) term->cx = term->wid - 1;
 283                         break;
 284
 285                 default:
 286                         return -1;
 287         }
 288
 289         return 0;
 290 }
 291
 292
 293
 294 static int parse_dec_priv (vt100 *term, int args, int arg[MAX_ARGS])
 295 {
 296         switch (term->esc[term->esc_len - 1])
 297         {
 298                 case 'h':
 299                         if (args == 0) return -1;
 300                         if (arg[0] == 25) term->cmode = CM_NORM;
 301                         break;
 302
 303                 case 'l':
 304                         if (args == 0) return -1;
 305                         if (arg[0] == 25) term->cmode = CM_HIDE;
 306                         break;
 307
 308                 default:
 309                         return -1;
 310         }
 311
 312         return 0;
 313 }
 314
 315
 316
 317 static int parse_esc (vt100 *term)
 318 {
 319         int arg[MAX_ARGS];
 320         int p = 2, args = 0;
 321
 322
 323         // XXX something unknown - skip
 324         if (!isalnum(term->esc[2]))
 325         {
 326                 if (term->esc[2] == '@' || term->esc[2] == '?') p++;
 327                 else return -1;
 328         }
 329
 330         // parse numbers
 331         while (args < MAX_ARGS)
 332         {
 333                 int np;
 334
 335                 arg[args] = get_num(&term->esc[p], term->esc_len - p, &np);
 336                 if (np == 0) break;
 337
 338                 p += 1 + np;
 339                 args++;
 340                 if (term->esc[p - 1] != ';') break;
 341         }
 342
 343         // DEC command
 344         if (term->esc[1] == '[')
 345         {
 346                 // DEC private mode command
 347                 if (term->esc[2] == '?') return parse_dec_priv(term, args, arg);
 348
 349                 return parse_dec(term, args, arg);
 350         }
 351
 352         return -1;
 353 }
 354
 355
 356
 357 static void process_esc (vt100 *term)
 358 {
 359         char c = term->esc[term->esc_len - 1];
 360
 361         // sequence is not complete yet
 362         if (!isalpha(c) && c != '@' && c != 033) return;
 363         if (term->esc_len > 2) parse_esc (term);
 364
 365         term->esc_len = 0;
 366 }
 367
 368
 369
 370 void term_process (vt100 *term, const char *data, int len)
 371 {
 372         int i, j;
 373
 374
 375         for (i = 0; i < len; i++)
 376         {
 377                 // inside esc seqence
 378                 if (term->esc_len)
 379                 {
 380                         term->esc[term->esc_len++] = data[i];
 381                         process_esc (term);
 382
 383                         // XXX sequence is too long, just dump it to the terminal
 384                         if (term->esc_len >= VT100_ESC_BUF)
 385                         {
 386                                 for (j = 0; j < VT100_ESC_BUF; j++)
 387                                 {
 388                                         process_char (term, term->esc[j]);
 389                                 }
 390                         }
 391
 392                         continue;
 393                 }
 394
 395                 // esc
 396                 if (data[i] == 033) term->esc[0] = 0x33, term->esc_len = 1;
 397                 // a normal character
 398                 else process_char (term, data[i]);
 399         }
 400 }
 401
 402
 403
 404 #define BUFSZ   1280
 405
 406 static void add_buf (char *buf, int *pos, const char *data, int len, int fd)
 407 {
 408         int l, max;
 409
 410
 411         while (len > 0)
 412         {
 413                 max = BUFSZ - *pos;
 414                 l = (len < max) ? len : max;
 415                 memcpy (&buf[*pos], data, l);
 416                 *pos = *pos + l;
 417                 len -= l;
 418                 data += l;
 419
 420                 if (*pos == BUFSZ)
 421                 {
 422                         write (fd, buf, BUFSZ);
 423                         *pos = 0;
 424                 }
 425         }
 426 }
 427
 428
 429
 430 void term_copy_data (vt100 *term, int fd)
 431 {
 432         char buf[BUFSZ] = "\033[H\033[2J";
 433         int i, pos = 7, a, c, cf, cb;
 434         char b2[80];
 435         int p2;
 436
 437
 438         // initial colours and attribute
 439         a = term->attrib[0];
 440         c = term->colour[0];
 441         cf = (c & 0x0F);
 442         cb = (c >> 4);
 443         pos += sprintf(&buf[pos], "\033[0;%dm\033[%d;%dm", a, cb + 40, cf + 30);
 444
 445
 446         for (i = 0; i < term->wid * term->hgt; i++)
 447         {
 448                 int cf2, cb2;
 449                 p2 = 0;
 450
 451                 // change attribute
 452                 if (a != term->attrib[i])
 453                 {
 454                         a = term->attrib[i];
 455                         p2 += sprintf(&b2[p2], "\033[0;%dm", a);
 456
 457                         // force colour change since colours are reset
 458                         c = cf = cb = -1;
 459                 }
 460
 461                 // change colour
 462                 if (c != term->colour[i])
 463                 {
 464                         c = term->colour[i];
 465                         cf2 = (c & 0x0F);
 466                         cb2 = (c >> 4);
 467
 468                         if (cf2 != cf && cb2 != cb) p2 += sprintf(&b2[p2], "\033[%d;%dm", cb2 + 40, cf2 + 30);
 469                         else if (cf2 != cf) p2 += sprintf(&b2[p2], "\033[%dm", cf2 + 30);
 470                         else p2 += sprintf(&b2[p2], "\033[%dm", cb2 + 40);
 471
 472                         cb = cb2;
 473                         cf = cf2;
 474                 }
 475
 476                 add_buf (buf, &pos, b2, p2, fd);
 477
 478                 add_buf (buf, &pos, (char*)&term->screen[i], 1, fd);
 479         }
 480
 481         p2 = sprintf(b2, "\033[%d;%dH", term->cy + 1, term->cx + 1);
 482         add_buf (buf, &pos, b2, p2, fd);
 483
 484         // cursor state
 485         if (term->cmode == CM_HIDE) p2 = sprintf(b2, "\033[?25l");
 486         else p2 = sprintf(b2, "\033[?25h");
 487         add_buf (buf, &pos, b2, p2, fd);
 488
 489         if (pos > 0) write (fd, buf, pos);
 490 }
 491