OpenCoverage

signals.c

Absolute File Name:

/home/opencoverage/opencoverage/guest-scripts/bash/src/lib/readline/signals.c

Source code

Switch to Preprocessed file

Line Source Count

1 /* signals.c -- signal handling support for readline. */ -

2 -

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 #if defined (HAVE_POSIX_SIGNALS) -

117 sigset_t _rl_orig_sigset; -

118 #endif /* !HAVE_POSIX_SIGNALS */ -

119 -

120 /* **************************************************************** */ -

121 /* */ -

122 /* Signal Handling */ -

123 /* */ -

124 /* **************************************************************** */ -

125 -

126 static sighandler_cxt old_int, old_term, old_hup, old_alrm, old_quit; -

127 #if defined (SIGTSTP) -

128 static sighandler_cxt old_tstp, old_ttou, old_ttin; -

129 #endif -

130 #if defined (SIGWINCH) -

131 static sighandler_cxt old_winch; -

132 #endif -

133 -

134 _rl_sigcleanup_func_t *_rl_sigcleanup; -

135 void *_rl_sigcleanarg; -

136 -

137 /* Readline signal handler functions. */ -

138 -

139 /* Called from RL_CHECK_SIGNALS() macro */ -

140 RETSIGTYPE -

141 _rl_signal_handler (int sig) -

142 { -

143 _rl_caught_signal = 0; /* XXX */ -

144 -

145 #if defined (SIGWINCH) -

146

if (sig == SIGWINCH)

sig == 28	Description
TRUE	never evaluated
FALSE	never evaluated

147 { -

148 rl_resize_terminal (); -

149 /* XXX - experimental for now */ -

150 /* Call a signal hook because though we called the original signal handler -

151 in rl_sigwinch_handler below, we will not resend the signal to -

152 ourselves. */ -

153

if (rl_signal_event_hook)

rl_signal_event_hook	Description
TRUE	never evaluated
FALSE	never evaluated

154

(*rl_signal_event_hook) ();

never executed: (*rl_signal_event_hook) ();

155

}

never executed: end of block

156 else -

157 #endif -

158

_rl_handle_signal (sig);

never executed: _rl_handle_signal (sig);

159 -

160

SIGHANDLER_RETURN;

never executed: return;

161 } -

162 -

163 static RETSIGTYPE -

164 rl_signal_handler (int sig) -

165 { -

166

if (_rl_interrupt_immediately)

_rl_interrupt_immediately	Description
TRUE	never evaluated
FALSE	never evaluated

167 { -

168 _rl_interrupt_immediately = 0; -

169 _rl_handle_signal (sig); -

170

}

never executed: end of block

171 else -

172

_rl_caught_signal = sig;

never executed: _rl_caught_signal = sig;

173 -

174

SIGHANDLER_RETURN;

never executed: return;

175 } -

176 -

177 static RETSIGTYPE -

178 _rl_handle_signal (int sig) -

