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