root/dev/wscons/wsemul_sun.c

DEFINITIONS

1. wsemul_sun_init
2. wsemul_sun_reset
3. wsemul_sun_cnattach
4. wsemul_sun_attach
5. wsemul_sun_output_lowchars
6. wsemul_sun_output_normal
7. wsemul_sun_output_haveesc
8. wsemul_sun_control
9. wsemul_sun_output_control
10. wsemul_sun_output
11. wsemul_sun_selectattribute
12. wsemul_sun_translate
13. wsemul_sun_detach
14. wsemul_sun_resetop
15. wsemul_sun_scrollup

    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 $ */
    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  */
   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  */
   41 #ifndef SMALL_KERNEL
   42 #define JUMP_SCROLL
   43 #endif
   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>
   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>
   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);
   66 const struct wsemul_ops wsemul_sun_ops = {
   67         "sun",
wsemul_sun_cnattach,
wsemul_sun_attach,
wsemul_sun_output,
wsemul_sun_translate,
wsemul_sun_detach,
wsemul_sun_resetop
   74 };
   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 */
   80 #define SUN_EMUL_NARGS  2               /* max # of args to a command */
   82 struct wsemul_sun_emuldata {
   83         const struct wsdisplay_emulops *emulops;
   84         void *emulcookie;
   85         void *cbcookie;
   86         int scrcapabilities;
u_int nrows, ncols, crow, ccol;
   88         long defattr;                   /* default attribute (rendition) */
u_int state;                    /* processing state */
u_int args[SUN_EMUL_NARGS];     /* command args, if CONTROL */
   92         int nargs;                      /* number of args */
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 */
   99 #ifdef DIAGNOSTIC
  100         int console;
  101 #endif
  102 };
  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);
u_int wsemul_sun_output_haveesc(struct wsemul_sun_emuldata *, u_char);
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);
  116 struct wsemul_sun_emuldata wsemul_sun_console_emuldata;
  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)
  125 void
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 {
edp->emulops = type->textops;
edp->emulcookie = cookie;
edp->scrcapabilities = type->capabilities;
edp->nrows = type->nrows;
edp->ncols = type->ncols;
edp->crow = crow;
edp->ccol = ccol;
edp->defattr = defattr;
  141 }
  143 void
wsemul_sun_reset(edp)
  145         struct wsemul_sun_emuldata *edp;
  146 {
edp->state = SUN_EMUL_STATE_NORMAL;
edp->bkgdattr = edp->curattr = edp->defattr;
edp->attrflags = 0;
edp->fgcol = WSCOL_BLACK;
edp->bgcol = WSCOL_WHITE;
edp->scrolldist = 1;
  153 }
  155 void *
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;
edp = &wsemul_sun_console_emuldata;
wsemul_sun_init(edp, type, cookie, ccol, crow, defattr);
  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)
res = (*edp->emulops->alloc_attr)(cookie,
WS_KERNEL_FG, WS_KERNEL_BG,
WS_KERNEL_COLATTR | WSATTR_WSCOLORS,
  184                                             &edp->kernattr);
  185         else
res = (*edp->emulops->alloc_attr)(cookie, 0, 0,
WS_KERNEL_MONOATTR,
  188                                             &edp->kernattr);
  189         if (res)
edp->kernattr = defattr;
edp->cbcookie = NULL;
  194 #ifdef DIAGNOSTIC
edp->console = 1;
  196 #endif
wsemul_sun_reset(edp);
  199         return (edp);
  200 }
  202 void *
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;
  213         if (console) {
edp = &wsemul_sun_console_emuldata;
  215 #ifdef DIAGNOSTIC
KASSERT(edp->console == 1);
  217 #endif
  218         } else {
edp = malloc(sizeof *edp, M_DEVBUF, M_NOWAIT);
  220                 if (edp == NULL)
  221                         return (NULL);
wsemul_sun_init(edp, type, cookie, ccol, crow, defattr);
  224 #ifdef DIAGNOSTIC
edp->console = 0;
  226 #endif
  227         }
edp->cbcookie = cbcookie;
wsemul_sun_reset(edp);
  232         return (edp);
  233 }
  235 void
wsemul_sun_output_lowchars(edp, c, kernel)
  237         struct wsemul_sun_emuldata *edp;