179 { -

180 #if defined (HAVE_POSIX_SIGNALS) -

181 sigset_t set; -

182 #else /* !HAVE_POSIX_SIGNALS */ -

183 # if defined (HAVE_BSD_SIGNALS) -

184 long omask; -

185 # else /* !HAVE_BSD_SIGNALS */ -

186 sighandler_cxt dummy_cxt; /* needed for rl_set_sighandler call */ -

187 # endif /* !HAVE_BSD_SIGNALS */ -

188 #endif /* !HAVE_POSIX_SIGNALS */ -

189 -

190 RL_SETSTATE(RL_STATE_SIGHANDLER); -

191 -

192 #if !defined (HAVE_BSD_SIGNALS) && !defined (HAVE_POSIX_SIGNALS) -

193 /* Since the signal will not be blocked while we are in the signal -

194 handler, ignore it until rl_clear_signals resets the catcher. */ -

195 # if defined (SIGALRM) -

196 if (sig == SIGINT || sig == SIGALRM) -

197 # else -

198 if (sig == SIGINT) -

199 # endif -

200 rl_set_sighandler (sig, SIG_IGN, &dummy_cxt); -

201 #endif /* !HAVE_BSD_SIGNALS && !HAVE_POSIX_SIGNALS */ -

202 -

203 /* If there's a sig cleanup function registered, call it and `deregister' -

204 the cleanup function to avoid multiple calls */ -

205

if (_rl_sigcleanup)

_rl_sigcleanup	Description
TRUE	never evaluated
FALSE	never evaluated

206 { -

207 (*_rl_sigcleanup) (sig, _rl_sigcleanarg); -

208 _rl_sigcleanup = 0; -

209 _rl_sigcleanarg = 0; -

210

}

never executed: end of block

211 -

212 switch (sig) -

213 { -

214

case SIGINT:

never executed: case 2 :

215 _rl_reset_completion_state (); -

216 rl_free_line_state (); -

217 #if defined (READLINE_CALLBACKS) -

218 rl_callback_sigcleanup (); -

219 #endif -

220 -

221 /* FALLTHROUGH */ -

222 -

223 #if defined (SIGTSTP) -

224

case SIGTSTP:

code before this statement never executed: case 20 :

never executed: case 20 :

225

case SIGTTIN:

never executed: case 21 :

226 # if defined (HAVE_POSIX_SIGNALS) -

227 /* Block SIGTTOU so we can restore the terminal settings to something -

228 sane without stopping on SIGTTOU if we have been placed into the -

229 background. Even trying to get the current terminal pgrp with -

230 tcgetpgrp() will generate SIGTTOU, so we don't bother. Don't bother -

231 doing this if we've been stopped on SIGTTOU; it's aready too late. */ -

232 sigemptyset (&set); -

233 sigaddset (&set, SIGTTOU); -

234 sigprocmask (SIG_BLOCK, &set, (sigset_t *)NULL); -

235 # endif -

236

case SIGTTOU:

code before this statement never executed: case 22 :

never executed: case 22 :

237 #endif /* SIGTSTP */ -

238

case SIGTERM:

never executed: case 15 :

239 #if defined (SIGHUP) -

240

case SIGHUP:

never executed: case 1 :

241 #endif -

242 #if defined (SIGALRM) -

243

case SIGALRM:

never executed: case 14 :

244 #endif -

245 #if defined (SIGQUIT) -

246

case SIGQUIT:

never executed: case 3 :

247 #endif -

248 rl_echo_signal_char (sig); -

249 rl_cleanup_after_signal (); -

250 -

251 #if defined (HAVE_POSIX_SIGNALS) -

252 # if defined (SIGTSTP) -

253 /* Unblock SIGTTOU blocked above */ -

254

if (sig == SIGTTIN || sig == SIGTSTP)

sig == 21	Description
TRUE	never evaluated
FALSE	never evaluated

sig == 20	Description
TRUE	never evaluated
FALSE	never evaluated

255

sigprocmask (SIG_UNBLOCK, &set, (sigset_t *)NULL);

never executed: sigprocmask ( 1 , &set, (sigset_t *) ((void *)0) );

256 # endif -

257 -

258 sigemptyset (&set); -

259 sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &set); -

260 sigdelset (&set, sig); -

261 #else /* !HAVE_POSIX_SIGNALS */ -

262 # if defined (HAVE_BSD_SIGNALS) -

263 omask = sigblock (0); -

264 # endif /* HAVE_BSD_SIGNALS */ -

265 #endif /* !HAVE_POSIX_SIGNALS */ -

266 -

267 #if defined (__EMX__) -

268 signal (sig, SIG_ACK); -

269 #endif -

270 -

271 #if defined (HAVE_KILL) -

272 kill (getpid (), sig); -

273 #else -

274 raise (sig); /* assume we have raise */ -

275 #endif -

276 -

277 /* Let the signal that we just sent through. */ -

278 #if defined (HAVE_POSIX_SIGNALS) -

279 sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL); -

280 #else /* !HAVE_POSIX_SIGNALS */ -

281 # if defined (HAVE_BSD_SIGNALS) -

282 sigsetmask (omask & ~(sigmask (sig))); -

283 # endif /* HAVE_BSD_SIGNALS */ -

