Annotation of sys/dev/wscons/wsemul_sun.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: wsemul_sun.c,v 1.20 2007/02/14 01:12:16 jsg Exp $ */
! 2: /* $NetBSD: wsemul_sun.c,v 1.11 2000/01/05 11:19:36 drochner Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1996, 1997 Christopher G. Demetriou. 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: * 3. All advertising materials mentioning features or use of this software
! 16: * must display the following acknowledgement:
! 17: * This product includes software developed by Christopher G. Demetriou
! 18: * for the NetBSD Project.
! 19: * 4. The name of the author may not be used to endorse or promote products
! 20: * derived from this software without specific prior written permission
! 21: *
! 22: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 23: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 24: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 25: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 26: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 27: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 28: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 29: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 30: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 31: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 32: */
! 33:
! 34: /*
! 35: * This file implements a sun terminal personality for wscons.
! 36: *
! 37: * Derived from old rcons code.
! 38: * Color support from NetBSD's rcons color code, and wsemul_vt100.
! 39: */
! 40:
! 41: #ifndef SMALL_KERNEL
! 42: #define JUMP_SCROLL
! 43: #endif
! 44:
! 45: #include <sys/param.h>
! 46: #include <sys/systm.h>
! 47: #include <sys/time.h>
! 48: #include <sys/malloc.h>
! 49: #include <sys/fcntl.h>
! 50:
! 51: #include <dev/wscons/wsconsio.h>
! 52: #include <dev/wscons/wsdisplayvar.h>
! 53: #include <dev/wscons/wsemulvar.h>
! 54: #include <dev/wscons/wsksymdef.h>
! 55: #include <dev/wscons/ascii.h>
! 56:
! 57: void *wsemul_sun_cnattach(const struct wsscreen_descr *, void *,
! 58: int, int, long);
! 59: void *wsemul_sun_attach(int, const struct wsscreen_descr *,
! 60: void *, int, int, void *, long);
! 61: void wsemul_sun_output(void *, const u_char *, u_int, int);
! 62: int wsemul_sun_translate(void *, keysym_t, char **);
! 63: void wsemul_sun_detach(void *, u_int *, u_int *);
! 64: void wsemul_sun_resetop(void *, enum wsemul_resetops);
! 65:
! 66: const struct wsemul_ops wsemul_sun_ops = {
! 67: "sun",
! 68: wsemul_sun_cnattach,
! 69: wsemul_sun_attach,
! 70: wsemul_sun_output,
! 71: wsemul_sun_translate,
! 72: wsemul_sun_detach,
! 73: wsemul_sun_resetop
! 74: };
! 75:
! 76: #define SUN_EMUL_STATE_NORMAL 0 /* normal processing */
! 77: #define SUN_EMUL_STATE_HAVEESC 1 /* seen start of ctl seq */
! 78: #define SUN_EMUL_STATE_CONTROL 2 /* processing ctl seq */
! 79:
! 80: #define SUN_EMUL_NARGS 2 /* max # of args to a command */
! 81:
! 82: struct wsemul_sun_emuldata {
! 83: const struct wsdisplay_emulops *emulops;
! 84: void *emulcookie;
! 85: void *cbcookie;
! 86: int scrcapabilities;
! 87: u_int nrows, ncols, crow, ccol;
! 88: long defattr; /* default attribute (rendition) */
! 89:
! 90: u_int state; /* processing state */
! 91: u_int args[SUN_EMUL_NARGS]; /* command args, if CONTROL */
! 92: int nargs; /* number of args */
! 93:
! 94: u_int scrolldist; /* distance to scroll */
! 95: long curattr, bkgdattr; /* currently used attribute */
! 96: long kernattr; /* attribute for kernel output */
! 97: int attrflags, fgcol, bgcol; /* properties of curattr */
! 98:
! 99: #ifdef DIAGNOSTIC
! 100: int console;
! 101: #endif
! 102: };
! 103:
! 104: void wsemul_sun_init(struct wsemul_sun_emuldata *,
! 105: const struct wsscreen_descr *, void *, int, int, long);
! 106: void wsemul_sun_reset(struct wsemul_sun_emuldata *);
! 107: void wsemul_sun_output_lowchars(struct wsemul_sun_emuldata *, u_char, int);
! 108: void wsemul_sun_output_normal(struct wsemul_sun_emuldata *, u_char, int);
! 109: u_int wsemul_sun_output_haveesc(struct wsemul_sun_emuldata *, u_char);
! 110: u_int wsemul_sun_output_control(struct wsemul_sun_emuldata *, u_char);
! 111: void wsemul_sun_control(struct wsemul_sun_emuldata *, u_char);
! 112: int wsemul_sun_selectattribute(struct wsemul_sun_emuldata *, int, int, int,
! 113: long *, long *);
! 114: void wsemul_sun_scrollup(struct wsemul_sun_emuldata *, u_int);
! 115:
! 116: struct wsemul_sun_emuldata wsemul_sun_console_emuldata;
! 117:
! 118: /* some useful utility macros */
! 119: #define ARG(n,c) \
! 120: ((n) >= edp->nargs ? 0 : edp->args[(n) + MAX(0, edp->nargs - (c))])
! 121: #define NORMALIZE(arg) ((arg) != 0 ? (arg) : 1)
! 122: #define COLS_LEFT (edp->ncols - 1 - edp->ccol)
! 123: #define ROWS_LEFT (edp->nrows - 1 - edp->crow)
! 124:
! 125: void
! 126: wsemul_sun_init(edp, type, cookie, ccol, crow, defattr)
! 127: struct wsemul_sun_emuldata *edp;
! 128: const struct wsscreen_descr *type;
! 129: void *cookie;
! 130: int ccol, crow;
! 131: long defattr;
! 132: {
! 133: edp->emulops = type->textops;
! 134: edp->emulcookie = cookie;
! 135: edp->scrcapabilities = type->capabilities;
! 136: edp->nrows = type->nrows;
! 137: edp->ncols = type->ncols;
! 138: edp->crow = crow;
! 139: edp->ccol = ccol;
! 140: edp->defattr = defattr;
! 141: }
! 142:
! 143: void
! 144: wsemul_sun_reset(edp)
! 145: struct wsemul_sun_emuldata *edp;
! 146: {
! 147: edp->state = SUN_EMUL_STATE_NORMAL;
! 148: edp->bkgdattr = edp->curattr = edp->defattr;
! 149: edp->attrflags = 0;
! 150: edp->fgcol = WSCOL_BLACK;
! 151: edp->bgcol = WSCOL_WHITE;
! 152: edp->scrolldist = 1;
! 153: }
! 154:
! 155: void *
! 156: wsemul_sun_cnattach(type, cookie, ccol, crow, defattr)
! 157: const struct wsscreen_descr *type;
! 158: void *cookie;
! 159: int ccol, crow;
! 160: long defattr;
! 161: {
! 162: struct wsemul_sun_emuldata *edp;
! 163: int res;
! 164:
! 165: edp = &wsemul_sun_console_emuldata;
! 166: wsemul_sun_init(edp, type, cookie, ccol, crow, defattr);
! 167:
! 168: #ifndef WS_KERNEL_FG
! 169: #define WS_KERNEL_FG WSCOL_BLACK
! 170: #endif
! 171: #ifndef WS_KERNEL_BG
! 172: #define WS_KERNEL_BG WSCOL_WHITE
! 173: #endif
! 174: #ifndef WS_KERNEL_COLATTR
! 175: #define WS_KERNEL_COLATTR 0
! 176: #endif
! 177: #ifndef WS_KERNEL_MONOATTR
! 178: #define WS_KERNEL_MONOATTR 0
! 179: #endif
! 180: if (type->capabilities & WSSCREEN_WSCOLORS)
! 181: res = (*edp->emulops->alloc_attr)(cookie,
! 182: WS_KERNEL_FG, WS_KERNEL_BG,
! 183: WS_KERNEL_COLATTR | WSATTR_WSCOLORS,
! 184: &edp->kernattr);
! 185: else
! 186: res = (*edp->emulops->alloc_attr)(cookie, 0, 0,
! 187: WS_KERNEL_MONOATTR,
! 188: &edp->kernattr);
! 189: if (res)
! 190: edp->kernattr = defattr;
! 191:
! 192: edp->cbcookie = NULL;
! 193:
! 194: #ifdef DIAGNOSTIC
! 195: edp->console = 1;
! 196: #endif
! 197:
! 198: wsemul_sun_reset(edp);
! 199: return (edp);
! 200: }
! 201:
! 202: void *
! 203: wsemul_sun_attach(console, type, cookie, ccol, crow, cbcookie, defattr)
! 204: int console;
! 205: const struct wsscreen_descr *type;
! 206: void *cookie;
! 207: int ccol, crow;
! 208: void *cbcookie;
! 209: long defattr;
! 210: {
! 211: struct wsemul_sun_emuldata *edp;
! 212:
! 213: if (console) {
! 214: edp = &wsemul_sun_console_emuldata;
! 215: #ifdef DIAGNOSTIC
! 216: KASSERT(edp->console == 1);
! 217: #endif
! 218: } else {
! 219: edp = malloc(sizeof *edp, M_DEVBUF, M_NOWAIT);
! 220: if (edp == NULL)
! 221: return (NULL);
! 222: wsemul_sun_init(edp, type, cookie, ccol, crow, defattr);
! 223:
! 224: #ifdef DIAGNOSTIC
! 225: edp->console = 0;
! 226: #endif
! 227: }
! 228:
! 229: edp->cbcookie = cbcookie;
! 230:
! 231: wsemul_sun_reset(edp);
! 232: return (edp);
! 233: }
! 234:
! 235: void
! 236: wsemul_sun_output_lowchars(edp, c, kernel)
! 237: struct wsemul_sun_emuldata *edp;
! 238: u_char c;
! 239: int kernel;
! 240: {
! 241: u_int n;
! 242:
! 243: switch (c) {
! 244: case ASCII_NUL:
! 245: default:
! 246: /* ignore */
! 247: break;
! 248:
! 249: case ASCII_BEL: /* "Bell (BEL)" */
! 250: wsdisplay_emulbell(edp->cbcookie);
! 251: break;
! 252:
! 253: case ASCII_BS: /* "Backspace (BS)" */
! 254: if (edp->ccol > 0)
! 255: edp->ccol--;
! 256: break;
! 257:
! 258: case ASCII_CR: /* "Return (CR)" */
! 259: edp->ccol = 0;
! 260: break;
! 261:
! 262: case ASCII_HT: /* "Tab (TAB)" */
! 263: n = min(8 - (edp->ccol & 7), COLS_LEFT);
! 264: if (n != 0) {
! 265: (*edp->emulops->erasecols)(edp->emulcookie, edp->crow,
! 266: edp->ccol, n,
! 267: kernel ? edp->kernattr : edp->bkgdattr);
! 268: edp->ccol += n;
! 269: }
! 270: break;
! 271:
! 272: case ASCII_FF: /* "Form Feed (FF)" */
! 273: (*edp->emulops->eraserows)(edp->emulcookie, 0, edp->nrows,
! 274: edp->bkgdattr);
! 275: edp->ccol = edp->crow = 0;
! 276: break;
! 277:
! 278: case ASCII_VT: /* "Reverse Line Feed" */
! 279: if (edp->crow > 0)
! 280: edp->crow--;
! 281: break;
! 282:
! 283: case ASCII_ESC: /* "Escape (ESC)" */
! 284: if (kernel) {
! 285: printf("wsemul_sun_output_lowchars: ESC in kernel "
! 286: "output ignored\n");
! 287: break; /* ignore the ESC */
! 288: }
! 289:
! 290: edp->state = SUN_EMUL_STATE_HAVEESC;
! 291: break;
! 292:
! 293: case ASCII_LF: /* "Line Feed (LF)" */
! 294: /* if the cur line isn't the last, incr and leave. */
! 295: if (ROWS_LEFT > 0)
! 296: edp->crow++;
! 297: else
! 298: wsemul_sun_scrollup(edp, edp->scrolldist);
! 299: break;
! 300: }
! 301: }
! 302:
! 303: void
! 304: wsemul_sun_output_normal(edp, c, kernel)
! 305: struct wsemul_sun_emuldata *edp;
! 306: u_char c;
! 307: int kernel;
! 308: {
! 309:
! 310: (*edp->emulops->putchar)(edp->emulcookie, edp->crow, edp->ccol,
! 311: c, kernel ? edp->kernattr : edp->curattr);
! 312:
! 313: if (++edp->ccol >= edp->ncols) {
! 314: /* if the cur line isn't the last, incr and leave. */
! 315: if (ROWS_LEFT > 0)
! 316: edp->crow++;
! 317: else
! 318: wsemul_sun_scrollup(edp, edp->scrolldist);
! 319: edp->ccol = 0;
! 320: }
! 321: }
! 322:
! 323: u_int
! 324: wsemul_sun_output_haveesc(edp, c)
! 325: struct wsemul_sun_emuldata *edp;
! 326: u_char c;
! 327: {
! 328: u_int newstate;
! 329:
! 330: switch (c) {
! 331: case '[': /* continuation of multi-char sequence */
! 332: edp->nargs = 0;
! 333: bzero(edp->args, sizeof (edp->args));
! 334: newstate = SUN_EMUL_STATE_CONTROL;
! 335: break;
! 336:
! 337: default:
! 338: #ifdef DEBUG
! 339: printf("ESC%c unknown\n", c);
! 340: #endif
! 341: newstate = SUN_EMUL_STATE_NORMAL; /* XXX is this wise? */
! 342: break;
! 343: }
! 344:
! 345: return (newstate);
! 346: }
! 347:
! 348: void
! 349: wsemul_sun_control(edp, c)
! 350: struct wsemul_sun_emuldata *edp;
! 351: u_char c;
! 352: {
! 353: u_int n, src, dst;
! 354: int flags, fgcol, bgcol;
! 355: long attr, bkgdattr;
! 356:
! 357: switch (c) {
! 358: case '@': /* "Insert Character (ICH)" */
! 359: n = min(NORMALIZE(ARG(0,1)), COLS_LEFT + 1);
! 360: src = edp->ccol;
! 361: dst = edp->ccol + n;
! 362: if (dst < edp->ncols) {
! 363: (*edp->emulops->copycols)(edp->emulcookie, edp->crow,
! 364: src, dst, edp->ncols - dst);
! 365: }
! 366: (*edp->emulops->erasecols)(edp->emulcookie, edp->crow,
! 367: src, n, edp->bkgdattr);
! 368: break;
! 369:
! 370: case 'A': /* "Cursor Up (CUU)" */
! 371: edp->crow -= min(NORMALIZE(ARG(0,1)), edp->crow);
! 372: break;
! 373:
! 374: case 'E': /* "Cursor Next Line (CNL)" */
! 375: edp->ccol = 0;
! 376: /* FALLTHROUGH */
! 377: case 'B': /* "Cursor Down (CUD)" */
! 378: edp->crow += min(NORMALIZE(ARG(0,1)), ROWS_LEFT);
! 379: break;
! 380:
! 381: case 'C': /* "Cursor Forward (CUF)" */
! 382: edp->ccol += min(NORMALIZE(ARG(0,1)), COLS_LEFT);
! 383: break;
! 384:
! 385: case 'D': /* "Cursor Backward (CUB)" */
! 386: edp->ccol -= min(NORMALIZE(ARG(0,1)), edp->ccol);
! 387: break;
! 388:
! 389: case 'f': /* "Horizontal And Vertical Position (HVP)" */
! 390: case 'H': /* "Cursor Position (CUP)" */
! 391: edp->crow = min(NORMALIZE(ARG(0,2)), edp->nrows) - 1;
! 392: edp->ccol = min(NORMALIZE(ARG(1,2)), edp->ncols) - 1;
! 393: break;
! 394:
! 395: case 'J': /* "Erase in Display (ED)" */
! 396: if (ROWS_LEFT > 0) {
! 397: (*edp->emulops->eraserows)(edp->emulcookie,
! 398: edp->crow + 1, ROWS_LEFT, edp->bkgdattr);
! 399: }
! 400: /* FALLTHROUGH */
! 401: case 'K': /* "Erase in Line (EL)" */
! 402: (*edp->emulops->erasecols)(edp->emulcookie, edp->crow,
! 403: edp->ccol, COLS_LEFT + 1, edp->bkgdattr);
! 404: break;
! 405:
! 406: case 'L': /* "Insert Line (IL)" */
! 407: n = min(NORMALIZE(ARG(0,1)), ROWS_LEFT + 1);
! 408: src = edp->crow;
! 409: dst = edp->crow + n;
! 410: if (dst < edp->nrows) {
! 411: (*edp->emulops->copyrows)(edp->emulcookie,
! 412: src, dst, edp->nrows - dst);
! 413: }
! 414: (*edp->emulops->eraserows)(edp->emulcookie,
! 415: src, n, edp->bkgdattr);
! 416: break;
! 417:
! 418: case 'M': /* "Delete Line (DL)" */
! 419: n = min(NORMALIZE(ARG(0,1)), ROWS_LEFT + 1);
! 420: src = edp->crow + n;
! 421: dst = edp->crow;
! 422: if (src < edp->nrows) {
! 423: (*edp->emulops->copyrows)(edp->emulcookie,
! 424: src, dst, edp->nrows - src);
! 425: }
! 426: (*edp->emulops->eraserows)(edp->emulcookie,
! 427: dst + edp->nrows - src, n, edp->bkgdattr);
! 428: break;
! 429:
! 430: case 'P': /* "Delete Character (DCH)" */
! 431: n = min(NORMALIZE(ARG(0,1)), COLS_LEFT + 1);
! 432: src = edp->ccol + n;
! 433: dst = edp->ccol;
! 434: if (src < edp->ncols) {
! 435: (*edp->emulops->copycols)(edp->emulcookie, edp->crow,
! 436: src, dst, edp->ncols - src);
! 437: }
! 438: (*edp->emulops->erasecols)(edp->emulcookie, edp->crow,
! 439: edp->ncols - n, n, edp->bkgdattr);
! 440: break;
! 441:
! 442: case 'm': /* "Select Graphic Rendition (SGR)" */
! 443: flags = edp->attrflags;
! 444: fgcol = edp->fgcol;
! 445: bgcol = edp->bgcol;
! 446:
! 447: for (n = 0; n < edp->nargs; n++) {
! 448: switch (ARG(n,edp->nargs)) {
! 449: /* Clear all attributes || End underline */
! 450: case 0:
! 451: if (n == edp->nargs - 1) {
! 452: edp->bkgdattr =
! 453: edp->curattr = edp->defattr;
! 454: edp->attrflags = 0;
! 455: edp->fgcol = WSCOL_BLACK;
! 456: edp->bgcol = WSCOL_WHITE;
! 457: return;
! 458: }
! 459: flags = 0;
! 460: fgcol = WSCOL_BLACK;
! 461: bgcol = WSCOL_WHITE;
! 462: break;
! 463: /* Begin bold */
! 464: case 1:
! 465: flags |= WSATTR_HILIT;
! 466: break;
! 467: /* Begin underline */
! 468: case 4:
! 469: flags |= WSATTR_UNDERLINE;
! 470: break;
! 471: /* Begin reverse */
! 472: case 7:
! 473: flags |= WSATTR_REVERSE;
! 474: break;
! 475: /* ANSI foreground color */
! 476: case 30: case 31: case 32: case 33:
! 477: case 34: case 35: case 36: case 37:
! 478: fgcol = ARG(n,edp->nargs) - 30;
! 479: break;
! 480: /* ANSI background color */
! 481: case 40: case 41: case 42: case 43:
! 482: case 44: case 45: case 46: case 47:
! 483: bgcol = ARG(n,edp->nargs) - 40;
! 484: break;
! 485: }
! 486: }
! 487: setattr:
! 488: if (wsemul_sun_selectattribute(edp, flags, fgcol, bgcol, &attr,
! 489: &bkgdattr)) {
! 490: #ifdef DEBUG
! 491: printf("error allocating attr %d/%d/%x\n",
! 492: fgcol, bgcol, flags);
! 493: #endif
! 494: } else {
! 495: edp->curattr = attr;
! 496: edp->bkgdattr = bkgdattr;
! 497: edp->attrflags = flags;
! 498: edp->fgcol = fgcol;
! 499: edp->bgcol = bgcol;
! 500: }
! 501: break;
! 502:
! 503: case 'p': /* "Black On White (SUNBOW)" */
! 504: flags = 0;
! 505: fgcol = WSCOL_BLACK;
! 506: bgcol = WSCOL_WHITE;
! 507: goto setattr;
! 508:
! 509: case 'q': /* "White On Black (SUNWOB)" */
! 510: flags = 0;
! 511: fgcol = WSCOL_WHITE;
! 512: bgcol = WSCOL_BLACK;
! 513: goto setattr;
! 514:
! 515: case 'r': /* "Set Scrolling (SUNSCRL)" */
! 516: edp->scrolldist = min(ARG(0,1), edp->nrows);
! 517: break;
! 518:
! 519: case 's': /* "Reset Terminal Emulator (SUNRESET)" */
! 520: wsemul_sun_reset(edp);
! 521: break;
! 522: }
! 523: }
! 524:
! 525: u_int
! 526: wsemul_sun_output_control(edp, c)
! 527: struct wsemul_sun_emuldata *edp;
! 528: u_char c;
! 529: {
! 530: u_int newstate = SUN_EMUL_STATE_CONTROL;
! 531:
! 532: switch (c) {
! 533: case '0': case '1': case '2': case '3': case '4': /* argument digit */
! 534: case '5': case '6': case '7': case '8': case '9':
! 535: /*
! 536: * If we receive more arguments than we are expecting,
! 537: * discard the earliest arguments.
! 538: */
! 539: if (edp->nargs > SUN_EMUL_NARGS - 1) {
! 540: bcopy(edp->args + 1, edp->args,
! 541: (SUN_EMUL_NARGS - 1) * sizeof(edp->args[0]));
! 542: edp->args[edp->nargs = SUN_EMUL_NARGS - 1] = 0;
! 543: }
! 544: edp->args[edp->nargs] = (edp->args[edp->nargs] * 10) +
! 545: (c - '0');
! 546: break;
! 547:
! 548: case ';': /* argument terminator */
! 549: edp->nargs++;
! 550: break;
! 551:
! 552: default: /* end of escape sequence */
! 553: edp->nargs++;
! 554: if (edp->nargs > SUN_EMUL_NARGS)
! 555: edp->nargs = SUN_EMUL_NARGS;
! 556: wsemul_sun_control(edp, c);
! 557: newstate = SUN_EMUL_STATE_NORMAL;
! 558: break;
! 559: }
! 560: return (newstate);
! 561: }
! 562:
! 563: void
! 564: wsemul_sun_output(cookie, data, count, kernel)
! 565: void *cookie;
! 566: const u_char *data;
! 567: u_int count;
! 568: int kernel;
! 569: {
! 570: struct wsemul_sun_emuldata *edp = cookie;
! 571: u_int newstate;
! 572: #ifdef JUMP_SCROLL
! 573: const u_char *eot;
! 574: u_char curchar;
! 575: u_int cnt, pos, lines;
! 576: #endif
! 577:
! 578: #ifdef DIAGNOSTIC
! 579: if (kernel && !edp->console)
! 580: panic("wsemul_sun_output: kernel output, not console");
! 581: #endif
! 582:
! 583: /* XXX */
! 584: (*edp->emulops->cursor)(edp->emulcookie, 0, edp->crow, edp->ccol);
! 585:
! 586: for (; count > 0; data++, count--) {
! 587: #ifdef JUMP_SCROLL
! 588: /*
! 589: * If scrolling is not disabled and we are the bottom of
! 590: * the screen, count newlines until an escape sequence
! 591: * appears.
! 592: */
! 593: if ((edp->state == SUN_EMUL_STATE_NORMAL || kernel) &&
! 594: ROWS_LEFT == 0 && edp->scrolldist != 0) {
! 595: lines = 0;
! 596: pos = edp->ccol;
! 597: for (eot = data, cnt = count; cnt != 0; eot++, cnt--) {
! 598: curchar = *eot;
! 599: if (curchar == ASCII_FF ||
! 600: curchar == ASCII_VT || curchar == ASCII_ESC)
! 601: break;
! 602:
! 603: switch (curchar) {
! 604: case ASCII_BS:
! 605: if (pos > 0)
! 606: pos--;
! 607: break;
! 608: case ASCII_CR:
! 609: pos = 0;
! 610: break;
! 611: case ASCII_HT:
! 612: pos = (pos + 7) & ~7;
! 613: if (pos >= edp->ncols)
! 614: pos = edp->ncols - 1;
! 615: break;
! 616: default:
! 617: if (++pos >= edp->ncols) {
! 618: pos = 0;
! 619: curchar = ASCII_LF;
! 620: }
! 621: break;
! 622: }
! 623: if (curchar == ASCII_LF) {
! 624: if (++lines >= edp->nrows - 1)
! 625: break;
! 626: }
! 627: }
! 628:
! 629: if (lines > 1) {
! 630: wsemul_sun_scrollup(edp, lines);
! 631: edp->crow--;
! 632: }
! 633: }
! 634: #endif
! 635:
! 636: if (*data < ' ') {
! 637: wsemul_sun_output_lowchars(edp, *data, kernel);
! 638: continue;
! 639: }
! 640:
! 641: if (kernel) {
! 642: wsemul_sun_output_normal(edp, *data, 1);
! 643: continue;
! 644: }
! 645:
! 646: switch (newstate = edp->state) {
! 647: case SUN_EMUL_STATE_NORMAL:
! 648: wsemul_sun_output_normal(edp, *data, 0);
! 649: break;
! 650: case SUN_EMUL_STATE_HAVEESC:
! 651: newstate = wsemul_sun_output_haveesc(edp, *data);
! 652: break;
! 653: case SUN_EMUL_STATE_CONTROL:
! 654: newstate = wsemul_sun_output_control(edp, *data);
! 655: break;
! 656: default:
! 657: #ifdef DIAGNOSTIC
! 658: panic("wsemul_sun: invalid state %d", edp->state);
! 659: #else
! 660: /* try to recover, if things get screwed up... */
! 661: newstate = SUN_EMUL_STATE_NORMAL;
! 662: wsemul_sun_output_normal(edp, *data, 0);
! 663: #endif
! 664: break;
! 665: }
! 666: edp->state = newstate;
! 667: }
! 668: /* XXX */
! 669: (*edp->emulops->cursor)(edp->emulcookie, 1, edp->crow, edp->ccol);
! 670: }
! 671:
! 672:
! 673: /*
! 674: * Get an attribute from the graphics driver.
! 675: * Try to find replacements if the desired appearance is not supported.
! 676: */
! 677: int
! 678: wsemul_sun_selectattribute(edp, flags, fgcol, bgcol, attr, bkgdattr)
! 679: struct wsemul_sun_emuldata *edp;
! 680: int flags, fgcol, bgcol;
! 681: long *attr, *bkgdattr;
! 682: {
! 683: int error;
! 684:
! 685: /*
! 686: * Rasops will force white on black as normal output colors, unless
! 687: * WSATTR_WSCOLORS is specified. Since Sun console is black on white,
! 688: * always use WSATTR_WSCOLORS and our colors, as we know better.
! 689: */
! 690: if (!(edp->scrcapabilities & WSSCREEN_WSCOLORS)) {
! 691: flags &= ~WSATTR_WSCOLORS;
! 692: } else {
! 693: flags |= WSATTR_WSCOLORS;
! 694: }
! 695:
! 696: error = (*edp->emulops->alloc_attr)(edp->emulcookie, fgcol, bgcol,
! 697: flags & WSATTR_WSCOLORS, bkgdattr);
! 698: if (error)
! 699: return (error);
! 700:
! 701: if ((flags & WSATTR_HILIT) &&
! 702: !(edp->scrcapabilities & WSSCREEN_HILIT)) {
! 703: flags &= ~WSATTR_HILIT;
! 704: if (edp->scrcapabilities & WSSCREEN_WSCOLORS) {
! 705: fgcol = WSCOL_RED;
! 706: flags |= WSATTR_WSCOLORS;
! 707: }
! 708: }
! 709: if ((flags & WSATTR_UNDERLINE) &&
! 710: !(edp->scrcapabilities & WSSCREEN_UNDERLINE)) {
! 711: flags &= ~WSATTR_UNDERLINE;
! 712: if (edp->scrcapabilities & WSSCREEN_WSCOLORS) {
! 713: fgcol = WSCOL_CYAN;
! 714: flags &= ~WSATTR_UNDERLINE;
! 715: flags |= WSATTR_WSCOLORS;
! 716: }
! 717: }
! 718: if ((flags & WSATTR_BLINK) &&
! 719: !(edp->scrcapabilities & WSSCREEN_BLINK)) {
! 720: flags &= ~WSATTR_BLINK;
! 721: }
! 722: if ((flags & WSATTR_REVERSE) &&
! 723: !(edp->scrcapabilities & WSSCREEN_REVERSE)) {
! 724: flags &= ~WSATTR_REVERSE;
! 725: if (edp->scrcapabilities & WSSCREEN_WSCOLORS) {
! 726: int help;
! 727: help = bgcol;
! 728: bgcol = fgcol;
! 729: fgcol = help;
! 730: flags |= WSATTR_WSCOLORS;
! 731: }
! 732: }
! 733: error = (*edp->emulops->alloc_attr)(edp->emulcookie, fgcol, bgcol,
! 734: flags, attr);
! 735: if (error)
! 736: return (error);
! 737:
! 738: return (0);
! 739: }
! 740:
! 741: static char *sun_fkeys[] = {
! 742: "\033[224z", /* F1 */
! 743: "\033[225z",
! 744: "\033[226z",
! 745: "\033[227z",
! 746: "\033[228z",
! 747: "\033[229z",
! 748: "\033[230z",
! 749: "\033[231z",
! 750: "\033[232z",
! 751: "\033[233z",
! 752: "\033[234z",
! 753: "\033[235z", /* F12 */
! 754: };
! 755:
! 756: static char *sun_lkeys[] = {
! 757: "\033[207z", /* KS_Help */
! 758: NULL, /* KS_Execute */
! 759: "\033[200z", /* KS_Find */
! 760: NULL, /* KS_Select */
! 761: "\033[193z", /* KS_Again */
! 762: "\033[194z", /* KS_Props */
! 763: "\033[195z", /* KS_Undo */
! 764: "\033[196z", /* KS_Front */
! 765: "\033[197z", /* KS_Copy */
! 766: "\033[198z", /* KS_Open */
! 767: "\033[199z", /* KS_Paste */
! 768: "\033[201z", /* KS_Cut */
! 769: };
! 770:
! 771: int
! 772: wsemul_sun_translate(cookie, in, out)
! 773: void *cookie;
! 774: keysym_t in;
! 775: char **out;
! 776: {
! 777: static char c;
! 778:
! 779: if (KS_GROUP(in) == KS_GROUP_Keypad && (in & 0x80) == 0) {
! 780: c = in & 0xff; /* turn into ASCII */
! 781: *out = &c;
! 782: return (1);
! 783: }
! 784:
! 785: if (in >= KS_f1 && in <= KS_f12) {
! 786: *out = sun_fkeys[in - KS_f1];
! 787: return (6);
! 788: }
! 789: if (in >= KS_F1 && in <= KS_F12) {
! 790: *out = sun_fkeys[in - KS_F1];
! 791: return (6);
! 792: }
! 793: if (in >= KS_KP_F1 && in <= KS_KP_F4) {
! 794: *out = sun_fkeys[in - KS_KP_F1];
! 795: return (6);
! 796: }
! 797: if (in >= KS_Help && in <= KS_Cut && sun_lkeys[in - KS_Help] != NULL) {
! 798: *out = sun_lkeys[in - KS_Help];
! 799: return (6);
! 800: }
! 801:
! 802: switch (in) {
! 803: case KS_Home:
! 804: case KS_KP_Home:
! 805: case KS_KP_Begin:
! 806: *out = "\033[214z";
! 807: return (6);
! 808: case KS_End:
! 809: case KS_KP_End:
! 810: *out = "\033[220z";
! 811: return (6);
! 812: case KS_Insert:
! 813: case KS_KP_Insert:
! 814: *out = "\033[247z";
! 815: return (6);
! 816: case KS_Prior:
! 817: case KS_KP_Prior:
! 818: *out = "\033[216z";
! 819: return (6);
! 820: case KS_Next:
! 821: case KS_KP_Next:
! 822: *out = "\033[222z";
! 823: return (6);
! 824: case KS_Up:
! 825: case KS_KP_Up:
! 826: *out = "\033[A";
! 827: return (3);
! 828: case KS_Down:
! 829: case KS_KP_Down:
! 830: *out = "\033[B";
! 831: return (3);
! 832: case KS_Left:
! 833: case KS_KP_Left:
! 834: *out = "\033[D";
! 835: return (3);
! 836: case KS_Right:
! 837: case KS_KP_Right:
! 838: *out = "\033[C";
! 839: return (3);
! 840: case KS_KP_Delete:
! 841: *out = "\177";
! 842: return (1);
! 843: }
! 844: return (0);
! 845: }
! 846:
! 847: void
! 848: wsemul_sun_detach(cookie, crowp, ccolp)
! 849: void *cookie;
! 850: u_int *crowp, *ccolp;
! 851: {
! 852: struct wsemul_sun_emuldata *edp = cookie;
! 853:
! 854: *crowp = edp->crow;
! 855: *ccolp = edp->ccol;
! 856: if (edp != &wsemul_sun_console_emuldata)
! 857: free(edp, M_DEVBUF);
! 858: }
! 859:
! 860: void
! 861: wsemul_sun_resetop(cookie, op)
! 862: void *cookie;
! 863: enum wsemul_resetops op;
! 864: {
! 865: struct wsemul_sun_emuldata *edp = cookie;
! 866:
! 867: switch (op) {
! 868: case WSEMUL_RESET:
! 869: wsemul_sun_reset(edp);
! 870: break;
! 871: case WSEMUL_CLEARSCREEN:
! 872: (*edp->emulops->eraserows)(edp->emulcookie, 0, edp->nrows,
! 873: edp->bkgdattr);
! 874: edp->ccol = edp->crow = 0;
! 875: (*edp->emulops->cursor)(edp->emulcookie, 1, 0, 0);
! 876: break;
! 877: default:
! 878: break;
! 879: }
! 880: }
! 881:
! 882: void
! 883: wsemul_sun_scrollup(edp, lines)
! 884: struct wsemul_sun_emuldata *edp;
! 885: u_int lines;
! 886: {
! 887: /*
! 888: * if we're in wrap-around mode, go to the first
! 889: * line and clear it.
! 890: */
! 891: if (lines == 0) {
! 892: edp->crow = 0;
! 893: (*edp->emulops->eraserows)(edp->emulcookie, 0, 1,
! 894: edp->bkgdattr);
! 895: return;
! 896: }
! 897:
! 898: /*
! 899: * If the scrolling distance is equal to the screen height
! 900: * (usually 34), clear the screen; otherwise, scroll by the
! 901: * scrolling distance.
! 902: */
! 903: if (lines < edp->nrows)
! 904: (*edp->emulops->copyrows)(edp->emulcookie, lines, 0,
! 905: edp->nrows - lines);
! 906: (*edp->emulops->eraserows)(edp->emulcookie,
! 907: edp->nrows - lines, lines, edp->bkgdattr);
! 908: edp->crow -= lines - 1;
! 909: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to wsemul_sun.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / wscons