u_char c;
  239         int kernel;
  240 {
u_int n;
  243         switch (c) {
  244         case ASCII_NUL:
  245         default:
  246                 /* ignore */
  247                 break;
  249         case ASCII_BEL:         /* "Bell (BEL)" */
wsdisplay_emulbell(edp->cbcookie);
  251                 break;
  253         case ASCII_BS:          /* "Backspace (BS)" */
  254                 if (edp->ccol > 0)
edp->ccol--;
  256                 break;
  258         case ASCII_CR:          /* "Return (CR)" */
edp->ccol = 0;
  260                 break;
  262         case ASCII_HT:          /* "Tab (TAB)" */
n = min(8 - (edp->ccol & 7), COLS_LEFT);
  264                 if (n != 0) {
  265                         (*edp->emulops->erasecols)(edp->emulcookie, edp->crow,
edp->ccol, n,
kernel ? edp->kernattr : edp->bkgdattr);
edp->ccol += n;
  269                 }
  270                 break;
  272         case ASCII_FF:          /* "Form Feed (FF)" */
  273                 (*edp->emulops->eraserows)(edp->emulcookie, 0, edp->nrows,
edp->bkgdattr);
edp->ccol = edp->crow = 0;
  276                 break;
  278         case ASCII_VT:          /* "Reverse Line Feed" */
  279                 if (edp->crow > 0)
edp->crow--;
  281                 break;
  283         case ASCII_ESC:         /* "Escape (ESC)" */
  284                 if (kernel) {
printf("wsemul_sun_output_lowchars: ESC in kernel "
  286                             "output ignored\n");
  287                         break;  /* ignore the ESC */
  288                 }
edp->state = SUN_EMUL_STATE_HAVEESC;
  291                 break;
  293         case ASCII_LF:          /* "Line Feed (LF)" */
  294                 /* if the cur line isn't the last, incr and leave. */
  295                 if (ROWS_LEFT > 0)
edp->crow++;
  297                 else
wsemul_sun_scrollup(edp, edp->scrolldist);
  299                 break;
  300         }
  301 }
  303 void
wsemul_sun_output_normal(edp, c, kernel)
  305         struct wsemul_sun_emuldata *edp;
u_char c;
  307         int kernel;
  308 {
  310         (*edp->emulops->putchar)(edp->emulcookie, edp->crow, edp->ccol,
c, kernel ? edp->kernattr : edp->curattr);
  313         if (++edp->ccol >= edp->ncols) {
  314                 /* if the cur line isn't the last, incr and leave. */
  315                 if (ROWS_LEFT > 0)
edp->crow++;
  317                 else
wsemul_sun_scrollup(edp, edp->scrolldist);
edp->ccol = 0;
  320         }
  321 }
u_int
wsemul_sun_output_haveesc(edp, c)
  325         struct wsemul_sun_emuldata *edp;
u_char c;
  327 {
u_int newstate;
  330         switch (c) {
  331         case '[':               /* continuation of multi-char sequence */
edp->nargs = 0;
bzero(edp->args, sizeof (edp->args));
newstate = SUN_EMUL_STATE_CONTROL;
  335                 break;
  337         default:
  338 #ifdef DEBUG
printf("ESC%c unknown\n", c);
  340 #endif
newstate = SUN_EMUL_STATE_NORMAL;       /* XXX is this wise? */
  342                 break;
  343         }
  345         return (newstate);
  346 }
  348 void
wsemul_sun_control(edp, c)
  350         struct wsemul_sun_emuldata *edp;
