![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ite.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / amiga / dev|
Return to ite.c CVS log | Up to [Net/2] / Net2 / arch / amiga / dev |
1.1 root 1: /*
2: * Copyright (c) 1988 University of Utah.
3: * Copyright (c) 1990 The Regents of the University of California.
4: * All rights reserved.
5: *
6: * This code is derived from software contributed to Berkeley by
7: * the Systems Programming Group of the University of Utah Computer
8: * Science Department.
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: * 2. Redistributions in binary form must reproduce the above copyright
16: * notice, this list of conditions and the following disclaimer in the
17: * documentation and/or other materials provided with the distribution.
18: * 3. All advertising materials mentioning features or use of this software
19: * must display the following acknowledgement:
20: * This product includes software developed by the University of
21: * California, Berkeley and its contributors.
22: * 4. Neither the name of the University nor the names of its contributors
23: * may be used to endorse or promote products derived from this software
24: * without specific prior written permission.
25: *
26: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36: * SUCH DAMAGE.
37: *
38: * from: Utah $Hdr: ite.c 1.1 90/07/09$
39: *
40: * from: @(#)ite.c 7.6 (Berkeley) 5/16/91
41: * ite.c,v 1.1.1.1 1993/07/05 19:19:44 mw Exp
42: */
43:
44: /*
45: * Bit-mapped display terminal emulator machine independent code.
46: * This is a very rudimentary. Much more can be abstracted out of
47: * the hardware dependent routines.
48: */
49: #include "ite.h"
50: #if NITE > 0
51:
52: #include "grf.h"
53:
54: #undef NITE
55: #define NITE NGRF
56:
57: #include "param.h"
58: #include "conf.h"
59: #include "proc.h"
60: #include "ioctl.h"
61: #include "tty.h"
62: #include "systm.h"
63: #include "malloc.h"
64:
65: #include "itevar.h"
66: #include "iteioctl.h"
67: #include "kbdmap.h"
68:
69: #include "machine/cpu.h"
70:
71: #ifdef __STDC__
72: /* automatically generated, as you might guess:-) */
73:
74: struct consdev;
75: struct itesw;
76:
77: extern int iteon (dev_t dev, int flag);
78: extern int iteinit (dev_t dev);
79: extern int iteoff (dev_t dev, int flag);
80: extern int iteopen (dev_t dev, int mode, int devtype, struct proc *p);
81: extern int iteclose (dev_t dev, int flag, int mode, struct proc *p);
82: extern int iteread (dev_t dev, struct uio *uio, int flag);
83: extern int itewrite (dev_t dev, struct uio *uio, int flag);
84: extern int iteioctl (dev_t dev, int cmd, caddr_t addr, int flag);
85: extern int itestart (register struct tty *tp);
86: extern int itefilter (register u_char c, enum caller caller);
87: extern int iteputchar (register int c, dev_t dev);
88: extern int itecheckwrap (register struct ite_softc *ip, register struct itesw *sp);
89: extern int itecnprobe (struct consdev *cp);
90: extern int itecninit (struct consdev *cp);
91: extern int itecngetc (dev_t dev);
92: extern int itecnputc (dev_t dev, int c);
93: static void repeat_handler (int a0, int a1);
94: static void ite_dnchar (struct ite_softc *ip, struct itesw *sp, int n);
95: static void ite_inchar (struct ite_softc *ip, struct itesw *sp, int n);
96: static void ite_clrtoeol (struct ite_softc *ip, struct itesw *sp, int y, int x);
97: static void ite_clrtobol (struct ite_softc *ip, struct itesw *sp, int y, int x);
98: static void ite_clrline (struct ite_softc *ip, struct itesw *sp, int y, int x);
99: static void ite_clrtoeos (struct ite_softc *ip, struct itesw *sp);
100: static void ite_clrtobos (struct ite_softc *ip, struct itesw *sp);
101: static void ite_clrscreen (struct ite_softc *ip, struct itesw *sp);
102: static void ite_dnline (struct ite_softc *ip, struct itesw *sp, int n);
103: static void ite_inline (struct ite_softc *ip, struct itesw *sp, int n);
104: static void ite_lf (struct ite_softc *ip, struct itesw *sp);
105: static void ite_crlf (struct ite_softc *ip, struct itesw *sp);
106: static void ite_cr (struct ite_softc *ip, struct itesw *sp);
107: static void ite_rlf (struct ite_softc *ip, struct itesw *sp);
108: static int atoi (const char *cp);
109: static char *index (const char *cp, char ch);
110: static int ite_argnum (struct ite_softc *ip);
111: static int ite_zargnum (struct ite_softc *ip);
112: static void ite_sendstr (struct ite_softc *ip, char *str);
113: static int strncmp (const char *a, const char *b, int l);
114: #endif
115:
116:
117: #define set_attr(ip, attr) ((ip)->attribute |= (attr))
118: #define clr_attr(ip, attr) ((ip)->attribute &= ~(attr))
119:
120: extern int nodev();
121:
122: int customc_scroll(), customc_init(), customc_deinit();
123: int customc_clear(), customc_putc(), customc_cursor();
124:
125: int tiga_scroll(), tiga_init(), tiga_deinit();
126: int tiga_clear(), tiga_putc(), tiga_cursor();
127:
128:
129: struct itesw itesw[] =
130: {
131: customc_init, customc_deinit, customc_clear,
132: customc_putc, customc_cursor, customc_scroll,
133:
134: tiga_init, tiga_deinit, tiga_clear,
135: tiga_putc, tiga_cursor, tiga_scroll,
136: };
137:
138: /*
139: * # of chars are output in a single itestart() call.
140: * If this is too big, user processes will be blocked out for
141: * long periods of time while we are emptying the queue in itestart().
142: * If it is too small, console output will be very ragged.
143: */
144: int iteburst = 64;
145:
146: int nite = NITE;
147: struct tty *kbd_tty = NULL;
148: struct tty ite_cons;
149: struct tty *ite_tty[NITE] = { &ite_cons };
150: struct ite_softc ite_softc[NITE];
151:
152: int itestart();
153: extern int ttrstrt();
154: extern struct tty *constty;
155:
156: /* These are (later..) settable via an ioctl */
157: int start_repeat_timo = 30; /* /100: initial timeout till pressed key repeats */
158: int next_repeat_timo = 5; /* /100: timeout when repeating for next char */
159:
160: /*
161: * Primary attribute buffer to be used by the first bitmapped console
162: * found. Secondary displays alloc the attribute buffer as needed.
163: * Size is based on a 68x128 display, which is currently our largest.
164: */
165: u_char console_attributes[0x2200];
166:
167: /*
168: * Perform functions necessary to setup device as a terminal emulator.
169: */
170: iteon(dev, flag)
171: dev_t dev;
172: {
173: int unit = UNIT(dev);
174: struct tty *tp = ite_tty[unit];
175: struct ite_softc *ip = &ite_softc[unit];
176:
177: if (unit < 0 || unit >= NITE || (ip->flags&ITE_ALIVE) == 0)
178: return(ENXIO);
179: /* force ite active, overriding graphics mode */
180: if (flag & 1) {
181: ip->flags |= ITE_ACTIVE;
182: ip->flags &= ~(ITE_INGRF|ITE_INITED);
183: }
184: /* leave graphics mode */
185: if (flag & 2) {
186: ip->flags &= ~ITE_INGRF;
187: if ((ip->flags & ITE_ACTIVE) == 0)
188: return(0);
189: }
190: ip->flags |= ITE_ACTIVE;
191: if (ip->flags & ITE_INGRF)
192: return(0);
193: if (kbd_tty == NULL || kbd_tty == tp) {
194: kbd_tty = tp;
195: kbdenable();
196: }
197: iteinit(dev);
198: return(0);
199: }
200:
201: /* used by the grf layer to reinitialize ite after changing fb parameters */
202: itereinit(dev)
203: dev_t dev;
204: {
205: int unit = UNIT(dev);
206: struct ite_softc *ip = &ite_softc[unit];
207:
208: ip->flags &= ~ITE_INITED;
209: iteinit (dev);
210: }
211:
212: iteinit(dev)
213: dev_t dev;
214: {
215: int unit = UNIT(dev);
216: struct ite_softc *ip = &ite_softc[unit];
217:
218: if (ip->flags & ITE_INITED)
219: return;
220:
221: ip->curx = 0;
222: ip->cury = 0;
223: ip->cursorx = 0;
224: ip->cursory = 0;
225: ip->save_curx = 0;
226: ip->save_cury = 0;
227: ip->ap = ip->argbuf;
228: ip->emul_level = EMUL_VT300_7;
229: ip->eightbit_C1 = 0;
230: ip->inside_margins = 0;
231: ip->linefeed_newline = 0;
232:
233: (*itesw[ip->type].ite_init)(ip);
234: (*itesw[ip->type].ite_cursor)(ip, DRAW_CURSOR);
235:
236: /* ip->rows initialized by ite_init above */
237: ip->top_margin = 0; ip->bottom_margin = ip->rows - 1;
238:
239: ip->attribute = 0;
240: if (ip->attrbuf == NULL)
241: ip->attrbuf = (u_char *)
242: malloc(ip->rows * ip->cols, M_DEVBUF, M_WAITOK);
243: bzero(ip->attrbuf, (ip->rows * ip->cols));
244:
245: ip->imode = 0;
246: ip->flags |= ITE_INITED;
247: }
248:
249: /*
250: * "Shut down" device as terminal emulator.
251: * Note that we do not deinit the console device unless forced.
252: * Deinit'ing the console every time leads to a very active
253: * screen when processing /etc/rc.
254: */
255: iteoff(dev, flag)
256: dev_t dev;
257: {
258: register struct ite_softc *ip = &ite_softc[UNIT(dev)];
259:
260: if (flag & 2)
261: ip->flags |= ITE_INGRF;
262: if ((ip->flags & ITE_ACTIVE) == 0)
263: return;
264: if ((flag & 1) ||
265: (ip->flags & (ITE_INGRF|ITE_ISCONS|ITE_INITED)) == ITE_INITED)
266: (*itesw[ip->type].ite_deinit)(ip);
267: if ((flag & 2) == 0)
268: ip->flags &= ~ITE_ACTIVE;
269: }
270:
271: /* ARGSUSED */
272: #ifdef __STDC__
273: iteopen(dev_t dev, int mode, int devtype, struct proc *p)
274: #else
275: iteopen(dev, mode, devtype, p)
276: dev_t dev;
277: int mode, devtype;
278: struct proc *p;
279: #endif
280: {
281: int unit = UNIT(dev);
282: register struct tty *tp;
283: register struct ite_softc *ip = &ite_softc[unit];
284: register int error;
285: int first = 0;
286:
287: if(!ite_tty[unit]) {
288: MALLOC(tp, struct tty *, sizeof(struct tty), M_TTYS, M_WAITOK);
289: bzero(tp, sizeof(struct tty));
290: ite_tty[unit] = tp;
291: } else
292: tp = ite_tty[unit];
293:
294: if ((tp->t_state&(TS_ISOPEN|TS_XCLUDE)) == (TS_ISOPEN|TS_XCLUDE)
295: && p->p_ucred->cr_uid != 0)
296: return (EBUSY);
297: if ((ip->flags & ITE_ACTIVE) == 0) {
298: error = iteon(dev, 0);
299: if (error)
300: return (error);
301: first = 1;
302: }
303: tp->t_oproc = itestart;
304: tp->t_param = NULL;
305: tp->t_dev = dev;
306: if ((tp->t_state&TS_ISOPEN) == 0) {
307: ttychars(tp);
308: tp->t_iflag = TTYDEF_IFLAG;
309: tp->t_oflag = TTYDEF_OFLAG;
310: tp->t_cflag = CS8|CREAD;
311: tp->t_lflag = TTYDEF_LFLAG;
312: tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
313: /* don't set TS_ISOPEN here, or the tty queues won't
314: be initialized in ttyopen()! */
315: tp->t_state = TS_CARR_ON;
316: ttsetwater(tp);
317: }
318: error = (*linesw[tp->t_line].l_open)(dev, tp);
319: if (error == 0) {
320: tp->t_winsize.ws_row = ip->rows;
321: tp->t_winsize.ws_col = ip->cols;
322: } else if (first)
323: iteoff(dev, 0);
324: return (error);
325: }
326:
327: /*ARGSUSED*/
328: iteclose(dev, flag, mode, p)
329: dev_t dev;
330: int flag, mode;
331: struct proc *p;
332: {
333: register struct tty *tp = ite_tty[UNIT(dev)];
334:
335: (*linesw[tp->t_line].l_close)(tp, flag);
336: ttyclose(tp);
337: iteoff(dev, 0);
338: if (tp != &ite_cons)
339: {
340: FREE(tp, M_TTYS);
341: ite_tty[UNIT(dev)] = (struct tty *)NULL;
342: }
343: return(0);
344: }
345:
346: iteread(dev, uio, flag)
347: dev_t dev;
348: struct uio *uio;
349: {
350: register struct tty *tp = ite_tty[UNIT(dev)];
351: int rc;
352:
353: rc = ((*linesw[tp->t_line].l_read)(tp, uio, flag));
354: return rc;
355: }
356:
357: itewrite(dev, uio, flag)
358: dev_t dev;
359: struct uio *uio;
360: {
361: int unit = UNIT(dev);
362: register struct tty *tp = ite_tty[unit];
363:
364: if ((ite_softc[unit].flags & ITE_ISCONS) && constty &&
365: (constty->t_state&(TS_CARR_ON|TS_ISOPEN))==(TS_CARR_ON|TS_ISOPEN))
366: tp = constty;
367: return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
368: }
369:
370: iteioctl(dev, cmd, addr, flag)
371: dev_t dev;
372: caddr_t addr;
373: {
374: register struct tty *tp = ite_tty[UNIT(dev)];
375: int error;
376:
377: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, addr, flag);
378: if (error >= 0)
379: return (error);
380: error = ttioctl(tp, cmd, addr, flag);
381: if (error >= 0)
382: return (error);
383: return (ENOTTY);
384: }
385:
386: itestart(tp)
387: register struct tty *tp;
388: {
389: register int cc, s;
390: int hiwat = 0;
391:
392: s = spltty();
393: if (tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP)) {
394: splx(s);
395: return;
396: }
397: tp->t_state |= TS_BUSY;
398: cc = RB_LEN (&tp->t_out);
399: if (cc <= tp->t_lowat) {
400: if (tp->t_state & TS_ASLEEP) {
401: tp->t_state &= ~TS_ASLEEP;
402: wakeup(&tp->t_out);
403: }
404: selwakeup(&tp->t_wsel);
405: }
406: /*
407: * Limit the amount of output we do in one burst
408: * to prevent hogging the CPU.
409: */
410: if (cc > iteburst) {
411: hiwat++;
412: cc = iteburst;
413: }
414: while (--cc >= 0) {
415: register int c;
416:
417: c = rbgetc(&tp->t_out);
418: /*
419: * iteputchar() may take a long time and we don't want to
420: * block all interrupts for long periods of time. Since
421: * there is no need to stay at high priority while outputing
422: * the character (since we don't have to worry about
423: * interrupts), we don't. We just need to make sure that
424: * we don't reenter iteputchar, which is guarenteed by the
425: * earlier setting of TS_BUSY.
426: */
427: splx(s);
428: iteputchar(c, tp->t_dev);
429: spltty();
430: }
431: if (hiwat) {
432: tp->t_state |= TS_TIMEOUT;
433: timeout(ttrstrt, tp, 1);
434: }
435: tp->t_state &= ~TS_BUSY;
436: splx(s);
437: }
438:
439: /* these are used to implement repeating keys.. */
440: static u_char last_char = 0;
441: static u_char tout_pending = 0;
442:
443: static void
444: repeat_handler (a0, a1)
445: int a0, a1;
446: {
447: tout_pending = 0;
448: /* leave it up to itefilter() to possible install a new callout entry
449: to reinvoke repeat_handler() */
450: itefilter (last_char, ITEFILT_REPEATER);
451: }
452:
453:
454: int
455: itefilter(c, caller)
456: register u_char c;
457: enum caller caller;
458: {
459: static u_char mod = 0;
460: static u_char last_dead = 0;
461: register char code, *str;
462: u_char up, mask, i;
463: struct key key;
464:
465: if (caller != ITEFILT_CONSOLE && kbd_tty == NULL)
466: return;
467:
468: up = c & 0x80 ? 1 : 0;
469: c &= 0x7f;
470: code = 0;
471:
472: mask = 0;
473: if (c >= KBD_LEFT_SHIFT)
474: {
475: switch (c)
476: {
477: case KBD_LEFT_SHIFT:
478: mask = KBD_MOD_LSHIFT;
479: break;
480:
481: case KBD_RIGHT_SHIFT:
482: mask = KBD_MOD_RSHIFT;
483: break;
484:
485: case KBD_LEFT_ALT:
486: mask = KBD_MOD_LALT;
487: break;
488:
489: case KBD_RIGHT_ALT:
490: mask = KBD_MOD_RALT;
491: break;
492:
493: case KBD_LEFT_META:
494: mask = KBD_MOD_LMETA;
495: break;
496:
497: case KBD_RIGHT_META:
498: mask = KBD_MOD_RMETA;
499: break;
500:
501: case KBD_CAPS_LOCK:
502: /* capslock already behaves `right', don't need to keep track of the
503: state in here. */
504: mask = KBD_MOD_CAPS;
505: break;
506:
507: case KBD_CTRL:
508: mask = KBD_MOD_CTRL;
509: break;
510: }
511:
512: if (mask)
513: {
514: if (up)
515: mod &= ~mask;
516: else
517: mod |= mask;
518: }
519:
520: /* these keys should not repeat, so it's the Right Thing dealing with
521: repeaters only after this block. */
522:
523: /* return even if it wasn't a modifier key, the other codes up here
524: are either special (like reset warning), or not yet defined */
525: return -1;
526: }
527:
528: /* no matter which character we're repeating, stop it if we get a key-up
529: event. I think this is the same thing amigados does. */
530: if (up)
531: {
532: if (tout_pending)
533: {
534: untimeout (repeat_handler, 0);
535: tout_pending = 0;
536: }
537: return -1;
538: }
539:
540:
541: switch (mod & (KBD_MOD_ALT | KBD_MOD_SHIFT))
542: {
543: case 0:
544: key = kbdmap.keys[c];
545: if (!(mod & KBD_MOD_CAPS) || !(key.mode & KBD_MODE_CAPS))
546: break;
547: /* FALL INTO */
548:
549: case KBD_MOD_LSHIFT:
550: case KBD_MOD_RSHIFT:
551: case KBD_MOD_SHIFT:
552: key = kbdmap.shift_keys[c];
553: break;
554:
555: case KBD_MOD_LALT:
556: case KBD_MOD_RALT:
557: case KBD_MOD_ALT:
558: key = kbdmap.alt_keys[c];
559: if (!(mod & KBD_MOD_CAPS) || !(key.mode & KBD_MODE_CAPS))
560: break;
561: /* FALL INTO */
562:
563: case KBD_MOD_LALT|KBD_MOD_LSHIFT:
564: case KBD_MOD_LALT|KBD_MOD_RSHIFT:
565: case KBD_MOD_LALT|KBD_MOD_SHIFT:
566: case KBD_MOD_RALT|KBD_MOD_RSHIFT:
567: case KBD_MOD_RALT|KBD_MOD_SHIFT:
568: case KBD_MOD_ALT|KBD_MOD_RSHIFT:
569: key = kbdmap.alt_shift_keys[c];
570: break;
571: }
572:
573: code = key.code;
574:
575: /* arrange to repeat the keystroke. By doing this at the level of scan-codes,
576: we can have function keys, and keys that send strings, repeat too. This
577: also entitles an additional overhead, since we have to do the conversion
578: each time, but I guess that's ok. */
579: if (!tout_pending && caller == ITEFILT_TTY)
580: {
581: tout_pending = 1;
582: last_char = c;
583: timeout (repeat_handler, 0, start_repeat_timo);
584: }
585: else if (!tout_pending && caller == ITEFILT_REPEATER)
586: {
587: tout_pending = 1;
588: last_char = c;
589: timeout (repeat_handler, 0, next_repeat_timo);
590: }
591:
592: /* handle dead keys */
593: if (key.mode & KBD_MODE_DEAD)
594: {
595: /* if entered twice, send accent itself */
596: if (last_dead == key.mode & KBD_MODE_ACCMASK)
597: last_dead = 0;
598: else
599: {
600: last_dead = key.mode & KBD_MODE_ACCMASK;
601: return -1;
602: }
603: }
604: if (last_dead)
605: {
606: /* can't apply dead flag to string-keys */
607: if (! (key.mode & KBD_MODE_STRING) && code >= '@' && code < 0x7f)
608: code = acctable[KBD_MODE_ACCENT (last_dead)][code - '@'];
609:
610: last_dead = 0;
611: }
612:
613: /* if not string, apply META and CTRL modifiers */
614: if (! (key.mode & KBD_MODE_STRING))
615: {
616: if (mod & KBD_MOD_CTRL)
617: code &= 0x1f;
618:
619: if (mod & KBD_MOD_META)
620: code |= 0x80;
621: }
622: else
623: {
624: /* strings are only supported in normal tty mode, not in console mode */
625: if (caller != ITEFILT_CONSOLE)
626: {
627: str = kbdmap.strings + code;
628: /* using a length-byte instead of 0-termination allows to embed \0 into
629: strings, although this is not used in the default keymap */
630: for (i = *str++; i; i--)
631: (*linesw[kbd_tty->t_line].l_rint)(*str++, kbd_tty);
632: }
633: return -1;
634: }
635:
636: if (caller == ITEFILT_CONSOLE)
637: return code;
638: else
639: (*linesw[kbd_tty->t_line].l_rint)(code, kbd_tty);
640:
641: return -1;
642: }
643:
644:
645: /* helper functions, makes the code below more readable */
646: static void inline
647: ite_dnchar(ip, sp, n)
648: struct ite_softc *ip;
649: struct itesw *sp;
650: int n;
651: {
652: (*sp->ite_scroll)(ip, ip->cury, ip->curx + n, n, SCROLL_LEFT);
653: attrmov(ip, ip->cury, ip->curx + n, ip->cury, ip->curx,
654: 1, ip->cols - ip->curx - n);
655: attrclr(ip, ip->cury, ip->cols - n, 1, n);
656: while (n--)
657: (*sp->ite_putc)(ip, ' ', ip->cury, ip->cols - n - 1, ATTR_NOR);
658: (*sp->ite_cursor)(ip, DRAW_CURSOR);
659: }
660:
661: static void inline
662: ite_inchar(ip, sp, n)
663: struct ite_softc *ip;
664: struct itesw *sp;
665: int n;
666: {
667: (*sp->ite_scroll)(ip, ip->cury, ip->curx, n, SCROLL_RIGHT);
668: attrmov(ip, ip->cury, ip->curx, ip->cury, ip->curx + n,
669: 1, ip->cols - ip->curx - n);
670: attrclr(ip, ip->cury, ip->curx, 1, n);
671: while (n--)
672: (*sp->ite_putc)(ip, ' ', ip->cury, ip->curx + n, ATTR_NOR);
673: (*sp->ite_cursor)(ip, DRAW_CURSOR);
674: }
675:
676: static void inline
677: ite_clrtoeol(ip, sp, y, x)
678: struct ite_softc *ip;
679: struct itesw *sp;
680: int y, x;
681: {
682: (*sp->ite_clear)(ip, y, x, 1, ip->cols - x);
683: attrclr(ip, y, x, 1, ip->cols - x);
684: (*sp->ite_cursor)(ip, DRAW_CURSOR);
685: }
686:
687: static void inline
688: ite_clrtobol(ip, sp, y, x)
689: struct ite_softc *ip;
690: struct itesw *sp;
691: int y, x;
692: {
693: (*sp->ite_clear)(ip, y, 0, 1, x);
694: attrclr(ip, y, 0, 1, x);
695: (*sp->ite_cursor)(ip, DRAW_CURSOR);
696: }
697:
698: static void inline
699: ite_clrline(ip, sp, y, x)
700: struct ite_softc *ip;
701: struct itesw *sp;
702: int y, x;
703: {
704: (*sp->ite_clear)(ip, y, 0, 1, ip->cols);
705: attrclr(ip, y, 0, 1, ip->cols);
706: (*sp->ite_cursor)(ip, DRAW_CURSOR);
707: }
708:
709:
710:
711: static void inline
712: ite_clrtoeos(ip, sp)
713: struct ite_softc *ip;
714: struct itesw *sp;
715: {
716: (*sp->ite_clear)(ip, ip->cury, 0, ip->rows - ip->cury, ip->cols);
717: attrclr(ip, ip->cury, 0, ip->rows - ip->cury, ip->cols);
718: (*sp->ite_cursor)(ip, DRAW_CURSOR);
719: }
720:
721: static void inline
722: ite_clrtobos(ip, sp)
723: struct ite_softc *ip;
724: struct itesw *sp;
725: {
726: (*sp->ite_clear)(ip, 0, 0, ip->cury, ip->cols);
727: attrclr(ip, 0, 0, ip->cury, ip->cols);
728: (*sp->ite_cursor)(ip, DRAW_CURSOR);
729: }
730:
731: static void inline
732: ite_clrscreen(ip, sp)
733: struct ite_softc *ip;
734: struct itesw *sp;
735: {
736: (*sp->ite_clear)(ip, 0, 0, ip->rows, ip->cols);
737: attrclr(ip, 0, 0, ip->rows, ip->cols);
738: (*sp->ite_cursor)(ip, DRAW_CURSOR);
739: }
740:
741:
742:
743: static void inline
744: ite_dnline(ip, sp, n)
745: struct ite_softc *ip;
746: struct itesw *sp;
747: int n;
748: {
749: (*sp->ite_scroll)(ip, ip->cury + n, 0, n, SCROLL_UP);
750: attrmov(ip, ip->cury + n, 0, ip->cury, 0,
751: ip->bottom_margin + 1 - ip->cury - n, ip->cols);
752: (*sp->ite_clear)(ip, ip->bottom_margin - n + 1, 0, n, ip->cols);
753: attrclr(ip, ip->bottom_margin - n + 1, 0, n, ip->cols);
754: (*sp->ite_cursor)(ip, DRAW_CURSOR);
755: }
756:
757: static void inline
758: ite_inline(ip, sp, n)
759: struct ite_softc *ip;
760: struct itesw *sp;
761: int n;
762: {
763: (*sp->ite_scroll)(ip, ip->cury, 0, n, SCROLL_DOWN);
764: attrmov(ip, ip->cury, 0, ip->cury + n, 0,
765: ip->bottom_margin + 1 - ip->cury - n, ip->cols);
766: (*sp->ite_clear)(ip, ip->cury, 0, n, ip->cols);
767: attrclr(ip, ip->cury, 0, n, ip->cols);
768: (*sp->ite_cursor)(ip, DRAW_CURSOR);
769: }
770:
771: static void inline
772: ite_lf (ip, sp)
773: struct ite_softc *ip;
774: struct itesw *sp;
775: {
776: #if 0
777: if (ip->inside_margins)
778: {
779: #endif
780: if (++ip->cury >= ip->bottom_margin + 1)
781: {
782: ip->cury = ip->bottom_margin;
783: (*sp->ite_scroll)(ip, ip->top_margin + 1, 0, 1, SCROLL_UP);
784: ite_clrtoeol(ip, sp, ip->cury, 0);
785: }
786: else
787: (*sp->ite_cursor)(ip, MOVE_CURSOR);
788: #if 0
789: }
790: else
791: {
792: if (++ip->cury == ip->rows)
793: {
794: --ip->cury;
795: (*sp->ite_scroll)(ip, 1, 0, 1, SCROLL_UP);
796: ite_clrtoeol(ip, sp, ip->cury, 0);
797: }
798: else
799: (*sp->ite_cursor)(ip, MOVE_CURSOR);
800: }
801: #endif
802: clr_attr(ip, ATTR_INV);
803: }
804:
805: static void inline
806: ite_crlf (ip, sp)
807: struct ite_softc *ip;
808: struct itesw *sp;
809: {
810: ip->curx = 0;
811: ite_lf (ip, sp);
812: }
813:
814: static void inline
815: ite_cr (ip, sp)
816: struct ite_softc *ip;
817: struct itesw *sp;
818: {
819: if (ip->curx)
820: {
821: ip->curx = 0;
822: (*sp->ite_cursor)(ip, MOVE_CURSOR);
823: }
824: }
825:
826: static void inline
827: ite_rlf (ip, sp)
828: struct ite_softc *ip;
829: struct itesw *sp;
830: {
831: if (ip->cury > 0)
832: {
833: ip->cury--;
834: (*sp->ite_cursor)(ip, MOVE_CURSOR);
835: }
836: else
837: ite_inline (ip, sp, 1);
838: clr_attr(ip, ATTR_INV);
839: }
840:
841: static int inline
842: atoi (cp)
843: const char *cp;
844: {
845: int n;
846:
847: for (n = 0; *cp && *cp >= '0' && *cp <= '9'; cp++)
848: n = n * 10 + *cp - '0';
849:
850: return n;
851: }
852:
853: static char *
854: index (cp, ch)
855: const char *cp;
856: char ch;
857: {
858: while (*cp && *cp != ch) cp++;
859: return *cp ? cp : 0;
860: }
861:
862:
863:
864: static int inline
865: ite_argnum (ip)
866: struct ite_softc *ip;
867: {
868: char ch;
869: int n;
870:
871: /* convert argument string into number */
872: if (ip->ap == ip->argbuf)
873: return 1;
874: ch = *ip->ap;
875: *ip->ap = 0;
876: n = atoi (ip->argbuf);
877: *ip->ap = ch;
878:
879: return n;
880: }
881:
882: static int inline
883: ite_zargnum (ip)
884: struct ite_softc *ip;
885: {
886: char ch, *cp;
887: int n;
888:
889: /* convert argument string into number */
890: if (ip->ap == ip->argbuf)
891: return 0;
892: ch = *ip->ap;
893: *ip->ap = 0;
894: n = atoi (ip->argbuf);
895: *ip->ap = ch;
896:
897: return n;
898: }
899:
900: static void inline
901: ite_sendstr (ip, str)
902: struct ite_softc *ip;
903: char *str;
904: {
905: while (*str)
906: (*linesw[kbd_tty->t_line].l_rint)(*str++, kbd_tty);
907: }
908:
909: static int inline
910: strncmp (a, b, l)
911: const char *a, *b;
912: int l;
913: {
914: for (;l--; a++, b++)
915: if (*a != *b)
916: return *a - *b;
917: return 0;
918: }
919:
920: static void inline
921: ite_reinit(ip)
922: struct ite_softc *ip;
923: {
924: ip->curx = 0;
925: ip->cury = 0;
926: ip->cursorx = 0;
927: ip->cursory = 0;
928: ip->save_curx = 0;
929: ip->save_cury = 0;
930: ip->ap = ip->argbuf;
931: ip->emul_level = EMUL_VT300_7;
932: ip->eightbit_C1 = 0;
933: ip->top_margin = 0; ip->bottom_margin = 23;
934: ip->inside_margins = 0;
935: ip->linefeed_newline = 0;
936:
937: (*itesw[ip->type].ite_cursor)(ip, DRAW_CURSOR);
938:
939: ip->attribute = 0;
940: bzero(ip->attrbuf, (ip->rows * ip->cols));
941:
942: ip->imode = 0;
943: }
944:
945:
946:
947: iteputchar(c, dev)
948: register int c;
949: dev_t dev;
950: {
951: int unit = UNIT(dev);
952: register struct ite_softc *ip = &ite_softc[unit];
953: register struct itesw *sp = &itesw[ip->type];
954: register int n;
955: int x, y;
956: char *cp;
957:
958: if ((ip->flags & (ITE_ACTIVE|ITE_INGRF)) != ITE_ACTIVE)
959: return;
960:
961: if ((ite_tty[unit]->t_cflag & CSIZE) == CS7
962: || (ite_tty[unit]->t_cflag & PARENB))
963: c &= 0x7f;
964:
965: if (ip->escape)
966: {
967: doesc:
968: switch (ip->escape)
969: {
970: case ESC:
971: switch (c)
972: {
973: /* first 7bit equivalents for the 8bit control characters */
974:
975: case 'D':
976: c = IND;
977: ip->escape = 0;
978: break;
979:
980: case 'E':
981: c = NEL;
982: ip->escape = 0;
983: break;
984:
985: case 'H':
986: c = HTS;
987: ip->escape = 0;
988: break;
989:
990: case 'M':
991: c = RI;
992: ip->escape = 0;
993: break;
994:
995: case 'N':
996: c = SS2;
997: ip->escape = 0;
998: break;
999:
1000: case 'O':
1001: c = SS3;
1002: ip->escape = 0;
1003: break;
1004:
1005: case 'P':
1006: c = DCS;
1007: ip->escape = 0;
1008: break;
1009:
1010: case '[':
1011: c = CSI;
1012: ip->escape = 0;
1013: break;
1014:
1015: case '\\':
1016: c = ST;
1017: ip->escape = 0;
1018: break;
1019:
1020: case ']':
1021: c = OSC;
1022: ip->escape = 0;
1023: break;
1024:
1025: case '^':
1026: c = PM;
1027: ip->escape = 0;
1028: break;
1029:
1030: case '_':
1031: c = APC;
1032: ip->escape = 0;
1033: break;
1034:
1035:
1036: /* introduces 7/8bit control */
1037: case ' ':
1038: /* can be followed by either F or G */
1039: ip->escape = ' ';
1040: break;
1041:
1042:
1043: /* a lot of character set selections, not yet used...
1044: 94-character sets: */
1045: case '(': /* G0 */
1046: case ')': /* G1 */
1047: case '*': /* G2 */
1048: case '+': /* G3 */
1049: case 'B': /* ASCII */
1050: case 'A': /* ISO latin 1 */
1051: case '<': /* user preferred suplemental */
1052: case '0': /* dec special graphics */
1053:
1054: /* 96-character sets: */
1055: case '-': /* G1 */
1056: case '.': /* G2 */
1057: case '/': /* G3 */
1058:
1059: /* national character sets: */
1060: case '4': /* dutch */
1061: case '5':
1062: case 'C': /* finnish */
1063: case 'R': /* french */
1064: case 'Q': /* french canadian */
1065: case 'K': /* german */
1066: case 'Y': /* italian */
1067: case '6': /* norwegian/danish */
1068: case 'Z': /* spanish */
1069: case '=': /* swiss */
1070: /* note: %5 and %6 are not supported (two chars..) */
1071:
1072: ip->escape = 0;
1073: /* just ignore for now */
1074: return -1;
1075:
1076:
1077: /* locking shift modes (as you might guess, not yet supported..) */
1078: case '`':
1079: ip->GR = ip->G1;
1080: ip->escape = 0;
1081: return -1;
1082:
1083: case 'n':
1084: ip->GL = ip->G2;
1085: ip->escape = 0;
1086: return -1;
1087:
1088: case '}':
1089: ip->GR = ip->G2;
1090: ip->escape = 0;
1091: return -1;
1092:
1093: case 'o':
1094: ip->GL = ip->G3;
1095: ip->escape = 0;
1096: return -1;
1097:
1098: case '|':
1099: ip->GR = ip->G3;
1100: ip->escape = 0;
1101: return -1;
1102:
1103:
1104: /* font width/height control */
1105: case '#':
1106: ip->escape = '#';
1107: return -1;
1108:
1109:
1110: /* hard terminal reset .. */
1111: case 'c':
1112: ite_reinit (ip);
1113: ip->escape = 0;
1114: return -1;
1115:
1116:
1117: case '7':
1118: ip->save_curx = ip->curx;
1119: ip->save_cury = ip->cury;
1120: ip->escape = 0;
1121: return -1;
1122:
1123: case '8':
1124: ip->curx = ip->save_curx;
1125: ip->cury = ip->save_cury;
1126: (*sp->ite_cursor)(ip, MOVE_CURSOR);
1127: ip->escape = 0;
1128: return -1;
1129:
1130:
1131: /* default catch all for not recognized ESC sequences */
1132: default:
1133: ip->escape = 0;
1134: return -1;
1135: }
1136: break;
1137:
1138:
1139: case ' ':
1140: switch (c)
1141: {
1142: case 'F':
1143: ip->eightbit_C1 = 0;
1144: ip->escape = 0;
1145: return -1;
1146:
1147: case 'G':
1148: ip->eightbit_C1 = 1;
1149: ip->escape = 0;
1150: return -1;
1151:
1152: default:
1153: /* not supported */
1154: ip->escape = 0;
1155: return -1;
1156: }
1157: break;
1158:
1159:
1160: case '#':
1161: switch (c)
1162: {
1163: case '5':
1164: /* single height, single width */
1165: ip->escape = 0;
1166: return -1;
1167:
1168: case '6':
1169: /* double width, single height */
1170: ip->escape = 0;
1171: return -1;
1172:
1173: case '3':
1174: /* top half */
1175: ip->escape = 0;
1176: return -1;
1177:
1178: case '4':
1179: /* bottom half */
1180: ip->escape = 0;
1181: return -1;
1182:
1183: case '8':
1184: /* screen alignment pattern... */
1185: ip->escape = 0;
1186: return -1;
1187:
1188: default:
1189: ip->escape = 0;
1190: return -1;
1191: }
1192: break;
1193:
1194:
1195:
1196: #if 0
1197: case DCS:
1198: case PM:
1199: case APC:
1200: case OSC:
1201: switch (c)
1202: {
1203: case ST:
1204: ip->escape = 0;
1205: return -1;
1206:
1207: default:
1208: return -1;
1209: }
1210: break;
1211: #endif
1212:
1213:
1214: case CSI:
1215: /* the biggie... */
1216: switch (c)
1217: {
1218: case '0': case '1': case '2': case '3': case '4':
1219: case '5': case '6': case '7': case '8': case '9':
1220: case ';': case '\"': case '$': case '>':
1221: if (ip->ap < ip->argbuf + ARGBUF_SIZE)
1222: *ip->ap++ = c;
1223: return -1;
1224:
1225: case CAN:
1226: ip->escape = 0;
1227: return -1;
1228:
1229:
1230: case 'p':
1231: *ip->ap = 0;
1232: if (! strncmp (ip->argbuf, "61\"", 3))
1233: ip->emul_level = EMUL_VT100;
1234: else if (! strncmp (ip->argbuf, "63;1\"", 5)
1235: || ! strncmp (ip->argbuf, "62;1\"", 5))
1236: ip->emul_level = EMUL_VT300_7;
1237: else
1238: ip->emul_level = EMUL_VT300_8;
1239: ip->escape = 0;
1240: return -1;
1241:
1242:
1243: case '?':
1244: *ip->ap = 0;
1245: ip->escape = '?';
1246: ip->ap = ip->argbuf;
1247: return -1;
1248:
1249:
1250: case 'c':
1251: *ip->ap = 0;
1252: if (ip->ap == ip->argbuf
1253: || (ip->ap == &ip->argbuf[1] && ip->argbuf[0] == '0'))
1254: {
1255: /* primary DA request, send primary DA response */
1256: if (ip->emul_level == EMUL_VT100)
1257: ite_sendstr (ip, "\033[61;0c");
1258: else
1259: ite_sendstr (ip, "\033[63;0c");
1260: }
1261:
1262: else if ((ip->ap == &ip->argbuf[1] && ip->argbuf[0] == '>')
1263: || (ip->ap == &ip->argbuf[2]
1264: && !strncmp (ip->argbuf, ">0", 2)))
1265: {
1266: ite_sendstr (ip, "\033[>24;0;0;0c");
1267: }
1268:
1269: ip->escape = 0;
1270: return -1;
1271:
1272:
1273: case 'n':
1274: *ip->ap = 0;
1275: if (ip->ap == &ip->argbuf[1])
1276: {
1277: if (ip->argbuf[0] == '5')
1278: ite_sendstr (ip, "\033[0n"); /* no malfunction */
1279:
1280: else if (ip->argbuf[0] == '6')
1281: {
1282: sprintf (ip->argbuf, "\033[%d;%dR",
1283: ip->cury + 1, ip->curx + 1);
1284: /* cursor position report */
1285: ite_sendstr (ip, ip->argbuf);
1286: }
1287:
1288: }
1289: ip->escape = 0;
1290: return -1;
1291:
1292:
1293: case 'h': case 'l':
1294: *ip->ap = 0;
1295: if (ip->ap == &ip->argbuf[1] && ip->argbuf[0] == '4')
1296: ip->imode = (c == 'h'); /* insert/replace mode */
1297:
1298: else if (ip->ap == &ip->argbuf[2]
1299: && !strncmp (ip->argbuf, "20", 2))
1300: ip->linefeed_newline = (c == 'h');
1301:
1302:
1303: /* various not supported commands */
1304: ip->escape = 0;
1305: return -1;
1306:
1307:
1308: case 'M':
1309: *ip->ap = 0;
1310: ite_dnline (ip, sp, ite_argnum (ip));
1311: ip->escape = 0;
1312: return -1;
1313:
1314:
1315: case 'L':
1316: *ip->ap = 0;
1317: ite_inline (ip, sp, ite_argnum (ip));
1318: ip->escape = 0;
1319: return -1;
1320:
1321:
1322: case 'P':
1323: *ip->ap = 0;
1324: ite_dnchar (ip, sp, ite_argnum (ip));
1325: ip->escape = 0;
1326: return -1;
1327:
1328:
1329: case '@':
1330: *ip->ap = 0;
1331: ite_inchar (ip, sp, ite_argnum (ip));
1332: ip->escape = 0;
1333: return -1;
1334:
1335:
1336: case 'H':
1337: case 'f':
1338: *ip->ap = 0;
1339: y = atoi (ip->argbuf);
1340: x = 0;
1341: cp = index (ip->argbuf, ';');
1342: if (cp)
1343: x = atoi (cp + 1);
1344: if (x) x--;
1345: if (y) y--;
1346: if (ip->inside_margins)
1347: {
1348: y += ip->top_margin;
1349: ip->cury = MIN(y, ip->bottom_margin);
1350: }
1351: else
1352: {
1353: ip->cury = MIN(y, ip->rows - 1);
1354: }
1355: ip->curx = MIN(x, ip->cols - 1);
1356: ip->escape = 0;
1357: (*sp->ite_cursor)(ip, MOVE_CURSOR);
1358: clr_attr (ip, ATTR_INV);
1359: return -1;
1360:
1361: case 'A':
1362: *ip->ap = 0;
1363: n = ip->cury - ite_argnum (ip);
1364: ip->cury = n >= 0 ? n : 0;
1365: ip->escape = 0;
1366: (*sp->ite_cursor)(ip, MOVE_CURSOR);
1367: clr_attr (ip, ATTR_INV);
1368: return -1;
1369:
1370: case 'B':
1371: *ip->ap = 0;
1372: n = ite_argnum (ip) + ip->cury;
1373: ip->cury = MIN(n, ip->rows - 1);
1374: ip->escape = 0;
1375: (*sp->ite_cursor)(ip, MOVE_CURSOR);
1376: clr_attr (ip, ATTR_INV);
1377: return -1;
1378:
1379: case 'C':
1380: *ip->ap = 0;
1381: n = ite_argnum (ip) + ip->curx;
1382: ip->curx = MIN(n, ip->cols - 1);
1383: ip->escape = 0;
1384: (*sp->ite_cursor)(ip, MOVE_CURSOR);
1385: clr_attr (ip, ATTR_INV);
1386: return -1;
1387:
1388: case 'D':
1389: *ip->ap = 0;
1390: n = ip->curx - ite_argnum (ip);
1391: ip->curx = n >= 0 ? n : 0;
1392: ip->escape = 0;
1393: (*sp->ite_cursor)(ip, MOVE_CURSOR);
1394: clr_attr (ip, ATTR_INV);
1395: return -1;
1396:
1397:
1398:
1399:
1400: case 'J':
1401: *ip->ap = 0;
1402: n = ite_zargnum (ip);
1403: if (n == 0)
1404: ite_clrtoeos(ip, sp);
1405: else if (n == 1)
1406: ite_clrtobos(ip, sp);
1407: else if (n == 2)
1408: ite_clrscreen(ip, sp);
1409: ip->escape = 0;
1410: return -1;
1411:
1412:
1413: case 'K':
1414: *ip->ap = 0;
1415: n = ite_zargnum (ip);
1416: if (n == 0)
1417: ite_clrtoeol(ip, sp, ip->cury, ip->curx);
1418: else if (n == 1)
1419: ite_clrtobol(ip, sp, ip->cury, ip->curx);
1420: else if (n == 2)
1421: ite_clrline(ip, sp, ip->cury, ip->curx);
1422: ip->escape = 0;
1423: return -1;
1424:
1425:
1426: case 'X':
1427: *ip->ap = 0;
1428: for (n = ite_argnum (ip); n > 0; n--)
1429: {
1430: attrclr(ip, ip->cury, ip->curx + n - 1, 1, 1);
1431: (*sp->ite_putc)(ip, ' ', ip->cury, ip->curx + n - 1, ATTR_NOR);
1432: }
1433: ip->escape = 0;
1434: return -1;
1435:
1436:
1437: case '}': case '`':
1438: /* status line control */
1439: ip->escape = 0;
1440: return -1;
1441:
1442:
1443: case 'r':
1444: *ip->ap = 0;
1445: x = atoi (ip->argbuf);
1446: y = 0;
1447: cp = index (ip->argbuf, ';');
1448: if (cp)
1449: y = atoi (cp + 1);
1450: if (x) x--;
1451: if (y) y--;
1452: ip->top_margin = MIN(x, ip->rows - 1);
1453: ip->bottom_margin = MIN(y, ip->rows - 1);
1454: ip->escape = 0;
1455: return -1;
1456:
1457:
1458: case 'm':
1459: /* big attribute setter/resetter */
1460: {
1461: char *cp;
1462: *ip->ap = 0;
1463: for (cp = ip->argbuf; cp < ip->ap; )
1464: {
1465: switch (*cp)
1466: {
1467: case '0':
1468: clr_attr (ip, ATTR_ALL);
1469: cp++;
1470: break;
1471:
1472: case '1':
1473: set_attr (ip, ATTR_BOLD);
1474: cp++;
1475: break;
1476:
1477: case '2':
1478: switch (cp[1])
1479: {
1480: case '2':
1481: clr_attr (ip, ATTR_BOLD);
1482: cp += 2;
1483: break;
1484:
1485: case '4':
1486: clr_attr (ip, ATTR_UL);
1487: cp += 2;
1488: break;
1489:
1490: case '5':
1491: clr_attr (ip, ATTR_BLINK);
1492: cp += 2;
1493: break;
1494:
1495: case '7':
1496: clr_attr (ip, ATTR_INV);
1497: cp += 2;
1498: break;
1499:
1500: default:
1501: cp++;
1502: break;
1503: }
1504: break;
1505:
1506: case '4':
1507: set_attr (ip, ATTR_UL);
1508: cp++;
1509: break;
1510:
1511: case '5':
1512: set_attr (ip, ATTR_BLINK);
1513: cp++;
1514: break;
1515:
1516: case '7':
1517: set_attr (ip, ATTR_INV);
1518: cp++;
1519: break;
1520:
1521: default:
1522: cp++;
1523: break;
1524: }
1525: }
1526:
1527: }
1528: ip->escape = 0;
1529: return -1;
1530:
1531:
1532: case 'u':
1533: /* DECRQTSR */
1534: ite_sendstr (ip, "\033P\033\\");
1535: ip->escape = 0;
1536: return -1;
1537:
1538:
1539:
1540: default:
1541: ip->escape = 0;
1542: return -1;
1543: }
1544: break;
1545:
1546:
1547:
1548: case '?': /* CSI ? */
1549: switch (c)
1550: {
1551: case '0': case '1': case '2': case '3': case '4':
1552: case '5': case '6': case '7': case '8': case '9':
1553: case ';': case '\"': case '$':
1554: if (ip->ap < ip->argbuf + ARGBUF_SIZE)
1555: *ip->ap++ = c;
1556: return -1;
1557:
1558:
1559: case CAN:
1560: ip->escape = 0;
1561: return -1;
1562:
1563:
1564: case 'n':
1565: *ip->ap = 0;
1566: if (ip->ap == &ip->argbuf[2])
1567: {
1568: if (! strncmp (ip->argbuf, "15", 2))
1569: /* printer status: no printer */
1570: ite_sendstr (ip, "\033[13n");
1571:
1572: else if (! strncmp (ip->argbuf, "25", 2))
1573: /* udk status */
1574: ite_sendstr (ip, "\033[20n");
1575:
1576: else if (! strncmp (ip->argbuf, "26", 2))
1577: /* keyboard dialect: US */
1578: ite_sendstr (ip, "\033[27;1n");
1579: }
1580: ip->escape = 0;
1581: return -1;
1582:
1583:
1584: case 'h': case 'l':
1585: *ip->ap = 0;
1586: if (ip->ap[0] == '6')
1587: ip->inside_margins = (c == 'h');
1588:
1589: else if (! strncmp (ip->ap, "25", 2))
1590: (*itesw[ip->type].ite_cursor)(ip,
1591: (c == 'h') ? DRAW_CURSOR : ERASE_CURSOR);
1592:
1593: /* others.. */
1594:
1595: default:
1596: ip->escape = 0;
1597: return -1;
1598: }
1599: break;
1600:
1601:
1602: default:
1603: ip->escape = 0;
1604: return -1;
1605: }
1606: }
1607:
1608:
1609: switch (c) {
1610:
1611: case VT: /* VT is treated like LF */
1612: case FF: /* so is FF */
1613: case LF:
1614: if (ip->linefeed_newline)
1615: ite_crlf (ip, sp);
1616: else
1617: ite_lf (ip, sp);
1618: break;
1619:
1620: case CR:
1621: ite_cr (ip, sp);
1622: break;
1623:
1624: case BS:
1625: if (--ip->curx < 0)
1626: ip->curx = 0;
1627: else
1628: (*sp->ite_cursor)(ip, MOVE_CURSOR);
1629: break;
1630:
1631: case HT:
1632: if (ip->curx < TABEND(unit)) {
1633: n = TABSIZE - (ip->curx & (TABSIZE - 1));
1634: ip->curx += n;
1635: (*sp->ite_cursor)(ip, MOVE_CURSOR);
1636: } else
1637: itecheckwrap(ip, sp);
1638: break;
1639:
1640: case BEL:
1641: if (ite_tty[unit] == kbd_tty)
1642: kbdbell();
1643: break;
1644:
1645: case SO:
1646: ip->GL = ip->G1;
1647: break;
1648:
1649: case SI:
1650: ip->GL = ip->G0;
1651: break;
1652:
1653: case ENQ:
1654: /* send answer-back message !! */
1655: break;
1656:
1657: case CAN:
1658: ip->escape = 0; /* cancel any escape sequence in progress */
1659: break;
1660:
1661: case SUB:
1662: ip->escape = 0; /* dito, but see below */
1663: /* should also display a reverse question mark!! */
1664: break;
1665:
1666: case ESC:
1667: ip->escape = ESC;
1668: break;
1669:
1670:
1671: /* now it gets weird.. 8bit control sequences.. */
1672: case IND: /* index: move cursor down, scroll */
1673: ite_lf (ip, sp);
1674: break;
1675:
1676: case NEL: /* next line. next line, first pos. */
1677: ite_crlf (ip, sp);
1678: break;
1679:
1680: case HTS: /* set horizontal tab */
1681: /* not yet supported */
1682: break;
1683:
1684: case RI: /* reverse index */
1685: ite_rlf (ip, sp);
1686: break;
1687:
1688: case SS2: /* go into G2 for one character */
1689: /* not yet supported */
1690: break;
1691:
1692: case SS3: /* go into G3 for one character */
1693: break;
1694:
1695: case DCS: /* device control string introducer */
1696: ip->escape = DCS;
1697: ip->ap = ip->argbuf;
1698: break;
1699:
1700: case CSI: /* control sequence introducer */
1701: ip->escape = CSI;
1702: ip->ap = ip->argbuf;
1703: break;
1704:
1705: case ST: /* string terminator */
1706: /* ignore, if not used as terminator */
1707: break;
1708:
1709: case OSC: /* introduces OS command. Ignore everything upto ST */
1710: ip->escape = OSC;
1711: break;
1712:
1713: case PM: /* privacy message, ignore everything upto ST */
1714: ip->escape = PM;
1715: break;
1716:
1717: case APC: /* application program command, ignore everything upto ST */
1718: ip->escape = APC;
1719: break;
1720:
1721: default:
1722: if (c < ' ' || c == DEL)
1723: break;
1724: if (ip->imode)
1725: ite_inchar(ip, sp, 1);
1726: if ((ip->attribute & ATTR_INV) || attrtest(ip, ATTR_INV)) {
1727: attrset(ip, ATTR_INV);
1728: (*sp->ite_putc)(ip, c, ip->cury, ip->curx, ATTR_INV);
1729: }
1730: else
1731: (*sp->ite_putc)(ip, c, ip->cury, ip->curx, ATTR_NOR);
1732: (*sp->ite_cursor)(ip, DRAW_CURSOR);
1733: itecheckwrap(ip, sp);
1734: break;
1735: }
1736: }
1737:
1738: itecheckwrap(ip, sp)
1739: register struct ite_softc *ip;
1740: register struct itesw *sp;
1741: {
1742: if (++ip->curx == ip->cols) {
1743: ip->curx = 0;
1744: clr_attr(ip, ATTR_INV);
1745: if (++ip->cury >= ip->bottom_margin + 1) {
1746: ip->cury = ip->bottom_margin;
1747: (*sp->ite_scroll)(ip, ip->top_margin + 1, 0, 1, SCROLL_UP);
1748: ite_clrtoeol(ip, sp, ip->cury, 0);
1749: return;
1750: }
1751: }
1752: (*sp->ite_cursor)(ip, MOVE_CURSOR);
1753: }
1754:
1755: /*
1756: * Console functions
1757: */
1758: #include "../amiga/cons.h"
1759: #include "grfioctl.h"
1760: #include "grfvar.h"
1761:
1762: #ifdef DEBUG
1763: /*
1764: * Minimum ITE number at which to start looking for a console.
1765: * Setting to 0 will do normal search, 1 will skip first ITE device,
1766: * NITE will skip ITEs and use serial port.
1767: */
1768: int whichconsole = 0;
1769: #endif
1770:
1771: itecnprobe(cp)
1772: struct consdev *cp;
1773: {
1774: register struct ite_softc *ip;
1775: int i, maj, unit, pri;
1776:
1777: /* locate the major number */
1778: for (maj = 0; maj < nchrdev; maj++)
1779: if (cdevsw[maj].d_open == iteopen)
1780: break;
1781:
1782: /* urk! */
1783: grfconfig();
1784:
1785: /* check all the individual displays and find the best */
1786: unit = -1;
1787: pri = CN_DEAD;
1788: for (i = 0; i < NITE; i++) {
1789: struct grf_softc *gp = &grf_softc[i];
1790:
1791: ip = &ite_softc[i];
1792: if ((gp->g_flags & GF_ALIVE) == 0)
1793: continue;
1794: ip->flags = (ITE_ALIVE|ITE_CONSOLE);
1795:
1796: /* XXX - we need to do something about mapping these */
1797: switch (gp->g_type) {
1798: case GT_CUSTOMCHIPS:
1799: ip->type = ITE_CUSTOMCHIPS;
1800: break;
1801:
1802: case GT_TIGA_A2410:
1803: ip->type = ITE_TIGA_A2410;
1804: break;
1805: }
1806: #ifdef DEBUG
1807: if (i < whichconsole)
1808: continue;
1809: #endif
1810: if ((int)gp->g_type == GT_CUSTOMCHIPS) {
1811: pri = CN_INTERNAL;
1812: unit = i;
1813: } else if (unit < 0) {
1814: pri = CN_NORMAL;
1815: unit = i;
1816: }
1817: }
1818:
1819: /* initialize required fields */
1820: cp->cn_dev = makedev(maj, unit);
1821: cp->cn_tp = ite_tty[unit];
1822: cp->cn_pri = pri;
1823: }
1824:
1825: itecninit(cp)
1826: struct consdev *cp;
1827: {
1828: int unit = UNIT(cp->cn_dev);
1829: struct ite_softc *ip = &ite_softc[unit];
1830: ip->attrbuf = console_attributes;
1831: iteinit(cp->cn_dev);
1832: ip->flags |= (ITE_ACTIVE|ITE_ISCONS);
1833: kbd_tty = ite_tty[unit];
1834: kbdenable();
1835: }
1836:
1837: /*ARGSUSED*/
1838: itecngetc(dev)
1839: dev_t dev;
1840: {
1841: register int c;
1842:
1843: do
1844: {
1845: c = kbdgetcn ();
1846: c = itefilter (c, ITEFILT_CONSOLE);
1847: }
1848: while (c == -1);
1849:
1850: return(c);
1851: }
1852:
1853: itecnputc(dev, c)
1854: dev_t dev;
1855: int c;
1856: {
1857: static int paniced = 0;
1858: struct ite_softc *ip = &ite_softc[UNIT(dev)];
1859: extern char *panicstr;
1860:
1861: if (panicstr && !paniced &&
1862: (ip->flags & (ITE_ACTIVE|ITE_INGRF)) != ITE_ACTIVE) {
1863: (void) iteon(dev, 3);
1864: paniced = 1;
1865: }
1866: iteputchar(c, dev);
1867: }
1868: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.