1: /* direct key io driver
2:
3: The following is stolen from the readline library for bash
4: */
5:
6: /* Use -DDOMAINOS for Apollo Domain-OS.
7: Use -D_POSIX_VERSION for POSIX systems.
8: */
9:
10: #ifdef DOMAINOS
11: #define _POSIX_VERSION
12: #endif
13:
14: #include <stdio.h>
15: #include <signal.h>
16: #include <sys/types.h>
17: #ifndef DOMAINOS
18: #include <sys/ioctl.h>
19: #endif
20: #include <fcntl.h>
21: #include <sys/file.h>
22: #include <setjmp.h>
23: #include "forth.h"
24: #include "io.h"
25:
26: #if defined (__GNUC__)
27: # define alloca __builtin_alloca
28: #else
29: # if defined (sparc) || defined (HAVE_ALLOCA_H)
30: # include <alloca.h>
31: # endif
32: #endif
33:
34: #if defined (HAVE_UNISTD_H)
35: # include <unistd.h>
36: #endif
37:
38: #define NEW_TTY_DRIVER
39: #define HAVE_BSD_SIGNALS
40: /*
41: #ifndef DOMAINOS
42: #define USE_XON_XOFF
43: #endif
44: */
45:
46: #define HANDLE_SIGNALS
47:
48: /* Some USG machines have BSD signal handling (sigblock, sigsetmask, etc.) */
49: #if defined (USG) && !defined (hpux)
50: #undef HAVE_BSD_SIGNALS
51: #endif
52:
53: /* System V machines use termio. */
54: #if !defined (_POSIX_VERSION)
55: # if defined (USG) || defined (hpux) || defined (Xenix) || defined (sgi) || defined (DGUX) || defined (ultrix)
56: # undef NEW_TTY_DRIVER
57: # define TERMIO_TTY_DRIVER
58: # include <termio.h>
59: # if !defined (TCOON)
60: # define TCOON 1
61: # endif
62: # endif /* USG || hpux || Xenix || sgi || DUGX || ultrix*/
63: #endif /* !_POSIX_VERSION */
64:
65: /* Posix systems use termios and the Posix signal functions. */
66: #if defined (_POSIX_VERSION)
67: # if !defined (TERMIOS_MISSING)
68: # undef NEW_TTY_DRIVER
69: # define TERMIOS_TTY_DRIVER
70: # include <termios.h>
71: # endif /* !TERMIOS_MISSING */
72: # define HAVE_POSIX_SIGNALS
73: # if !defined (O_NDELAY)
74: # define O_NDELAY O_NONBLOCK /* Posix-style non-blocking i/o */
75: # endif /* O_NDELAY */
76: #endif /* _POSIX_VERSION */
77:
78: /* Other (BSD) machines use sgtty. */
79: #if defined (NEW_TTY_DRIVER)
80: #include <sgtty.h>
81: #endif
82:
83: /* Define _POSIX_VDISABLE if we are not using the `new' tty driver and
84: it is not already defined. It is used both to determine if a
85: special character is disabled and to disable certain special
86: characters. Posix systems should set to 0, USG systems to -1. */
87: #if !defined (NEW_TTY_DRIVER) && !defined (_POSIX_VDISABLE)
88: # if defined (_POSIX_VERSION)
89: # define _POSIX_VDISABLE 0
90: # else /* !_POSIX_VERSION */
91: # define _POSIX_VDISABLE -1
92: # endif /* !_POSIX_VERSION */
93: #endif /* !NEW_TTY_DRIVER && !_POSIX_VDISABLE */
94:
95: #include <errno.h>
96: extern int errno;
97:
98: #if defined (SHELL)
99: # include <posixstat.h>
100: #else
101: # include <sys/stat.h>
102: #endif /* !SHELL */
103: /* #define HACK_TERMCAP_MOTION */
104:
105: #if defined (USG) && defined (hpux)
106: # if !defined (USGr3)
107: # define USGr3
108: # endif /* USGr3 */
109: #endif /* USG && hpux */
110:
111: #if (defined (_POSIX_VERSION) || defined (USGr3)) && !defined(DOMAINOS)
112: # include <dirent.h>
113: # define direct dirent
114: # if defined (_POSIX_VERSION)
115: # define D_NAMLEN(d) (strlen ((d)->d_name))
116: # else /* !_POSIX_VERSION */
117: # define D_NAMLEN(d) ((d)->d_reclen)
118: # endif /* !_POSIX_VERSION */
119: #else /* !_POSIX_VERSION && !USGr3 */
120: # define D_NAMLEN(d) ((d)->d_namlen)
121: # if !defined (USG)
122: # include <sys/dir.h>
123: # else /* USG */
124: # if defined (Xenix)
125: # include <sys/ndir.h>
126: # else /* !Xenix */
127: # include <ndir.h>
128: # endif /* !Xenix */
129: # endif /* USG */
130: #endif /* !POSIX_VERSION && !USGr3 */
131:
132: #if defined (USG) && defined (TIOCGWINSZ)
133: # include <sys/stream.h>
134: # if defined (USGr4) || defined (USGr3)
135: # if defined (Symmetry) || defined (_SEQUENT_)
136: # include <sys/pte.h>
137: # else
138: # include <sys/ptem.h>
139: # endif /* !Symmetry || _SEQUENT_ */
140: # endif /* USGr4 */
141: #endif /* USG && TIOCGWINSZ */
142:
143: #if defined (TERMIOS_TTY_DRIVER)
144: static struct termios otio;
145: #else
146: static struct termio otio;
147: #endif /* !TERMIOS_TTY_DRIVER */
148:
149: /* Non-zero means echo characters as they are read. */
150: int readline_echoing_p = 1;
151:
152: /* The character that can generate an EOF. Really read from
153: the terminal driver... just defaulted here. */
154:
155: #ifndef CTRL
156: #define CTRL(key) ((key)-'@')
157: #endif
158:
159: static int eof_char = CTRL ('D');
160:
161: /* **************************************************************** */
162: /* */
163: /* Saving and Restoring the TTY */
164: /* */
165: /* **************************************************************** */
166:
167: /* Non-zero means that the terminal is in a prepped state. */
168: static int terminal_prepped = 0;
169:
170: #if defined (NEW_TTY_DRIVER)
171:
172: /* Standard flags, including ECHO. */
173: static int original_tty_flags = 0;
174:
175: /* Local mode flags, like LPASS8. */
176: static int local_mode_flags = 0;
177:
178: /* Terminal characters. This has C-s and C-q in it. */
179: static struct tchars original_tchars;
180:
181: /* Local special characters. This has the interrupt characters in it. */
182: #if defined (TIOCGLTC)
183: static struct ltchars original_ltchars;
184: #endif
185:
186: /* Bind KEY to FUNCTION. Returns non-zero if KEY is out of range. */
187:
188: #if defined (TIOCGETC)
189: #if defined (USE_XON_XOFF)
190:
191: int
192: bind_key (key, function)
193: int key;
194: Function *function;
195: {
196: if (key < 0)
197: return (key);
198:
199: if (key > 127 && key < 256)
200: {
201: if (keymap[ESC].type == ISKMAP)
202: {
203: Keymap escmap = (Keymap)keymap[ESC].function;
204:
205: key -= 128;
206: escmap[key].type = ISFUNC;
207: escmap[key].function = function;
208: return (0);
209: }
210: return (key);
211: }
212:
213: keymap[key].type = ISFUNC;
214: keymap[key].function = function;
215: return (0);
216: }
217: #endif
218: #endif
219:
220: /* We use this to get and set the tty_flags. */
221: static struct sgttyb the_ttybuff;
222:
223: #if defined (USE_XON_XOFF)
224: /* If the terminal was in xoff state when we got to it, then xon_char
225: contains the character that is supposed to start it again. */
226: static int xon_char, xoff_state;
227: #endif /* USE_XON_XOFF */
228:
229: /* **************************************************************** */
230: /* */
231: /* Bogus Flow Control */
232: /* */
233: /* **************************************************************** */
234:
235: restart_output (count, key)
236: int count, key;
237: {
238: int fildes = fileno (stdin);
239: #if defined (TIOCSTART)
240: #if defined (apollo)
241: ioctl (&fildes, TIOCSTART, 0);
242: #else
243: ioctl (fildes, TIOCSTART, 0);
244: #endif /* apollo */
245:
246: #else
247: # if defined (TERMIOS_TTY_DRIVER)
248: tcflow (fildes, TCOON);
249: # else
250: # if defined (TCXONC)
251: ioctl (fildes, TCXONC, TCOON);
252: # endif /* TCXONC */
253: # endif /* !TERMIOS_TTY_DRIVER */
254: #endif /* TIOCSTART */
255: }
256:
257: /* Put the terminal in CBREAK mode so that we can detect key presses. */
258: void prep_terminal ()
259: {
260: int tty = fileno (stdin);
261: #if defined (HAVE_BSD_SIGNALS)
262: int oldmask;
263: #endif /* HAVE_BSD_SIGNALS */
264:
265: if (terminal_prepped)
266: return;
267:
268: oldmask = sigblock (sigmask (SIGINT));
269:
270: /* We always get the latest tty values. Maybe stty changed them. */
271: ioctl (tty, TIOCGETP, &the_ttybuff);
272: original_tty_flags = the_ttybuff.sg_flags;
273:
274: readline_echoing_p = (original_tty_flags & ECHO);
275:
276: #if defined (TIOCLGET)
277: ioctl (tty, TIOCLGET, &local_mode_flags);
278: #endif
279:
280: #if !defined (ANYP)
281: # define ANYP (EVENP | ODDP)
282: #endif
283:
284: /* If this terminal doesn't care how the 8th bit is used,
285: then we can use it for the meta-key. We check by seeing
286: if BOTH odd and even parity are allowed. */
287: if (the_ttybuff.sg_flags & ANYP)
288: {
289: #if defined (PASS8)
290: the_ttybuff.sg_flags |= PASS8;
291: #endif
292:
293: /* Hack on local mode flags if we can. */
294: #if defined (TIOCLGET) && defined (LPASS8)
295: {
296: int flags;
297: flags = local_mode_flags | LPASS8;
298: ioctl (tty, TIOCLSET, &flags);
299: }
300: #endif /* TIOCLGET && LPASS8 */
301: }
302:
303: #if defined (TIOCGETC)
304: {
305: struct tchars temp;
306:
307: ioctl (tty, TIOCGETC, &original_tchars);
308: temp = original_tchars;
309:
310: #if defined (USE_XON_XOFF)
311: /* Get rid of C-s and C-q.
312: We remember the value of startc (C-q) so that if the terminal is in
313: xoff state, the user can xon it by pressing that character. */
314: xon_char = temp.t_startc;
315: temp.t_stopc = -1;
316: temp.t_startc = -1;
317:
318: /* If there is an XON character, bind it to restart the output. */
319: if (xon_char != -1)
320: bind_key (xon_char, restart_output);
321: #endif /* USE_XON_XOFF */
322:
323: /* If there is an EOF char, bind eof_char to it. */
324: if (temp.t_eofc != -1)
325: eof_char = temp.t_eofc;
326:
327: #if defined (NO_KILL_INTR)
328: /* Get rid of C-\ and C-c. */
329: temp.t_intrc = temp.t_quitc = -1;
330: #endif /* NO_KILL_INTR */
331:
332: ioctl (tty, TIOCSETC, &temp);
333: }
334: #endif /* TIOCGETC */
335:
336: #if defined (TIOCGLTC)
337: {
338: struct ltchars temp;
339:
340: ioctl (tty, TIOCGLTC, &original_ltchars);
341: temp = original_ltchars;
342:
343: /* Make the interrupt keys go away. Just enough to make people
344: happy. */
345: temp.t_dsuspc = -1; /* C-y */
346: temp.t_lnextc = -1; /* C-v */
347:
348: ioctl (tty, TIOCSLTC, &temp);
349: }
350: #endif /* TIOCGLTC */
351:
352: the_ttybuff.sg_flags &= ~(ECHO | CRMOD);
353: the_ttybuff.sg_flags |= CBREAK;
354: ioctl (tty, TIOCSETN, &the_ttybuff);
355:
356: terminal_prepped = 1;
357:
358: #if defined (HAVE_BSD_SIGNALS)
359: sigsetmask (oldmask);
360: #endif
361: }
362:
363: /* Restore the terminal to its original state. */
364: void deprep_terminal ()
365: {
366: int tty = fileno (stdin);
367: #if defined (HAVE_BSD_SIGNALS)
368: int oldmask;
369: #endif
370:
371: if (!terminal_prepped)
372: return;
373:
374: oldmask = sigblock (sigmask (SIGINT));
375:
376: the_ttybuff.sg_flags = original_tty_flags;
377: ioctl (tty, TIOCSETN, &the_ttybuff);
378: readline_echoing_p = 1;
379:
380: #if defined (TIOCLGET)
381: ioctl (tty, TIOCLSET, &local_mode_flags);
382: #endif
383:
384: #if defined (TIOCSLTC)
385: ioctl (tty, TIOCSLTC, &original_ltchars);
386: #endif
387:
388: #if defined (TIOCSETC)
389: ioctl (tty, TIOCSETC, &original_tchars);
390: #endif
391: terminal_prepped = 0;
392:
393: #if defined (HAVE_BSD_SIGNALS)
394: sigsetmask (oldmask);
395: #endif
396: }
397:
398: #else /* !defined (NEW_TTY_DRIVER) */
399:
400: #if !defined (VMIN)
401: #define VMIN VEOF
402: #endif
403:
404: #if !defined (VTIME)
405: #define VTIME VEOL
406: #endif
407:
408: void prep_terminal ()
409: {
410: int tty = fileno (stdin);
411: #if defined (TERMIOS_TTY_DRIVER)
412: struct termios tio;
413: #else
414: struct termio tio;
415: #endif /* !TERMIOS_TTY_DRIVER */
416:
417: #if defined (HAVE_POSIX_SIGNALS)
418: sigset_t set, oset;
419: #else
420: # if defined (HAVE_BSD_SIGNALS)
421: int oldmask;
422: # endif /* HAVE_BSD_SIGNALS */
423: #endif /* !HAVE_POSIX_SIGNALS */
424:
425: if (terminal_prepped)
426: return;
427:
428: /* Try to keep this function from being INTerrupted. We can do it
429: on POSIX and systems with BSD-like signal handling. */
430: #if defined (HAVE_POSIX_SIGNALS)
431: sigemptyset (&set);
432: sigemptyset (&oset);
433: sigaddset (&set, SIGINT);
434: sigprocmask (SIG_BLOCK, &set, &oset);
435: #else /* !HAVE_POSIX_SIGNALS */
436: # if defined (HAVE_BSD_SIGNALS)
437: oldmask = sigblock (sigmask (SIGINT));
438: # endif /* HAVE_BSD_SIGNALS */
439: #endif /* !HAVE_POSIX_SIGNALS */
440:
441: #if defined (TERMIOS_TTY_DRIVER)
442: tcgetattr (tty, &tio);
443: #else
444: ioctl (tty, TCGETA, &tio);
445: #endif /* !TERMIOS_TTY_DRIVER */
446:
447: otio = tio;
448:
449: readline_echoing_p = (tio.c_lflag & ECHO);
450:
451: tio.c_lflag &= ~(ICANON | ECHO);
452:
453: if (otio.c_cc[VEOF] != _POSIX_VDISABLE)
454: eof_char = otio.c_cc[VEOF];
455:
456: #if defined (USE_XON_XOFF)
457: #if defined (IXANY)
458: tio.c_iflag &= ~(IXON | IXOFF | IXANY);
459: #else
460: /* `strict' Posix systems do not define IXANY. */
461: tio.c_iflag &= ~(IXON | IXOFF);
462: #endif /* IXANY */
463: #endif /* USE_XON_XOFF */
464:
465: /* Only turn this off if we are using all 8 bits. */
466: if ((tio.c_cflag & CSIZE) == CS8)
467: tio.c_iflag &= ~(ISTRIP | INPCK);
468:
469: /* Make sure we differentiate between CR and NL on input. */
470: tio.c_iflag &= ~(ICRNL | INLCR);
471:
472: #if !defined (HANDLE_SIGNALS)
473: tio.c_lflag &= ~ISIG;
474: #else
475: tio.c_lflag |= ISIG;
476: #endif
477:
478: tio.c_cc[VMIN] = 1;
479: tio.c_cc[VTIME] = 0;
480:
481: /* Turn off characters that we need on Posix systems with job control,
482: just to be sure. This includes ^Y and ^V. This should not really
483: be necessary. */
484: #if defined (TERMIOS_TTY_DRIVER) && defined (_POSIX_JOB_CONTROL)
485:
486: #if defined (VLNEXT)
487: tio.c_cc[VLNEXT] = _POSIX_VDISABLE;
488: #endif
489:
490: #if defined (VDSUSP)
491: tio.c_cc[VDSUSP] = _POSIX_VDISABLE;
492: #endif
493:
494: #endif /* POSIX && JOB_CONTROL */
495:
496: #if defined (TERMIOS_TTY_DRIVER)
497: tcsetattr (tty, TCSADRAIN, &tio);
498: tcflow (tty, TCOON); /* Simulate a ^Q. */
499: #else
500: ioctl (tty, TCSETAW, &tio);
501: ioctl (tty, TCXONC, 1); /* Simulate a ^Q. */
502: #endif /* !TERMIOS_TTY_DRIVER */
503:
504: terminal_prepped = 1;
505:
506: #if defined (HAVE_POSIX_SIGNALS)
507: sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
508: #else
509: # if defined (HAVE_BSD_SIGNALS)
510: sigsetmask (oldmask);
511: # endif /* HAVE_BSD_SIGNALS */
512: #endif /* !HAVE_POSIX_SIGNALS */
513: }
514:
515: void deprep_terminal ()
516: {
517: int tty = fileno (stdin);
518:
519: /* Try to keep this function from being INTerrupted. We can do it
520: on POSIX and systems with BSD-like signal handling. */
521: #if defined (HAVE_POSIX_SIGNALS)
522: sigset_t set, oset;
523: #else /* !HAVE_POSIX_SIGNALS */
524: # if defined (HAVE_BSD_SIGNALS)
525: int oldmask;
526: # endif /* HAVE_BSD_SIGNALS */
527: #endif /* !HAVE_POSIX_SIGNALS */
528:
529: if (!terminal_prepped)
530: return;
531:
532: #if defined (HAVE_POSIX_SIGNALS)
533: sigemptyset (&set);
534: sigemptyset (&oset);
535: sigaddset (&set, SIGINT);
536: sigprocmask (SIG_BLOCK, &set, &oset);
537: #else /* !HAVE_POSIX_SIGNALS */
538: # if defined (HAVE_BSD_SIGNALS)
539: oldmask = sigblock (sigmask (SIGINT));
540: # endif /* HAVE_BSD_SIGNALS */
541: #endif /* !HAVE_POSIX_SIGNALS */
542:
543: #if defined (TERMIOS_TTY_DRIVER)
544: tcsetattr (tty, TCSADRAIN, &otio);
545: tcflow (tty, TCOON); /* Simulate a ^Q. */
546: #else /* TERMIOS_TTY_DRIVER */
547: ioctl (tty, TCSETAW, &otio);
548: ioctl (tty, TCXONC, 1); /* Simulate a ^Q. */
549: #endif /* !TERMIOS_TTY_DRIVER */
550:
551: terminal_prepped = 0;
552:
553: #if defined (HAVE_POSIX_SIGNALS)
554: sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
555: #else /* !HAVE_POSIX_SIGNALS */
556: # if defined (HAVE_BSD_SIGNALS)
557: sigsetmask (oldmask);
558: # endif /* HAVE_BSD_SIGNALS */
559: #endif /* !HAVE_POSIX_SIGNALS */
560: }
561: #endif /* NEW_TTY_DRIVER */
562:
563: /* If a character is available to be read, then read it
564: and stuff it into IBUFFER. Otherwise, just return. */
565:
566: long pending = -1L;
567:
568: long key_avail (stream)
569: FILE *stream;
570: {
571: int tty = fileno (stream);
572: long chars_avail = pending;
573: int result;
574:
575: #if defined (FIONREAD)
576: result = ioctl (tty, FIONREAD, &chars_avail);
577: #endif
578:
579: if(chars_avail == -1L)
580: { unsigned char inchar;
581:
582: fcntl(tty, F_SETFL, O_NDELAY);
583: result = read(tty, &inchar, sizeof(char));
584: if(result == sizeof(char))
585: {
586: chars_avail = 1;
587: pending = (long)inchar;
588: }
589: else
590: chars_avail = 0;
591: fcntl(tty, F_SETFL, 0);
592: }
593:
594: return chars_avail;
595: }
596:
597: /* Get a key from the buffer of characters to be read.
598: Return the key in KEY.
599: Result is KEY if there was a key, or 0 if there wasn't. */
600:
601: /* When compiling and running in the `Posix' environment, Ultrix does
602: not restart system calls, so this needs to do it. */
603:
604: unsigned char getkey(stream)
605: FILE *stream;
606: {
607: int result;
608: unsigned char c;
609:
610: while (pending < 0)
611: {
612: result = read (fileno (stream), &c, sizeof (char));
613:
614: if (result == sizeof (char))
615: return /* (c == 0x7F ? 0x08 :*/ c /*)*/;
616:
617: /* If zero characters are returned, then the file that we are
618: reading from is empty! Return EOF in that case. */
619: if (result == 0)
620: return (0);
621:
622: /* If the error that we received was SIGINT, then try again,
623: this is simply an interrupted system call to read ().
624: Otherwise, some error ocurred, also signifying EOF. */
625: if (errno != EINTR)
626: return (EOF);
627: }
628:
629: result = (int) pending;
630: pending = -1L;
631:
632: return result;
633: }
634:
635: #ifdef TEST
636:
637: #include <time.h>
638:
639: int timewait=100000;
640:
641: int main()
642: {
643: unsigned char c;
644:
645: prep_terminal();
646:
647: do
648: {
649: int i=0;
650:
651: while(!key_avail(stdin))
652: {
653: printf("%04d",i);
654: fflush(stdout);
655: {
656: struct timeval timeout;
657: timeout.tv_sec=timewait/1000000;
658: timeout.tv_usec=timewait%1000000;
659: (void)select(0,0,0,0,&timeout);
660: }
661: i++;
662: printf("\b\b\b\b");
663: fflush(stdout);
664: }
665: c = getkey(stdin);
666: printf("%02x,",(int)c);
667: fflush(stdout);
668: } while(c != 0x1B);
669:
670: deprep_terminal();
671: puts("");
672: }
673: #endif
674:
675: /* signal handling taken from pfe by Dirk Zoller (Copylefted) - anton */
676: /* !! needs cleanup */
677: char *
678: sigmsg (int sig)
679: {
680: static char buf [25];
681: static char *msg [] =
682: {
683: "Hangup", /* These strings are cited from */
684: "Interrupt", /* Rochkind: Advanced UNIX programming */
685: "Quit",
686: "Illegal Instruction",
687: "Trace Trap",
688: "IOT instruction",
689: "EMT instruction",
690: "Floating point exception",
691: "Kill",
692: "Bus error",
693: "Segmentation Violation",
694: "Bad arg to system call",
695: "Broken pipe",
696: "Alarm clock",
697: "Terminate signal",
698: "User signal 1",
699: "User signal 2",
700: };
701:
702: if ((unsigned)sig <= 17)
703: return msg [sig - 1];
704: sprintf (buf, "signal %d received", sig);
705: return buf;
706: }
707:
708: static void
709: graceful_exit (int sig)
710: {
711: deprep_terminal();
712: if ((unsigned)sig <= 17)
713: fprintf (stderr, "\n\n%s.\n", sigmsg (sig));
714: else
715: fprintf (stderr, "\n\nSignal %d received, terminated.\n", sig);
716: exit (0x80|sig);
717: }
718:
719: jmp_buf throw_jmp_buf;
720:
721: static void
722: signal_throw(int sig)
723: {
724: static int throw_codes[] = {
725: -256,
726: -28,
727: -257,
728: -258,
729: -259,
730: -260,
731: -261,
732: -55,
733: -262,
734: -23,
735: -9,
736: -263,
737: -264,
738: -265,
739: -266,
740: -267,
741: -268,
742: };
743: signal(sig,signal_throw);
744: longjmp(throw_jmp_buf,throw_codes[sig-1]); /* or use siglongjmp ? */
745: }
746:
747: static void
748: termprep (int sig)
749: {
750: terminal_prepped=0; prep_terminal();
751: signal(sig,termprep);
752: }
753:
754: void
755: install_signal_handlers (void)
756: {
757: /* !! These definitions seem to be system dependent
758: We could have them in the machine.h file,
759: but I would like something more automatic - anton */
760: #define SIGS_TO_IGNORE SIGCHLD
761: #define SIGS_TO_ABORT SIGINT, SIGILL, SIGFPE, SIGUSR1, SIGSEGV, SIGUSR2, \
762: SIGALRM, SIGBUS
763: #define SIGS_TO_QUIT SIGHUP, SIGQUIT, SIGABRT, SIGPIPE, \
764: SIGTERM
765: #define SIGS_TO_TERMPREP SIGCONT
766:
767: static short sigs_to_ignore [] = { SIGS_TO_IGNORE };
768: static short sigs_to_abort [] = { SIGS_TO_ABORT };
769: static short sigs_to_quit [] = { SIGS_TO_QUIT };
770: static short sigs_to_termprep [] = { SIGS_TO_TERMPREP };
771: int i;
772:
773: #define DIM(X) (sizeof (X) / sizeof *(X))
774: for (i = 0; i < DIM (sigs_to_ignore); i++)
775: if (sigs_to_ignore [i])
776: signal (sigs_to_ignore [i], SIG_IGN);
777: for (i = 0; i < DIM (sigs_to_abort); i++)
778: signal (sigs_to_abort [i], signal_throw); /* !! change to throw */
779: for (i = 0; i < DIM (sigs_to_quit); i++)
780: signal (sigs_to_quit [i], graceful_exit);
781: for (i = 0; i < DIM (sigs_to_termprep); i++)
782: signal (sigs_to_termprep [i], termprep);
783: }
784: /* end signal handling */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to io.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [gforth] / gforth