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