Annotation of embedaddon/readline/signals.c, revision 1.1.1.1
1.1 misho 1: /* signals.c -- signal handling support for readline. */
2:
3: /* Copyright (C) 1987-2011 Free Software Foundation, Inc.
4:
5: This file is part of the GNU Readline Library (Readline), a library
6: for reading lines of text with interactive input and history editing.
7:
8: Readline is free software: you can redistribute it and/or modify
9: it under the terms of the GNU General Public License as published by
10: the Free Software Foundation, either version 3 of the License, or
11: (at your option) any later version.
12:
13: Readline is distributed in the hope that it will be useful,
14: but WITHOUT ANY WARRANTY; without even the implied warranty of
15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16: GNU General Public License for more details.
17:
18: You should have received a copy of the GNU General Public License
19: along with Readline. If not, see <http://www.gnu.org/licenses/>.
20: */
21:
22: #define READLINE_LIBRARY
23:
24: #if defined (HAVE_CONFIG_H)
25: # include <config.h>
26: #endif
27:
28: #include <stdio.h> /* Just for NULL. Yuck. */
29: #include <sys/types.h>
30: #include <signal.h>
31:
32: #if defined (HAVE_UNISTD_H)
33: # include <unistd.h>
34: #endif /* HAVE_UNISTD_H */
35:
36: /* System-specific feature definitions and include files. */
37: #include "rldefs.h"
38:
39: #if defined (GWINSZ_IN_SYS_IOCTL)
40: # include <sys/ioctl.h>
41: #endif /* GWINSZ_IN_SYS_IOCTL */
42:
43: /* Some standard library routines. */
44: #include "readline.h"
45: #include "history.h"
46:
47: #include "rlprivate.h"
48:
49: #if defined (HANDLE_SIGNALS)
50:
51: #if !defined (RETSIGTYPE)
52: # if defined (VOID_SIGHANDLER)
53: # define RETSIGTYPE void
54: # else
55: # define RETSIGTYPE int
56: # endif /* !VOID_SIGHANDLER */
57: #endif /* !RETSIGTYPE */
58:
59: #if defined (VOID_SIGHANDLER)
60: # define SIGHANDLER_RETURN return
61: #else
62: # define SIGHANDLER_RETURN return (0)
63: #endif
64:
65: /* This typedef is equivalent to the one for Function; it allows us
66: to say SigHandler *foo = signal (SIGKILL, SIG_IGN); */
67: typedef RETSIGTYPE SigHandler ();
68:
69: #if defined (HAVE_POSIX_SIGNALS)
70: typedef struct sigaction sighandler_cxt;
71: # define rl_sigaction(s, nh, oh) sigaction(s, nh, oh)
72: #else
73: typedef struct { SigHandler *sa_handler; int sa_mask, sa_flags; } sighandler_cxt;
74: # define sigemptyset(m)
75: #endif /* !HAVE_POSIX_SIGNALS */
76:
77: #ifndef SA_RESTART
78: # define SA_RESTART 0
79: #endif
80:
81: static SigHandler *rl_set_sighandler PARAMS((int, SigHandler *, sighandler_cxt *));
82: static void rl_maybe_set_sighandler PARAMS((int, SigHandler *, sighandler_cxt *));
83: static void rl_maybe_restore_sighandler PARAMS((int, sighandler_cxt *));
84:
85: static RETSIGTYPE rl_signal_handler PARAMS((int));
86: static RETSIGTYPE _rl_handle_signal PARAMS((int));
87:
88: /* Exported variables for use by applications. */
89:
90: /* If non-zero, readline will install its own signal handlers for
91: SIGINT, SIGTERM, SIGHUP, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. */
92: int rl_catch_signals = 1;
93:
94: /* If non-zero, readline will install a signal handler for SIGWINCH. */
95: #ifdef SIGWINCH
96: int rl_catch_sigwinch = 1;
97: #else
98: int rl_catch_sigwinch = 0; /* for the readline state struct in readline.c */
99: #endif
100:
101: /* Private variables. */
102: int _rl_interrupt_immediately = 0;
103: int volatile _rl_caught_signal = 0; /* should be sig_atomic_t, but that requires including <signal.h> everywhere */
104:
105: /* If non-zero, print characters corresponding to received signals as long as
106: the user has indicated his desire to do so (_rl_echo_control_chars). */
107: int _rl_echoctl = 0;
108:
109: int _rl_intr_char = 0;
110: int _rl_quit_char = 0;
111: int _rl_susp_char = 0;
112:
113: static int signals_set_flag;
114: static int sigwinch_set_flag;
115:
116: /* **************************************************************** */
117: /* */
118: /* Signal Handling */
119: /* */
120: /* **************************************************************** */
121:
122: static sighandler_cxt old_int, old_term, old_hup, old_alrm, old_quit;
123: #if defined (SIGTSTP)
124: static sighandler_cxt old_tstp, old_ttou, old_ttin;
125: #endif
126: #if defined (SIGWINCH)
127: static sighandler_cxt old_winch;
128: #endif
129:
130: _rl_sigcleanup_func_t *_rl_sigcleanup;
131: void *_rl_sigcleanarg;
132:
133: /* Readline signal handler functions. */
134:
135: /* Called from RL_CHECK_SIGNALS() macro */
136: RETSIGTYPE
137: _rl_signal_handler (sig)
138: int sig;
139: {
140: _rl_caught_signal = 0; /* XXX */
141:
142: #if defined (SIGWINCH)
143: if (sig == SIGWINCH)
144: {
145: rl_resize_terminal ();
146: /* XXX - experimental for now */
147: /* Call a signal hook because though we called the original signal handler
148: in rl_sigwinch_handler below, we will not resend the signal to
149: ourselves. */
150: if (rl_signal_event_hook)
151: (*rl_signal_event_hook) ();
152: }
153: else
154: #endif
155: _rl_handle_signal (sig);
156:
157: SIGHANDLER_RETURN;
158: }
159:
160: static RETSIGTYPE
161: rl_signal_handler (sig)
162: int sig;
163: {
164: if (_rl_interrupt_immediately)
165: {
166: _rl_interrupt_immediately = 0;
167: _rl_handle_signal (sig);
168: }
169: else
170: _rl_caught_signal = sig;
171:
172: SIGHANDLER_RETURN;
173: }
174:
175: static RETSIGTYPE
176: _rl_handle_signal (sig)
177: int sig;
178: {
179: #if defined (HAVE_POSIX_SIGNALS)
180: sigset_t set;
181: #else /* !HAVE_POSIX_SIGNALS */
182: # if defined (HAVE_BSD_SIGNALS)
183: long omask;
184: # else /* !HAVE_BSD_SIGNALS */
185: sighandler_cxt dummy_cxt; /* needed for rl_set_sighandler call */
186: # endif /* !HAVE_BSD_SIGNALS */
187: #endif /* !HAVE_POSIX_SIGNALS */
188:
189: RL_SETSTATE(RL_STATE_SIGHANDLER);
190:
191: #if !defined (HAVE_BSD_SIGNALS) && !defined (HAVE_POSIX_SIGNALS)
192: /* Since the signal will not be blocked while we are in the signal
193: handler, ignore it until rl_clear_signals resets the catcher. */
194: # if defined (SIGALRM)
195: if (sig == SIGINT || sig == SIGALRM)
196: # else
197: if (sig == SIGINT)
198: # endif
199: rl_set_sighandler (sig, SIG_IGN, &dummy_cxt);
200: #endif /* !HAVE_BSD_SIGNALS && !HAVE_POSIX_SIGNALS */
201:
202: /* If there's a sig cleanup function registered, call it and `deregister'
203: the cleanup function to avoid multiple calls */
204: if (_rl_sigcleanup)
205: {
206: (*_rl_sigcleanup) (sig, _rl_sigcleanarg);
207: _rl_sigcleanup = 0;
208: _rl_sigcleanarg = 0;
209: }
210:
211: switch (sig)
212: {
213: case SIGINT:
214: _rl_reset_completion_state ();
215: rl_free_line_state ();
216: /* FALLTHROUGH */
217:
218: case SIGTERM:
219: case SIGHUP:
220: #if defined (SIGTSTP)
221: case SIGTSTP:
222: case SIGTTOU:
223: case SIGTTIN:
224: #endif /* SIGTSTP */
225: #if defined (SIGALRM)
226: case SIGALRM:
227: #endif
228: #if defined (SIGQUIT)
229: case SIGQUIT:
230: #endif
231: rl_echo_signal_char (sig);
232: rl_cleanup_after_signal ();
233:
234: #if defined (HAVE_POSIX_SIGNALS)
235: sigemptyset (&set);
236: sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &set);
237: sigdelset (&set, sig);
238: #else /* !HAVE_POSIX_SIGNALS */
239: # if defined (HAVE_BSD_SIGNALS)
240: omask = sigblock (0);
241: # endif /* HAVE_BSD_SIGNALS */
242: #endif /* !HAVE_POSIX_SIGNALS */
243:
244: #if defined (__EMX__)
245: signal (sig, SIG_ACK);
246: #endif
247:
248: #if defined (HAVE_KILL)
249: kill (getpid (), sig);
250: #else
251: raise (sig); /* assume we have raise */
252: #endif
253:
254: /* Let the signal that we just sent through. */
255: #if defined (HAVE_POSIX_SIGNALS)
256: sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL);
257: #else /* !HAVE_POSIX_SIGNALS */
258: # if defined (HAVE_BSD_SIGNALS)
259: sigsetmask (omask & ~(sigmask (sig)));
260: # endif /* HAVE_BSD_SIGNALS */
261: #endif /* !HAVE_POSIX_SIGNALS */
262:
263: rl_reset_after_signal ();
264: }
265:
266: RL_UNSETSTATE(RL_STATE_SIGHANDLER);
267: SIGHANDLER_RETURN;
268: }
269:
270: #if defined (SIGWINCH)
271: static RETSIGTYPE
272: rl_sigwinch_handler (sig)
273: int sig;
274: {
275: SigHandler *oh;
276:
277: #if defined (MUST_REINSTALL_SIGHANDLERS)
278: sighandler_cxt dummy_winch;
279:
280: /* We don't want to change old_winch -- it holds the state of SIGWINCH
281: disposition set by the calling application. We need this state
282: because we call the application's SIGWINCH handler after updating
283: our own idea of the screen size. */
284: rl_set_sighandler (SIGWINCH, rl_sigwinch_handler, &dummy_winch);
285: #endif
286:
287: RL_SETSTATE(RL_STATE_SIGHANDLER);
288: _rl_caught_signal = sig;
289:
290: /* If another sigwinch handler has been installed, call it. */
291: oh = (SigHandler *)old_winch.sa_handler;
292: if (oh && oh != (SigHandler *)SIG_IGN && oh != (SigHandler *)SIG_DFL)
293: (*oh) (sig);
294:
295: RL_UNSETSTATE(RL_STATE_SIGHANDLER);
296: SIGHANDLER_RETURN;
297: }
298: #endif /* SIGWINCH */
299:
300: /* Functions to manage signal handling. */
301:
302: #if !defined (HAVE_POSIX_SIGNALS)
303: static int
304: rl_sigaction (sig, nh, oh)
305: int sig;
306: sighandler_cxt *nh, *oh;
307: {
308: oh->sa_handler = signal (sig, nh->sa_handler);
309: return 0;
310: }
311: #endif /* !HAVE_POSIX_SIGNALS */
312:
313: /* Set up a readline-specific signal handler, saving the old signal
314: information in OHANDLER. Return the old signal handler, like
315: signal(). */
316: static SigHandler *
317: rl_set_sighandler (sig, handler, ohandler)
318: int sig;
319: SigHandler *handler;
320: sighandler_cxt *ohandler;
321: {
322: sighandler_cxt old_handler;
323: #if defined (HAVE_POSIX_SIGNALS)
324: struct sigaction act;
325:
326: act.sa_handler = handler;
327: # if defined (SIGWINCH)
328: act.sa_flags = (sig == SIGWINCH) ? SA_RESTART : 0;
329: # else
330: act.sa_flags = 0;
331: # endif /* SIGWINCH */
332: sigemptyset (&act.sa_mask);
333: sigemptyset (&ohandler->sa_mask);
334: sigaction (sig, &act, &old_handler);
335: #else
336: old_handler.sa_handler = (SigHandler *)signal (sig, handler);
337: #endif /* !HAVE_POSIX_SIGNALS */
338:
339: /* XXX -- assume we have memcpy */
340: /* If rl_set_signals is called twice in a row, don't set the old handler to
341: rl_signal_handler, because that would cause infinite recursion. */
342: if (handler != rl_signal_handler || old_handler.sa_handler != rl_signal_handler)
343: memcpy (ohandler, &old_handler, sizeof (sighandler_cxt));
344:
345: return (ohandler->sa_handler);
346: }
347:
348: /* Set disposition of SIG to HANDLER, returning old state in OHANDLER. Don't
349: change disposition if OHANDLER indicates the signal was ignored. */
350: static void
351: rl_maybe_set_sighandler (sig, handler, ohandler)
352: int sig;
353: SigHandler *handler;
354: sighandler_cxt *ohandler;
355: {
356: sighandler_cxt dummy;
357: SigHandler *oh;
358:
359: sigemptyset (&dummy.sa_mask);
360: dummy.sa_flags = 0;
361: oh = rl_set_sighandler (sig, handler, ohandler);
362: if (oh == (SigHandler *)SIG_IGN)
363: rl_sigaction (sig, ohandler, &dummy);
364: }
365:
366: /* Set the disposition of SIG to HANDLER, if HANDLER->sa_handler indicates the
367: signal was not being ignored. MUST only be called for signals whose
368: disposition was changed using rl_maybe_set_sighandler or for which the
369: SIG_IGN check was performed inline (e.g., SIGALRM below). */
370: static void
371: rl_maybe_restore_sighandler (sig, handler)
372: int sig;
373: sighandler_cxt *handler;
374: {
375: sighandler_cxt dummy;
376:
377: sigemptyset (&dummy.sa_mask);
378: dummy.sa_flags = 0;
379: if (handler->sa_handler != SIG_IGN)
380: rl_sigaction (sig, handler, &dummy);
381: }
382:
383: int
384: rl_set_signals ()
385: {
386: sighandler_cxt dummy;
387: SigHandler *oh;
388: #if defined (HAVE_POSIX_SIGNALS)
389: static int sigmask_set = 0;
390: static sigset_t bset, oset;
391: #endif
392:
393: #if defined (HAVE_POSIX_SIGNALS)
394: if (rl_catch_signals && sigmask_set == 0)
395: {
396: sigemptyset (&bset);
397:
398: sigaddset (&bset, SIGINT);
399: sigaddset (&bset, SIGTERM);
400: sigaddset (&bset, SIGHUP);
401: #if defined (SIGQUIT)
402: sigaddset (&bset, SIGQUIT);
403: #endif
404: #if defined (SIGALRM)
405: sigaddset (&bset, SIGALRM);
406: #endif
407: #if defined (SIGTSTP)
408: sigaddset (&bset, SIGTSTP);
409: #endif
410: #if defined (SIGTTIN)
411: sigaddset (&bset, SIGTTIN);
412: #endif
413: #if defined (SIGTTOU)
414: sigaddset (&bset, SIGTTOU);
415: #endif
416: sigmask_set = 1;
417: }
418: #endif /* HAVE_POSIX_SIGNALS */
419:
420: if (rl_catch_signals && signals_set_flag == 0)
421: {
422: #if defined (HAVE_POSIX_SIGNALS)
423: sigemptyset (&oset);
424: sigprocmask (SIG_BLOCK, &bset, &oset);
425: #endif
426:
427: rl_maybe_set_sighandler (SIGINT, rl_signal_handler, &old_int);
428: rl_maybe_set_sighandler (SIGTERM, rl_signal_handler, &old_term);
429: rl_maybe_set_sighandler (SIGHUP, rl_signal_handler, &old_hup);
430: #if defined (SIGQUIT)
431: rl_maybe_set_sighandler (SIGQUIT, rl_signal_handler, &old_quit);
432: #endif
433:
434: #if defined (SIGALRM)
435: oh = rl_set_sighandler (SIGALRM, rl_signal_handler, &old_alrm);
436: if (oh == (SigHandler *)SIG_IGN)
437: rl_sigaction (SIGALRM, &old_alrm, &dummy);
438: #if defined (HAVE_POSIX_SIGNALS) && defined (SA_RESTART)
439: /* If the application using readline has already installed a signal
440: handler with SA_RESTART, SIGALRM will cause reads to be restarted
441: automatically, so readline should just get out of the way. Since
442: we tested for SIG_IGN above, we can just test for SIG_DFL here. */
443: if (oh != (SigHandler *)SIG_DFL && (old_alrm.sa_flags & SA_RESTART))
444: rl_sigaction (SIGALRM, &old_alrm, &dummy);
445: #endif /* HAVE_POSIX_SIGNALS */
446: #endif /* SIGALRM */
447:
448: #if defined (SIGTSTP)
449: rl_maybe_set_sighandler (SIGTSTP, rl_signal_handler, &old_tstp);
450: #endif /* SIGTSTP */
451:
452: #if defined (SIGTTOU)
453: rl_maybe_set_sighandler (SIGTTOU, rl_signal_handler, &old_ttou);
454: #endif /* SIGTTOU */
455:
456: #if defined (SIGTTIN)
457: rl_maybe_set_sighandler (SIGTTIN, rl_signal_handler, &old_ttin);
458: #endif /* SIGTTIN */
459:
460: signals_set_flag = 1;
461:
462: #if defined (HAVE_POSIX_SIGNALS)
463: sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
464: #endif
465: }
466:
467: #if defined (SIGWINCH)
468: if (rl_catch_sigwinch && sigwinch_set_flag == 0)
469: {
470: rl_maybe_set_sighandler (SIGWINCH, rl_sigwinch_handler, &old_winch);
471: sigwinch_set_flag = 1;
472: }
473: #endif /* SIGWINCH */
474:
475: return 0;
476: }
477:
478: int
479: rl_clear_signals ()
480: {
481: sighandler_cxt dummy;
482:
483: if (rl_catch_signals && signals_set_flag == 1)
484: {
485: sigemptyset (&dummy.sa_mask);
486:
487: /* Since rl_maybe_set_sighandler doesn't override a SIG_IGN handler,
488: we should in theory not have to restore a handler where
489: old_xxx.sa_handler == SIG_IGN. That's what rl_maybe_restore_sighandler
490: does. Fewer system calls should reduce readline's per-line
491: overhead */
492: rl_maybe_restore_sighandler (SIGINT, &old_int);
493: rl_maybe_restore_sighandler (SIGTERM, &old_term);
494: rl_maybe_restore_sighandler (SIGHUP, &old_hup);
495: #if defined (SIGQUIT)
496: rl_maybe_restore_sighandler (SIGQUIT, &old_quit);
497: #endif
498: #if defined (SIGALRM)
499: rl_maybe_restore_sighandler (SIGALRM, &old_alrm);
500: #endif
501:
502: #if defined (SIGTSTP)
503: rl_maybe_restore_sighandler (SIGTSTP, &old_tstp);
504: #endif /* SIGTSTP */
505:
506: #if defined (SIGTTOU)
507: rl_maybe_restore_sighandler (SIGTTOU, &old_ttou);
508: #endif /* SIGTTOU */
509:
510: #if defined (SIGTTIN)
511: rl_maybe_restore_sighandler (SIGTTIN, &old_ttin);
512: #endif /* SIGTTIN */
513:
514: signals_set_flag = 0;
515: }
516:
517: #if defined (SIGWINCH)
518: if (rl_catch_sigwinch && sigwinch_set_flag == 1)
519: {
520: sigemptyset (&dummy.sa_mask);
521: rl_sigaction (SIGWINCH, &old_winch, &dummy);
522: sigwinch_set_flag = 0;
523: }
524: #endif
525:
526: return 0;
527: }
528:
529: /* Clean up the terminal and readline state after catching a signal, before
530: resending it to the calling application. */
531: void
532: rl_cleanup_after_signal ()
533: {
534: _rl_clean_up_for_exit ();
535: if (rl_deprep_term_function)
536: (*rl_deprep_term_function) ();
537: rl_clear_pending_input ();
538: rl_clear_signals ();
539: }
540:
541: /* Reset the terminal and readline state after a signal handler returns. */
542: void
543: rl_reset_after_signal ()
544: {
545: if (rl_prep_term_function)
546: (*rl_prep_term_function) (_rl_meta_flag);
547: rl_set_signals ();
548: }
549:
550: /* Free up the readline variable line state for the current line (undo list,
551: any partial history entry, any keyboard macros in progress, and any
552: numeric arguments in process) after catching a signal, before calling
553: rl_cleanup_after_signal(). */
554: void
555: rl_free_line_state ()
556: {
557: register HIST_ENTRY *entry;
558:
559: rl_free_undo_list ();
560:
561: entry = current_history ();
562: if (entry)
563: entry->data = (char *)NULL;
564:
565: _rl_kill_kbd_macro ();
566: rl_clear_message ();
567: _rl_reset_argument ();
568: }
569:
570: #endif /* HANDLE_SIGNALS */
571:
572: /* **************************************************************** */
573: /* */
574: /* SIGINT Management */
575: /* */
576: /* **************************************************************** */
577:
578: #if defined (HAVE_POSIX_SIGNALS)
579: static sigset_t sigint_set, sigint_oset;
580: static sigset_t sigwinch_set, sigwinch_oset;
581: #else /* !HAVE_POSIX_SIGNALS */
582: # if defined (HAVE_BSD_SIGNALS)
583: static int sigint_oldmask;
584: static int sigwinch_oldmask;
585: # endif /* HAVE_BSD_SIGNALS */
586: #endif /* !HAVE_POSIX_SIGNALS */
587:
588: static int sigint_blocked;
589: static int sigwinch_blocked;
590:
591: /* Cause SIGINT to not be delivered until the corresponding call to
592: release_sigint(). */
593: void
594: _rl_block_sigint ()
595: {
596: if (sigint_blocked)
597: return;
598:
599: sigint_blocked = 1;
600: }
601:
602: /* Allow SIGINT to be delivered. */
603: void
604: _rl_release_sigint ()
605: {
606: if (sigint_blocked == 0)
607: return;
608:
609: sigint_blocked = 0;
610: RL_CHECK_SIGNALS ();
611: }
612:
613: /* Cause SIGWINCH to not be delivered until the corresponding call to
614: release_sigwinch(). */
615: void
616: _rl_block_sigwinch ()
617: {
618: if (sigwinch_blocked)
619: return;
620:
621: #if defined (SIGWINCH)
622:
623: #if defined (HAVE_POSIX_SIGNALS)
624: sigemptyset (&sigwinch_set);
625: sigemptyset (&sigwinch_oset);
626: sigaddset (&sigwinch_set, SIGWINCH);
627: sigprocmask (SIG_BLOCK, &sigwinch_set, &sigwinch_oset);
628: #else /* !HAVE_POSIX_SIGNALS */
629: # if defined (HAVE_BSD_SIGNALS)
630: sigwinch_oldmask = sigblock (sigmask (SIGWINCH));
631: # else /* !HAVE_BSD_SIGNALS */
632: # if defined (HAVE_USG_SIGHOLD)
633: sighold (SIGWINCH);
634: # endif /* HAVE_USG_SIGHOLD */
635: # endif /* !HAVE_BSD_SIGNALS */
636: #endif /* !HAVE_POSIX_SIGNALS */
637:
638: #endif /* SIGWINCH */
639:
640: sigwinch_blocked = 1;
641: }
642:
643: /* Allow SIGWINCH to be delivered. */
644: void
645: _rl_release_sigwinch ()
646: {
647: if (sigwinch_blocked == 0)
648: return;
649:
650: #if defined (SIGWINCH)
651:
652: #if defined (HAVE_POSIX_SIGNALS)
653: sigprocmask (SIG_SETMASK, &sigwinch_oset, (sigset_t *)NULL);
654: #else
655: # if defined (HAVE_BSD_SIGNALS)
656: sigsetmask (sigwinch_oldmask);
657: # else /* !HAVE_BSD_SIGNALS */
658: # if defined (HAVE_USG_SIGHOLD)
659: sigrelse (SIGWINCH);
660: # endif /* HAVE_USG_SIGHOLD */
661: # endif /* !HAVE_BSD_SIGNALS */
662: #endif /* !HAVE_POSIX_SIGNALS */
663:
664: #endif /* SIGWINCH */
665:
666: sigwinch_blocked = 0;
667: }
668:
669: /* **************************************************************** */
670: /* */
671: /* Echoing special control characters */
672: /* */
673: /* **************************************************************** */
674: void
675: rl_echo_signal_char (sig)
676: int sig;
677: {
678: char cstr[3];
679: int cslen, c;
680:
681: if (_rl_echoctl == 0 || _rl_echo_control_chars == 0)
682: return;
683:
684: switch (sig)
685: {
686: case SIGINT: c = _rl_intr_char; break;
687: #if defined (SIGQUIT)
688: case SIGQUIT: c = _rl_quit_char; break;
689: #endif
690: #if defined (SIGTSTP)
691: case SIGTSTP: c = _rl_susp_char; break;
692: #endif
693: default: return;
694: }
695:
696: if (CTRL_CHAR (c) || c == RUBOUT)
697: {
698: cstr[0] = '^';
699: cstr[1] = CTRL_CHAR (c) ? UNCTRL (c) : '?';
700: cstr[cslen = 2] = '\0';
701: }
702: else
703: {
704: cstr[0] = c;
705: cstr[cslen = 1] = '\0';
706: }
707:
708: _rl_output_some_chars (cstr, cslen);
709: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to signals.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / readline