u_char c;
  352 {
u_int n, src, dst;
  354         int flags, fgcol, bgcol;
  355         long attr, bkgdattr;
  357         switch (c) {
  358         case '@':               /* "Insert Character (ICH)" */
n = min(NORMALIZE(ARG(0,1)), COLS_LEFT + 1);
src = edp->ccol;
dst = edp->ccol + n;
  362                 if (dst < edp->ncols) {
  363                         (*edp->emulops->copycols)(edp->emulcookie, edp->crow,
src, dst, edp->ncols - dst);
  365                 }
  366                 (*edp->emulops->erasecols)(edp->emulcookie, edp->crow,
src, n, edp->bkgdattr);
  368                 break;
  370         case 'A':               /* "Cursor Up (CUU)" */
edp->crow -= min(NORMALIZE(ARG(0,1)), edp->crow);
  372                 break;
  374         case 'E':               /* "Cursor Next Line (CNL)" */
edp->ccol = 0;
  376                 /* FALLTHROUGH */
  377         case 'B':               /* "Cursor Down (CUD)" */
edp->crow += min(NORMALIZE(ARG(0,1)), ROWS_LEFT);
  379                 break;
  381         case 'C':               /* "Cursor Forward (CUF)" */
edp->ccol += min(NORMALIZE(ARG(0,1)), COLS_LEFT);
  383                 break;
  385         case 'D':               /* "Cursor Backward (CUB)" */
edp->ccol -= min(NORMALIZE(ARG(0,1)), edp->ccol);
  387                 break;
  389         case 'f':               /* "Horizontal And Vertical Position (HVP)" */
  390         case 'H':               /* "Cursor Position (CUP)" */
edp->crow = min(NORMALIZE(ARG(0,2)), edp->nrows) - 1;
edp->ccol = min(NORMALIZE(ARG(1,2)), edp->ncols) - 1;
  393                 break;
  395         case 'J':               /* "Erase in Display (ED)" */
  396                 if (ROWS_LEFT > 0) {
  397                         (*edp->emulops->eraserows)(edp->emulcookie,
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,
edp->ccol, COLS_LEFT + 1, edp->bkgdattr);
  404                 break;
  406         case 'L':               /* "Insert Line (IL)" */
n = min(NORMALIZE(ARG(0,1)), ROWS_LEFT + 1);
src = edp->crow;
dst = edp->crow + n;
  410                 if (dst < edp->nrows) {
  411                         (*edp->emulops->copyrows)(edp->emulcookie,
src, dst, edp->nrows - dst);
  413                 }
  414                 (*edp->emulops->eraserows)(edp->emulcookie,
src, n, edp->bkgdattr);
  416                 break;
  418         case 'M':               /* "Delete Line (DL)" */
n = min(NORMALIZE(ARG(0,1)), ROWS_LEFT + 1);
src = edp->crow + n;
dst = edp->crow;
  422                 if (src < edp->nrows) {
  423                         (*edp->emulops->copyrows)(edp->emulcookie,
src, dst, edp->nrows - src);
  425                 }
  426                 (*edp->emulops->eraserows)(edp->emulcookie,
dst + edp->nrows - src, n, edp->bkgdattr);
  428                 break;
  430         case 'P':               /* "Delete Character (DCH)" */
n = min(NORMALIZE(ARG(0,1)), COLS_LEFT + 1);
src = edp->ccol + n;
dst = edp->ccol;
  434                 if (src < edp->ncols) {
  435                         (*edp->emulops->copycols)(edp->emulcookie, edp->crow,
src, dst, edp->ncols - src);
  437                 }
  438                 (*edp->emulops->erasecols)(edp->emulcookie, edp->crow,
edp->ncols - n, n, edp->bkgdattr);
  440                 break;
  442         case 'm':               /* "Select Graphic Rendition (SGR)" */
flags = edp->attrflags;
fgcol = edp->fgcol;
bgcol = edp->bgcol;
  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) {
edp->bkgdattr =
edp->curattr = edp->defattr;
edp->attrflags = 0;
edp->fgcol = WSCOL_BLACK;
edp->bgcol = WSCOL_WHITE;
  457                                         return;
  458                                 }
flags = 0;
fgcol = WSCOL_BLACK;
bgcol = WSCOL_WHITE;
  462                                 break;
  463                         /* Begin bold */
  464                         case 1:
flags |= WSATTR_HILIT;
  466                                 break;
  467                         /* Begin underline */
  468                         case 4:
flags |= WSATTR_UNDERLINE;
  470                                 break;
  471                         /* Begin reverse */
  472                         case 7:
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:
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:
bgcol = ARG(n,edp->nargs) - 40;
  484                                 break;
  485                         }
  486                 }
setattr:
  488                 if (wsemul_sun_selectattribute(edp, flags, fgcol, bgcol, &attr,
  489                     &bkgdattr)) {
  490 #ifdef DEBUG
printf("error allocating attr %d/%d/%x\n",
fgcol, bgcol, flags);
  493 #endif
  494                 } else {
edp->curattr = attr;
edp->bkgdattr = bkgdattr;
edp->attrflags = flags;
edp->fgcol = fgcol;
edp->bgcol = bgcol;
  500                 }
  501                 break;
  503         case 'p':               /* "Black On White (SUNBOW)" */
flags = 0;
fgcol = WSCOL_BLACK;
bgcol = WSCOL_WHITE;
  507                 goto setattr;
  509         case 'q':               /* "White On Black (SUNWOB)" */
flags = 0;
fgcol = WSCOL_WHITE;
bgcol = WSCOL_BLACK;
  513                 goto setattr;
  515         case 'r':               /* "Set Scrolling (SUNSCRL)" */
