![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to curses.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / usr / bin / elvis|
Return to curses.c CVS log | Up to [MW Coherent from dump] / coherent / d / usr / bin / elvis |
1.1 root 1: /* curses.c */
2:
3: /* Author:
4: * Steve Kirkendall
5: * 16820 SW Tallac Way
6: * Beaverton, OR 97006
7: * [email protected], or ...uunet!tektronix!psueea!jove!kirkenda
8: */
9:
10:
11: /* This file contains the functions & variables needed for a tiny subset of
12: * curses. The principle advantage of this version of curses is its
13: * extreme speed. Disadvantages are potentially larger code, few supported
14: * functions, limited compatibility with full curses, and only stdscr.
15: */
16:
17: #include "config.h"
18: #include "vi.h"
19:
20: #if ANY_UNIX
21: # if UNIXV
22: # include <termio.h>
23: # undef TIOCWINSZ /* we can't handle it correctly yet */
24: # else
25: # include <sgtty.h>
26: # endif
27: #endif
28:
29: #if TOS
30: # include <osbind.h>
31: #endif
32:
33: #if OSK
34: # include <sgstat.h>
35: #endif
36:
37: #include <signal.h>
38:
39: extern char *getenv();
40: static void starttcap();
41:
42: /* variables, publicly available & used in the macros */
43: short ospeed; /* speed of the tty, eg B2400 */
44: #if OSK
45: char PC_; /* Pad char */
46: char *BC; /* backspace character string */
47: #else
48: char PC; /* Pad char */
49: #endif
50: WINDOW *stdscr; /* pointer into kbuf[] */
51: WINDOW kbuf[KBSIZ]; /* a very large output buffer */
52: int LINES; /* :li#: number of rows */
53: int COLS; /* :co#: number of columns */
54: int AM; /* :am: boolean: auto margins? */
55: int PT; /* :pt: boolean: physical tabs? */
56: char *VB; /* :vb=: visible bell */
57: char *UP; /* :up=: move cursor up */
58: char *SO; /* :so=: standout start */
59: char *SE; /* :se=: standout end */
60: char *US = ""; /* :us=: underline start */
61: char *UE = ""; /* :ue=: underline end */
62: char *MD = ""; /* :md=: bold start */
63: char *ME = ""; /* :me=: bold end */
64: char *AS; /* :as=: alternate (italic) start */
65: char *AE; /* :ae=: alternate (italic) end */
66: char *CM; /* :cm=: cursor movement */
67: char *CE; /* :ce=: clear to end of line */
68: char *CD; /* :cd=: clear to end of screen */
69: char *AL; /* :al=: add a line */
70: char *DL; /* :dl=: delete a line */
71: #if OSK
72: char *SR_; /* :sr=: scroll reverse */
73: #else
74: char *SR; /* :sr=: scroll reverse */
75: #endif
76: char *KS; /* :ks=: init string for cursor */
77: char *KE; /* :ke=: restore string for cursor */
78: char *KU; /* :ku=: key sequence sent by up arrow */
79: char *KD; /* :kd=: key sequence sent by down arrow */
80: char *KL; /* :kl=: key sequence sent by left arrow */
81: char *KR; /* :kr=: key sequence sent by right arrow */
82: char *HM; /* :HM=: key sequence sent by the <Home> key */
83: char *EN; /* :EN=: key sequence sent by the <End> key */
84: char *PU; /* :PU=: key sequence sent by the <PgUp> key */
85: char *PD; /* :PD=: key sequence sent by the <PgDn> key */
86: char *IM; /* :im=: insert mode start */
87: char *IC = ""; /* :ic=: insert the following character */
88: char *EI; /* :ei=: insert mode end */
89: char *DC; /* :dc=: delete a character */
90: char *TI; /* :ti=: terminal init */ /* GB */
91: char *TE; /* :te=: terminal exit */ /* GB */
92: #ifndef NO_CURSORSHAPE
93: char *CQ = (char *)0;/* :cQ=: normal cursor */
94: char *CX = (char *)1;/* :cX=: cursor used for EX command/entry */
95: char *CV = (char *)2;/* :cV=: cursor used for VI command mode */
96: char *CI = (char *)3;/* :cI=: cursor used for VI input mode */
97: char *CR = (char *)4;/* :cR=: cursor used for VI replace mode */
98: #endif
99: char *aend = ""; /* end an attribute -- either UE or ME */
100: char ERASEKEY; /* backspace key taken from ioctl structure */
101:
102: #if ANY_UNIX
103: # if UNIXV
104: static struct termio oldtermio; /* original tty mode */
105: static struct termio newtermio; /* cbreak/noecho tty mode */
106: # else
107: static struct sgttyb oldsgttyb; /* original tty mode */
108: static struct sgttyb newsgttyb; /* cbreak/nl/noecho tty mode */
109: static int oldint; /* ^C or DEL, the "intr" character */
110: # ifdef TIOCSLTC
111: static int oldswitch; /* ^Z, the "suspend" character */
112: static int oldquote; /* ^V, the "quote next char" char */
113: # endif
114: # endif
115: #endif
116:
117: #if OSK
118: static struct sgbuf oldsgttyb; /* orginal tty mode */
119: static struct sgbuf newsgttyb; /* noecho tty mode */
120: #endif
121:
122: static char *capbuf; /* capability string buffer */
123:
124:
125: void initscr()
126: {
127: /* make sure TERM variable is set */
128: #if MSDOS
129: char *val;
130: if (! (val = getenv("TERM"))
131: || !strcmp(val, "pcbios"))
132: #else
133: if (!getenv("TERM"))
134: #endif
135: {
136: #if ANY_UNIX
137: write(2, "Environment variable TERM must be set\n", (unsigned)38);
138: exit(1);
139: #endif
140: #if OSK
141: writeln(2, "Environment variable TERM must be set\n", (unsigned)38);
142: exit(1);
143: #endif
144: #if MSDOS || TOS
145: getsize(0);
146: #endif
147: }
148: else
149: {
150: #if MSDOS
151: *o_pcbios=0;
152: #endif
153: /* start termcap stuff */
154: starttcap();
155: }
156:
157: /* create stdscr and curscr */
158: stdscr = kbuf;
159:
160: /* change the terminal mode to cbreak/noecho */
161: #if ANY_UNIX
162: # if UNIXV
163: ioctl(2, TCGETA, &oldtermio);
164: # else
165: ioctl(2, TIOCGETP, &oldsgttyb);
166: # endif
167: #endif
168:
169: #if OSK
170: _gs_opt(0, &oldsgttyb);
171: #endif
172: resume_curses(TRUE);
173: }
174:
175:
176: void endwin()
177: {
178: /* change the terminal mode back the way it was */
179: suspend_curses();
180: }
181:
182:
183: static int curses_active = FALSE;
184:
185: void suspend_curses()
186: {
187: #if ANY_UNIX && !UNIXV
188: struct tchars tbuf;
189: # ifdef TIOCSLTC
190: struct ltchars ltbuf;
191: # endif
192: #endif
193: #ifndef NO_CURSORSHAPE
194: if (has_CQ)
195: {
196: do_CQ();
197: }
198: #endif
199: if (has_TE) /* GB */
200: {
201: do_TE();
202: }
203: if (has_KE)
204: {
205: do_KE();
206: }
207: refresh();
208:
209: /* change the terminal mode back the way it was */
210: #if ANY_UNIX
211: # if UNIXV
212: ioctl(2, TCSETAW, &oldtermio);
213: # else
214: ioctl(2, TIOCSETP, &oldsgttyb);
215:
216: ioctl(2, TIOCGETC, &tbuf);
217: tbuf.t_intrc = oldint;
218: ioctl(2, TIOCSETC, &tbuf);
219:
220: # ifdef TIOCSLTC
221: ioctl(2, TIOCGLTC, <buf);
222: ltbuf.t_suspc = oldswitch;
223: ltbuf.t_lnextc = oldquote;
224: ioctl(2, TIOCSLTC, <buf);
225: # endif
226: # endif
227: #endif
228: #if OSK
229: _ss_opt(0, &oldsgttyb);
230: #endif
231: curses_active = FALSE;
232: }
233:
234: void resume_curses(quietly)
235: int quietly;
236: {
237: if (!curses_active)
238: {
239: /* change the terminal mode to cbreak/noecho */
240: #if ANY_UNIX
241: # if UNIXV
242: ospeed = (oldtermio.c_cflag & CBAUD);
243: ERASEKEY = oldtermio.c_cc[VERASE];
244: newtermio = oldtermio;
245: newtermio.c_iflag &= (IXON|IXOFF|IXANY|ISTRIP|IGNBRK);
246: newtermio.c_oflag &= ~OPOST;
247: newtermio.c_lflag &= ISIG;
248: newtermio.c_cc[VINTR] = ctrl('C'); /* always use ^C for interrupts */
249: newtermio.c_cc[VMIN] = 1;
250: newtermio.c_cc[VTIME] = 0;
251: # ifdef VSWTCH
252: newtermio.c_cc[VSWTCH] = 0;
253: # endif
254: ioctl(2, TCSETAW, &newtermio);
255: # else /* BSD or V7 or Coherent or Minix */
256: struct tchars tbuf;
257: # ifdef TIOCSLTC
258: struct ltchars ltbuf;
259: # endif
260:
261: ospeed = oldsgttyb.sg_ospeed;
262: ERASEKEY = oldsgttyb.sg_erase;
263: newsgttyb = oldsgttyb;
264: newsgttyb.sg_flags |= CBREAK;
265: newsgttyb.sg_flags &= ~(CRMOD|ECHO|XTABS);
266: ioctl(2, TIOCSETP, &newsgttyb);
267:
268: ioctl(2, TIOCGETC, &tbuf);
269: oldint = tbuf.t_intrc;
270: tbuf.t_intrc = ctrl('C'); /* always use ^C for interrupts */
271: ioctl(2, TIOCSETC, &tbuf);
272:
273: # ifdef TIOCSLTC
274: ioctl(2, TIOCGLTC, <buf);
275: oldswitch = ltbuf.t_suspc;
276: ltbuf.t_suspc = 0; /* disable ^Z for elvis */
277: oldquote = ltbuf.t_lnextc;
278: ltbuf.t_lnextc = 0; /* disable ^V for elvis */
279: ioctl(2, TIOCSLTC, <buf);
280: # endif
281:
282: # endif
283: #endif
284: #if OSK
285: newsgttyb = oldsgttyb;
286: newsgttyb.sg_echo = 0;
287: newsgttyb.sg_eofch = 0;
288: newsgttyb.sg_kbach = 0;
289: newsgttyb.sg_kbich = ctrl('C');
290: _ss_opt(0, &newsgttyb);
291: ospeed = oldsgttyb.sg_baud;
292: ERASEKEY = oldsgttyb.sg_bspch;
293: #endif
294:
295: if (has_TI) /* GB */
296: {
297: do_TI();
298: }
299: if (has_KS)
300: {
301: do_KS();
302: }
303:
304: curses_active = TRUE;
305: }
306:
307: /* If we're supposed to quit quietly, then we're done */
308: if (quietly)
309: {
310: return;
311: }
312:
313: signal(SIGINT, SIG_IGN);
314:
315: move(LINES - 1, 0);
316: do_SO();
317: qaddstr("[Press <RETURN> to continue]");
318: do_SE();
319: refresh();
320: ttyread(kbuf, 20); /* in RAW mode, so <20 is very likely */
321: if (kbuf[0] == ':')
322: {
323: mode = MODE_COLON;
324: addch('\n');
325: refresh();
326: }
327: else
328: {
329: mode = MODE_VI;
330: redraw(MARK_UNSET, FALSE);
331: }
332: exwrote = FALSE;
333:
334: #if TURBOC
335: signal(SIGINT, (void(*)()) trapint);
336: #else
337: signal(SIGINT, trapint);
338: #endif
339: }
340:
341: static void lacking(s)
342: char *s;
343: {
344: write(2, "This termcap entry lacks the :", (unsigned)30);
345: write(2, s, (unsigned)2);
346: write(2, "=: capability\n", (unsigned)14);
347: #if OSK
348: write(2, "\l", 1);
349: #endif
350: exit(1);
351: }
352:
353: static void starttcap()
354: {
355: char *str;
356: static char cbmem[800];
357: #define MUSTHAVE(T,s) if (!(T = tgetstr(s, &capbuf))) lacking(s)
358: #define MAYHAVE(T,s) if (str = tgetstr(s, &capbuf)) T = str
359: #define PAIR(T,U,sT,sU) T=tgetstr(sT,&capbuf);U=tgetstr(sU,&capbuf);if (!T||!U)T=U=""
360:
361: /* allocate memory for capbuf */
362: capbuf = cbmem;
363:
364: /* get the termcap entry */
365: switch (tgetent(kbuf, getenv("TERM")))
366: {
367: case -1:
368: write(2, "Can't read /etc/termcap\n", (unsigned)24);
369: #if OSK
370: write(2, "\l", 1);
371: #endif
372: exit(2);
373:
374: case 0:
375: write(2, "Unrecognized TERM type\n", (unsigned)23);
376: #if OSK
377: write(2, "\l", 1);
378: #endif
379: exit(3);
380: }
381:
382: /* get strings */
383: MUSTHAVE(UP, "up");
384: MAYHAVE(VB, "vb");
385: MUSTHAVE(CM, "cm");
386: PAIR(SO, SE, "so", "se");
387: PAIR(TI, TE, "ti", "te");
388: if (tgetnum("ug") <= 0)
389: {
390: PAIR(US, UE, "us", "ue");
391: PAIR(MD, ME, "md", "me");
392:
393: /* get italics, or have it default to underline */
394: PAIR(AS, AE, "as", "ae");
395: if (!*AS)
396: {
397: AS = US;
398: AE = UE;
399: }
400: }
401: MAYHAVE(AL, "al");
402: MAYHAVE(DL, "dl");
403: MUSTHAVE(CE, "ce");
404: MAYHAVE(CD, "cd");
405: #if OSK
406: MAYHAVE(SR_, "sr");
407: #else
408: MAYHAVE(SR, "sr");
409: #endif
410: PAIR(IM, EI, "im", "ei");
411: MAYHAVE(IC, "ic");
412: MAYHAVE(DC, "dc");
413:
414: /* other termcap stuff */
415: AM = tgetflag("am");
416: PT = tgetflag("pt");
417: getsize(0);
418:
419: /* Key sequences */
420: PAIR(KS, KE, "ks", "ke");
421: MAYHAVE(KU, "ku"); /* up */
422: MAYHAVE(KD, "kd"); /* down */
423: MAYHAVE(KL, "kl"); /* left */
424: MAYHAVE(KR, "kr"); /* right */
425: MAYHAVE(PU, "kP"); /* PgUp */
426: MAYHAVE(PD, "kN"); /* PgDn */
427: MAYHAVE(HM, "kh"); /* Home */
428: MAYHAVE(EN, "kH"); /* End */
429: #ifndef CRUNCH
430: if (!PU) MAYHAVE(PU, "K2"); /* "3x3 pad" names for PgUp, etc. */
431: if (!PD) MAYHAVE(PD, "K5");
432: if (!HM) MAYHAVE(HM, "K1");
433: if (!EN) MAYHAVE(EN, "K4");
434:
435: MAYHAVE(PU, "PU"); /* old XENIX names for PgUp, etc. */
436: MAYHAVE(PD, "PD"); /* (overrides others, if used.) */
437: MAYHAVE(HM, "HM");
438: MAYHAVE(EN, "EN");
439: #endif
440:
441: #ifndef NO_CURSORSHAPE
442: /* cursor shapes */
443: CQ = tgetstr("cQ", &capbuf);
444: if (has_CQ)
445: {
446: CX = tgetstr("cX", &capbuf);
447: if (!CX) CX = CQ;
448: CV = tgetstr("cV", &capbuf);
449: if (!CV) CV = CQ;
450: CI = tgetstr("cI", &capbuf);
451: if (!CI) CI = CQ;
452: CR = tgetstr("cR", &capbuf);
453: if (!CR) CR = CQ;
454: }
455: # ifndef CRUNCH
456: else
457: {
458: PAIR(CQ, CV, "ve", "vs");
459: CX = CI = CR = CQ;
460: }
461: # endif /* !CRUNCH */
462: #endif /* !NO_CURSORSHAPE */
463:
464: #undef MUSTHAVE
465: #undef MAYHAVE
466: #undef PAIR
467: }
468:
469:
470: /* This function gets the window size. It uses the TIOCGWINSZ ioctl call if
471: * your system has it, or tgetnum("li") and tgetnum("co") if it doesn't.
472: * This function is called once during initialization, and thereafter it is
473: * called whenever the SIGWINCH signal is sent to this process.
474: */
475: int getsize(signo)
476: int signo;
477: {
478: int lines;
479: int cols;
480: #ifdef TIOCGWINSZ
481: struct winsize size;
482: #endif
483:
484: #ifdef SIGWINCH
485: /* reset the signal vector */
486: signal(SIGWINCH, getsize);
487: #endif
488:
489: /* get the window size, one way or another. */
490: lines = cols = 0;
491: #ifdef TIOCGWINSZ
492: if (ioctl(2, TIOCGWINSZ, &size) >= 0)
493: {
494: lines = size.ws_row;
495: cols = size.ws_col;
496: }
497: #endif
498: if ((lines == 0 || cols == 0) && signo == 0)
499: {
500: LINES = CHECKBIOS(v_rows(), tgetnum("li"));
501: COLS = CHECKBIOS(v_cols(), tgetnum("co"));
502: }
503: if (lines >= 2 && cols >= 30)
504: {
505: LINES = lines;
506: COLS = cols;
507: }
508:
509: /* Make sure we got values that we can live with */
510: if (LINES < 2 || COLS < 30)
511: {
512: write(2, "Screen too small\n", (unsigned)17);
513: #if OSK
514: write(2, "\l", 1);
515: #endif
516: endwin();
517: exit(2);
518: }
519:
520: /* !!! copy the new values into Elvis' options */
521: {
522: extern char o_columns[], o_lines[];
523:
524: *o_columns = COLS;
525: *o_lines = LINES;
526: }
527:
528: return 0;
529: }
530:
531:
532: /* This is a function version of addch() -- it is used by tputs() */
533: int faddch(ch)
534: int ch;
535: {
536: addch(ch);
537:
538: return 0;
539: }
540:
541: /* These functions are equivelent to the macros of the same names... */
542:
543: void qaddstr(str)
544: char *str;
545: {
546: REG char *s_, *d_;
547:
548: #if MSDOS
549: if (o_pcbios[0])
550: {
551: while (*str)
552: qaddch(*str++);
553: return;
554: }
555: #endif
556: for (s_=(str), d_=stdscr; *d_++ = *s_++; )
557: {
558: }
559: stdscr = d_ - 1;
560: }
561:
562: void attrset(a)
563: int a;
564: {
565: do_aend();
566: if (a == A_BOLD)
567: {
568: do_MD();
569: aend = ME;
570: }
571: else if (a == A_UNDERLINE)
572: {
573: do_US();
574: aend = UE;
575: }
576: else if (a == A_ALTCHARSET)
577: {
578: do_AS();
579: aend = AE;
580: }
581: else
582: {
583: aend = "";
584: }
585: }
586:
587:
588: void insch(ch)
589: int ch;
590: {
591: if (has_IM)
592: do_IM();
593: do_IC();
594: qaddch(ch);
595: if (has_EI)
596: do_EI();
597: }
598:
599: #if MSDOS
600:
601: static int alarmtime;
602:
603: /* raw read - #defined to read (0, ...) on non-MSDOS.
604: * With MSDOS, am maximum of 1 byte is read.
605: * If more bytes should be read, just change the loop.
606: * The following code uses the IBM-PC-System-Timer, so probably wont't work
607: * on non-compatibles.
608: */
609: /*ARGSUSED*/
610: ttyread(buf, len)
611: char *buf;
612: int len;
613: {
614: volatile char far *biostimer;
615: char oldtime;
616: int nticks = 0;
617: int pos = 0;
618:
619: biostimer = (char far *)0x0040006cl;
620: oldtime = *biostimer;
621:
622: while (!pos && (!alarmtime || nticks<alarmtime))
623: { if (kbhit())
624: if ((buf[pos++] = getch()) == 0) /* function key */
625: buf[pos-1] = '#';
626: if (oldtime != *biostimer)
627: { nticks++;
628: oldtime = *biostimer;
629: }
630: }
631: return pos;
632: }
633:
634: alarm(time)
635: int time;
636: {
637: alarmtime = 2 * time; /* ticks are 1/18 sec. */
638: }
639: #endif
640:
641: #if TOS
642:
643: static int alarmtime;
644: static long timer;
645:
646: static gettime()
647: {
648: timer = *(long *)(0x4ba);
649: }
650:
651: /*ARGSUSED*/
652: ttyread(buf, len)
653: char *buf;
654: int len;
655: {
656: int pos=0;
657: long l;
658: long endtime;
659:
660: Supexec(gettime);
661: endtime = timer+alarmtime;
662:
663: while (!pos && (!alarmtime || timer<endtime))
664: {
665: if (Bconstat(2))
666: {
667: l = Bconin(2);
668: if ((buf[pos++]=l) == '\0')
669: {
670: buf[pos-1]='#';
671: buf[pos++]=l>>16;
672: }
673: }
674: Supexec(gettime);
675: }
676: return pos;
677: }
678:
679: alarm(time)
680: int time;
681: {
682: alarmtime = 50 * time; /* ticks are 1/200 sec. */
683: }
684:
685: ttywrite(buf, len)
686: char *buf;
687: int len;
688: {
689: while (len--)
690: Bconout(2, *buf++);
691: }
692: #endif
693:
694: #if OSK
695: ttyread(buf, len)
696: char *buf;
697: int len;
698: {
699: REG int i;
700: if ((i = _gs_rdy(0)) > 0)
701: return read(0, buf, i < len ? i : len);
702: else
703: return read(0, buf, 1);
704: }
705:
706: alarm(time)
707: int time;
708: {
709: #define TIME(secs) ((secs << 8) | 0x80000000)
710: static int alrmid;
711:
712: if (time)
713: alrmid = alm_set(SIGQUIT, TIME(time));
714: else
715: alm_delete(alrmid);
716: }
717: #endif /* OSK */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.