284 #endif /* !HAVE_POSIX_SIGNALS */ -

285 -

286 rl_reset_after_signal (); -

287

}

never executed: end of block

288 -

289 RL_UNSETSTATE(RL_STATE_SIGHANDLER); -

290

SIGHANDLER_RETURN;

never executed: return;

291 } -

292 -

293 #if defined (SIGWINCH) -

294 static RETSIGTYPE -

295 rl_sigwinch_handler (int sig) -

296 { -

297 SigHandler *oh; -

298 -

299 #if defined (MUST_REINSTALL_SIGHANDLERS) -

300 sighandler_cxt dummy_winch; -

301 -

302 /* We don't want to change old_winch -- it holds the state of SIGWINCH -

303 disposition set by the calling application. We need this state -

304 because we call the application's SIGWINCH handler after updating -

305 our own idea of the screen size. */ -

306 rl_set_sighandler (SIGWINCH, rl_sigwinch_handler, &dummy_winch); -

307 #endif -

308 -

309 RL_SETSTATE(RL_STATE_SIGHANDLER); -

310 _rl_caught_signal = sig; -

311 -

312 /* If another sigwinch handler has been installed, call it. */ -

313 oh = (SigHandler *)old_winch.sa_handler; -

314

if (oh && oh != (SigHandler *)SIG_IGN && oh != (SigHandler *)SIG_DFL)

oh	Description
TRUE	never evaluated
FALSE	never evaluated

oh != (SigHand...ghandler_t) 1)	Description
TRUE	never evaluated
FALSE	never evaluated

oh != (SigHand...ghandler_t) 0)	Description
TRUE	never evaluated
FALSE	never evaluated

315

(*oh) (sig);

never executed: (*oh) (sig);

316 -

317 RL_UNSETSTATE(RL_STATE_SIGHANDLER); -

318

SIGHANDLER_RETURN;

never executed: return;

319 } -

320 #endif /* SIGWINCH */ -

321 -

322 /* Functions to manage signal handling. */ -

323 -

324 #if !defined (HAVE_POSIX_SIGNALS) -

325 static int -

326 rl_sigaction (int sig, sighandler_cxt *nh, sighandler_cxt *oh) -

327 { -

328 oh->sa_handler = signal (sig, nh->sa_handler); -

329 return 0; -

330 } -

331 #endif /* !HAVE_POSIX_SIGNALS */ -

332 -

333 /* Set up a readline-specific signal handler, saving the old signal -

334 information in OHANDLER. Return the old signal handler, like -

335 signal(). */ -

336 static SigHandler * -

337 rl_set_sighandler (int sig, SigHandler *handler, sighandler_cxt *ohandler) -

338 { -

339 sighandler_cxt old_handler; -

340 #if defined (HAVE_POSIX_SIGNALS) -

341 struct sigaction act; -

342 -

343 act.sa_handler = handler; -

344 # if defined (SIGWINCH) -

345

act.sa_flags = (sig == SIGWINCH) ? SA_RESTART : 0;

(sig == 28 )	Description
TRUE	never evaluated
FALSE	never evaluated

346 # else -

347 act.sa_flags = 0; -

348 # endif /* SIGWINCH */ -

349 sigemptyset (&act.sa_mask); -

350 sigemptyset (&ohandler->sa_mask); -

351 sigaction (sig, &act, &old_handler); -

352 #else -

353 old_handler.sa_handler = (SigHandler *)signal (sig, handler); -

354 #endif /* !HAVE_POSIX_SIGNALS */ -

355 -

356 /* XXX -- assume we have memcpy */ -

357 /* If rl_set_signals is called twice in a row, don't set the old handler to -

358 rl_signal_handler, because that would cause infinite recursion. */ -

359

if (handler != rl_signal_handler || old_handler.sa_handler != rl_signal_handler)

handler != rl_signal_handler	Description
TRUE	never evaluated
FALSE	never evaluated

old_handler. _...signal_handler	Description
TRUE	never evaluated
FALSE	never evaluated

360

memcpy (ohandler, &old_handler, sizeof (sighandler_cxt));

never executed: memcpy (ohandler, &old_handler, sizeof (sighandler_cxt));

361 -

362

return (ohandler->sa_handler);

never executed: return (ohandler-> __sigaction_handler.sa_handler );

363 } -

