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