xref: /titanic_41/usr/src/cmd/vi/port/ex_vget.c (revision 6a634c9dca3093f3922e4b7ab826d7bdf17bf78e)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
27 /*	  All Rights Reserved  	*/
28 
29 
30 /* Copyright (c) 1981 Regents of the University of California */
31 
32 #include "ex.h"
33 #include "ex_tty.h"
34 #include "ex_vis.h"
35 
36 /*
37  * Input routines for open/visual.
38  * We handle upper case only terminals in visual and reading from the
39  * echo area here as well as notification on large changes
40  * which appears in the echo area.
41  */
42 
43 /*
44  * Return the key.
45  */
46 void
ungetkey(int c)47 ungetkey(int c)
48 {
49 
50 	if (Peekkey != ATTN)
51 		Peekkey = c;
52 }
53 
54 /*
55  * Return a keystroke, but never a ^@.
56  */
57 int
getkey(void)58 getkey(void)
59 {
60 	int c;		/* char --> int */
61 
62 	do {
63 		c = getbr();
64 		if (c==0)
65 			(void) beep();
66 	} while (c == 0);
67 	return (c);
68 }
69 
70 /*
71  * Tell whether next keystroke would be a ^@.
72  */
73 int
peekbr(void)74 peekbr(void)
75 {
76 
77 	Peekkey = getbr();
78 	return (Peekkey == 0);
79 }
80 
81 short	precbksl;
82 
83 /*
84  * Get a keystroke, including a ^@.
85  * If an key was returned with ungetkey, that
86  * comes back first.  Next comes unread input (e.g.
87  * from repeating commands with .), and finally new
88  * keystrokes.
89  *
90  * The hard work here is in mapping of \ escaped
91  * characters on upper case only terminals.
92  */
93 int
getbr(void)94 getbr(void)
95 {
96 	unsigned char ch;
97 	int c, d;
98 	unsigned char *colp;
99 	int cnt;
100 	static unsigned char Peek2key;
101 	extern short slevel, ttyindes;
102 
103 getATTN:
104 	if (Peekkey) {
105 		c = Peekkey;
106 		Peekkey = 0;
107 		return (c);
108 	}
109 	if (Peek2key) {
110 		c = Peek2key;
111 		Peek2key = 0;
112 		return (c);
113 	}
114 	if (vglobp) {
115 		if (*vglobp)
116 			return (lastvgk = *vglobp++);
117 		lastvgk = 0;
118 		return (ESCAPE);
119 	}
120 	if (vmacp) {
121 		if (*vmacp)
122 			return(*vmacp++);
123 		/* End of a macro or set of nested macros */
124 		vmacp = 0;
125 		if (inopen == -1)	/* don't mess up undo for esc esc */
126 			vundkind = VMANY;
127 		inopen = 1;	/* restore old setting now that macro done */
128 		vch_mac = VC_NOTINMAC;
129 	}
130 	flusho();
131 again:
132 	if ((c=read(slevel == 0 ? 0 : ttyindes, &ch, 1)) != 1) {
133 		if (errno == EINTR)
134 			goto getATTN;
135 		else if (errno == EIO)
136 		  kill(getpid(), SIGHUP);
137 
138 		error(gettext("Input read error"));
139 	}
140 	c = ch;
141 	if (beehive_glitch && slevel==0 && c == ESCAPE) {
142 		if (read(0, &Peek2key, 1) != 1)
143 			goto getATTN;
144 		switch (Peek2key) {
145 		case 'C':	/* SPOW mode sometimes sends \EC for space */
146 			c = ' ';
147 			Peek2key = 0;
148 			break;
149 		case 'q':	/* f2 -> ^C */
150 			c = CTRL('c');
151 			Peek2key = 0;
152 			break;
153 		case 'p':	/* f1 -> esc */
154 			Peek2key = 0;
155 			break;
156 		}
157 	}
158 
159 	/*
160 	 * The algorithm here is that of the UNIX kernel.
161 	 * See the description in the programmers manual.
162 	 */
163 	if (UPPERCASE) {
164 		if (isupper(c))
165 			c = tolower(c);
166 		if (c == '\\') {
167 			if (precbksl < 2)
168 				precbksl++;
169 			if (precbksl == 1)
170 				goto again;
171 		} else if (precbksl) {
172 			d = 0;
173 			if (islower(c))
174 				d = toupper(c);
175 			else {
176 				colp = (unsigned char *)"({)}!|^~'~";
177 				while (d = *colp++)
178 					if (d == c) {
179 						d = *colp++;
180 						break;
181 					} else
182 						colp++;
183 			}
184 			if (precbksl == 2) {
185 				if (!d) {
186 					Peekkey = c;
187 					precbksl = 0;
188 					c = '\\';
189 				}
190 			} else if (d)
191 				c = d;
192 			else {
193 				Peekkey = c;
194 				precbksl = 0;
195 				c = '\\';
196 			}
197 		}
198 		if (c != '\\')
199 			precbksl = 0;
200 	}
201 #ifdef TRACE
202 	if (trace) {
203 		if (!techoin) {
204 			tfixnl();
205 			techoin = 1;
206 			fprintf(trace, "*** Input: ");
207 		}
208 		tracec(c);
209 	}
210 #endif
211 	lastvgk = 0;
212 	return (c);
213 }
214 
215 /*
216  * Get a key, but if a delete, quit or attention
217  * is typed return 0 so we will abort a partial command.
218  */
219 int
getesc(void)220 getesc(void)
221 {
222 	int c;
223 
224 	c = getkey();
225 	switch (c) {
226 
227 	case CTRL('v'):
228 	case CTRL('q'):
229 		c = getkey();
230 		return (c);
231 
232 	case ATTN:
233 	case QUIT:
234 		ungetkey(c);
235 		return (0);
236 
237 	case ESCAPE:
238 		return (0);
239 	}
240 	return (c);
241 }
242 
243 /*
244  * Peek at the next keystroke.
245  */
246 int
peekkey(void)247 peekkey(void)
248 {
249 
250 	Peekkey = getkey();
251 	return (Peekkey);
252 }
253 
254 /*
255  * Read a line from the echo area, with single character prompt c.
256  * A return value of 1 means the user blewit or blewit away.
257  */
258 int
readecho(c)259 readecho(c)
260 	unsigned char c;
261 {
262 	unsigned char *sc = cursor;
263 	int (*OP)();
264 	bool waste;
265 	int OPeek;
266 
267 	if (WBOT == WECHO)
268 		vclean();
269 	else
270 		vclrech(0);
271 	splitw++;
272 	vgoto(WECHO, 0);
273 	putchar(c);
274 	vclreol();
275 	vgoto(WECHO, 1);
276 	cursor = linebuf; linebuf[0] = 0; genbuf[0] = c;
277 	ixlatctl(1);
278 	if (peekbr()) {
279 		if (!INS[0] || (unsigned char)INS[128] == 0200) {
280 			INS[128] = 0;
281 			goto blewit;
282 		}
283 		vglobp = INS;
284 	}
285 	OP = Pline; Pline = normline;
286 	(void)vgetline(0, genbuf + 1, &waste, c);
287 	doomed = 0;	/* don't care about doomed characters in echo line */
288 	ixlatctl(0);
289 	if (Outchar == termchar)
290 		putchar('\n');
291 	vscrap();
292 	Pline = OP;
293 	if (Peekkey != ATTN && Peekkey != QUIT && Peekkey != CTRL('h')) {
294 		cursor = sc;
295 		vclreol();
296 		return (0);
297 	}
298 blewit:
299 	OPeek = Peekkey==CTRL('h') ? 0 : Peekkey; Peekkey = 0;
300 	splitw = 0;
301 	vclean();
302 	vshow(dot, NOLINE);
303 	vnline(sc);
304 	Peekkey = OPeek;
305 	return (1);
306 }
307 
308 /*
309  * A complete command has been defined for
310  * the purposes of repeat, so copy it from
311  * the working to the previous command buffer.
312  */
313 void
setLAST(void)314 setLAST(void)
315 {
316 
317 	if (vglobp || vmacp)
318 		return;
319 	lastreg = vreg;
320 	lasthad = Xhadcnt;
321 	lastcnt = Xcnt;
322 	*lastcp = 0;
323 	CP(lastcmd, workcmd);
324 }
325 
326 /*
327  * Gather up some more text from an insert.
328  * If the insertion buffer oveflows, then destroy
329  * the repeatability of the insert.
330  */
331 void
addtext(unsigned char * cp)332 addtext(unsigned char *cp)
333 {
334 
335 	if (vglobp)
336 		return;
337 	addto(INS, cp);
338 	if ((unsigned char)INS[128] == 0200)
339 		lastcmd[0] = 0;
340 }
341 
342 void
setDEL(void)343 setDEL(void)
344 {
345 
346 	setBUF(DEL);
347 }
348 
349 /*
350  * Put text from cursor upto wcursor in BUF.
351  */
352 void
setBUF(unsigned char * BUF)353 setBUF(unsigned char *BUF)
354 {
355 	int c;
356 	unsigned char *wp = wcursor;
357 
358 	c = *wp;
359 	*wp = 0;
360 	BUF[0] = 0;
361 	BUF[128] = 0;
362 	addto(BUF, cursor);
363 	*wp = c;
364 }
365 
366 void
addto(unsigned char * buf,unsigned char * str)367 addto(unsigned char *buf, unsigned char *str)
368 {
369 
370 	if ((unsigned char)buf[128] == 0200)
371 		return;
372 	if (strlen(buf) + strlen(str) + 1 >= VBSIZE) {
373 		buf[128] = 0200;
374 		return;
375 	}
376 	(void)strcat(buf, str);
377 	buf[128] = 0;
378 }
379 
380 /*
381  * Verbalize command name and embed it in message.
382  */
383 char *
verbalize(cnt,cmdstr,sgn)384 verbalize(cnt, cmdstr, sgn)
385 int cnt;
386 char *cmdstr, *sgn;
387 {
388 	if (cmdstr[0] == '\0')
389 		cmdstr = (char *)Command;
390 	if (sgn[0] == '\0') {
391 		switch (cmdstr[0]) {
392 		    case 'c':
393 			if (cmdstr[1] == 'h') {
394 				viprintf((cnt == 1) ?
395 				    gettext("1 line changed") :
396 				    gettext("%d lines changed"), cnt);
397 				break;
398 			} else if (cmdstr[1] != 'o') {
399 				goto Default;
400 			}
401 		    case 't':
402 			if (cmdstr[1] != '\0')
403 				goto Default;
404 			viprintf((cnt == 1) ? gettext("1 line copied") :
405 			       gettext("%d lines copied"), cnt);
406 			break;
407 		    case 'd':
408 			viprintf((cnt == 1) ? gettext("1 line deleted") :
409 			       gettext("%d lines deleted"), cnt);
410 			break;
411 		    case 'j':
412 			viprintf((cnt == 1) ? gettext("1 line joined") :
413 			       gettext("%d lines joined"), cnt);
414 			break;
415 		    case 'm':
416 			viprintf((cnt == 1) ? gettext("1 line moved") :
417 			       gettext("%d lines moved"), cnt);
418 			break;
419 		    case 'p':
420 			viprintf((cnt == 1) ? gettext("1 line put") :
421 			       gettext("%d lines put"), cnt);
422 			break;
423 		    case 'y':
424 			viprintf((cnt == 1) ? gettext("1 line yanked") :
425 			       gettext("%d lines yanked"), cnt);
426 			break;
427 		    case '>':
428 			viprintf((cnt == 1) ? gettext("1 line >>ed") :
429 			       gettext("%d lines >>ed"), cnt);
430 			break;
431 		    case '=':
432 			viprintf((cnt == 1) ? gettext("1 line =ed") :
433 			       gettext("%d lines =ed"), cnt);
434 			break;
435 		    case '<':
436 			viprintf((cnt == 1) ? gettext("1 line <<ed") :
437 			       gettext("%d lines <<ed"), cnt);
438 			break;
439 		    default:
440 Default:
441 			viprintf((cnt == 1) ? gettext("1 line") :
442 			       gettext("%d lines"), cnt);
443 			break;
444 		}
445 	} else if (sgn[0] == 'm') {
446 		viprintf((cnt == 1) ? gettext("1 more line") :
447 			gettext("%d more lines"), cnt);
448 	} else {
449 		viprintf((cnt == 1) ? gettext("1 fewer line") :
450 			gettext("%d fewer lines"), cnt);
451 	}
452 	return (NULL);
453 }
454 
455 /*
456  * Note a change affecting a lot of lines, or non-visible
457  * lines.  If the parameter must is set, then we only want
458  * to do this for open modes now; return and save for later
459  * notification in visual.
460  */
461 int
noteit(must)462 noteit(must)
463 	bool must;
464 {
465 	int sdl = destline, sdc = destcol;
466 
467 	if (notecnt < 1 || !must && state == VISUAL)
468 		return (0);
469 	splitw++;
470 	if (WBOT == WECHO)
471 		vmoveitup(1, 1);
472 	vigoto(WECHO, 0);
473 
474 	verbalize(notecnt, notenam, notesgn);
475 	vclreol();
476 	notecnt = 0;
477 	if (state != VISUAL)
478 		vcnt = vcline = 0;
479 	splitw = 0;
480 	if (state == ONEOPEN || state == CRTOPEN)
481 		vup1();
482 	destline = sdl; destcol = sdc;
483 	return (1);
484 }
485 
486 /*
487  * Ring or beep.
488  * If possible, flash screen.
489  */
490 int
beep(void)491 beep(void)
492 {
493 
494 	if (flash_screen && value(vi_FLASH))
495 		vputp(flash_screen, 0);
496 	else if (bell)
497 		vputp(bell, 0);
498 	return (0);
499 }
500 
501 /*
502  * Map the command input character c,
503  * for keypads and labelled keys which do cursor
504  * motions.  I.e. on an adm3a we might map ^K to ^P.
505  * DM1520 for example has a lot of mappable characters.
506  */
507 
508 int
map(c,maps,commch)509 map(c, maps, commch)
510 	int c;
511 	struct maps *maps;
512 	unsigned char commch; /* indicate if in append/insert/replace mode */
513 {
514 	int d;
515 	unsigned char *p, *q;
516 	unsigned char b[10];	/* Assumption: no keypad sends string longer than 10 */
517 	unsigned char *st;
518 
519 	/*
520 	 * Mapping for special keys on the terminal only.
521 	 * BUG: if there's a long sequence and it matches
522 	 * some chars and then misses, we lose some chars.
523 	 *
524 	 * For this to work, some conditions must be met.
525 	 * 1) Keypad sends SHORT (2 or 3 char) strings
526 	 * 2) All strings sent are same length & similar
527 	 * 3) The user is unlikely to type the first few chars of
528 	 *    one of these strings very fast.
529 	 * Note: some code has been fixed up since the above was laid out,
530 	 * so conditions 1 & 2 are probably not required anymore.
531 	 * However, this hasn't been tested with any first char
532 	 * that means anything else except escape.
533 	 */
534 #ifdef MDEBUG
535 	if (trace)
536 		fprintf(trace,"map(%c): ",c);
537 #endif
538 	/*
539 	 * If c==0, the char came from getesc typing escape.  Pass it through
540 	 * unchanged.  0 messes up the following code anyway.
541 	 */
542 	if (c==0)
543 		return(0);
544 
545 	b[0] = c;
546 	b[1] = 0;
547 	for (d=0; d < MAXNOMACS && maps[d].mapto; d++) {
548 #ifdef MDEBUG
549 		if (trace)
550 			fprintf(trace,"\ntry '%s', ",maps[d].cap);
551 #endif
552 		if (p = maps[d].cap) {
553 			for (q=b; *p; p++, q++) {
554 #ifdef MDEBUG
555 				if (trace)
556 					fprintf(trace,"q->b[%d], ",q-b);
557 #endif
558 				if (*q==0) {
559 					/*
560 					 * Is there another char waiting?
561 					 *
562 					 * This test is oversimplified, but
563 					 * should work mostly. It handles the
564 					 * case where we get an ESCAPE that
565 					 * wasn't part of a keypad string.
566 					 */
567 					if ((c=='#' ? peekkey() : fastpeekkey()) == 0) {
568 #ifdef MDEBUG
569 						if (trace)
570 							fprintf(trace,"fpk=0: will return '%c'",c);
571 #endif
572 						/*
573 						 * Nothing waiting.  Push back
574 						 * what we peeked at & return
575 						 * failure (c).
576 						 *
577 						 * We want to be able to undo
578 						 * commands, but it's nonsense
579 						 * to undo part of an insertion
580 						 * so if in input mode don't.
581 						 */
582 #ifdef MDEBUG
583 						if (trace)
584 							fprintf(trace, "Call macpush, b %d %d %d\n", b[0], b[1], b[2]);
585 #endif
586 						macpush(&b[1],maps == arrows);
587 #ifdef MDEBUG
588 						if (trace)
589 							fprintf(trace, "return %d\n", c);
590 #endif
591 						return(c);
592 					}
593 					*q = getkey();
594 					q[1] = 0;
595 				}
596 				if (*p != *q)
597 					goto contin;
598 			}
599 			macpush(maps[d].mapto,maps == arrows);
600 			/*
601 			 * For all macros performed within insert,
602 			 * append, or replacement mode, we must end
603 			 * up returning back to that mode when we
604 			 * return (except that append will become
605 			 * insert for <home> key, so cursor is not
606 			 * in second column).
607 			 *
608 			 * In order to preserve backward movement
609 			 * when leaving insert mode, an 'l' must be
610 			 * done to compensate for the left done by
611 			 * the <esc> (except when cursor is already
612 			 * in the first column: i.e., outcol = 0).
613 			 */
614 			 if ((maps == immacs)
615 			 && strcmp(maps[d].descr, maps[d].cap)) {
616 				switch (commch) {
617 				  case 'R':
618 					if (!strcmp(maps[d].descr, "home"))
619 						st = (unsigned char *)"R";
620 					else
621 						if (outcol == 0)
622 							st = (unsigned char *)"R";
623 						else
624 							st = (unsigned char *)"lR";
625 					break;
626 				  case 'i':
627 					if (!strcmp(maps[d].descr, "home"))
628 						st = (unsigned char *)"i";
629 					else
630 						if (outcol == 0)
631 							st = (unsigned char *)"i";
632 						else
633 							st = (unsigned char *)"li";
634 					break;
635 				  case 'a':
636 					if (!strcmp(maps[d].descr, "home"))
637 						st = (unsigned char *)"i";
638 					else
639 						st = (unsigned char *)"a";
640 					break;
641 				  default:
642 					st = (unsigned char *)"i";
643 				}
644 				if(strlen(vmacbuf)  + strlen(st) > BUFSIZE)
645 					error(value(vi_TERSE) ?
646 gettext("Macro too long") : gettext("Macro too long  - maybe recursive?"));
647 				else
648 					/*
649 					 * Macros such as function keys are
650 					 * performed by leaving the insert,
651 					 * replace, or append mode, executing
652 					 * the proper cursor movement commands
653 					 * and returning to the mode we are
654 					 * currently in (commch).
655 					 */
656 					strcat(vmacbuf, st);
657 			}
658 			c = getkey();
659 #ifdef MDEBUG
660 			if (trace)
661 				fprintf(trace,"Success: push(%s), return %c",maps[d].mapto, c);
662 #endif
663 			return(c);	/* first char of map string */
664 			contin:;
665 		}
666 	}
667 #ifdef MDEBUG
668 	if (trace)
669 		fprintf(trace,"Fail: push(%s), return %c", &b[1], c);
670 #endif
671 	macpush(&b[1],0);
672 	return(c);
673 }
674 
675 /*
676  * Push st onto the front of vmacp. This is tricky because we have to
677  * worry about where vmacp was previously pointing. We also have to
678  * check for overflow (which is typically from a recursive macro)
679  * Finally we have to set a flag so the whole thing can be undone.
680  * canundo is 1 iff we want to be able to undo the macro.  This
681  * is false for, for example, pushing back lookahead from fastpeekkey(),
682  * since otherwise two fast escapes can clobber our undo.
683  */
684 void
macpush(unsigned char * st,int canundo)685 macpush(unsigned char *st, int canundo)
686 {
687 	unsigned char tmpbuf[BUFSIZE];
688 
689 	if (st==0 || *st==0)
690 		return;
691 #ifdef MDEBUG
692 	if (trace)
693 		fprintf(trace, "macpush(%s), canundo=%d\n",st,canundo);
694 #endif
695 	if ((vmacp ? strlen(vmacp) : 0) + strlen(st) > BUFSIZE)
696 		error(value(vi_TERSE) ? gettext("Macro too long") :
697 gettext("Macro too long  - maybe recursive?"));
698 	if (vmacp) {
699 		strcpy(tmpbuf, vmacp);
700 		if (!FIXUNDO)
701 			canundo = 0;	/* can't undo inside a macro anyway */
702 	}
703 	strcpy(vmacbuf, st);
704 	if (vmacp)
705 		strcat(vmacbuf, tmpbuf);
706 	vmacp = vmacbuf;
707 	/* arrange to be able to undo the whole macro */
708 	if (canundo) {
709 #ifdef notdef
710 		otchng = tchng;
711 		vsave();
712 		saveall();
713 		inopen = -1;	/* no need to save since it had to be 1 or -1 before */
714 		vundkind = VMANY;
715 #endif
716 		vch_mac = VC_NOCHANGE;
717 	}
718 }
719 
720 #ifdef UNDOTRACE
visdump(s)721 visdump(s)
722 unsigned char *s;
723 {
724 	int i;
725 
726 	if (!trace) return;
727 
728 	fprintf(trace, "\n%s: basWTOP=%d, basWLINES=%d, WTOP=%d, WBOT=%d, WLINES=%d, WCOLS=%d, WECHO=%d\n",
729 		s, basWTOP, basWLINES, WTOP, WBOT, WLINES, WCOLS, WECHO);
730 	fprintf(trace, "   vcnt=%d, vcline=%d, cursor=%d, wcursor=%d, wdot=%d\n",
731 		vcnt, vcline, cursor-linebuf, wcursor-linebuf, wdot-zero);
732 	for (i=0; i<TUBELINES; i++)
733 		if (vtube[i] && *vtube[i])
734 			fprintf(trace, "%d: '%s'\n", i, vtube[i]);
735 	tvliny();
736 }
737 
vudump(s)738 vudump(s)
739 unsigned char *s;
740 {
741 	line *p;
742 	unsigned char savelb[1024];
743 
744 	if (!trace) return;
745 
746 	fprintf(trace, "\n%s: undkind=%d, vundkind=%d, unddel=%d, undap1=%d, undap2=%d,\n",
747 		s, undkind, vundkind, lineno(unddel), lineno(undap1), lineno(undap2));
748 	fprintf(trace, "  undadot=%d, dot=%d, dol=%d, unddol=%d, truedol=%d\n",
749 		lineno(undadot), lineno(dot), lineno(dol), lineno(unddol), lineno(truedol));
750 	fprintf(trace, "  [\n");
751 	CP(savelb, linebuf);
752 	fprintf(trace, "linebuf = '%s'\n", linebuf);
753 	for (p=zero+1; p<=truedol; p++) {
754 		fprintf(trace, "%o ", *p);
755 		getaline(*p);
756 		fprintf(trace, "'%s'\n", linebuf);
757 	}
758 	fprintf(trace, "]\n");
759 	CP(linebuf, savelb);
760 }
761 #endif
762 
763 /*
764  * Get a count from the keyed input stream.
765  * A zero count is indistinguishable from no count.
766  */
767 int
vgetcnt(void)768 vgetcnt(void)
769 {
770 	int c, cnt;
771 
772 	cnt = 0;
773 	for (;;) {
774 		c = getkey();
775 		if (!isdigit(c))
776 			break;
777 		cnt *= 10, cnt += c - '0';
778 	}
779 	ungetkey(c);
780 	Xhadcnt = 1;
781 	Xcnt = cnt;
782 	return(cnt);
783 }
784 
785 /*
786  * fastpeekkey is just like peekkey but insists the character come in
787  * fast (within 1 second). This will succeed if it is the 2nd char of
788  * a machine generated sequence (such as a function pad from an escape
789  * flavor terminal) but fail for a human hitting escape then waiting.
790  */
791 int
fastpeekkey(void)792 fastpeekkey(void)
793 {
794 	void trapalarm();
795 	int c;
796 
797 	/*
798 	 * If the user has set notimeout, we wait forever for a key.
799 	 * If we are in a macro we do too, but since it's already
800 	 * buffered internally it will return immediately.
801 	 * In other cases we force this to die in 1 second.
802 	 * This is pretty reliable (VMUNIX rounds it to .5 - 1.5 secs,
803 	 * but UNIX truncates it to 0 - 1 secs) but due to system delays
804 	 * there are times when arrow keys or very fast typing get counted
805 	 * as separate.  notimeout is provided for people who dislike such
806 	 * nondeterminism.
807 	 */
808 	CATCH
809 		if (value(vi_TIMEOUT) && inopen >= 0) {
810 			signal(SIGALRM, trapalarm);
811 			setalarm();
812 		}
813 		c = peekkey();
814 		cancelalarm();
815 	ONERR
816 		c = 0;
817 	ENDCATCH
818 	/* Should have an alternative method based on select for 4.2BSD */
819 	return(c);
820 }
821 
822 static int ftfd;
823 struct requestbuf {
824 	short time;
825 	short signo;
826 };
827 
828 /*
829  * Arrange for SIGALRM to come in shortly, so we don't
830  * hang very long if the user didn't type anything.  There are
831  * various ways to do this on different systems.
832  */
833 void
setalarm(void)834 setalarm(void)
835 {
836 	unsigned char ftname[20];
837 	struct requestbuf rb;
838 
839 #ifdef FTIOCSET
840 	/*
841 	 * Use nonstandard "fast timer" to get better than
842 	 * one second resolution.  We must wait at least
843 	 * 1/15th of a second because some keypads don't
844 	 * transmit faster than this.
845 	 */
846 
847 	/* Open ft psuedo-device - we need our own copy. */
848 	if (ftfd == 0) {
849 		strcpy(ftname, "/dev/ft0");
850 		while (ftfd <= 0 && ftname[7] <= '~') {
851 			ftfd = open(ftname, 0);
852 			if (ftfd <= 0)
853 				ftname[7] ++;
854 		}
855 	}
856 	if (ftfd <= 0) {	/* Couldn't open a /dev/ft? */
857 		alarm(1);
858 	} else {
859 		rb.time = 6;	/* 6 ticks = 100 ms > 67 ms. */
860 		rb.signo = SIGALRM;
861 		ioctl(ftfd, FTIOCSET, &rb);
862 	}
863 #else
864 	/*
865 	 * No special capabilities, so we use alarm, with 1 sec. resolution.
866 	 */
867 	alarm(1);
868 #endif
869 }
870 
871 /*
872  * Get rid of any impending incoming SIGALRM.
873  */
874 void
cancelalarm(void)875 cancelalarm(void)
876 {
877 	struct requestbuf rb;
878 #ifdef FTIOCSET
879 	if (ftfd > 0) {
880 		rb.time = 0;
881 		rb.signo = SIGALRM;
882 		ioctl(ftfd, FTIOCCANCEL, &rb);
883 	}
884 #endif
885 	alarm(0);	/* Have to do this whether or not FTIOCSET */
886 }
887 
trapalarm()888 void trapalarm() {
889 	alarm(0);
890 	longjmp(vreslab,1);
891 }
892