364 -

365 /* Set disposition of SIG to HANDLER, returning old state in OHANDLER. Don't -

366 change disposition if OHANDLER indicates the signal was ignored. */ -

367 static void -

368 rl_maybe_set_sighandler (int sig, SigHandler *handler, sighandler_cxt *ohandler) -

369 { -

370 sighandler_cxt dummy; -

371 SigHandler *oh; -

372 -

373 sigemptyset (&dummy.sa_mask); -

374 dummy.sa_flags = 0; -

375 oh = rl_set_sighandler (sig, handler, ohandler); -

376

if (oh == (SigHandler *)SIG_IGN)

oh == (SigHand...ghandler_t) 1)	Description
TRUE	never evaluated
FALSE	never evaluated

377

rl_sigaction (sig, ohandler, &dummy);

never executed: sigaction(sig, ohandler, &dummy);

378

}

never executed: end of block

379 -

380 /* Set the disposition of SIG to HANDLER, if HANDLER->sa_handler indicates the -

381 signal was not being ignored. MUST only be called for signals whose -

382 disposition was changed using rl_maybe_set_sighandler or for which the -

383 SIG_IGN check was performed inline (e.g., SIGALRM below). */ -

384 static void -

385 rl_maybe_restore_sighandler (int sig, sighandler_cxt *handler) -

386 { -

387 sighandler_cxt dummy; -

388 -

389 sigemptyset (&dummy.sa_mask); -

390 dummy.sa_flags = 0; -

391

if (handler->sa_handler != SIG_IGN)

handler-> __si...ghandler_t) 1)	Description
TRUE	never evaluated
FALSE	never evaluated

392

rl_sigaction (sig, handler, &dummy);

never executed: sigaction(sig, handler, &dummy);

393

}

never executed: end of block

394 -

395 int -

396 rl_set_signals (void) -

397 { -

398 sighandler_cxt dummy; -

399 SigHandler *oh; -

400 #if defined (HAVE_POSIX_SIGNALS) -

401 static int sigmask_set = 0; -

402 static sigset_t bset, oset; -

403 #endif -

404 -

405 #if defined (HAVE_POSIX_SIGNALS) -

406

if (rl_catch_signals && sigmask_set == 0)

rl_catch_signals	Description
TRUE	never evaluated
FALSE	never evaluated

sigmask_set == 0	Description
TRUE	never evaluated
FALSE	never evaluated

407 { -

408 sigemptyset (&bset); -

409 -

410 sigaddset (&bset, SIGINT); -

411 sigaddset (&bset, SIGTERM); -

412 #if defined (SIGHUP) -

413 sigaddset (&bset, SIGHUP); -

414 #endif -

415 #if defined (SIGQUIT) -

416 sigaddset (&bset, SIGQUIT); -

417 #endif -

418 #if defined (SIGALRM) -

419 sigaddset (&bset, SIGALRM); -

420 #endif -

421 #if defined (SIGTSTP) -

422 sigaddset (&bset, SIGTSTP); -

423 #endif -

424 #if defined (SIGTTIN) -

425 sigaddset (&bset, SIGTTIN); -

426 #endif -

427 #if defined (SIGTTOU) -

428 sigaddset (&bset, SIGTTOU); -

429 #endif -

430 sigmask_set = 1; -

431

}

never executed: end of block

432 #endif /* HAVE_POSIX_SIGNALS */ -

433 -

434

if (rl_catch_signals && signals_set_flag == 0)

rl_catch_signals	Description
TRUE	never evaluated
FALSE	never evaluated

signals_set_flag == 0	Description
TRUE	never evaluated
FALSE	never evaluated

435 { -

436 #if defined (HAVE_POSIX_SIGNALS) -

437 sigemptyset (&_rl_orig_sigset); -

438 sigprocmask (SIG_BLOCK, &bset, &_rl_orig_sigset); -

439 #endif -

440 -

441 rl_maybe_set_sighandler (SIGINT, rl_signal_handler, &old_int); -

442 rl_maybe_set_sighandler (SIGTERM, rl_signal_handler, &old_term); -

443 #if defined (SIGHUP) -

444 rl_maybe_set_sighandler (SIGHUP, rl_signal_handler, &old_hup); -

445 #endif -

446 #if defined (SIGQUIT) -

447 rl_maybe_set_sighandler (SIGQUIT, rl_signal_handler, &old_quit); -

448 #endif -

449 -

450 #if defined (SIGALRM) -

451 oh = rl_set_sighandler (SIGALRM, rl_signal_handler, &old_alrm); -

452

if (oh == (SigHandler *)SIG_IGN)

oh == (SigHand...ghandler_t) 1)	Description
TRUE	never evaluated
FALSE	never evaluated

453

rl_sigaction (SIGALRM, &old_alrm, &dummy);

never executed: sigaction( 14 , &old_alrm, &dummy);

454 #if defined (HAVE_POSIX_SIGNALS) && defined (SA_RESTART) -

455 /* If the application using readline has already installed a signal -

456 handler with SA_RESTART, SIGALRM will cause reads to be restarted -

457 automatically, so readline should just get out of the way. Since -

458 we tested for SIG_IGN above, we can just test for SIG_DFL here. */ -

459

if (oh != (SigHandler *)SIG_DFL && (old_alrm.sa_flags & SA_RESTART))

oh != (SigHand...ghandler_t) 0)	Description
TRUE	never evaluated
FALSE	never evaluated

