/* $OpenBSD: wsemul_sun.c,v 1.37 2023/07/24 17:03:32 miod Exp $ */ /* $NetBSD: wsemul_sun.c,v 1.11 2000/01/05 11:19:36 drochner Exp $ */ /* * Copyright (c) 2007, 2013 Miodrag Vallat. * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice, this permission notice, and the disclaimer below * appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ /* * Copyright (c) 1996, 1997 Christopher G. Demetriou. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Christopher G. Demetriou * for the NetBSD Project. * 4. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* * This file implements a sun terminal personality for wscons. * * Derived from old rcons code. * Color support from NetBSD's rcons color code, and wsemul_vt100. */ #include #include #include #include #include #include #include #include #include #include #include void *wsemul_sun_cnattach(const struct wsscreen_descr *, void *, int, int, uint32_t); void *wsemul_sun_attach(int, const struct wsscreen_descr *, void *, int, int, void *, uint32_t); u_int wsemul_sun_output(void *, const u_char *, u_int, int); int wsemul_sun_translate(void *, kbd_t, keysym_t, const u_char **); void wsemul_sun_detach(void *, u_int *, u_int *); void wsemul_sun_resetop(void *, enum wsemul_resetops); const struct wsemul_ops wsemul_sun_ops = { "sun", wsemul_sun_cnattach, wsemul_sun_attach, wsemul_sun_output, wsemul_sun_translate, wsemul_sun_detach, wsemul_sun_resetop }; #define SUN_EMUL_STATE_NORMAL 0 /* normal processing */ #define SUN_EMUL_STATE_HAVEESC 1 /* seen start of ctl seq */ #define SUN_EMUL_STATE_CONTROL 2 /* processing ESC [ ctl seq */ #define SUN_EMUL_STATE_PERCENT 3 /* processing ESC % ctl seq */ #define SUN_EMUL_FLAGS_UTF8 0x01 /* UTF-8 character set */ #define SUN_EMUL_NARGS 2 /* max # of args to a command */ struct wsemul_sun_emuldata { const struct wsdisplay_emulops *emulops; struct wsemul_abortstate abortstate; void *emulcookie; void *cbcookie; int scrcapabilities; u_int nrows, ncols, crow, ccol; uint32_t defattr; /* default attribute (rendition) */ u_int state; /* processing state */ u_int flags; u_int args[SUN_EMUL_NARGS]; /* command args, if CONTROL */ int nargs; /* number of args */ u_int scrolldist; /* distance to scroll */ uint32_t curattr, bkgdattr; /* currently used attribute */ uint32_t kernattr; /* attribute for kernel output */ int attrflags, fgcol, bgcol; /* properties of curattr */ struct wsemul_inputstate instate; /* userland input state */ struct wsemul_inputstate kstate; /* kernel input state */ #ifdef HAVE_UTF8_SUPPORT u_char translatebuf[4]; #else u_char translatebuf[1]; #endif #ifdef DIAGNOSTIC int console; #endif }; void wsemul_sun_init(struct wsemul_sun_emuldata *, const struct wsscreen_descr *, void *, int, int, uint32_t); int wsemul_sun_jump_scroll(struct wsemul_sun_emuldata *, const u_char *, u_int, int); void wsemul_sun_reset(struct wsemul_sun_emuldata *); int wsemul_sun_output_lowchars(struct wsemul_sun_emuldata *, struct wsemul_inputstate *, int); int wsemul_sun_output_normal(struct wsemul_sun_emuldata *, struct wsemul_inputstate *, int); int wsemul_sun_output_haveesc(struct wsemul_sun_emuldata *, struct wsemul_inputstate *); int wsemul_sun_output_control(struct wsemul_sun_emuldata *, struct wsemul_inputstate *); int wsemul_sun_output_percent(struct wsemul_sun_emuldata *, struct wsemul_inputstate *); int wsemul_sun_control(struct wsemul_sun_emuldata *, struct wsemul_inputstate *); int wsemul_sun_selectattribute(struct wsemul_sun_emuldata *, int, int, int, uint32_t *, uint32_t *); int wsemul_sun_scrollup(struct wsemul_sun_emuldata *, u_int); struct wsemul_sun_emuldata wsemul_sun_console_emuldata; /* some useful utility macros */ #define ARG(n,c) \ ((n) >= edp->nargs ? 0 : edp->args[(n) + MAX(0, edp->nargs - (c))]) #define NORMALIZE(arg) ((arg) != 0 ? (arg) : 1) #define COLS_LEFT (edp->ncols - 1 - edp->ccol) #define ROWS_LEFT (edp->nrows - 1 - edp->crow) void wsemul_sun_init(struct wsemul_sun_emuldata *edp, const struct wsscreen_descr *type, void *cookie, int ccol, int crow, uint32_t defattr) { 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; wsemul_reset_abortstate(&edp->abortstate); } void wsemul_sun_reset(struct wsemul_sun_emuldata *edp) { edp->flags = 0; 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; edp->instate.inchar = 0; edp->instate.lbound = 0; edp->instate.mbleft = 0; edp->kstate.inchar = 0; edp->kstate.lbound = 0; edp->kstate.mbleft = 0; } void * wsemul_sun_cnattach(const struct wsscreen_descr *type, void *cookie, int ccol, int crow, uint32_t defattr) { struct wsemul_sun_emuldata *edp; int res; edp = &wsemul_sun_console_emuldata; wsemul_sun_init(edp, type, cookie, ccol, crow, defattr); #ifndef WS_KERNEL_FG #define WS_KERNEL_FG WSCOL_BLACK #endif #ifndef WS_KERNEL_BG #define WS_KERNEL_BG WSCOL_WHITE #endif #ifndef WS_KERNEL_COLATTR #define WS_KERNEL_COLATTR 0 #endif #ifndef WS_KERNEL_MONOATTR #define WS_KERNEL_MONOATTR 0 #endif if (type->capabilities & WSSCREEN_WSCOLORS) res = (*edp->emulops->pack_attr)(cookie, WS_KERNEL_FG, WS_KERNEL_BG, WS_KERNEL_COLATTR | WSATTR_WSCOLORS, &edp->kernattr); else res = (*edp->emulops->pack_attr)(cookie, 0, 0, WS_KERNEL_MONOATTR, &edp->kernattr); if (res) edp->kernattr = defattr; edp->cbcookie = NULL; #ifdef DIAGNOSTIC edp->console = 1; #endif wsemul_sun_reset(edp); return (edp); } void * wsemul_sun_attach(int console, const struct wsscreen_descr *type, void *cookie, int ccol, int crow, void *cbcookie, uint32_t defattr) { struct wsemul_sun_emuldata *edp; if (console) { edp = &wsemul_sun_console_emuldata; #ifdef DIAGNOSTIC KASSERT(edp->console == 1); #endif } else { edp = malloc(sizeof *edp, M_DEVBUF, M_NOWAIT); if (edp == NULL) return (NULL); wsemul_sun_init(edp, type, cookie, ccol, crow, defattr); #ifdef DIAGNOSTIC edp->console = 0; #endif } edp->cbcookie = cbcookie; wsemul_sun_reset(edp); return (edp); } int wsemul_sun_output_lowchars(struct wsemul_sun_emuldata *edp, struct wsemul_inputstate *instate, int kernel) { u_int n; int rc = 0; switch (instate->inchar) { case ASCII_NUL: default: /* ignore */ break; case ASCII_BEL: /* "Bell (BEL)" */ wsdisplay_emulbell(edp->cbcookie); break; case ASCII_BS: /* "Backspace (BS)" */ if (edp->ccol > 0) edp->ccol--; break; case ASCII_CR: /* "Return (CR)" */ edp->ccol = 0; break; case ASCII_HT: /* "Tab (TAB)" */ n = min(8 - (edp->ccol & 7), COLS_LEFT); if (n != 0) { WSEMULOP(rc, edp, &edp->abortstate, erasecols, (edp->emulcookie, edp->crow, edp->ccol, n, kernel ? edp->kernattr : edp->bkgdattr)); if (rc != 0) break; edp->ccol += n; } break; case ASCII_FF: /* "Form Feed (FF)" */ WSEMULOP(rc, edp, &edp->abortstate, eraserows, (edp->emulcookie, 0, edp->nrows, edp->bkgdattr)); if (rc != 0) break; edp->ccol = edp->crow = 0; break; case ASCII_VT: /* "Reverse Line Feed" */ if (edp->crow > 0) edp->crow--; break; case ASCII_ESC: /* "Escape (ESC)" */ if (kernel) { printf("wsemul_sun_output_lowchars: ESC in kernel " "output ignored\n"); break; /* ignore the ESC */ } edp->state = SUN_EMUL_STATE_HAVEESC; break; case ASCII_LF: /* "Line Feed (LF)" */ /* if the cur line isn't the last, incr and leave. */ if (ROWS_LEFT > 0) edp->crow++; else { rc = wsemul_sun_scrollup(edp, edp->scrolldist); if (rc != 0) break; } break; } return rc; } int wsemul_sun_output_normal(struct wsemul_sun_emuldata *edp, struct wsemul_inputstate *instate, int kernel) { int rc; u_int outchar; (*edp->emulops->mapchar)(edp->emulcookie, instate->inchar, &outchar); WSEMULOP(rc, edp, &edp->abortstate, putchar, (edp->emulcookie, edp->crow, edp->ccol, outchar, kernel ? edp->kernattr : edp->curattr)); if (rc != 0) return rc; if (++edp->ccol >= edp->ncols) { /* if the cur line isn't the last, incr and leave. */ if (ROWS_LEFT > 0) edp->crow++; else { rc = wsemul_sun_scrollup(edp, edp->scrolldist); if (rc != 0) { /* undo line wrap */ edp->ccol--; return rc; } } edp->ccol = 0; } return 0; } int wsemul_sun_output_haveesc(struct wsemul_sun_emuldata *edp, struct wsemul_inputstate *instate) { switch (instate->inchar) { case '[': /* continuation of multi-char sequence */ edp->nargs = 0; bzero(edp->args, sizeof (edp->args)); edp->state = SUN_EMUL_STATE_CONTROL; break; #ifdef HAVE_UTF8_SUPPORT case '%': edp->state = SUN_EMUL_STATE_PERCENT; break; #endif default: #ifdef DEBUG printf("ESC %x unknown\n", instate->inchar); #endif edp->state = SUN_EMUL_STATE_NORMAL; /* XXX is this wise? */ break; } return 0; } int wsemul_sun_control(struct wsemul_sun_emuldata *edp, struct wsemul_inputstate *instate) { u_int n, src, dst; int flags, fgcol, bgcol; uint32_t attr, bkgdattr; int rc = 0; switch (instate->inchar) { case '@': /* "Insert Character (ICH)" */ n = min(NORMALIZE(ARG(0,1)), COLS_LEFT + 1); src = edp->ccol; dst = edp->ccol + n; if (dst < edp->ncols) { WSEMULOP(rc, edp, &edp->abortstate, copycols, (edp->emulcookie, edp->crow, src, dst, edp->ncols - dst)); if (rc != 0) break; } WSEMULOP(rc, edp, &edp->abortstate, erasecols, (edp->emulcookie, edp->crow, src, n, edp->bkgdattr)); break; case 'A': /* "Cursor Up (CUU)" */ edp->crow -= min(NORMALIZE(ARG(0,1)), edp->crow); break; case 'E': /* "Cursor Next Line (CNL)" */ edp->ccol = 0; /* FALLTHROUGH */ case 'B': /* "Cursor Down (CUD)" */ edp->crow += min(NORMALIZE(ARG(0,1)), ROWS_LEFT); break; case 'C': /* "Cursor Forward (CUF)" */ edp->ccol += min(NORMALIZE(ARG(0,1)), COLS_LEFT); break; case 'D': /* "Cursor Backward (CUB)" */ edp->ccol -= min(NORMALIZE(ARG(0,1)), edp->ccol); break; case 'f': /* "Horizontal And Vertical Position (HVP)" */ 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; break; case 'J': /* "Erase in Display (ED)" */ if (ROWS_LEFT > 0) { WSEMULOP(rc, edp, &edp->abortstate, eraserows, (edp->emulcookie, edp->crow + 1, ROWS_LEFT, edp->bkgdattr)); if (rc != 0) break; } /* FALLTHROUGH */ case 'K': /* "Erase in Line (EL)" */ WSEMULOP(rc, edp, &edp->abortstate, erasecols, (edp->emulcookie, edp->crow, edp->ccol, COLS_LEFT + 1, edp->bkgdattr)); break; case 'L': /* "Insert Line (IL)" */ n = min(NORMALIZE(ARG(0,1)), ROWS_LEFT + 1); src = edp->crow; dst = edp->crow + n; if (dst < edp->nrows) { WSEMULOP(rc, edp, &edp->abortstate, copyrows, (edp->emulcookie, src, dst, edp->nrows - dst)); if (rc != 0) break; } WSEMULOP(rc, edp, &edp->abortstate, eraserows, (edp->emulcookie, src, n, edp->bkgdattr)); break; case 'M': /* "Delete Line (DL)" */ n = min(NORMALIZE(ARG(0,1)), ROWS_LEFT + 1); src = edp->crow + n; dst = edp->crow; if (src < edp->nrows) { WSEMULOP(rc, edp, &edp->abortstate, copyrows, (edp->emulcookie, src, dst, edp->nrows - src)); if (rc != 0) break; } WSEMULOP(rc, edp, &edp->abortstate, eraserows, (edp->emulcookie, dst + edp->nrows - src, n, edp->bkgdattr)); break; case 'P': /* "Delete Character (DCH)" */ n = min(NORMALIZE(ARG(0,1)), COLS_LEFT + 1); src = edp->ccol + n; dst = edp->ccol; if (src < edp->ncols) { WSEMULOP(rc, edp, &edp->abortstate, copycols, (edp->emulcookie, edp->crow, src, dst, edp->ncols - src)); if (rc != 0) break; } WSEMULOP(rc, edp, &edp->abortstate, erasecols, (edp->emulcookie, edp->crow, edp->ncols - n, n, edp->bkgdattr)); break; case 'm': /* "Select Graphic Rendition (SGR)" */ flags = edp->attrflags; fgcol = edp->fgcol; bgcol = edp->bgcol; for (n = 0; n < edp->nargs; n++) { switch (ARG(n,edp->nargs)) { /* Clear all attributes || End underline */ case 0: if (n == edp->nargs - 1) { edp->bkgdattr = edp->curattr = edp->defattr; edp->attrflags = 0; edp->fgcol = WSCOL_BLACK; edp->bgcol = WSCOL_WHITE; return 0; } flags = 0; fgcol = WSCOL_BLACK; bgcol = WSCOL_WHITE; break; /* Begin bold */ case 1: flags |= WSATTR_HILIT; break; /* Begin underline */ case 4: flags |= WSATTR_UNDERLINE; break; /* Begin reverse */ case 7: flags |= WSATTR_REVERSE; break; /* ANSI foreground color */ case 30: case 31: case 32: case 33: case 34: case 35: case 36: case 37: fgcol = ARG(n,edp->nargs) - 30; break; /* ANSI background color */ case 40: case 41: case 42: case 43: case 44: case 45: case 46: case 47: bgcol = ARG(n,edp->nargs) - 40; break; } } setattr: if (wsemul_sun_selectattribute(edp, flags, fgcol, bgcol, &attr, &bkgdattr)) { #ifdef DEBUG printf("error allocating attr %d/%d/%x\n", fgcol, bgcol, flags); #endif } else { edp->curattr = attr; edp->bkgdattr = bkgdattr; edp->attrflags = flags; edp->fgcol = fgcol; edp->bgcol = bgcol; } break; case 'p': /* "Black On White (SUNBOW)" */ flags = 0; fgcol = WSCOL_BLACK; bgcol = WSCOL_WHITE; goto setattr; case 'q': /* "White On Black (SUNWOB)" */ flags = 0; fgcol = WSCOL_WHITE; bgcol = WSCOL_BLACK; goto setattr; case 'r': /* "Set Scrolling (SUNSCRL)" */ edp->scrolldist = min(ARG(0,1), edp->nrows); break; case 's': /* "Reset Terminal Emulator (SUNRESET)" */ wsemul_sun_reset(edp); break; } return rc; } int wsemul_sun_output_control(struct wsemul_sun_emuldata *edp, struct wsemul_inputstate *instate) { int oargs; int rc; switch (instate->inchar) { case '0': case '1': case '2': case '3': case '4': /* argument digit */ case '5': case '6': case '7': case '8': case '9': /* * If we receive more arguments than we are expecting, * discard the earliest arguments. */ if (edp->nargs > SUN_EMUL_NARGS - 1) { bcopy(edp->args + 1, edp->args, (SUN_EMUL_NARGS - 1) * sizeof(edp->args[0])); edp->args[edp->nargs = SUN_EMUL_NARGS - 1] = 0; } edp->args[edp->nargs] = (edp->args[edp->nargs] * 10) + (instate->inchar - '0'); break; case ';': /* argument terminator */ if (edp->nargs < SUN_EMUL_NARGS) edp->nargs++; break; default: /* end of escape sequence */ oargs = edp->nargs; if (edp->nargs < SUN_EMUL_NARGS) edp->nargs++; rc = wsemul_sun_control(edp, instate); if (rc != 0) { /* undo nargs progress */ edp->nargs = oargs; return rc; } edp->state = SUN_EMUL_STATE_NORMAL; break; } return 0; } #ifdef HAVE_UTF8_SUPPORT int wsemul_sun_output_percent(struct wsemul_sun_emuldata *edp, struct wsemul_inputstate *instate) { switch (instate->inchar) { case 'G': edp->flags |= SUN_EMUL_FLAGS_UTF8; edp->kstate.mbleft = edp->instate.mbleft = 0; break; case '@': edp->flags &= ~SUN_EMUL_FLAGS_UTF8; break; } edp->state = SUN_EMUL_STATE_NORMAL; return 0; } #endif u_int wsemul_sun_output(void *cookie, const u_char *data, u_int count, int kernel) { struct wsemul_sun_emuldata *edp = cookie; struct wsemul_inputstate *instate; u_int prev_count, processed = 0; #ifdef HAVE_JUMP_SCROLL int lines; #endif int rc = 0; #ifdef DIAGNOSTIC if (kernel && !edp->console) panic("wsemul_sun_output: kernel output, not console"); #endif instate = kernel ? &edp->kstate : &edp->instate; switch (edp->abortstate.state) { case ABORT_FAILED_CURSOR: /* * If we could not display the cursor back, we pretended not * having been able to process the last byte. But this * is a lie, so compensate here. */ data++, count--; processed++; wsemul_reset_abortstate(&edp->abortstate); break; case ABORT_OK: /* remove cursor image */ rc = (*edp->emulops->cursor) (edp->emulcookie, 0, edp->crow, edp->ccol); if (rc != 0) return 0; break; default: break; } for (;;) { #ifdef HAVE_JUMP_SCROLL switch (edp->abortstate.state) { case ABORT_FAILED_JUMP_SCROLL: /* * If we failed a previous jump scroll attempt, we * need to try to resume it with the same distance. * We can not recompute it since there might be more * bytes in the tty ring, causing a different result. */ lines = edp->abortstate.lines; break; case ABORT_OK: /* * If scrolling is not disabled and we are the bottom of * the screen, count newlines until an escape sequence * appears. */ if ((edp->state == SUN_EMUL_STATE_NORMAL || kernel) && ROWS_LEFT == 0 && edp->scrolldist != 0) lines = wsemul_sun_jump_scroll(edp, data, count, kernel); else lines = 0; break; default: /* * If we are recovering a non-scrolling failure, * do not try to scroll yet. */ lines = 0; break; } if (lines > 1) { wsemul_resume_abort(&edp->abortstate); rc = wsemul_sun_scrollup(edp, lines); if (rc != 0) { wsemul_abort_jump_scroll(&edp->abortstate, lines); return processed; } wsemul_reset_abortstate(&edp->abortstate); edp->crow--; } #endif wsemul_resume_abort(&edp->abortstate); prev_count = count; if (wsemul_getchar(&data, &count, instate, #ifdef HAVE_UTF8_SUPPORT (edp->state == SUN_EMUL_STATE_NORMAL && !kernel) ? edp->flags & SUN_EMUL_FLAGS_UTF8 : 0 #else 0 #endif ) != 0) break; if (instate->inchar < ' ') { rc = wsemul_sun_output_lowchars(edp, instate, kernel); if (rc != 0) break; processed += prev_count - count; continue; } if (kernel) { rc = wsemul_sun_output_normal(edp, instate, 1); if (rc != 0) break; processed += prev_count - count; continue; } switch (edp->state) { case SUN_EMUL_STATE_NORMAL: rc = wsemul_sun_output_normal(edp, instate, 0); break; case SUN_EMUL_STATE_HAVEESC: rc = wsemul_sun_output_haveesc(edp, instate); break; case SUN_EMUL_STATE_CONTROL: rc = wsemul_sun_output_control(edp, instate); break; #ifdef HAVE_UTF8_SUPPORT case SUN_EMUL_STATE_PERCENT: rc = wsemul_sun_output_percent(edp, instate); break; #endif default: #ifdef DIAGNOSTIC panic("wsemul_sun: invalid state %d", edp->state); #else /* try to recover, if things get screwed up... */ edp->state = SUN_EMUL_STATE_NORMAL; rc = wsemul_sun_output_normal(edp, instate, 0); #endif break; } if (rc != 0) break; processed += prev_count - count; } if (rc != 0) wsemul_abort_other(&edp->abortstate); else { /* put cursor image back */ rc = (*edp->emulops->cursor) (edp->emulcookie, 1, edp->crow, edp->ccol); if (rc != 0) { /* * Pretend the last byte hasn't been processed, while * remembering that only the cursor operation really * needs to be done. */ wsemul_abort_cursor(&edp->abortstate); processed--; } } if (rc == 0) wsemul_reset_abortstate(&edp->abortstate); return processed; } #ifdef HAVE_JUMP_SCROLL int wsemul_sun_jump_scroll(struct wsemul_sun_emuldata *edp, const u_char *data, u_int count, int kernel) { u_int pos, lines; struct wsemul_inputstate tmpstate; lines = 0; pos = edp->ccol; tmpstate = kernel ? edp->kstate : edp->instate; /* structure copy */ while (wsemul_getchar(&data, &count, &tmpstate, #ifdef HAVE_UTF8_SUPPORT kernel ? 0 : edp->flags & SUN_EMUL_FLAGS_UTF8 #else 0 #endif ) == 0) { if (tmpstate.inchar == ASCII_FF || tmpstate.inchar == ASCII_VT || tmpstate.inchar == ASCII_ESC) break; switch (tmpstate.inchar) { case ASCII_BS: if (pos > 0) pos--; break; case ASCII_CR: pos = 0; break; case ASCII_HT: pos = (pos + 7) & ~7; if (pos >= edp->ncols) pos = edp->ncols - 1; break; case ASCII_LF: break; default: if (++pos >= edp->ncols) { pos = 0; tmpstate.inchar = ASCII_LF; } break; } if (tmpstate.inchar == ASCII_LF) { if (++lines >= edp->nrows - 1) break; } } return lines; } #endif /* * Get an attribute from the graphics driver. * Try to find replacements if the desired appearance is not supported. */ int wsemul_sun_selectattribute(struct wsemul_sun_emuldata *edp, int flags, int fgcol, int bgcol, uint32_t *attr, uint32_t *bkgdattr) { int error; /* * Rasops will force white on black as normal output colors, unless * WSATTR_WSCOLORS is specified. Since Sun console is black on white, * always use WSATTR_WSCOLORS and our colors, as we know better. */ if (!(edp->scrcapabilities & WSSCREEN_WSCOLORS)) { flags &= ~WSATTR_WSCOLORS; } else { flags |= WSATTR_WSCOLORS; } error = (*edp->emulops->pack_attr)(edp->emulcookie, fgcol, bgcol, flags & WSATTR_WSCOLORS, bkgdattr); if (error) return (error); if ((flags & WSATTR_HILIT) && !(edp->scrcapabilities & WSSCREEN_HILIT)) { flags &= ~WSATTR_HILIT; if (edp->scrcapabilities & WSSCREEN_WSCOLORS) { fgcol = WSCOL_RED; flags |= WSATTR_WSCOLORS; } } if ((flags & WSATTR_UNDERLINE) && !(edp->scrcapabilities & WSSCREEN_UNDERLINE)) { flags &= ~WSATTR_UNDERLINE; if (edp->scrcapabilities & WSSCREEN_WSCOLORS) { fgcol = WSCOL_CYAN; flags &= ~WSATTR_UNDERLINE; flags |= WSATTR_WSCOLORS; } } if ((flags & WSATTR_BLINK) && !(edp->scrcapabilities & WSSCREEN_BLINK)) { flags &= ~WSATTR_BLINK; } if ((flags & WSATTR_REVERSE) && !(edp->scrcapabilities & WSSCREEN_REVERSE)) { flags &= ~WSATTR_REVERSE; if (edp->scrcapabilities & WSSCREEN_WSCOLORS) { int help; help = bgcol; bgcol = fgcol; fgcol = help; flags |= WSATTR_WSCOLORS; } } error = (*edp->emulops->pack_attr)(edp->emulcookie, fgcol, bgcol, flags, attr); if (error) return (error); return (0); } static const u_char *sun_fkeys[] = { "\033[224z", /* F1 */ "\033[225z", "\033[226z", "\033[227z", "\033[228z", "\033[229z", "\033[230z", "\033[231z", "\033[232z", "\033[233z", "\033[234z", "\033[235z", /* F12 */ }; static const u_char *sun_lkeys[] = { "\033[207z", /* KS_Help */ NULL, /* KS_Execute */ "\033[200z", /* KS_Find */ NULL, /* KS_Select */ "\033[193z", /* KS_Again */ "\033[194z", /* KS_Props */ "\033[195z", /* KS_Undo */ "\033[196z", /* KS_Front */ "\033[197z", /* KS_Copy */ "\033[198z", /* KS_Open */ "\033[199z", /* KS_Paste */ "\033[201z", /* KS_Cut */ }; int wsemul_sun_translate(void *cookie, kbd_t layout, keysym_t in, const u_char **out) { struct wsemul_sun_emuldata *edp = cookie; if (KS_GROUP(in) == KS_GROUP_Ascii) { *out = edp->translatebuf; return (wsemul_utf8_translate(KS_VALUE(in), layout, edp->translatebuf, edp->flags & SUN_EMUL_FLAGS_UTF8)); } if (KS_GROUP(in) == KS_GROUP_Keypad && (in & 0x80) == 0) { edp->translatebuf[0] = in & 0xff; /* turn into ASCII */ *out = edp->translatebuf; return (1); } if (in >= KS_f1 && in <= KS_f12) { *out = sun_fkeys[in - KS_f1]; return (6); } if (in >= KS_F1 && in <= KS_F12) { *out = sun_fkeys[in - KS_F1]; return (6); } if (in >= KS_KP_F1 && in <= KS_KP_F4) { *out = sun_fkeys[in - KS_KP_F1]; return (6); } if (in >= KS_Help && in <= KS_Cut && sun_lkeys[in - KS_Help] != NULL) { *out = sun_lkeys[in - KS_Help]; return (6); } switch (in) { case KS_Home: case KS_KP_Home: case KS_KP_Begin: *out = "\033[214z"; return (6); case KS_End: case KS_KP_End: *out = "\033[220z"; return (6); case KS_Insert: case KS_KP_Insert: *out = "\033[247z"; return (6); case KS_Prior: case KS_KP_Prior: *out = "\033[216z"; return (6); case KS_Next: case KS_KP_Next: *out = "\033[222z"; return (6); case KS_Up: case KS_KP_Up: *out = "\033[A"; return (3); case KS_Down: case KS_KP_Down: *out = "\033[B"; return (3); case KS_Left: case KS_KP_Left: *out = "\033[D"; return (3); case KS_Right: case KS_KP_Right: *out = "\033[C"; return (3); case KS_KP_Delete: *out = "\177"; return (1); } return (0); } void wsemul_sun_detach(void *cookie, u_int *crowp, u_int *ccolp) { struct wsemul_sun_emuldata *edp = cookie; *crowp = edp->crow; *ccolp = edp->ccol; if (edp != &wsemul_sun_console_emuldata) free(edp, M_DEVBUF, sizeof *edp); } void wsemul_sun_resetop(void *cookie, enum wsemul_resetops op) { struct wsemul_sun_emuldata *edp = cookie; switch (op) { case WSEMUL_RESET: wsemul_sun_reset(edp); break; case WSEMUL_CLEARSCREEN: (*edp->emulops->eraserows)(edp->emulcookie, 0, edp->nrows, edp->bkgdattr); edp->ccol = edp->crow = 0; (*edp->emulops->cursor)(edp->emulcookie, 1, 0, 0); break; case WSEMUL_CLEARCURSOR: (*edp->emulops->cursor)(edp->emulcookie, 0, edp->crow, edp->ccol); break; default: break; } } int wsemul_sun_scrollup(struct wsemul_sun_emuldata *edp, u_int lines) { int rc; /* * if we're in wrap-around mode, go to the first * line and clear it. */ if (lines == 0) { WSEMULOP(rc, edp, &edp->abortstate, eraserows, (edp->emulcookie, 0, 1, edp->bkgdattr)); if (rc != 0) return rc; edp->crow = 0; return 0; } /* * If the scrolling distance is equal to the screen height * (usually 34), clear the screen; otherwise, scroll by the * scrolling distance. */ if (lines < edp->nrows) { WSEMULOP(rc, edp, &edp->abortstate, copyrows, (edp->emulcookie, lines, 0, edp->nrows - lines)); if (rc != 0) return rc; } WSEMULOP(rc, edp, &edp->abortstate, eraserows, (edp->emulcookie, edp->nrows - lines, lines, edp->bkgdattr)); if (rc != 0) return rc; edp->crow -= lines - 1; return 0; }