edp->scrolldist = min(ARG(0,1), edp->nrows);
  517                 break;
  519         case 's':               /* "Reset Terminal Emulator (SUNRESET)" */
wsemul_sun_reset(edp);
  521                 break;
  522         }
  523 }
u_int
wsemul_sun_output_control(edp, c)
  527         struct wsemul_sun_emuldata *edp;
u_char c;
  529 {
u_int newstate = SUN_EMUL_STATE_CONTROL;
  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) {
bcopy(edp->args + 1, edp->args,
  541                             (SUN_EMUL_NARGS - 1) * sizeof(edp->args[0]));
edp->args[edp->nargs = SUN_EMUL_NARGS - 1] = 0;
  543                 }
edp->args[edp->nargs] = (edp->args[edp->nargs] * 10) +
  545                     (c - '0');
  546                 break;
  548         case ';':               /* argument terminator */
edp->nargs++;
  550                 break;
  552         default:                /* end of escape sequence */
edp->nargs++;
  554                 if (edp->nargs > SUN_EMUL_NARGS)
edp->nargs = SUN_EMUL_NARGS;
wsemul_sun_control(edp, c);
newstate = SUN_EMUL_STATE_NORMAL;
  558                 break;
  559         }
  560         return (newstate);
  561 }
  563 void
wsemul_sun_output(cookie, data, count, kernel)
  565         void *cookie;
  566         const u_char *data;
u_int count;
  568         int kernel;
  569 {
  570         struct wsemul_sun_emuldata *edp = cookie;
u_int newstate;
  572 #ifdef JUMP_SCROLL
  573         const u_char *eot;
u_char curchar;
u_int cnt, pos, lines;
  576 #endif
  578 #ifdef DIAGNOSTIC
  579         if (kernel && !edp->console)
panic("wsemul_sun_output: kernel output, not console");
  581 #endif
  583         /* XXX */
  584         (*edp->emulops->cursor)(edp->emulcookie, 0, edp->crow, edp->ccol);
  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) &&
ROWS_LEFT == 0 && edp->scrolldist != 0) {
lines = 0;
pos = edp->ccol;
  597                         for (eot = data, cnt = count; cnt != 0; eot++, cnt--) {
curchar = *eot;
  599                                 if (curchar == ASCII_FF ||
curchar == ASCII_VT || curchar == ASCII_ESC)
  601                                         break;
  603                                 switch (curchar) {
  604                                 case ASCII_BS:
  605                                         if (pos > 0)
pos--;
  607                                         break;
  608                                 case ASCII_CR:
pos = 0;
  610                                         break;
  611                                 case ASCII_HT:
pos = (pos + 7) & ~7;
  613                                         if (pos >= edp->ncols)
pos = edp->ncols - 1;
  615                                         break;
  616                                 default:
  617                                         if (++pos >= edp->ncols) {
pos = 0;
curchar = ASCII_LF;
  620                                         }
  621                                         break;
  622                                 }
  623                                 if (curchar == ASCII_LF) {
  624                                         if (++lines >= edp->nrows - 1)
  625                                                 break;
  626                                 }
  627                         }
  629                         if (lines > 1) {
wsemul_sun_scrollup(edp, lines);
edp->crow--;
  632                         }
  633                 }
  634 #endif
  636                 if (*data < ' ') {
wsemul_sun_output_lowchars(edp, *data, kernel);
  638                         continue;
  639                 }
  641                 if (kernel) {
wsemul_sun_output_normal(edp, *data, 1);
  643                         continue;
  644                 }
  646                 switch (newstate = edp->state) {
  647                 case SUN_EMUL_STATE_NORMAL:
wsemul_sun_output_normal(edp, *data, 0);
  649                         break;
  650                 case SUN_EMUL_STATE_HAVEESC:
newstate = wsemul_sun_output_haveesc(edp, *data);
  652                         break;
  653                 case SUN_EMUL_STATE_CONTROL:
newstate = wsemul_sun_output_control(edp, *data);
  655                         break;
  656                 default:
  657 #ifdef DIAGNOSTIC
panic("wsemul_sun: invalid state %d", edp->state);
  659 #else
  660                         /* try to recover, if things get screwed up... */
newstate = SUN_EMUL_STATE_NORMAL;
wsemul_sun_output_normal(edp, *data, 0);
  663 #endif
  664                         break;
  665                 }