(old_alrm.sa_f...& 0x10000000 )	Description
TRUE	never evaluated
FALSE	never evaluated

460

rl_sigaction (SIGALRM, &old_alrm, &dummy);

never executed: sigaction( 14 , &old_alrm, &dummy);

461 #endif /* HAVE_POSIX_SIGNALS */ -

462 #endif /* SIGALRM */ -

463 -

464 #if defined (SIGTSTP) -

465 rl_maybe_set_sighandler (SIGTSTP, rl_signal_handler, &old_tstp); -

466 #endif /* SIGTSTP */ -

467 -

468 #if defined (SIGTTOU) -

469 rl_maybe_set_sighandler (SIGTTOU, rl_signal_handler, &old_ttou); -

470 #endif /* SIGTTOU */ -

471 -

472 #if defined (SIGTTIN) -

473 rl_maybe_set_sighandler (SIGTTIN, rl_signal_handler, &old_ttin); -

474 #endif /* SIGTTIN */ -

475 -

476 signals_set_flag = 1; -

477 -

478 #if defined (HAVE_POSIX_SIGNALS) -

479 sigprocmask (SIG_SETMASK, &_rl_orig_sigset, (sigset_t *)NULL); -

480 #endif -

481

}

never executed: end of block

482

else if (rl_catch_signals == 0)

rl_catch_signals == 0	Description
TRUE	never evaluated
FALSE	never evaluated

483 { -

484 #if defined (HAVE_POSIX_SIGNALS) -

485 sigemptyset (&_rl_orig_sigset); -

486 sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &_rl_orig_sigset); -

487 #endif -

488

}

never executed: end of block

489 -

490 #if defined (SIGWINCH) -

491

if (rl_catch_sigwinch && sigwinch_set_flag == 0)

rl_catch_sigwinch	Description
TRUE	never evaluated
FALSE	never evaluated

sigwinch_set_flag == 0	Description
TRUE	never evaluated
FALSE	never evaluated

492 { -

493 rl_maybe_set_sighandler (SIGWINCH, rl_sigwinch_handler, &old_winch); -

494 sigwinch_set_flag = 1; -

495

}

never executed: end of block

496 #endif /* SIGWINCH */ -

497 -

498

return 0;

never executed: return 0;

499 } -

500 -

501 int -

502 rl_clear_signals (void) -

