/* This should only be called from outside disturbance */ void sig_sys_spawn_cmd(int sig) /*{{{*/ { sig = errno; Signal_Sys_Spawn_Flag = 1; SLsignal_intr (SIGTSTP, sig_sys_spawn_cmd); errno = sig; }
static void sig_winch_handler (int sig) { sig = errno; Want_Window_Size_Change = 1; SLsignal_intr (SIGWINCH, sig_winch_handler); errno = sig; }
/* This function will cause system calls to be restarted after signal if possible */ SLSig_Fun_Type *SLsignal (int sig, SLSig_Fun_Type *f) { #if defined(SLANG_POSIX_SIGNALS) struct sigaction old_sa, new_sa; # ifdef SIGALRM /* We want system calls to be interrupted by SIGALRM. */ if (sig == SIGALRM) return SLsignal_intr (sig, f); # endif sigemptyset (&new_sa.sa_mask); new_sa.sa_handler = f; new_sa.sa_flags = 0; # ifdef SA_RESTART new_sa.sa_flags |= SA_RESTART; # endif if (-1 == sigaction (sig, &new_sa, &old_sa)) return (SLSig_Fun_Type *) SIG_ERR; return old_sa.sa_handler; #else /* Not POSIX. */ return signal (sig, f); #endif }
static int add_sigwinch_handlers (void) { #ifdef SIGWINCH (void) SLang_add_interrupt_hook (screen_size_changed_hook, NULL); (void) SLsignal_intr (SIGWINCH, sig_winch_handler); #endif return 0; }
static void sigint_handler (int sig) { SLsignal_intr (SIGINT, sigint_handler); keyboard_quit = true; #if SLANG_VERSION < 20000 if (SLang_Ignore_User_Abort == 0) SLang_Error = USER_BREAK; #endif }
static void default_sigint (int sig) { sig = errno; /* use parameter */ SLKeyBoard_Quit = 1; if (SLang_Ignore_User_Abort == 0) SLang_set_error (SL_USER_BREAK); SLsignal_intr (SIGINT, default_sigint); errno = sig; }
static void sigwinch_handler (int sig) /*{{{*/ { sig = errno; Jed_Resize_Pending = 1; # ifdef SIGWINCH SLsignal_intr (SIGWINCH, sigwinch_handler); # endif errno = sig; }
/* a control-G puts us here */ static void my_interrupt(int sig) /*{{{*/ { sig = errno; SLKeyBoard_Quit = 1; if (Ignore_User_Abort == 0) SLang_set_error (SL_USER_BREAK); SLsignal_intr (SIGINT, my_interrupt); errno = sig; }
int SLang_set_abort_signal (void (*hand)(int)) { int save_errno = errno; SLSig_Fun_Type *f; if (hand == NULL) hand = default_sigint; f = SLsignal_intr (SIGINT, hand); errno = save_errno; if (f == (SLSig_Fun_Type *) SIG_ERR) return -1; return 0; }
void init_signals (void) /*{{{*/ { #if !defined(VMS) || (__VMS_VER >= 70000000) #ifdef SIGWINCH (void) SLsignal_intr(SIGWINCH, sigwinch_handler); #endif Old_Sigint_Handler = SLsignal_intr (SIGINT, my_interrupt); SLsignal (SIGHUP, sig_hup_exit_jed); SLsignal (SIGQUIT, sig_hup_exit_jed); SLsignal (SIGTERM, sig_hup_exit_jed); SLsignal (SIGILL, sig_exit_jed); #if 0 && defined(SIGTRAP) SLsignal (SIGTRAP, sig_exit_jed); #endif #if 0 SLsignal (SIGIOT, sig_exit_jed); /* used by abort */ #endif #ifdef SIGPIPE SLsignal_intr (SIGPIPE, SIG_IGN); #endif /* SIGNAL (SIGFPE, sig_exit_jed); */ #ifdef SIGBUS SLsignal (SIGBUS, sig_exit_jed); #endif #if 0 SLsignal (SIGSEGV, sig_exit_jed); #endif #ifdef SIGSYS SLsignal (SIGSYS, sig_exit_jed); #endif #ifdef SIGTSTP if (Jed_Handle_SIGTSTP) { Old_Sigtstp_Handler = SLsignal_intr (SIGTSTP, sig_sys_spawn_cmd); if (SIG_DFL != Old_Sigtstp_Handler) Jed_Suspension_Not_Allowed = 1; } #endif #if CATCH_SIGTTIN # ifdef SIGTTOU SLsignal_intr (SIGTTOU, background_read); # endif # ifdef SIGTTIN SLsignal_intr (SIGTTIN, background_read); # endif #endif #endif /* VMS */ }
static void signal_handler (int sig) { Signal_Type *s; int e = errno; /* Until the signal has been delivered, block it. */ /* Hmmm... it appears that the system unblocks the signal as soon * as this function exits. Fortunately, this is not an issue. */ /* (void) block_signal (sig); */ (void) SLsignal_intr (sig, &signal_handler); s = find_signal (sig); /* cannot fail here */ s->pending = 1; if (sig == SIGINT) SLKeyBoard_Quit = 1; _pSLang_signal_interrupt (); errno = e; }
static int set_old_handler (Signal_Type *s, SLang_Ref_Type *ref, void (*old_handler)(int)) { if (old_handler == (void (*)(int))SIG_ERR) { _pSLang_verror (0, "signal system call failed"); return -1; } if (ref != NULL) { int ret; if (old_handler == signal_handler) ret = SLang_assign_nametype_to_ref (ref, s->handler); else { int h; if (old_handler == SIG_IGN) h = SIG_IGN_CONSTANT; else if (old_handler == SIG_DFL) h = SIG_DFL_CONSTANT; else h = SIG_APP_CONSTANT; ret = SLang_assign_to_ref (ref, SLANG_INT_TYPE, &h); } if (ret == -1) { (void) SLsignal_intr (s->sig, old_handler); return -1; } } if (old_handler != signal_handler) s->c_handler = old_handler; return 0; }
/** * @brief Initialize the newt library * @return int - 0 for success, else < 0 */ int newtInit(void) { char * MonoValue, * MonoEnv = "NEWT_MONO"; const char *lang; int ret; if ((lang = getenv("LC_ALL")) == NULL) if ((lang = getenv("LC_CTYPE")) == NULL) if ((lang = getenv("LANG")) == NULL) lang = ""; /* slang doesn't support multibyte encodings except UTF-8, avoid character corruption by redrawing the screen */ if (strstr (lang, ".euc") != NULL) trashScreen = 1; (void) strlen(ident); SLutf8_enable(-1); SLtt_get_terminfo(); SLtt_get_screen_size(); MonoValue = getenv(MonoEnv); if ( MonoValue != NULL ) SLtt_Use_Ansi_Colors = 0; if ((ret = SLsmg_init_smg()) < 0) return ret; if ((ret = SLang_init_tty(0, 0, 0)) < 0) return ret; initColors(); newtCursorOff(); initKeymap(); SLsignal_intr(SIGWINCH, handleSigwinch); SLang_getkey_intr_hook = getkeyInterruptHook; return 0; }
int newtInit(void) { char * MonoValue, * MonoEnv = "NEWT_MONO", * lang; lang = getenv ("LANG"); if (lang && !strcasecmp (lang, "ja_JP.eucJP")) trashScreen = 1; /* use the version variable just to be sure it gets included */ strlen(version); SLtt_get_terminfo(); SLtt_get_screen_size(); MonoValue = getenv(MonoEnv); if ( MonoValue == NULL ) { SLtt_Use_Ansi_Colors = 1; } else { SLtt_Use_Ansi_Colors = 0; } SLsmg_init_smg(); SLang_init_tty(0, 0, 0); newtSetColors(newtDefaultColorPalette); newtCursorOff(); /*initKeymap();*/ /*memset(&sa, 0, sizeof(sa)); sa.sa_handler = handleSigwinch; sigaction(SIGWINCH, &sa, NULL);*/ SLsignal_intr(SIGWINCH, handleSigwinch); SLang_getkey_intr_hook = getkeyInterruptHook; return 0; }
static void signal_intrinsic (void) { SLang_Name_Type *f; Signal_Type *s; void (*old_handler) (int); SLang_Ref_Type *old_ref; if (SLang_Num_Function_Args == 3) { if (-1 == SLang_pop_ref (&old_ref)) return; } else old_ref = NULL; if (SLang_Num_Function_Args == 0) { SLang_verror (SL_Internal_Error, "signal called with 0 args"); return; } if (SLANG_INT_TYPE == SLang_peek_at_stack ()) { int h; if ((-1 == SLang_pop_int (&h)) || (-1 == pop_signal (&s))) { SLang_free_ref (old_ref); return; } /* If this signal has already been caught, deliver it now to the old handler */ if (s->pending) handle_signal (s); /* Note that the signal has the potential of being lost if the user has * blocked its delivery. For this reason, the unblock_signal intrinsic * will have to deliver the signal via an explicit kill if it is pending. */ if (h == SIG_IGN_CONSTANT) old_handler = SLsignal_intr (s->sig, SIG_IGN); else if (h == SIG_DFL_CONSTANT) old_handler = SLsignal_intr (s->sig, SIG_DFL); else if (h == SIG_APP_CONSTANT) old_handler = SLsignal_intr (s->sig, s->c_handler); else { SLang_free_ref (old_ref); _pSLang_verror (SL_INVALID_PARM, "Signal handler '%d' is invalid", h); return; } if (-1 == set_old_handler (s, old_ref, old_handler)) { SLang_free_ref (old_ref); return; } if (s->handler != NULL) { SLang_free_function (s->handler); s->handler = NULL; } SLang_free_ref (old_ref); return; } if (NULL == (f = SLang_pop_function ())) { SLang_free_ref (old_ref); return; } if (-1 == pop_signal (&s)) { SLang_free_ref (old_ref); SLang_free_function (f); return; } old_handler = SLsignal_intr (s->sig, signal_handler); if (-1 == set_old_handler (s, old_ref, old_handler)) { SLang_free_ref (old_ref); SLang_free_function (f); return; } if (s->handler != NULL) SLang_free_function (s->handler); s->handler = f; SLang_free_ref (old_ref); }