edp->state = newstate;
  667         }
  668         /* XXX */
  669         (*edp->emulops->cursor)(edp->emulcookie, 1, edp->crow, edp->ccol);
  670 }
  673 /*
  674  * Get an attribute from the graphics driver.
  675  * Try to find replacements if the desired appearance is not supported.
  676  */
  677 int
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;
  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)) {
flags &= ~WSATTR_WSCOLORS;
  692         } else {
flags |= WSATTR_WSCOLORS;
  694         }
error = (*edp->emulops->alloc_attr)(edp->emulcookie, fgcol, bgcol,
flags & WSATTR_WSCOLORS, bkgdattr);
  698         if (error)
  699                 return (error);
  701         if ((flags & WSATTR_HILIT) &&
  702             !(edp->scrcapabilities & WSSCREEN_HILIT)) {
flags &= ~WSATTR_HILIT;
  704                 if (edp->scrcapabilities & WSSCREEN_WSCOLORS) {
fgcol = WSCOL_RED;
flags |= WSATTR_WSCOLORS;
  707                 }
  708         }
  709         if ((flags & WSATTR_UNDERLINE) &&
  710             !(edp->scrcapabilities & WSSCREEN_UNDERLINE)) {
flags &= ~WSATTR_UNDERLINE;
  712                 if (edp->scrcapabilities & WSSCREEN_WSCOLORS) {
fgcol = WSCOL_CYAN;
flags &= ~WSATTR_UNDERLINE;
flags |= WSATTR_WSCOLORS;
  716                 }
  717         }
  718         if ((flags & WSATTR_BLINK) &&
  719             !(edp->scrcapabilities & WSSCREEN_BLINK)) {
flags &= ~WSATTR_BLINK;
  721         }
  722         if ((flags & WSATTR_REVERSE) &&
  723             !(edp->scrcapabilities & WSSCREEN_REVERSE)) {
flags &= ~WSATTR_REVERSE;
  725                 if (edp->scrcapabilities & WSSCREEN_WSCOLORS) {
  726                         int help;
help = bgcol;
bgcol = fgcol;
fgcol = help;
flags |= WSATTR_WSCOLORS;
  731                 }
  732         }
error = (*edp->emulops->alloc_attr)(edp->emulcookie, fgcol, bgcol,
flags, attr);
  735         if (error)
  736                 return (error);
  738         return (0);
  739 }
  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 };
  756 static char *sun_lkeys[] = {
  757         "\033[207z",    /* KS_Help */
NULL,           /* KS_Execute */
  759         "\033[200z",    /* KS_Find */
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 };
  771 int
wsemul_sun_translate(cookie, in, out)
  773         void *cookie;
keysym_t in;
  775         char **out;
  776 {
  777         static char c;
  779         if (KS_GROUP(in) == KS_GROUP_Keypad && (in & 0x80) == 0) {
c = in & 0xff; /* turn into ASCII */
  781                 *out = &c;
  782                 return (1);
  783         }
  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         }
  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 }
  847 void
wsemul_sun_detach(cookie, crowp, ccolp)
  849         void *cookie;
u_int *crowp, *ccolp;
  851 {
  852         struct wsemul_sun_emuldata *edp = cookie;
  854         *crowp = edp->crow;
  855         *ccolp = edp->ccol;
  856         if (edp != &wsemul_sun_console_emuldata)
free(edp, M_DEVBUF);
  858 }
  860 void
wsemul_sun_resetop(cookie, op)
  862         void *cookie;
  863         enum wsemul_resetops op;
  864 {
  865         struct wsemul_sun_emuldata *edp = cookie;
  867         switch (op) {
  868         case WSEMUL_RESET:
wsemul_sun_reset(edp);
  870                 break;
  871         case WSEMUL_CLEARSCREEN:
  872                 (*edp->emulops->eraserows)(edp->emulcookie, 0, edp->nrows,
edp->bkgdattr);
edp->ccol = edp->crow = 0;
  875                 (*edp->emulops->cursor)(edp->emulcookie, 1, 0, 0);
  876                 break;
  877         default:
  878                 break;
  879         }
  880 }
  882 void
wsemul_sun_scrollup(edp, lines)
  884         struct wsemul_sun_emuldata *edp;
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) {
edp->crow = 0;
  893                 (*edp->emulops->eraserows)(edp->emulcookie, 0, 1,
edp->bkgdattr);
  895                 return;
  896         }
  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,
edp->nrows - lines);
  906         (*edp->emulops->eraserows)(edp->emulcookie,
edp->nrows - lines, lines, edp->bkgdattr);
edp->crow -= lines - 1;
  909 }