503 { -

504 sighandler_cxt dummy; -

505 -

506

if (rl_catch_signals && signals_set_flag == 1)

rl_catch_signals	Description
TRUE	never evaluated
FALSE	never evaluated

signals_set_flag == 1	Description
TRUE	never evaluated
FALSE	never evaluated

507 { -

508 /* Since rl_maybe_set_sighandler doesn't override a SIG_IGN handler, -

509 we should in theory not have to restore a handler where -

510 old_xxx.sa_handler == SIG_IGN. That's what rl_maybe_restore_sighandler -

511 does. Fewer system calls should reduce readline's per-line -

512 overhead */ -

513 rl_maybe_restore_sighandler (SIGINT, &old_int); -

514 rl_maybe_restore_sighandler (SIGTERM, &old_term); -

515 #if defined (SIGHUP) -

516 rl_maybe_restore_sighandler (SIGHUP, &old_hup); -

517 #endif -

518 #if defined (SIGQUIT) -

519 rl_maybe_restore_sighandler (SIGQUIT, &old_quit); -

520 #endif -

521 #if defined (SIGALRM) -

522 rl_maybe_restore_sighandler (SIGALRM, &old_alrm); -

523 #endif -

524 -

525 #if defined (SIGTSTP) -

526 rl_maybe_restore_sighandler (SIGTSTP, &old_tstp); -

527 #endif /* SIGTSTP */ -

528 -

529 #if defined (SIGTTOU) -

530 rl_maybe_restore_sighandler (SIGTTOU, &old_ttou); -

531 #endif /* SIGTTOU */ -

532 -

533 #if defined (SIGTTIN) -

534 rl_maybe_restore_sighandler (SIGTTIN, &old_ttin); -

535 #endif /* SIGTTIN */ -

536 -

537 signals_set_flag = 0; -

538

}

never executed: end of block

539 -

540 #if defined (SIGWINCH) -

541

if (rl_catch_sigwinch && sigwinch_set_flag == 1)

rl_catch_sigwinch	Description
TRUE	never evaluated
FALSE	never evaluated

sigwinch_set_flag == 1	Description
TRUE	never evaluated
FALSE	never evaluated

542 { -

543 sigemptyset (&dummy.sa_mask); -

544 rl_sigaction (SIGWINCH, &old_winch, &dummy); -

545 sigwinch_set_flag = 0; -

546

}

never executed: end of block

547 #endif -

548 -

549

return 0;

never executed: return 0;

550 } -

551 -

552 /* Clean up the terminal and readline state after catching a signal, before -

553 resending it to the calling application. */ -

554 void -

555 rl_cleanup_after_signal (void) -

556 { -

557 _rl_clean_up_for_exit (); -

558

if (rl_deprep_term_function)

rl_deprep_term_function	Description
TRUE	never evaluated
FALSE	never evaluated

559

(*rl_deprep_term_function) ();

never executed: (*rl_deprep_term_function) ();

560 rl_clear_pending_input (); -

561 rl_clear_signals (); -

562

}

never executed: end of block

563 -

564 /* Reset the terminal and readline state after a signal handler returns. */ -

565 void -

566 rl_reset_after_signal (void) -

567 { -

568

if (rl_prep_term_function)

rl_prep_term_function	Description
TRUE	never evaluated
FALSE	never evaluated

569

(*rl_prep_term_function) (_rl_meta_flag);

never executed: (*rl_prep_term_function) (_rl_meta_flag);

570 rl_set_signals (); -

571

}

never executed: end of block

572 -

573 /* Free up the readline variable line state for the current line (undo list, -

574 any partial history entry, any keyboard macros in progress, and any -

575 numeric arguments in process) after catching a signal, before calling -

576 rl_cleanup_after_signal(). */ -

577 void -

578 rl_free_line_state (void) -

579 { -

580 register HIST_ENTRY *entry; -

581 -

582 rl_free_undo_list (); -

583 -

584 entry = current_history (); -

585

if (entry)

entry	Description
TRUE	never evaluated
FALSE	never evaluated

586

entry->data = (char *)NULL;

never executed: entry->data = (char *) ((void *)0) ;

587 -

588 _rl_kill_kbd_macro (); -

589 rl_clear_message (); -

590 _rl_reset_argument (); -

591

}

