pintos-os.org Git - openvswitch/blob - extras/ezio/terminal.c

   1 /* Copyright (c) 2008, 2009 Nicira Networks, Inc.
   2  *
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <config.h>
  17 #include "terminal.h"
  18 #include <assert.h>
  19 #include <errno.h>
  20 #include <inttypes.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include "dynamic-string.h"
  26 #include "ezio.h"
  27 #include "poll-loop.h"
  28 #include "util.h"
  29
  30 #define THIS_MODULE VLM_terminal
  31 #include "vlog.h"
  32
  33 /* UTF-8 decoding. */
  34 static struct utf8_reader *utf8_reader_create(void);
  35 static void utf8_reader_destroy(struct utf8_reader *);
  36 static int utf8_reader_read(struct utf8_reader *, uint8_t c);
  37
  38 /* ANSI escape sequence decoding. */
  39 struct ansi_sequence {
  40     int n_args;
  41 #define ANSI_MAX_ARGS 16
  42     int args[ANSI_MAX_ARGS];
  43     int function;
  44 };
  45
  46 static struct ansi_decoder *ansi_decoder_create(void);
  47 static void ansi_decoder_destroy(struct ansi_decoder *);
  48 static int ansi_decoder_put(struct ansi_decoder *, uint8_t c);
  49 static const struct ansi_sequence *ansi_decoder_get(struct ansi_decoder *);
  50 \f
  51 /* Terminal emulation. */
  52 struct terminal {
  53     struct ansi_decoder *ansi;
  54     struct utf8_reader *utf8;
  55     enum { EZIO, UTF8 } encoding;
  56 };
  57
  58 static void recv_byte(struct terminal *term, struct ezio *ezio, uint8_t c);
  59
  60 struct terminal *
  61 terminal_create(void)
  62 {
  63     struct terminal *term = xmalloc(sizeof *term);
  64     term->ansi = ansi_decoder_create();
  65     term->utf8 = utf8_reader_create();
  66     term->encoding = UTF8;
  67     return term;
  68 }
  69
  70 void
  71 terminal_destroy(struct terminal *term)
  72 {
  73     if (term) {
  74         utf8_reader_destroy(term->utf8);
  75         ansi_decoder_destroy(term->ansi);
  76         free(term);
  77     }
  78 }
  79
  80 int
  81 terminal_run(struct terminal *term, struct ezio *ezio, int input_fd)
  82 {
  83     char input[512];
  84     int n;
  85
  86     n = read(input_fd, input, sizeof input);
  87     if (n > 0) {
  88         int i;
  89
  90         for (i = 0; i < n; i++) {
  91             recv_byte(term, ezio, input[i]);
  92         }
  93         return 0;
  94     } else {
  95         return !n ? EOF : errno == EAGAIN ? 0 : errno;
  96     }
  97 }
  98
  99 void
 100 terminal_wait(struct terminal *term UNUSED, int input_fd)
 101 {
 102     poll_fd_wait(input_fd, POLLIN);
 103 }
 104 \f
 105 static void recv_ansi_sequence(const struct ansi_sequence *, struct ezio *);
 106 static void recv_control(uint8_t c, struct ezio *);
 107 static void recv_character(uint8_t byte, struct ezio *);
 108 static int unicode_to_ezio(uint16_t unicode);
 109 static int default_arg(int value, int default_value);
 110 static int range(int value, int min, int max);
 111 static void clear_elements(uint8_t *p, size_t size, int pos, int clear_type);
 112 static void define_icon(struct ezio *e, const int *args);
 113 static void clear_icon(struct ezio *e, int icon_nr);
 114 static void set_cursor(struct ezio *e, int visibility);
 115
 116 static void
 117 recv_byte(struct terminal *term, struct ezio *ezio, uint8_t c)
 118 {
 119     int retval;
 120
 121     /* Decode and interpret ANSI escape sequences. */
 122     retval = ansi_decoder_put(term->ansi, c);
 123     if (retval <= 0) {
 124         if (retval < 0) {
 125             recv_ansi_sequence(ansi_decoder_get(term->ansi), ezio);
 126             return;
 127         }
 128         return;
 129     }
 130
 131     /* Encoding selection. */
 132     if (c == 0x0e) {
 133         /* Shift Out. */
 134         term->encoding = EZIO;
 135         return;
 136     } else if (c == 0x0f) {
 137         /* Shift In. */
 138         term->encoding = UTF8;
 139         return;
 140     }
 141
 142     if (term->encoding == UTF8) {
 143         int unicode, ezchar;
 144
 145         /* Convert UTF-8 input to Unicode code point. */
 146         unicode = utf8_reader_read(term->utf8, c);
 147         if (unicode < 0) {
 148             return;
 149         }
 150
 151         /* Convert Unicode code point to EZIO encoding. */
 152         ezchar = unicode_to_ezio(unicode);
 153         if (ezchar >= 0) {
 154             if (ezchar & 0xff00) {
 155                 recv_character(ezchar >> 8, ezio);
 156             }
 157             recv_character(ezchar, ezio);
 158         } else if (unicode < 0x100) {
 159             recv_control(unicode, ezio);
 160         } else {
 161             /* Unsupported Unicode code point. */
 162             return;
 163         }
 164     } else {
 165         if (c >= 0x80 && c < 0x87) {
 166             c &= 0x07;
 167         }
 168         if (c != 0xfe) {
 169             recv_character(c, ezio);
 170         }
 171     }
 172 }
 173
 174 static void
 175 log_ansi_sequence(const struct ansi_sequence *seq, struct ezio *e)
 176 {
 177     struct sequence {
 178         int function;
 179         const char *name;
 180     };
 181     static const struct sequence sequences[] = {
 182         {0x5a, "CBT: Cursor Backward Tabulation"},
 183         {0x47, "CHA: Cursor Character Absolute"},
 184         {0x49, "CHT: Cursor Forward Tabulation"},
 185         {0x45, "CNL: Cursor Next Line"},
 186         {0x46, "CPL: Cursor Preceding Line"},
 187         {0x44, "CUB: Cursor Left"},
 188         {0x42, "CUD: Cursor Down"},
 189         {0x43, "CUF: Cursor Right"},
 190         {0x48, "CUP: Cursor Position"},
 191         {0x41, "CUU: Cursor Up"},
 192         {0x50, "DCH: Delete Character"},
 193         {0x4d, "DL: Delete Line"},
 194         {0x58, "ECH: Erase Character"},
 195         {0x4a, "ED: Erase in Page"},
 196         {0x4b, "EL: Erase in Line"},
 197         {0x40, "ICH: Insert Character"},
 198         {0x4c, "IL: Insert Line"},
 199         {0x4500, "NEL: Next Line"},
 200         {0x4d00, "RI: Reverse Line Feed"},
 201         {0x6300, "RIS: Reset to Initial State"},
 202         {0x54, "SD: Scroll Down"},
 203         {0x240, "SL: Scroll Left"},
 204         {0x241, "SR: Scroll Right"},
 205         {0x53, "SU: Scroll Up"},
 206         {0x70, "DICO: Define Icon"},
 207         {0x71, "CICO: Clear Icon"},
 208         {0x72, "Set cursor visibility"},
 209     };
 210     const struct sequence *s;
 211     struct ds ds;
 212     int i;
 213
 214     ds_init(&ds);
 215     for (s = sequences; s < &sequences[ARRAY_SIZE(sequences)]; s++) {
 216         if (s->function == seq->function) {
 217             ds_put_cstr(&ds, s->name);
 218             goto found;
 219         }
 220     }
 221     ds_put_format(&ds, "0x%02x", s->function);
 222     if (s->function < 0x100) {
 223         ds_put_format(&ds, "(%02d/%02d)", s->function / 16, s->function % 16);
 224     }
 225
 226 found:
 227     for (i = 0; i < seq->n_args; i++) {
 228         ds_put_format(&ds, ", %d", seq->args[i]);
 229     }
 230     VLOG_DBG("%s (cursor:%d,%d)", ds_cstr(&ds), e->x, e->y);
 231     ds_destroy(&ds);
 232 }
 233
 234 static void
 235 recv_ansi_sequence(const struct ansi_sequence *seq, struct ezio *e)
 236 {
 237 #define ARG1(DEFAULT) default_arg(seq->args[0], DEFAULT)
 238 #define ARG2(DEFAULT) default_arg(seq->args[1], DEFAULT)
 239     if (VLOG_IS_DBG_ENABLED()) {
 240         log_ansi_sequence(seq, e);
 241     }
 242     switch (seq->function) {
 243     case 0x5a: /* CBT: Cursor Backward Tabulation. */
 244         e->x = 8 * (e->x / 8 - ARG1(1));
 245         break;
 246     case 0x47: /* CHA: Cursor Character Absolute. */
 247         e->x = ARG1(1) - 1;
 248         break;
 249     case 0x49: /* CHT: Cursor Forward Tabulation. */
 250         e->x = 8 * (e->x / 8 + ARG1(1));
 251         break;
 252     case 0x45: /* CNL: Cursor Next Line. */
 253         e->x = 0;
 254         e->y += ARG1(1);
 255         break;
 256     case 0x46: /* CPL: Cursor Preceding Line. */
 257         e->x = 0;
 258         e->y -= ARG1(1);
 259         break;
 260     case 0x44: /* CUB: Cursor Left. */
 261         e->x -= ARG1(1);
 262         break;
 263     case 0x42: /* CUD: Cursor Down. */
 264         e->y += ARG1(1);
 265         break;
 266     case 0x43: /* CUF: Cursor Right. */
 267         e->x += ARG1(1);
 268         break;
 269     case 0x48: /* CUP: Cursor Position. */
 270         e->y = ARG1(1) - 1;
 271         e->x = ARG2(1) - 1;
 272         break;
 273     case 0x41: /* CUU: Cursor Up. */
 274         e->y -= ARG1(1);
 275         break;
 276     case 0x50: /* DCH: Delete Character. */
 277         ezio_delete_char(e, e->x, e->y, ARG1(1));
 278         break;
 279     case 0x4d: /* DL: Delete Line. */
 280         ezio_delete_line(e, e->y, ARG1(1));
 281         break;
 282     case 0x58: /* ECH: Erase Character. */
 283         memset(&e->chars[e->y][e->x], ' ', MIN(ARG1(1), 40 - e->x));
 284         break;
 285     case 0x4a: /* ED: Erase in Page. */
 286         clear_elements(&e->chars[0][0], 2 * 40, e->x + 40 * e->y, ARG1(0));
 287         break;
 288     case 0x4b: /* EL: Erase in Line. */
 289         clear_elements(&e->chars[e->y][0], 40, e->x, ARG1(0));
 290         break;
 291     case 0x40: /* ICH: Insert Character. */
 292         ezio_insert_char(e, e->x, e->y, ARG1(1));
 293         break;
 294     case 0x4c: /* IL: Insert Line. */
 295         ezio_insert_line(e, e->y, ARG1(1));
 296         break;
 297     case 0x4500: /* NEL: Next Line. */
 298         e->x = 0;
 299         e->y++;
 300         break;
 301     case 0x4d00: /* RI: Reverse Line Feed. */
 302         e->y--;
 303         break;
 304     case 0x6300: /* RIS: Reset to Initial State. */
 305         ezio_init(e);
 306         break;
 307     case 0x54: /* SD: Scroll Down. */
 308         ezio_scroll_down(e, ARG1(1));
 309         break;
 310     case 0x240: /* SL: Scroll Left. */
 311         ezio_scroll_left(e, ARG1(1));
 312         break;
 313     case 0x241: /* SR: Scroll Right. */
 314         ezio_scroll_right(e, ARG1(1));
 315         break;
 316     case 0x53: /* SU: Scroll Up. */
 317         ezio_scroll_up(e, ARG1(1));
 318         break;
 319
 320         /* Private sequences. */
 321     case 0x70: /* DICO: Define Icon. */
 322         define_icon(e, seq->args);
 323         break;
 324     case 0x71: /* CICO: Clear Icon. */
 325         clear_icon(e, ARG1(0));
 326         break;
 327     case 0x72: /* Set cursor visibility. */
 328         set_cursor(e, ARG1(1));
 329         break;
 330     }
 331     e->x = range(e->x, 0, 40);
 332     e->y = range(e->y, 0, 1);
 333     VLOG_DBG("cursor:%d,%d", e->x, e->y);
 334 }
 335
 336 static void
 337 recv_control(uint8_t c, struct ezio *e)
 338 {
 339     switch (c) {
 340     case '\b':
 341         if (e->x > 0) {
 342             --e->x;
 343         }
 344         break;
 345
 346     case '\t':
 347         e->x = ROUND_UP(e->x + 1, 8);
 348         if (e->x > 40) {
 349             ezio_newline(e);
 350         }
 351         break;
 352
 353     case '\n':
 354         ezio_line_feed(e);
 355         break;
 356
 357     case '\f':
 358         ezio_clear(e);
 359         break;
 360
 361     case '\r':
 362         e->x = 0;
 363         break;
 364
 365     default:
 366         VLOG_DBG("Unhandled control character 0x%02"PRIx8, c);
 367     }
 368 }
 369
 370 static void
 371 recv_character(uint8_t byte, struct ezio *e)
 372 {
 373     if (e->x >= 40) {
 374         ezio_newline(e);
 375     }
 376     ezio_put_char(e, e->x++, e->y, byte);
 377 }
 378
 379 static int
 380 default_arg(int value, int default_value)
 381 {
 382     return value >= 0 ? value : default_value;
 383 }
 384
 385 static int
 386 range(int value, int min, int max)
 387 {
 388     return value < min ? min : value > max ? max : value;
 389 }
 390
 391 static void
 392 clear_elements(uint8_t *p, size_t size, int pos, int clear_type)
 393 {
 394     switch (clear_type) {
 395     case 0:
 396         /* Clear from 'pos' to end. */
 397         memset(p + pos, ' ', size - pos);
 398         break;
 399     case 1:
 400         /* Clear from beginning to 'pos'. */
 401         memset(p, ' ', pos + 1);
 402         break;
 403     case 2:
 404         /* Clear all. */
 405         memset(p, ' ', size);
 406         break;
 407     }
 408 }
 409
 410 static void
 411 define_icon(struct ezio *e, const int *args)
 412 {
 413     int icon_nr;
 414     int row;
 415
 416     icon_nr = args[0];
 417     if (icon_nr < 0 || icon_nr > 7) {
 418         return;
 419     }
 420
 421     for (row = 0; row < 8; row++) {
 422         e->icons[icon_nr][row] = default_arg(args[row + 1], 0) & 0x1f;
 423     }
 424 }
 425
 426 static void
 427 clear_icon(struct ezio *e, int icon_nr)
 428 {
 429     if (icon_nr >= 0 && icon_nr <= 7) {
 430         ezio_set_default_icon(e, icon_nr);
 431     }
 432 }
 433
 434 static void
 435 set_cursor(struct ezio *e, int visibility)
 436 {
 437     switch (visibility) {
 438     case 1:
 439         e->show_cursor = e->blink_cursor = false;
 440         break;
 441     case 2:
 442         e->show_cursor = true;
 443         e->blink_cursor = false;
 444         break;
 445     case 3:
 446         e->show_cursor = e->blink_cursor = true;
 447         break;
 448     }
 449 }
 450
 451 static int
 452 unicode_to_ezio(uint16_t unicode)
 453 {
 454     switch (unicode) {
 455         /* Most ASCII characters map one-to-one. */
 456     case 0x0020 ... 0x005b:
 457     case 0x005d ... 0x007d:
 458         return unicode;
 459
 460         /* A few ASCII characters have to be simulated with icons. */
 461     case 0x005c: return 0x06; /* BACKSLASH */
 462     case 0x007e: return 0x07; /* TILDE */
 463
 464         /* EZIO extended characters equivalents in Unicode - Japanese. */
 465     case 0x00a5: return '\\';   /* YEN SIGN */
 466     case 0x3002: return 0xa1;   /* IDEOGRAPHIC FULL STOP */
 467     case 0x300c: return 0xa2;   /* LEFT CORNER BRACKET */
 468     case 0x300d: return 0xa3;   /* RIGHT CORNER BRACKET */
 469     case 0x3001: return 0xa4;   /* IDEOGRAPHIC COMMA */
 470     case 0x30fb: return 0xa5;   /* KATAKANA MIDDLE DOT */
 471     case 0x30f2: return 0xa6;   /* KATAKANA LETTER WO */
 472     case 0x30a1: return 0xa7;   /* KATAKANA LETTER SMALL A */
 473     case 0x30a3: return 0xa8;   /* KATAKANA LETTER SMALL I */
 474     case 0x30a5: return 0xa9;   /* KATAKANA LETTER SMALL U */
 475     case 0x30a7: return 0xaa;   /* KATAKANA LETTER SMALL E */
 476     case 0x30a9: return 0xab;   /* KATAKANA LETTER SMALL O */
 477     case 0x30e3: return 0xac;   /* KATAKANA LETTER SMALL YA */
 478     case 0x30e5: return 0xad;   /* KATAKANA LETTER SMALL YU */
 479     case 0x30e7: return 0xae;   /* KATAKANA LETTER SMALL YO */
 480     case 0x30c3: return 0xaf;   /* KATAKANA LETTER SMALL TU = SMALL TSU */
 481         case 0x30fc: return 0xb0;   /* KATAKANA-HIRAGANA PROLONGED SOUND MARK */
 482     case 0x30a2: return 0xb1;   /* KATAKANA LETTER A */
 483     case 0x30a4: return 0xb2;   /* KATAKANA LETTER I */
 484     case 0x30a6: return 0xb3;   /* KATAKANA LETTER U */
 485     case 0x30a8: return 0xb4;   /* KATAKANA LETTER E */
 486     case 0x30aa: return 0xb5;   /* KATAKANA LETTER O */
 487     case 0x30ab: return 0xb6;   /* KATAKANA LETTER KA */
 488     case 0x30ac: return 0xb6de; /* KATAKANA LETTER GA */
 489     case 0x30ad: return 0xb7;   /* KATAKANA LETTER KI */
 490     case 0x30ae: return 0xb7de; /* KATAKANA LETTER GI */
 491     case 0x30af: return 0xb8;   /* KATAKANA LETTER KU */
 492     case 0x30b0: return 0xb8de; /* KATAKANA LETTER GU */
 493     case 0x30b1: return 0xb9;   /* KATAKANA LETTER KE */
 494     case 0x30b2: return 0xb9de; /* KATAKANA LETTER GE */
 495     case 0x30b3: return 0xba;   /* KATAKANA LETTER KO */
 496     case 0x30b4: return 0xbade; /* KATAKANA LETTER GO */
 497     case 0x30b5: return 0xbb;   /* KATAKANA LETTER SA */
 498     case 0x30b6: return 0xbbde; /* KATAKANA LETTER ZA */
 499     case 0x30b7: return 0xbc;   /* KATAKANA LETTER SI = SHI */
 500     case 0x30b8: return 0xbcde; /* KATAKANA LETTER ZI = JI */
 501     case 0x30b9: return 0xbd;   /* KATAKANA LETTER SU */
 502     case 0x30ba: return 0xbdde; /* KATAKANA LETTER ZU */
 503     case 0x30bb: return 0xbe;   /* KATAKANA LETTER SE */
 504     case 0x30bc: return 0xbede; /* KATAKANA LETTER ZE */
 505     case 0x30bd: return 0xbf;   /* KATAKANA LETTER SO */
 506     case 0x30be: return 0xbfde; /* KATAKANA LETTER ZO */
 507     case 0x30bf: return 0xc0;   /* KATAKANA LETTER TA */
 508     case 0x30c0: return 0xc0de; /* KATAKANA LETTER DA */
 509     case 0x30c1: return 0xc1;   /* KATAKANA LETTER TI = CHI */
 510     case 0x30c2: return 0xc1de; /* KATAKANA LETTER DI = JI */
 511     case 0x30c4: return 0xc2;   /* KATAKANA LETTER TU = TSU */
 512     case 0x30c5: return 0xc2de; /* KATAKANA LETTER DU = ZU */
 513     case 0x30c6: return 0xc3;   /* KATAKANA LETTER TE */
 514     case 0x30c7: return 0xc3de; /* KATAKANA LETTER DE */
 515     case 0x30c8: return 0xc4;   /* KATAKANA LETTER TO */
 516     case 0x30c9: return 0xc4de; /* KATAKANA LETTER DO */
 517     case 0x30ca: return 0xc5;   /* KATAKANA LETTER NA */
 518     case 0x30cb: return 0xc6;   /* KATAKANA LETTER NI */
 519     case 0x30cc: return 0xc7;   /* KATAKANA LETTER NU */
 520     case 0x30cd: return 0xc8;   /* KATAKANA LETTER NE */
 521     case 0x30ce: return 0xc9;   /* KATAKANA LETTER NO */
 522     case 0x30cf: return 0xca;   /* KATAKANA LETTER HA */
 523     case 0x30d0: return 0xcade; /* KATAKANA LETTER BA */
 524     case 0x30d1: return 0xcadf; /* KATAKANA LETTER PA */
 525     case 0x30d2: return 0xcb;   /* KATAKANA LETTER HI */
 526     case 0x30d3: return 0xcbde; /* KATAKANA LETTER BI */
 527     case 0x30d4: return 0xcbdf; /* KATAKANA LETTER PI */
 528     case 0x30d5: return 0xcc;   /* KATAKANA LETTER HU = FU */
 529     case 0x30d6: return 0xccde; /* KATAKANA LETTER BU */
 530     case 0x30d7: return 0xccdf; /* KATAKANA LETTER PU */
 531     case 0x30d8: return 0xcd;   /* KATAKANA LETTER HE */
 532     case 0x30d9: return 0xcdde; /* KATAKANA LETTER BE */
 533     case 0x30da: return 0xcddf; /* KATAKANA LETTER PE */
 534     case 0x30db: return 0xce;   /* KATAKANA LETTER HO */
 535     case 0x30dc: return 0xcede; /* KATAKANA LETTER BO */
 536     case 0x30dd: return 0xcedf; /* KATAKANA LETTER PO */
 537     case 0x30de: return 0xcf;   /* KATAKANA LETTER MA */
 538     case 0x30df: return 0xd0;   /* KATAKANA LETTER MI */
 539     case 0x30e0: return 0xd1;   /* KATAKANA LETTER MU */
 540     case 0x30e1: return 0xd2;   /* KATAKANA LETTER ME */
 541     case 0x30e2: return 0xd3;   /* KATAKANA LETTER MO */
 542     case 0x30e4: return 0xd4;   /* KATAKANA LETTER YA */
 543     case 0x30e6: return 0xd5;   /* KATAKANA LETTER YU */
 544     case 0x30e8: return 0xd6;   /* KATAKANA LETTER YO */
 545     case 0x30e9: return 0xd7;   /* KATAKANA LETTER RA */
 546     case 0x30ea: return 0xd8;   /* KATAKANA LETTER RI */
 547     case 0x30eb: return 0xd9;   /* KATAKANA LETTER RU */
 548     case 0x30ec: return 0xda;   /* KATAKANA LETTER RE */
 549     case 0x30ed: return 0xdb;   /* KATAKANA LETTER RO */
 550     case 0x30ef: return 0xdc;   /* KATAKANA LETTER WA */
 551     case 0x30f3: return 0xdd;   /* KATAKANA LETTER N */
 552     case 0x30f4: return 0xb3de; /* KATAKANA LETTER VU */
 553     case 0x30f7: return 0xdcde; /* KATAKANA LETTER VA */
 554     case 0x3099: return 0xde;   /* COMBINING KATAKANA-HIRAGANA VOICED SOUND
 555                                  * MARK */
 556     case 0x309a: return 0xdf;   /* COMBINING KATAKANA-HIRAGANA SEMI-VOICED
 557                                  * SOUND MARK */
 558     case 0x309b: return 0xde;   /* KATAKANA-HIRAGANA VOICED SOUND MARK */
 559         case 0x309c: return 0xdf;   /* KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK */
 560
 561         /* EZIO extended characters equivalents in Unicode - other. */
 562     case 0x2192: return 0x7e; /* RIGHTWARDS ARROW */
 563     case 0x2190: return 0x7f; /* LEFTWARDS ARROW */
 564     case 0x03b1: return 0xe0; /* GREEK SMALL LETTER ALPHA */
 565     case 0x00e4: return 0xe1; /* LATIN SMALL LETTER A WITH DIAERESIS */
 566     case 0x03b2: return 0xe2; /* GREEK SMALL LETTER BETA */
 567     case 0x03b5: return 0xe3; /* GREEK SMALL LETTER EPSILON */
 568     case 0x03bc: return 0xe4; /* GREEK SMALL LETTER MU */
 569     case 0x03c6: return 0xe5; /* GREEK SMALL LETTER PHI */
 570     case 0x03c1: return 0xe6; /* GREEK SMALL LETTER RHO */
 571                               /* 0xe7 is 'g'. */
 572     case 0x221a: return 0xe8; /* SQUARE ROOT = radical sign */
 573                               /* 0xe9 is an unrecognizable symbol. */
 574                               /* 0xea is 'j'. */
 575                               /* 0xeb is an unrecognizable symbol.*/
 576     case 0x00a2: return 0xec; /* CENT SIGN */
 577     case 0x00a3: return 0xed; /* POUND SIGN */
 578     case 0x00f1: return 0xee; /* LATIN SMALL LETTER N WITH TILDE */
 579     case 0x00f6: return 0xef; /* LATIN SMALL LETTER O WITH DIAERESIS */
 580                               /* 0xf0 is 'p'. */
 581                               /* 0xf1 is 'q'. */
 582     case 0x03b8: return 0xf2; /* GREEK SMALL LETTER THETA */
 583     case 0x221e: return 0xf3; /* INFINITY */
 584     case 0x03a9: return 0xf4; /* GREEK CAPITAL LETTER OMEGA */
 585     case 0x00fc: return 0xf5; /* LATIN SMALL LETTER U WITH DIAERESIS */
 586     case 0x03a3: return 0xf6; /* GREEK CAPITAL LETTER SIGMA */
 587     case 0x03c0: return 0xf7; /* GREEK SMALL LETTER PI */
 588                               /* 0xf8 is x-macron (the sample mean). */
 589                               /* 0xf9 is 'y'. */
 590     case 0x5343: return 0xfa; /* thousand */
 591     case 0x4e07: return 0xfb; /* ten thousand */
 592     case 0x5186: return 0xfc; /* yen */
 593     case 0x00f7: return 0xfd; /* DIVISION SIGN */
 594     case 0x2588: return 0xff; /* FULL BLOCK = solid */
 595
 596         /* EZIO icons (from the Unicode Private Use corporate subarea). */
 597     case 0xf8f8: return 0x00;
 598     case 0xf8f9: return 0x01;
 599     case 0xf8fa: return 0x02;
 600     case 0xf8fb: return 0x03;
 601     case 0xf8fc: return 0x04;
 602     case 0xf8fd: return 0x05;
 603     case 0xf8fe: return 0x06;
 604     case 0xf8ff: return 0x07;
 605
 606         /* No mappings for anything else. */
 607     default: return -1;
 608     }
 609 }
 610 \f
 611 /* UTF-8 decoder. */
 612
 613 #define UTF_STATES                              \
 614     UTF_STATE(UTF8_INIT, 0x00, 0xf4, UTF8_INIT) \
 615     UTF_STATE(UTF8_3,    0x80, 0xbf, UTF8_2)    \
 616     UTF_STATE(UTF8_2,    0x80, 0xbf, UTF8_1)    \
 617     UTF_STATE(UTF8_1,    0x80, 0xbf, UTF8_INIT) \
 618     UTF_STATE(UTF8_E0,   0xa0, 0xbf, UTF8_1)    \
 619     UTF_STATE(UTF8_ED,   0x80, 0x9f, UTF8_1)    \
 620     UTF_STATE(UTF8_F0,   0x90, 0xbf, UTF8_INIT) \
 621     UTF_STATE(UTF8_F4,   0x80, 0x8f, UTF8_INIT)
 622
 623 enum state {
 624 #define UTF_STATE(NAME, MIN, MAX, NEXT) NAME,
 625     UTF_STATES
 626 #undef UTF_STATE
 627 };
 628
 629 struct state_info {
 630     uint8_t min, max;
 631     enum state next;
 632 };
 633
 634 static const struct state_info states[] = {
 635 #define UTF_STATE(NAME, MIN, MAX, NEXT) {MIN, MAX, NEXT},
 636     UTF_STATES
 637 #undef UTF_STATE
 638 };
 639
 640 struct utf8_reader {
 641     int cp;
 642     enum state state;
 643 };
 644
 645 struct utf8_reader *
 646 utf8_reader_create(void)
 647 {
 648     struct utf8_reader *r = xmalloc(sizeof *r);
 649     r->state = UTF8_INIT;
 650     return r;
 651 }
 652
 653 void
 654 utf8_reader_destroy(struct utf8_reader *r)
 655 {
 656     free(r);
 657 }
 658
 659 int
 660 utf8_reader_read(struct utf8_reader *r, uint8_t c)
 661 {
 662     const struct state_info *s = &states[r->state];
 663     if (c >= s->min && c <= s->max) {
 664         if (r->state == UTF8_INIT) {
 665             if (c < 0x80) {
 666                 return c;
 667             } else if (c >= 0xc2 && c <= 0xdf) {
 668                 r->cp = c & 0x1f;
 669                 r->state = UTF8_1;
 670                 return -1;
 671             } else if (c >= 0xe0 && c <= 0xef) {
 672                 r->cp = c & 0x0f;
 673                 r->state = c == 0xe0 ? UTF8_E0 : c == 0xed ? UTF8_ED : UTF8_2;
 674                 return -1;
 675             } else if (c >= 0xf0 && c <= 0xf4) {
 676                 r->cp = c & 0x07;
 677                 r->state = c == 0xf0 ? UTF8_F0 : c == 0xf4 ? UTF8_F4 : UTF8_3;
 678                 return -1;
 679             }
 680         } else {
 681             r->cp = (r->cp << 6) | (c & 0x3f);
 682             r->state = s->next;
 683             return r->state == UTF8_INIT ? r->cp : -1;
 684         }
 685     }
 686
 687     /* Invalid UTF-8 sequence.  Return the Unicode general substitute
 688      * REPLACEMENT CHARACTER. */
 689     r->state = UTF8_INIT;
 690     return 0xfffd;
 691 }
 692 \f
 693 /* ANSI control sequence decoder. */
 694
 695 /* States are named for what we are looking for in that state. */
 696 enum ansi_state {
 697     ANSI_ESC,                      /* Looking for ESC. */
 698     ANSI_CSI,                      /* Looking for [ (to complete CSI). */
 699     ANSI_PARAMETER,                /* Looking for parameter. */
 700     ANSI_INTERMEDIATE,             /* Looking for intermediate byte. */
 701     ANSI_FINAL,                    /* Looking for final byte. */
 702     ANSI_COMPLETE                  /* Got an entire escape sequence. */
 703 };
 704
 705 struct ansi_decoder {
 706     enum ansi_state state;
 707     struct ansi_sequence seq;
 708     int c;
 709 };
 710
 711 struct ansi_decoder *
 712 ansi_decoder_create(void)
 713 {
 714     struct ansi_decoder *d = xmalloc(sizeof *d);
 715     d->state = ANSI_ESC;
 716     return d;
 717 }
 718
 719 void
 720 ansi_decoder_destroy(struct ansi_decoder *d)
 721 {
 722     free(d);
 723 }
 724
 725 int
 726 ansi_decoder_put(struct ansi_decoder *d, uint8_t c)
 727 {
 728     if (c == 27) {
 729         /* Escape always starts a new escape sequence, aborting an incomplete
 730          * one if necessary. */
 731         if (d->state != ANSI_ESC) {
 732             VLOG_DBG("Unexpected escape inside escape sequence");
 733         }
 734         d->state = ANSI_CSI;
 735         return 0;
 736     }
 737
 738     switch (d->state) {
 739     case ANSI_ESC:
 740         return 1;
 741
 742     case ANSI_CSI:
 743         if (c == '[') {
 744             d->state = ANSI_PARAMETER;
 745             d->seq.n_args = 0;
 746             d->seq.function = 0;
 747         } else if (c >= 0x40 && c <= 0x5f) {
 748             d->state = ANSI_COMPLETE;
 749             d->seq.n_args = 0;
 750             d->seq.function = 0;
 751             d->seq.function = c << 8;
 752             return -1;
 753         } else {
 754             d->state = ANSI_ESC;
 755         }
 756         break;
 757
 758     case ANSI_PARAMETER:
 759         if (c >= '0' && c <= '9') {
 760             int *arg;
 761             if (d->seq.n_args == 0) {
 762                 d->seq.args[d->seq.n_args++] = 0;
 763             } else if (d->seq.n_args > ANSI_MAX_ARGS) {
 764                 break;
 765             }
 766             arg = &d->seq.args[d->seq.n_args - 1];
 767             if (*arg == -1) {
 768                 *arg = 0;
 769             }
 770             *arg = *arg * 10 + (c - '0');
 771             break;
 772         } else if (c == ';') {
 773             if (d->seq.n_args < ANSI_MAX_ARGS) {
 774                 d->seq.args[d->seq.n_args] = -1;
 775             }
 776             d->seq.n_args++;
 777             break;
 778         }
 779         d->state = ANSI_INTERMEDIATE;
 780         /* Fall through. */
 781
 782     case ANSI_INTERMEDIATE:
 783         if (c >= 0x20 && c <= 0x2f) {
 784             d->seq.function = d->seq.function * 16 + (c - 0x20);
 785             break;
 786         }
 787         d->state = ANSI_FINAL;
 788         /* Fall through. */
 789
 790     case ANSI_FINAL:
 791         if (c >= 0x40 && c <= 0x7e) {
 792             d->seq.function = d->seq.function * 256 + c;
 793             d->state = ANSI_COMPLETE;
 794             return -1;
 795         } else {
 796             /* Invalid sequence. */
 797             d->state = ANSI_ESC;
 798         }
 799         break;
 800
 801     case ANSI_COMPLETE:
 802         NOT_REACHED();
 803     }
 804     return 0;
 805 }
 806
 807 const struct ansi_sequence *
 808 ansi_decoder_get(struct ansi_decoder *d)
 809 {
 810     assert(d->state == ANSI_COMPLETE);
 811     d->state = ANSI_ESC;
 812     if (d->seq.n_args < ANSI_MAX_ARGS) {
 813         int i;
 814         for (i = d->seq.n_args; i < ANSI_MAX_ARGS; i++) {
 815             d->seq.args[i] = -1;
 816         }
 817     } else {
 818         d->seq.n_args = ANSI_MAX_ARGS;
 819     }
 820     return &d->seq;
 821 }