wsemul_vt100.c revision 1.36
1 /* $NetBSD: wsemul_vt100.c,v 1.36 2013/10/19 21:01:39 mrg Exp $ */ 2 3 /* 4 * Copyright (c) 1998 5 * Matthias Drochner. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 * 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: wsemul_vt100.c,v 1.36 2013/10/19 21:01:39 mrg Exp $"); 31 32 #include "opt_wsmsgattrs.h" 33 34 #include <sys/param.h> 35 #include <sys/systm.h> 36 #include <sys/time.h> 37 #include <sys/malloc.h> 38 #include <sys/fcntl.h> 39 40 #include <dev/wscons/wsconsio.h> 41 #include <dev/wscons/wsdisplayvar.h> 42 #include <dev/wscons/wsemulvar.h> 43 #include <dev/wscons/wsemul_vt100var.h> 44 #include <dev/wscons/ascii.h> 45 46 void *wsemul_vt100_cnattach(const struct wsscreen_descr *, void *, 47 int, int, long); 48 void *wsemul_vt100_attach(int console, const struct wsscreen_descr *, 49 void *, int, int, void *, long); 50 void wsemul_vt100_output(void *cookie, const u_char *data, u_int count, int); 51 void wsemul_vt100_detach(void *cookie, u_int *crowp, u_int *ccolp); 52 void wsemul_vt100_resetop(void *, enum wsemul_resetops); 53 #ifdef WSDISPLAY_CUSTOM_OUTPUT 54 static void wsemul_vt100_getmsgattrs(void *, struct wsdisplay_msgattrs *); 55 static void wsemul_vt100_setmsgattrs(void *, const struct wsscreen_descr *, 56 const struct wsdisplay_msgattrs *); 57 #endif /* WSDISPLAY_CUSTOM_OUTPUT */ 58 59 const struct wsemul_ops wsemul_vt100_ops = { 60 "vt100", 61 wsemul_vt100_cnattach, 62 wsemul_vt100_attach, 63 wsemul_vt100_output, 64 wsemul_vt100_translate, 65 wsemul_vt100_detach, 66 wsemul_vt100_resetop, 67 #ifdef WSDISPLAY_CUSTOM_OUTPUT 68 wsemul_vt100_getmsgattrs, 69 wsemul_vt100_setmsgattrs, 70 #else 71 NULL, 72 NULL, 73 #endif 74 }; 75 76 struct wsemul_vt100_emuldata wsemul_vt100_console_emuldata; 77 78 static void wsemul_vt100_init(struct wsemul_vt100_emuldata *, 79 const struct wsscreen_descr *, 80 void *, int, int, long); 81 82 static void wsemul_vt100_output_normal(struct wsemul_vt100_emuldata *, 83 u_char, int); 84 static void wsemul_vt100_output_c0c1(struct wsemul_vt100_emuldata *, 85 u_char, int); 86 static void wsemul_vt100_nextline(struct wsemul_vt100_emuldata *); 87 typedef u_int vt100_handler(struct wsemul_vt100_emuldata *, u_char); 88 89 static vt100_handler 90 wsemul_vt100_output_esc, 91 wsemul_vt100_output_csi, 92 wsemul_vt100_output_scs94, 93 wsemul_vt100_output_scs94_percent, 94 wsemul_vt100_output_scs96, 95 wsemul_vt100_output_scs96_percent, 96 wsemul_vt100_output_esc_hash, 97 wsemul_vt100_output_esc_spc, 98 wsemul_vt100_output_string, 99 wsemul_vt100_output_string_esc, 100 wsemul_vt100_output_dcs, 101 wsemul_vt100_output_dcs_dollar; 102 103 #define VT100_EMUL_STATE_NORMAL 0 /* normal processing */ 104 #define VT100_EMUL_STATE_ESC 1 /* got ESC */ 105 #define VT100_EMUL_STATE_CSI 2 /* got CSI (ESC[) */ 106 #define VT100_EMUL_STATE_SCS94 3 /* got ESC{()*+} */ 107 #define VT100_EMUL_STATE_SCS94_PERCENT 4 /* got ESC{()*+}% */ 108 #define VT100_EMUL_STATE_SCS96 5 /* got ESC{-./} */ 109 #define VT100_EMUL_STATE_SCS96_PERCENT 6 /* got ESC{-./}% */ 110 #define VT100_EMUL_STATE_ESC_HASH 7 /* got ESC# */ 111 #define VT100_EMUL_STATE_ESC_SPC 8 /* got ESC<SPC> */ 112 #define VT100_EMUL_STATE_STRING 9 /* waiting for ST (ESC\) */ 113 #define VT100_EMUL_STATE_STRING_ESC 10 /* waiting for ST, got ESC */ 114 #define VT100_EMUL_STATE_DCS 11 /* got DCS (ESC P) */ 115 #define VT100_EMUL_STATE_DCS_DOLLAR 12 /* got DCS<p>$ */ 116 117 vt100_handler *vt100_output[] = { 118 wsemul_vt100_output_esc, 119 wsemul_vt100_output_csi, 120 wsemul_vt100_output_scs94, 121 wsemul_vt100_output_scs94_percent, 122 wsemul_vt100_output_scs96, 123 wsemul_vt100_output_scs96_percent, 124 wsemul_vt100_output_esc_hash, 125 wsemul_vt100_output_esc_spc, 126 wsemul_vt100_output_string, 127 wsemul_vt100_output_string_esc, 128 wsemul_vt100_output_dcs, 129 wsemul_vt100_output_dcs_dollar, 130 }; 131 132 static void 133 wsemul_vt100_init(struct wsemul_vt100_emuldata *edp, 134 const struct wsscreen_descr *type, void *cookie, int ccol, int crow, 135 long defattr) 136 { 137 struct vt100base_data *vd = &edp->bd; 138 int error; 139 140 vd->emulops = type->textops; 141 vd->emulcookie = cookie; 142 vd->scrcapabilities = type->capabilities; 143 vd->nrows = type->nrows; 144 vd->ncols = type->ncols; 145 vd->crow = crow; 146 vd->ccol = ccol; 147 148 /* The underlying driver has already allocated a default and simple 149 * attribute for us, which is stored in defattr. We try to set the 150 * values specified by the kernel options below, but in case of 151 * failure we fallback to the value given by the driver. */ 152 153 if (type->capabilities & WSSCREEN_WSCOLORS) { 154 vd->msgattrs.default_attrs = WS_DEFAULT_COLATTR | 155 WSATTR_WSCOLORS; 156 vd->msgattrs.default_bg = WS_DEFAULT_BG; 157 vd->msgattrs.default_fg = WS_DEFAULT_FG; 158 159 vd->msgattrs.kernel_attrs = WS_KERNEL_COLATTR | 160 WSATTR_WSCOLORS; 161 vd->msgattrs.kernel_bg = WS_KERNEL_BG; 162 vd->msgattrs.kernel_fg = WS_KERNEL_FG; 163 } else { 164 vd->msgattrs.default_attrs = WS_DEFAULT_MONOATTR; 165 vd->msgattrs.default_bg = vd->msgattrs.default_fg = 0; 166 167 vd->msgattrs.kernel_attrs = WS_KERNEL_MONOATTR; 168 vd->msgattrs.kernel_bg = vd->msgattrs.kernel_fg = 0; 169 } 170 171 error = (*vd->emulops->allocattr)(cookie, 172 vd->msgattrs.default_fg, 173 vd->msgattrs.default_bg, 174 vd->msgattrs.default_attrs, 175 &vd->defattr); 176 if (error) { 177 vd->defattr = defattr; 178 /* XXX This assumes the driver has allocated white on black 179 * XXX as the default attribute, which is not always true. 180 * XXX Maybe we need an emulop that, given an attribute, 181 * XXX (defattr) returns its flags and colors? */ 182 vd->msgattrs.default_attrs = 0; 183 vd->msgattrs.default_bg = WSCOL_BLACK; 184 vd->msgattrs.default_fg = WSCOL_WHITE; 185 } else { 186 if (vd->emulops->replaceattr != NULL) 187 (*vd->emulops->replaceattr)(cookie, defattr, 188 vd->defattr); 189 } 190 191 #if defined(WS_KERNEL_CUSTOMIZED) 192 /* Set up kernel colors, in case they were customized by the user; 193 * otherwise default to the colors specified for the console. 194 * In case of failure, we use console colors too; we can assume 195 * they are good as they have been previously allocated and 196 * verified. */ 197 error = (*vd->emulops->allocattr)(cookie, 198 vd->msgattrs.kernel_fg, 199 vd->msgattrs.kernel_bg, 200 vd->msgattrs.kernel_attrs, 201 &edp->kernattr); 202 if (error) 203 #endif 204 edp->kernattr = vd->defattr; 205 } 206 207 void * 208 wsemul_vt100_cnattach(const struct wsscreen_descr *type, void *cookie, 209 int ccol, int crow, long defattr) 210 { 211 struct wsemul_vt100_emuldata *edp; 212 struct vt100base_data *vd; 213 214 edp = &wsemul_vt100_console_emuldata; 215 vd = &edp->bd; 216 wsemul_vt100_init(edp, type, cookie, ccol, crow, defattr); 217 #ifdef DIAGNOSTIC 218 edp->console = 1; 219 #endif 220 vd->cbcookie = NULL; 221 222 vd->tabs = 0; 223 vd->dblwid = 0; 224 vd->dw = 0; 225 vd->dcsarg = 0; 226 edp->isolatin1tab = edp->decgraphtab = edp->dectechtab = 0; 227 edp->nrctab = 0; 228 wsemul_vt100_reset(edp); 229 return (edp); 230 } 231 232 void * 233 wsemul_vt100_attach(int console, const struct wsscreen_descr *type, 234 void *cookie, int ccol, int crow, void *cbcookie, long defattr) 235 { 236 struct wsemul_vt100_emuldata *edp; 237 struct vt100base_data *vd; 238 239 if (console) { 240 edp = &wsemul_vt100_console_emuldata; 241 #ifdef DIAGNOSTIC 242 KASSERT(edp->console == 1); 243 #endif 244 } else { 245 edp = malloc(sizeof *edp, M_DEVBUF, M_WAITOK); 246 wsemul_vt100_init(edp, type, cookie, ccol, crow, defattr); 247 #ifdef DIAGNOSTIC 248 edp->console = 0; 249 #endif 250 } 251 vd = &edp->bd; 252 vd->cbcookie = cbcookie; 253 254 vd->tabs = malloc(vd->ncols, M_DEVBUF, M_NOWAIT); 255 vd->dblwid = malloc(vd->nrows, M_DEVBUF, M_NOWAIT|M_ZERO); 256 vd->dw = 0; 257 vd->dcsarg = malloc(DCS_MAXLEN, M_DEVBUF, M_NOWAIT); 258 edp->isolatin1tab = malloc(128 * sizeof(int), M_DEVBUF, M_NOWAIT); 259 edp->decgraphtab = malloc(128 * sizeof(int), M_DEVBUF, M_NOWAIT); 260 edp->dectechtab = malloc(128 * sizeof(int), M_DEVBUF, M_NOWAIT); 261 edp->nrctab = malloc(128 * sizeof(int), M_DEVBUF, M_NOWAIT); 262 vt100_initchartables(edp); 263 wsemul_vt100_reset(edp); 264 return (edp); 265 } 266 267 void 268 wsemul_vt100_detach(void *cookie, u_int *crowp, u_int *ccolp) 269 { 270 struct wsemul_vt100_emuldata *edp = cookie; 271 struct vt100base_data *vd = &edp->bd; 272 273 *crowp = vd->crow; 274 *ccolp = vd->ccol; 275 #define f(ptr) if (ptr) {free(ptr, M_DEVBUF); ptr = 0;} 276 f(vd->tabs) 277 f(vd->dblwid) 278 f(vd->dcsarg) 279 f(edp->isolatin1tab) 280 f(edp->decgraphtab) 281 f(edp->dectechtab) 282 f(edp->nrctab) 283 #undef f 284 if (edp != &wsemul_vt100_console_emuldata) 285 free(edp, M_DEVBUF); 286 } 287 288 void 289 wsemul_vt100_resetop(void *cookie, enum wsemul_resetops op) 290 { 291 struct wsemul_vt100_emuldata *edp = cookie; 292 struct vt100base_data *vd = &edp->bd; 293 294 switch (op) { 295 case WSEMUL_RESET: 296 wsemul_vt100_reset(edp); 297 break; 298 case WSEMUL_SYNCFONT: 299 vt100_initchartables(edp); 300 break; 301 case WSEMUL_CLEARSCREEN: 302 wsemul_vt100_ed(vd, 2); 303 vd->ccol = vd->crow = 0; 304 (*vd->emulops->cursor)(vd->emulcookie, 305 vd->flags & VTFL_CURSORON, 0, 0); 306 break; 307 default: 308 break; 309 } 310 } 311 312 void 313 wsemul_vt100_reset(struct wsemul_vt100_emuldata *edp) 314 { 315 struct vt100base_data *vd = &edp->bd; 316 int i; 317 318 edp->state = VT100_EMUL_STATE_NORMAL; 319 vd->flags = VTFL_DECAWM | VTFL_CURSORON; 320 vd->bkgdattr = vd->curattr = vd->defattr; 321 vd->attrflags = vd->msgattrs.default_attrs; 322 vd->fgcol = vd->msgattrs.default_fg; 323 vd->bgcol = vd->msgattrs.default_bg; 324 vd->scrreg_startrow = 0; 325 vd->scrreg_nrows = vd->nrows; 326 if (vd->tabs) { 327 memset(vd->tabs, 0, vd->ncols); 328 for (i = 8; i < vd->ncols; i += 8) 329 vd->tabs[i] = 1; 330 } 331 vd->dcspos = 0; 332 vd->dcstype = 0; 333 edp->chartab_G[0] = 0; 334 edp->chartab_G[1] = edp->nrctab; /* ??? */ 335 edp->chartab_G[2] = edp->isolatin1tab; 336 edp->chartab_G[3] = edp->isolatin1tab; 337 edp->chartab0 = 0; 338 edp->chartab1 = 2; 339 edp->sschartab = 0; 340 } 341 342 /* 343 * now all the state machine bits 344 */ 345 346 /* 347 * Move the cursor to the next line if possible. If the cursor is at 348 * the bottom of the scroll area, then scroll it up. If the cursor is 349 * at the bottom of the screen then don't move it down. 350 */ 351 static void 352 wsemul_vt100_nextline(struct wsemul_vt100_emuldata *edp) 353 { 354 struct vt100base_data *vd = &edp->bd; 355 356 if (ROWS_BELOW(vd) == 0) { 357 /* Bottom of the scroll region. */ 358 wsemul_vt100_scrollup(vd, 1); 359 } else { 360 if ((vd->crow+1) < vd->nrows) 361 /* Cursor not at the bottom of the screen. */ 362 vd->crow++; 363 CHECK_DW(vd); 364 } 365 } 366 367 static void 368 wsemul_vt100_output_normal(struct wsemul_vt100_emuldata *edp, u_char c, 369 int kernel) 370 { 371 struct vt100base_data *vd = &edp->bd; 372 u_int *ct, dc; 373 374 if ((vd->flags & (VTFL_LASTCHAR | VTFL_DECAWM)) == 375 (VTFL_LASTCHAR | VTFL_DECAWM)) { 376 wsemul_vt100_nextline(edp); 377 vd->ccol = 0; 378 vd->flags &= ~VTFL_LASTCHAR; 379 } 380 381 if (c & 0x80) { 382 c &= 0x7f; 383 ct = edp->chartab_G[edp->chartab1]; 384 } else { 385 if (edp->sschartab) { 386 ct = edp->chartab_G[edp->sschartab]; 387 edp->sschartab = 0; 388 } else 389 ct = edp->chartab_G[edp->chartab0]; 390 } 391 dc = (ct ? ct[c] : c); 392 393 if ((vd->flags & VTFL_INSERTMODE) && COLS_LEFT(vd)) 394 COPYCOLS(vd, vd->ccol, vd->ccol + 1, COLS_LEFT(vd)); 395 396 (*vd->emulops->putchar)(vd->emulcookie, vd->crow, 397 vd->ccol << vd->dw, dc, 398 kernel ? edp->kernattr : vd->curattr); 399 400 if (COLS_LEFT(vd)) 401 vd->ccol++; 402 else 403 vd->flags |= VTFL_LASTCHAR; 404 } 405 406 static void 407 wsemul_vt100_output_c0c1(struct wsemul_vt100_emuldata *edp, u_char c, 408 int kernel) 409 { 410 struct vt100base_data *vd = &edp->bd; 411 u_int n; 412 413 switch (c) { 414 case ASCII_NUL: 415 default: 416 /* ignore */ 417 break; 418 case ASCII_BEL: 419 wsdisplay_emulbell(vd->cbcookie); 420 break; 421 case ASCII_BS: 422 if (vd->ccol > 0) { 423 vd->ccol--; 424 vd->flags &= ~VTFL_LASTCHAR; 425 } 426 break; 427 case ASCII_CR: 428 vd->ccol = 0; 429 vd->flags &= ~VTFL_LASTCHAR; 430 break; 431 case ASCII_HT: 432 if (vd->tabs) { 433 if (!COLS_LEFT(vd)) 434 break; 435 for (n = vd->ccol + 1; n < NCOLS(vd) - 1; n++) 436 if (vd->tabs[n]) 437 break; 438 } else { 439 n = vd->ccol + min(8 - (vd->ccol & 7), COLS_LEFT(vd)); 440 } 441 vd->ccol = n; 442 break; 443 case ASCII_SO: /* LS1 */ 444 edp->chartab0 = 1; 445 break; 446 case ASCII_SI: /* LS0 */ 447 edp->chartab0 = 0; 448 break; 449 case ASCII_ESC: 450 if (kernel) { 451 printf("wsemul_vt100_output_c0c1: ESC in kernel output ignored\n"); 452 break; /* ignore the ESC */ 453 } 454 455 if (edp->state == VT100_EMUL_STATE_STRING) { 456 /* might be a string end */ 457 edp->state = VT100_EMUL_STATE_STRING_ESC; 458 } else { 459 /* XXX cancel current escape sequence */ 460 edp->state = VT100_EMUL_STATE_ESC; 461 } 462 break; 463 #if 0 464 case CSI: /* 8-bit */ 465 /* XXX cancel current escape sequence */ 466 edp->nargs = 0; 467 memset(edp->args, 0, sizeof (edp->args)); 468 edp->modif1 = edp->modif2 = '\0'; 469 edp->state = VT100_EMUL_STATE_CSI; 470 break; 471 case DCS: /* 8-bit */ 472 /* XXX cancel current escape sequence */ 473 edp->nargs = 0; 474 memset(edp->args, 0, sizeof (edp->args)); 475 edp->state = VT100_EMUL_STATE_DCS; 476 break; 477 case ST: /* string end 8-bit */ 478 /* XXX only in VT100_EMUL_STATE_STRING */ 479 wsemul_vt100_handle_dcs(edp); 480 return (VT100_EMUL_STATE_NORMAL); 481 #endif 482 case ASCII_LF: 483 case ASCII_VT: 484 case ASCII_FF: 485 wsemul_vt100_nextline(edp); 486 break; 487 } 488 } 489 490 static u_int 491 wsemul_vt100_output_esc(struct wsemul_vt100_emuldata *edp, u_char c) 492 { 493 struct vt100base_data *vd = &edp->bd; 494 u_int newstate = VT100_EMUL_STATE_NORMAL; 495 int i; 496 497 switch (c) { 498 case '[': /* CSI */ 499 vd->nargs = 0; 500 memset(vd->args, 0, sizeof (vd->args)); 501 vd->modif1 = vd->modif2 = '\0'; 502 newstate = VT100_EMUL_STATE_CSI; 503 break; 504 case '7': /* DECSC */ 505 vd->flags |= VTFL_SAVEDCURS; 506 edp->savedcursor_row = vd->crow; 507 edp->savedcursor_col = vd->ccol; 508 edp->savedattr = vd->curattr; 509 edp->savedbkgdattr = vd->bkgdattr; 510 edp->savedattrflags = vd->attrflags; 511 edp->savedfgcol = vd->fgcol; 512 edp->savedbgcol = vd->bgcol; 513 for (i = 0; i < 4; i++) 514 edp->savedchartab_G[i] = edp->chartab_G[i]; 515 edp->savedchartab0 = edp->chartab0; 516 edp->savedchartab1 = edp->chartab1; 517 break; 518 case '8': /* DECRC */ 519 if ((vd->flags & VTFL_SAVEDCURS) == 0) 520 break; 521 vd->crow = edp->savedcursor_row; 522 vd->ccol = edp->savedcursor_col; 523 vd->curattr = edp->savedattr; 524 vd->bkgdattr = edp->savedbkgdattr; 525 vd->attrflags = edp->savedattrflags; 526 vd->fgcol = edp->savedfgcol; 527 vd->bgcol = edp->savedbgcol; 528 for (i = 0; i < 4; i++) 529 edp->chartab_G[i] = edp->savedchartab_G[i]; 530 edp->chartab0 = edp->savedchartab0; 531 edp->chartab1 = edp->savedchartab1; 532 break; 533 case '=': /* DECKPAM application mode */ 534 vd->flags |= VTFL_APPLKEYPAD; 535 break; 536 case '>': /* DECKPNM numeric mode */ 537 vd->flags &= ~VTFL_APPLKEYPAD; 538 break; 539 case 'E': /* NEL */ 540 vd->ccol = 0; 541 /* FALLTHRU */ 542 case 'D': /* IND */ 543 wsemul_vt100_nextline(edp); 544 break; 545 case 'H': /* HTS */ 546 KASSERT(vd->tabs != 0); 547 vd->tabs[vd->ccol] = 1; 548 break; 549 case '~': /* LS1R */ 550 edp->chartab1 = 1; 551 break; 552 case 'n': /* LS2 */ 553 edp->chartab0 = 2; 554 break; 555 case '}': /* LS2R */ 556 edp->chartab1 = 2; 557 break; 558 case 'o': /* LS3 */ 559 edp->chartab0 = 3; 560 break; 561 case '|': /* LS3R */ 562 edp->chartab1 = 3; 563 break; 564 case 'N': /* SS2 */ 565 edp->sschartab = 2; 566 break; 567 case 'O': /* SS3 */ 568 edp->sschartab = 3; 569 break; 570 case 'M': /* RI */ 571 if (ROWS_ABOVE(vd) > 0) { 572 vd->crow--; 573 CHECK_DW(vd); 574 break; 575 } 576 wsemul_vt100_scrolldown(vd, 1); 577 break; 578 case 'P': /* DCS */ 579 vd->nargs = 0; 580 memset(vd->args, 0, sizeof (vd->args)); 581 newstate = VT100_EMUL_STATE_DCS; 582 break; 583 case 'c': /* RIS */ 584 wsemul_vt100_reset(edp); 585 wsemul_vt100_ed(vd, 2); 586 vd->ccol = vd->crow = 0; 587 break; 588 case '(': case ')': case '*': case '+': /* SCS */ 589 edp->designating = c - '('; 590 newstate = VT100_EMUL_STATE_SCS94; 591 break; 592 case '-': case '.': case '/': /* SCS */ 593 edp->designating = c - '-' + 1; 594 newstate = VT100_EMUL_STATE_SCS96; 595 break; 596 case '#': 597 newstate = VT100_EMUL_STATE_ESC_HASH; 598 break; 599 case ' ': /* 7/8 bit */ 600 newstate = VT100_EMUL_STATE_ESC_SPC; 601 break; 602 case ']': /* OSC operating system command */ 603 case '^': /* PM privacy message */ 604 case '_': /* APC application program command */ 605 /* ignored */ 606 newstate = VT100_EMUL_STATE_STRING; 607 break; 608 case '<': /* exit VT52 mode - ignored */ 609 break; 610 default: 611 #ifdef VT100_PRINTUNKNOWN 612 printf("ESC%c unknown\n", c); 613 #endif 614 break; 615 } 616 617 return (newstate); 618 } 619 620 static u_int 621 wsemul_vt100_output_scs94(struct wsemul_vt100_emuldata *edp, u_char c) 622 { 623 u_int newstate = VT100_EMUL_STATE_NORMAL; 624 625 switch (c) { 626 case '%': /* probably DEC supplemental graphic */ 627 newstate = VT100_EMUL_STATE_SCS94_PERCENT; 628 break; 629 case 'A': /* british / national */ 630 edp->chartab_G[edp->designating] = edp->nrctab; 631 break; 632 case 'B': /* ASCII */ 633 edp->chartab_G[edp->designating] = 0; 634 break; 635 case '<': /* user preferred supplemental */ 636 /* XXX not really "user" preferred */ 637 edp->chartab_G[edp->designating] = edp->isolatin1tab; 638 break; 639 case '0': /* DEC special graphic */ 640 edp->chartab_G[edp->designating] = edp->decgraphtab; 641 break; 642 case '>': /* DEC tech */ 643 edp->chartab_G[edp->designating] = edp->dectechtab; 644 break; 645 default: 646 #ifdef VT100_PRINTUNKNOWN 647 printf("ESC%c%c unknown\n", edp->designating + '(', c); 648 #endif 649 break; 650 } 651 return (newstate); 652 } 653 654 static u_int 655 wsemul_vt100_output_scs94_percent(struct wsemul_vt100_emuldata *edp, u_char c) 656 { 657 switch (c) { 658 case '5': /* DEC supplemental graphic */ 659 /* XXX there are differences */ 660 edp->chartab_G[edp->designating] = edp->isolatin1tab; 661 break; 662 default: 663 #ifdef VT100_PRINTUNKNOWN 664 printf("ESC%c%%%c unknown\n", edp->designating + '(', c); 665 #endif 666 break; 667 } 668 return (VT100_EMUL_STATE_NORMAL); 669 } 670 671 static u_int 672 wsemul_vt100_output_scs96(struct wsemul_vt100_emuldata *edp, u_char c) 673 { 674 u_int newstate = VT100_EMUL_STATE_NORMAL; 675 int nrc; 676 677 switch (c) { 678 case '%': /* probably portuguese */ 679 newstate = VT100_EMUL_STATE_SCS96_PERCENT; 680 break; 681 case 'A': /* ISO-latin-1 supplemental */ 682 edp->chartab_G[edp->designating] = edp->isolatin1tab; 683 break; 684 case '4': /* dutch */ 685 nrc = 1; 686 goto setnrc; 687 case '5': case 'C': /* finnish */ 688 nrc = 2; 689 goto setnrc; 690 case 'R': /* french */ 691 nrc = 3; 692 goto setnrc; 693 case 'Q': /* french canadian */ 694 nrc = 4; 695 goto setnrc; 696 case 'K': /* german */ 697 nrc = 5; 698 goto setnrc; 699 case 'Y': /* italian */ 700 nrc = 6; 701 goto setnrc; 702 case 'E': case '6': /* norwegian / danish */ 703 nrc = 7; 704 goto setnrc; 705 case 'Z': /* spanish */ 706 nrc = 9; 707 goto setnrc; 708 case '7': case 'H': /* swedish */ 709 nrc = 10; 710 goto setnrc; 711 case '=': /* swiss */ 712 nrc = 11; 713 setnrc: 714 vt100_setnrc(edp, nrc); /* what table ??? */ 715 break; 716 default: 717 #ifdef VT100_PRINTUNKNOWN 718 printf("ESC%c%c unknown\n", edp->designating + '-' - 1, c); 719 #endif 720 break; 721 } 722 return (newstate); 723 } 724 725 static u_int 726 wsemul_vt100_output_scs96_percent(struct wsemul_vt100_emuldata *edp, u_char c) 727 { 728 switch (c) { 729 case '6': /* portuguese */ 730 vt100_setnrc(edp, 8); 731 break; 732 default: 733 #ifdef VT100_PRINTUNKNOWN 734 printf("ESC%c%%%c unknown\n", edp->designating + '-', c); 735 #endif 736 break; 737 } 738 return (VT100_EMUL_STATE_NORMAL); 739 } 740 741 static u_int 742 wsemul_vt100_output_esc_spc(struct wsemul_vt100_emuldata *edp, 743 u_char c) 744 { 745 switch (c) { 746 case 'F': /* 7-bit controls */ 747 case 'G': /* 8-bit controls */ 748 #ifdef VT100_PRINTNOTIMPL 749 printf("ESC<SPC>%c ignored\n", c); 750 #endif 751 break; 752 default: 753 #ifdef VT100_PRINTUNKNOWN 754 printf("ESC<SPC>%c unknown\n", c); 755 #endif 756 break; 757 } 758 return (VT100_EMUL_STATE_NORMAL); 759 } 760 761 static u_int 762 wsemul_vt100_output_string(struct wsemul_vt100_emuldata *edp, u_char c) 763 { 764 struct vt100base_data *vd = &edp->bd; 765 766 if (vd->dcstype && vd->dcspos < DCS_MAXLEN) 767 vd->dcsarg[vd->dcspos++] = c; 768 return (VT100_EMUL_STATE_STRING); 769 } 770 771 static u_int 772 wsemul_vt100_output_string_esc(struct wsemul_vt100_emuldata *edp, u_char c) 773 { 774 struct vt100base_data *vd = &edp->bd; 775 776 if (c == '\\') { /* ST complete */ 777 wsemul_vt100_handle_dcs(vd); 778 return (VT100_EMUL_STATE_NORMAL); 779 } else 780 return (VT100_EMUL_STATE_STRING); 781 } 782 783 static u_int 784 wsemul_vt100_output_dcs(struct wsemul_vt100_emuldata *edp, u_char c) 785 { 786 struct vt100base_data *vd = &edp->bd; 787 u_int newstate = VT100_EMUL_STATE_DCS; 788 789 switch (c) { 790 case '0': case '1': case '2': case '3': case '4': 791 case '5': case '6': case '7': case '8': case '9': 792 /* argument digit */ 793 if (vd->nargs > VT100_EMUL_NARGS - 1) 794 break; 795 vd->args[vd->nargs] = (vd->args[vd->nargs] * 10) + 796 (c - '0'); 797 break; 798 case ';': /* argument terminator */ 799 vd->nargs++; 800 break; 801 default: 802 vd->nargs++; 803 if (vd->nargs > VT100_EMUL_NARGS) { 804 #ifdef VT100_DEBUG 805 printf("vt100: too many arguments\n"); 806 #endif 807 vd->nargs = VT100_EMUL_NARGS; 808 } 809 newstate = VT100_EMUL_STATE_STRING; 810 switch (c) { 811 case '$': 812 newstate = VT100_EMUL_STATE_DCS_DOLLAR; 813 break; 814 case '{': /* DECDLD soft charset */ 815 case '!': /* DECRQUPSS user preferred supplemental set */ 816 /* 'u' must follow - need another state */ 817 case '|': /* DECUDK program F6..F20 */ 818 #ifdef VT100_PRINTNOTIMPL 819 printf("DCS%c ignored\n", c); 820 #endif 821 break; 822 default: 823 #ifdef VT100_PRINTUNKNOWN 824 printf("DCS%c (%d, %d) unknown\n", c, ARG(vd, 0), ARG(vd, 1)); 825 #endif 826 break; 827 } 828 } 829 830 return (newstate); 831 } 832 833 static u_int 834 wsemul_vt100_output_dcs_dollar(struct wsemul_vt100_emuldata *edp, u_char c) 835 { 836 struct vt100base_data *vd = &edp->bd; 837 838 switch (c) { 839 case 'p': /* DECRSTS terminal state restore */ 840 case 'q': /* DECRQSS control function request */ 841 #ifdef VT100_PRINTNOTIMPL 842 printf("DCS$%c ignored\n", c); 843 #endif 844 break; 845 case 't': /* DECRSPS restore presentation state */ 846 switch (ARG(vd, 0)) { 847 case 0: /* error */ 848 break; 849 case 1: /* cursor information restore */ 850 #ifdef VT100_PRINTNOTIMPL 851 printf("DCS1$t ignored\n"); 852 #endif 853 break; 854 case 2: /* tab stop restore */ 855 vd->dcspos = 0; 856 vd->dcstype = DCSTYPE_TABRESTORE; 857 break; 858 default: 859 #ifdef VT100_PRINTUNKNOWN 860 printf("DCS%d$t unknown\n", ARG(vd, 0)); 861 #endif 862 break; 863 } 864 break; 865 default: 866 #ifdef VT100_PRINTUNKNOWN 867 printf("DCS$%c (%d, %d) unknown\n", c, ARG(vd, 0), ARG(vd, 1)); 868 #endif 869 break; 870 } 871 return (VT100_EMUL_STATE_STRING); 872 } 873 874 static u_int 875 wsemul_vt100_output_esc_hash(struct wsemul_vt100_emuldata *edp, u_char c) 876 { 877 struct vt100base_data *vd = &edp->bd; 878 int i, j; 879 880 switch (c) { 881 case '5': /* DECSWL single width, single height */ 882 if (vd->dw) { 883 for (i = 0; i < vd->ncols / 2; i++) 884 (*vd->emulops->copycols)(vd->emulcookie, 885 vd->crow, 886 2 * i, i, 1); 887 (*vd->emulops->erasecols)(vd->emulcookie, vd->crow, 888 i, vd->ncols - i, 889 vd->bkgdattr); 890 vd->dblwid[vd->crow] = 0; 891 vd->dw = 0; 892 } 893 break; 894 case '6': /* DECDWL double width, single height */ 895 case '3': /* DECDHL double width, double height, top half */ 896 case '4': /* DECDHL double width, double height, bottom half */ 897 if (!vd->dw) { 898 for (i = vd->ncols / 2 - 1; i >= 0; i--) 899 (*vd->emulops->copycols)(vd->emulcookie, 900 vd->crow, 901 i, 2 * i, 1); 902 for (i = 0; i < vd->ncols / 2; i++) 903 (*vd->emulops->erasecols)(vd->emulcookie, 904 vd->crow, 905 2 * i + 1, 1, 906 vd->bkgdattr); 907 vd->dblwid[vd->crow] = 1; 908 vd->dw = 1; 909 if (vd->ccol > (vd->ncols >> 1) - 1) 910 vd->ccol = (vd->ncols >> 1) - 1; 911 } 912 break; 913 case '8': /* DECALN */ 914 for (i = 0; i < vd->nrows; i++) 915 for (j = 0; j < vd->ncols; j++) 916 (*vd->emulops->putchar)(vd->emulcookie, i, j, 917 'E', vd->curattr); 918 vd->ccol = 0; 919 vd->crow = 0; 920 break; 921 default: 922 #ifdef VT100_PRINTUNKNOWN 923 printf("ESC#%c unknown\n", c); 924 #endif 925 break; 926 } 927 return (VT100_EMUL_STATE_NORMAL); 928 } 929 930 static u_int 931 wsemul_vt100_output_csi(struct wsemul_vt100_emuldata *edp, u_char c) 932 { 933 struct vt100base_data *vd = &edp->bd; 934 u_int newstate = VT100_EMUL_STATE_CSI; 935 936 switch (c) { 937 case '0': case '1': case '2': case '3': case '4': 938 case '5': case '6': case '7': case '8': case '9': 939 /* argument digit */ 940 if (vd->nargs > VT100_EMUL_NARGS - 1) 941 break; 942 vd->args[vd->nargs] = (vd->args[vd->nargs] * 10) + 943 (c - '0'); 944 break; 945 case ';': /* argument terminator */ 946 vd->nargs++; 947 break; 948 case '?': /* DEC specific */ 949 case '>': /* DA query */ 950 vd->modif1 = c; 951 break; 952 case '!': 953 case '"': 954 case '$': 955 case '&': 956 vd->modif2 = c; 957 break; 958 default: /* end of escape sequence */ 959 vd->nargs++; 960 if (vd->nargs > VT100_EMUL_NARGS) { 961 #ifdef VT100_DEBUG 962 printf("vt100: too many arguments\n"); 963 #endif 964 vd->nargs = VT100_EMUL_NARGS; 965 } 966 wsemul_vt100_handle_csi(vd, c); 967 newstate = VT100_EMUL_STATE_NORMAL; 968 break; 969 } 970 return (newstate); 971 } 972 973 void 974 wsemul_vt100_output(void *cookie, const u_char *data, u_int count, int kernel) 975 { 976 struct wsemul_vt100_emuldata *edp = cookie; 977 struct vt100base_data *vd = &edp->bd; 978 979 #ifdef DIAGNOSTIC 980 if (kernel && !edp->console) 981 panic("wsemul_vt100_output: kernel output, not console"); 982 #endif 983 984 if (vd->flags & VTFL_CURSORON) 985 (*vd->emulops->cursor)(vd->emulcookie, 0, 986 vd->crow, vd->ccol << vd->dw); 987 for (; count > 0; data++, count--) { 988 if ((*data & 0x7f) < 0x20) { 989 wsemul_vt100_output_c0c1(edp, *data, kernel); 990 continue; 991 } 992 if (edp->state == VT100_EMUL_STATE_NORMAL || kernel) { 993 wsemul_vt100_output_normal(edp, *data, kernel); 994 continue; 995 } 996 #ifdef DIAGNOSTIC 997 if (edp->state > sizeof(vt100_output) / sizeof(vt100_output[0])) 998 panic("wsemul_vt100: invalid state %d", edp->state); 999 #endif 1000 edp->state = vt100_output[edp->state - 1](edp, *data); 1001 } 1002 if (vd->flags & VTFL_CURSORON) 1003 (*vd->emulops->cursor)(vd->emulcookie, 1, 1004 vd->crow, vd->ccol << vd->dw); 1005 } 1006 1007 #ifdef WSDISPLAY_CUSTOM_OUTPUT 1008 static void 1009 wsemul_vt100_getmsgattrs(void *cookie, struct wsdisplay_msgattrs *ma) 1010 { 1011 struct wsemul_vt100_emuldata *edp = cookie; 1012 struct vt100base_data *vd = &edp->bd; 1013 1014 *ma = vd->msgattrs; 1015 } 1016 1017 static void 1018 wsemul_vt100_setmsgattrs(void *cookie, const struct wsscreen_descr *type, 1019 const struct wsdisplay_msgattrs *ma) 1020 { 1021 int error; 1022 long tmp; 1023 struct wsemul_vt100_emuldata *edp = cookie; 1024 struct vt100base_data *vd = &edp->bd; 1025 1026 vd->msgattrs = *ma; 1027 if (type->capabilities & WSSCREEN_WSCOLORS) { 1028 vd->msgattrs.default_attrs |= WSATTR_WSCOLORS; 1029 vd->msgattrs.kernel_attrs |= WSATTR_WSCOLORS; 1030 } else { 1031 vd->msgattrs.default_bg = vd->msgattrs.kernel_bg = 0; 1032 vd->msgattrs.default_fg = vd->msgattrs.kernel_fg = 0; 1033 } 1034 1035 error = (*vd->emulops->allocattr)(vd->emulcookie, 1036 vd->msgattrs.default_fg, 1037 vd->msgattrs.default_bg, 1038 vd->msgattrs.default_attrs, 1039 &tmp); 1040 #ifndef VT100_DEBUG 1041 __USE(error); 1042 #else 1043 if (error) 1044 printf("vt100: failed to allocate attribute for default " 1045 "messages\n"); 1046 else 1047 #endif 1048 { 1049 if (vd->curattr == vd->defattr) { 1050 vd->bkgdattr = vd->curattr = tmp; 1051 vd->attrflags = vd->msgattrs.default_attrs; 1052 vd->bgcol = vd->msgattrs.default_bg; 1053 vd->fgcol = vd->msgattrs.default_fg; 1054 } else { 1055 edp->savedbkgdattr = edp->savedattr = tmp; 1056 edp->savedattrflags = vd->msgattrs.default_attrs; 1057 edp->savedbgcol = vd->msgattrs.default_bg; 1058 edp->savedfgcol = vd->msgattrs.default_fg; 1059 } 1060 if (vd->emulops->replaceattr != NULL) 1061 (*vd->emulops->replaceattr)(vd->emulcookie, 1062 vd->defattr, tmp); 1063 vd->defattr = tmp; 1064 } 1065 1066 error = (*vd->emulops->allocattr)(vd->emulcookie, 1067 vd->msgattrs.kernel_fg, 1068 vd->msgattrs.kernel_bg, 1069 vd->msgattrs.kernel_attrs, 1070 &tmp); 1071 #ifdef VT100_DEBUG 1072 if (error) 1073 printf("vt100: failed to allocate attribute for kernel " 1074 "messages\n"); 1075 else 1076 #endif 1077 { 1078 if (vd->emulops->replaceattr != NULL) 1079 (*vd->emulops->replaceattr)(vd->emulcookie, 1080 edp->kernattr, tmp); 1081 edp->kernattr = tmp; 1082 } 1083 } 1084 #endif /* WSDISPLAY_CUSTOM_OUTPUT */ 1085
Indexes created Mon Sep 29 21:09:56 GMT 2025