never executed: end of block

592 -

593 int -

594 rl_pending_signal (void) -

595 { -

596

return (_rl_caught_signal);

never executed: return (_rl_caught_signal);

597 } -

598 -

599 void -

600 rl_check_signals (void) -

601 { -

602

RL_CHECK_SIGNALS ();

never executed: _rl_signal_handler (_rl_caught_signal);

_rl_caught_signal	Description
TRUE	never evaluated
FALSE	never evaluated

603

}

never executed: end of block

604 #endif /* HANDLE_SIGNALS */ -

605 -

606 /* **************************************************************** */ -

607 /* */ -

608 /* SIGINT Management */ -

609 /* */ -

610 /* **************************************************************** */ -

611 -

612 #if defined (HAVE_POSIX_SIGNALS) -

613 static sigset_t sigint_set, sigint_oset; -

614 static sigset_t sigwinch_set, sigwinch_oset; -

615 #else /* !HAVE_POSIX_SIGNALS */ -

616 # if defined (HAVE_BSD_SIGNALS) -

617 static int sigint_oldmask; -

618 static int sigwinch_oldmask; -

619 # endif /* HAVE_BSD_SIGNALS */ -

620 #endif /* !HAVE_POSIX_SIGNALS */ -

621 -

622 static int sigint_blocked; -

623 static int sigwinch_blocked; -

624 -

625 /* Cause SIGINT to not be delivered until the corresponding call to -

626 release_sigint(). */ -

627 void -

628 _rl_block_sigint (void) -

629 { -

630

if (sigint_blocked)

sigint_blocked	Description
TRUE	never evaluated
FALSE	never evaluated

631

return;

never executed: return;

632 -

633 sigint_blocked = 1; -

634

}

never executed: end of block

635 -

636 /* Allow SIGINT to be delivered. */ -

637 void -

638 _rl_release_sigint (void) -

639 { -

640

if (sigint_blocked == 0)

sigint_blocked == 0	Description
TRUE	never evaluated
FALSE	never evaluated

641

return;

never executed: return;

642 -

643 sigint_blocked = 0; -

644

RL_CHECK_SIGNALS ();

never executed: _rl_signal_handler (_rl_caught_signal);

_rl_caught_signal	Description
TRUE	never evaluated
FALSE	never evaluated

645

}

never executed: end of block

646 -

647 /* Cause SIGWINCH to not be delivered until the corresponding call to -

648 release_sigwinch(). */ -

649 void -

650 _rl_block_sigwinch (void) -

651 { -

652

if (sigwinch_blocked)

sigwinch_blocked	Description
TRUE	never evaluated
FALSE	never evaluated

653

return;

never executed: return;

654 -

655 #if defined (SIGWINCH) -

656 -

657 #if defined (HAVE_POSIX_SIGNALS) -

658 sigemptyset (&sigwinch_set); -

659 sigemptyset (&sigwinch_oset); -

660 sigaddset (&sigwinch_set, SIGWINCH); -

661 sigprocmask (SIG_BLOCK, &sigwinch_set, &sigwinch_oset); -

662 #else /* !HAVE_POSIX_SIGNALS */ -

663 # if defined (HAVE_BSD_SIGNALS) -

664 sigwinch_oldmask = sigblock (sigmask (SIGWINCH)); -

665 # else /* !HAVE_BSD_SIGNALS */ -

666 # if defined (HAVE_USG_SIGHOLD) -

667 sighold (SIGWINCH); -

668 # endif /* HAVE_USG_SIGHOLD */ -

669 # endif /* !HAVE_BSD_SIGNALS */ -

670 #endif /* !HAVE_POSIX_SIGNALS */ -

671 -

672 #endif /* SIGWINCH */ -

673 -

674 sigwinch_blocked = 1; -

675

}

never executed: end of block

676 -

677 /* Allow SIGWINCH to be delivered. */ -

678 void -

679 _rl_release_sigwinch (void) -

680 { -

681

if (sigwinch_blocked == 0)

sigwinch_blocked == 0	Description
TRUE	never evaluated
FALSE	never evaluated

682

return;

never executed: return;

683 -

684 #if defined (SIGWINCH) -

685 -

686 #if defined (HAVE_POSIX_SIGNALS) -

687 sigprocmask (SIG_SETMASK, &sigwinch_oset, (sigset_t *)NULL); -

688 #else -

689 # if defined (HAVE_BSD_SIGNALS) -

690 sigsetmask (sigwinch_oldmask); -

691 # else /* !HAVE_BSD_SIGNALS */ -

692 # if defined (HAVE_USG_SIGHOLD) -

693 sigrelse (SIGWINCH); -

694 # endif /* HAVE_USG_SIGHOLD */ -

695 # endif /* !HAVE_BSD_SIGNALS */ -

696 #endif /* !HAVE_POSIX_SIGNALS */ -

697 -

698 #endif /* SIGWINCH */ -

699 -

700 sigwinch_blocked = 0; -

701

}

never executed: end of block

702 -

703 /* **************************************************************** */ -

704 /* */ -

705 /* Echoing special control characters */ -

706 /* */ -

707 /* **************************************************************** */ -

708 void -

709 rl_echo_signal_char (int sig) -

710 { -

711 char cstr[3]; -

712 int cslen, c; -

713 -

714

if (_rl_echoctl == 0 || _rl_echo_control_chars == 0)

_rl_echoctl == 0	Description
TRUE	never evaluated
FALSE	never evaluated

_rl_echo_control_chars == 0	Description
TRUE	never evaluated
FALSE	never evaluated

715

return;

never executed: return;

716 -

717 switch (sig) -

718 { -

719

case SIGINT: c = _rl_intr_char; break;

never executed: break;

never executed: case 2 :

720 #if defined (SIGQUIT) -

721

case SIGQUIT: c = _rl_quit_char; break;

never executed: break;

never executed: case 3 :

722 #endif -

723 #if defined (SIGTSTP) -

724

case SIGTSTP: c = _rl_susp_char; break;

never executed: break;

never executed: case 20 :

725 #endif -

726

default: return;

never executed: return;

never executed: default:

727 } -

728 -

729

if (CTRL_CHAR (c) || c == RUBOUT)

(c) < 0x020	Description
TRUE	never evaluated
FALSE	never evaluated

(((c) & 0x80) == 0)	Description
TRUE	never evaluated
FALSE	never evaluated

c == 0x7f	Description
TRUE	never evaluated
FALSE	never evaluated

730 { -

731 cstr[0] = '^'; -

732

cstr[1] = CTRL_CHAR (c) ? UNCTRL (c) : '?';

never executed: end of block

never executed: __res = toupper ( (unsigned char)((c)|0x40) );

never executed: __res = (*__ctype_toupper_loc ())[(int) ( (unsigned char)((c)|0x40) )];

sizeof ( (unsi...c)\|0x40) ) > 1	Description
TRUE	never evaluated
FALSE	never evaluated

__builtin_cons...r)((c)\|0x40) )	Description
TRUE	never evaluated
FALSE	never evaluated

(c) < 0x020	Description
TRUE	never evaluated
FALSE	never evaluated

(((c) & 0x80) == 0)	Description
TRUE	never evaluated
FALSE	never evaluated

((unsigned cha... (((c)\|0x40)))	Description
TRUE	never evaluated
FALSE	never evaluated

((*__ctype_b_l...int) _ISlower)	Description
TRUE	never evaluated
FALSE	never evaluated

__c < -128	Description
TRUE	never evaluated
FALSE	never evaluated

__c > 255	Description
TRUE	never evaluated
FALSE	never evaluated

733 cstr[cslen = 2] = '\0'; -

734

}

never executed: end of block

735 else -

736 { -

737 cstr[0] = c; -

738 cstr[cslen = 1] = '\0'; -

739

}

never executed: end of block

740 -

741 _rl_output_some_chars (cstr, cslen); -

742

}

never executed: end of block

Source code

Switch to Preprocessed file

Generated by Squish Coco 4.1.2