OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [readline/] [signals.c] - Blame information for rev 822

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* signals.c -- signal handling support for readline. */
2
 
3
/* Copyright (C) 1987-2005 Free Software Foundation, Inc.
4
 
5
   This file is part of the GNU Readline Library, a library for
6
   reading lines of text with interactive input and history editing.
7
 
8
   The GNU Readline Library is free software; you can redistribute it
9
   and/or modify it under the terms of the GNU General Public License
10
   as published by the Free Software Foundation; either version 2, or
11
   (at your option) any later version.
12
 
13
   The GNU Readline Library is distributed in the hope that it will be
14
   useful, but WITHOUT ANY WARRANTY; without even the implied warranty
15
   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   The GNU General Public License is often shipped with GNU software, and
19
   is generally kept in a file called COPYING or LICENSE.  If you do not
20
   have a copy of the license, write to the Free Software Foundation,
21
   59 Temple Place, Suite 330, Boston, MA 02111 USA. */
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
#if defined (HANDLE_SIGNALS)
44
/* Some standard library routines. */
45
#include "readline.h"
46
#include "history.h"
47
 
48
#include "rlprivate.h"
49
 
50
#if !defined (RETSIGTYPE)
51
#  if defined (VOID_SIGHANDLER)
52
#    define RETSIGTYPE void
53
#  else
54
#    define RETSIGTYPE int
55
#  endif /* !VOID_SIGHANDLER */
56
#endif /* !RETSIGTYPE */
57
 
58
#if defined (VOID_SIGHANDLER)
59
#  define SIGHANDLER_RETURN return
60
#else
61
#  define SIGHANDLER_RETURN return (0)
62
#endif
63
 
64
/* This typedef is equivalent to the one for Function; it allows us
65
   to say SigHandler *foo = signal (SIGKILL, SIG_IGN); */
66
typedef RETSIGTYPE SigHandler ();
67
 
68
#if defined (HAVE_POSIX_SIGNALS)
69
typedef struct sigaction sighandler_cxt;
70
#  define rl_sigaction(s, nh, oh)       sigaction(s, nh, oh)
71
#else
72
typedef struct { SigHandler *sa_handler; int sa_mask, sa_flags; } sighandler_cxt;
73
#  define sigemptyset(m)
74
#endif /* !HAVE_POSIX_SIGNALS */
75
 
76
#ifndef SA_RESTART
77
#  define SA_RESTART 0
78
#endif
79
 
80
static SigHandler *rl_set_sighandler PARAMS((int, SigHandler *, sighandler_cxt *));
81
static void rl_maybe_set_sighandler PARAMS((int, SigHandler *, sighandler_cxt *));
82
 
83
/* Exported variables for use by applications. */
84
 
85
/* If non-zero, readline will install its own signal handlers for
86
   SIGINT, SIGTERM, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. */
87
int rl_catch_signals = 1;
88
 
89
/* If non-zero, readline will install a signal handler for SIGWINCH. */
90
#ifdef SIGWINCH
91
int rl_catch_sigwinch = 1;
92
#else
93
int rl_catch_sigwinch = 0;       /* for the readline state struct in readline.c */
94
#endif
95
 
96
static int signals_set_flag;
97
static int sigwinch_set_flag;
98
 
99
/* **************************************************************** */
100
/*                                                                  */
101
/*                         Signal Handling                          */
102
/*                                                                  */
103
/* **************************************************************** */
104
 
105
static sighandler_cxt old_int, old_term, old_alrm, old_quit;
106
#if defined (SIGTSTP)
107
static sighandler_cxt old_tstp, old_ttou, old_ttin;
108
#endif
109
#if defined (SIGWINCH)
110
static sighandler_cxt old_winch;
111
#endif
112
 
113
/* Readline signal handler functions. */
114
 
115
static RETSIGTYPE
116
rl_signal_handler (sig)
117
     int sig;
118
{
119
#if defined (HAVE_POSIX_SIGNALS)
120
  sigset_t set;
121
#else /* !HAVE_POSIX_SIGNALS */
122
#  if defined (HAVE_BSD_SIGNALS)
123
  long omask;
124
#  else /* !HAVE_BSD_SIGNALS */
125
  sighandler_cxt dummy_cxt;     /* needed for rl_set_sighandler call */
126
#  endif /* !HAVE_BSD_SIGNALS */
127
#endif /* !HAVE_POSIX_SIGNALS */
128
 
129
  RL_SETSTATE(RL_STATE_SIGHANDLER);
130
 
131
#if !defined (HAVE_BSD_SIGNALS) && !defined (HAVE_POSIX_SIGNALS)
132
  /* Since the signal will not be blocked while we are in the signal
133
     handler, ignore it until rl_clear_signals resets the catcher. */
134
#  if defined (SIGALRM)
135
  if (sig == SIGINT || sig == SIGALRM)
136
#  else
137
  if (sig == SIGINT)
138
#  endif
139
    rl_set_sighandler (sig, SIG_IGN, &dummy_cxt);
140
#endif /* !HAVE_BSD_SIGNALS && !HAVE_POSIX_SIGNALS */
141
 
142
  switch (sig)
143
    {
144
    case SIGINT:
145
      rl_free_line_state ();
146
      /* FALLTHROUGH */
147
 
148
    case SIGTERM:
149
#if defined (SIGTSTP)
150
    case SIGTSTP:
151
    case SIGTTOU:
152
    case SIGTTIN:
153
#endif /* SIGTSTP */
154
#if defined (SIGALRM)
155
    case SIGALRM:
156
#endif
157
#if defined (SIGQUIT)
158
    case SIGQUIT:
159
#endif
160
      rl_cleanup_after_signal ();
161
 
162
#if defined (HAVE_POSIX_SIGNALS)
163
      sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &set);
164
      sigdelset (&set, sig);
165
#else /* !HAVE_POSIX_SIGNALS */
166
#  if defined (HAVE_BSD_SIGNALS)
167
      omask = sigblock (0);
168
#  endif /* HAVE_BSD_SIGNALS */
169
#endif /* !HAVE_POSIX_SIGNALS */
170
 
171
#if defined (__EMX__)
172
      signal (sig, SIG_ACK);
173
#endif
174
 
175
#if defined (HAVE_KILL)
176
      kill (getpid (), sig);
177
#else
178
      raise (sig);              /* assume we have raise */
179
#endif
180
 
181
      /* Let the signal that we just sent through.  */
182
#if defined (HAVE_POSIX_SIGNALS)
183
      sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL);
184
#else /* !HAVE_POSIX_SIGNALS */
185
#  if defined (HAVE_BSD_SIGNALS)
186
      sigsetmask (omask & ~(sigmask (sig)));
187
#  endif /* HAVE_BSD_SIGNALS */
188
#endif /* !HAVE_POSIX_SIGNALS */
189
 
190
      rl_reset_after_signal ();
191
    }
192
 
193
  RL_UNSETSTATE(RL_STATE_SIGHANDLER);
194
  SIGHANDLER_RETURN;
195
}
196
 
197
#if defined (SIGWINCH)
198
static RETSIGTYPE
199
rl_sigwinch_handler (sig)
200
     int sig;
201
{
202
  SigHandler *oh;
203
 
204
#if defined (MUST_REINSTALL_SIGHANDLERS)
205
  sighandler_cxt dummy_winch;
206
 
207
  /* We don't want to change old_winch -- it holds the state of SIGWINCH
208
     disposition set by the calling application.  We need this state
209
     because we call the application's SIGWINCH handler after updating
210
     our own idea of the screen size. */
211
  rl_set_sighandler (SIGWINCH, rl_sigwinch_handler, &dummy_winch);
212
#endif
213
 
214
  RL_SETSTATE(RL_STATE_SIGHANDLER);
215
  rl_resize_terminal ();
216
 
217
  /* If another sigwinch handler has been installed, call it. */
218
  oh = (SigHandler *)old_winch.sa_handler;
219
  if (oh &&  oh != (SigHandler *)SIG_IGN && oh != (SigHandler *)SIG_DFL)
220
    (*oh) (sig);
221
 
222
  RL_UNSETSTATE(RL_STATE_SIGHANDLER);
223
  SIGHANDLER_RETURN;
224
}
225
#endif  /* SIGWINCH */
226
 
227
/* Functions to manage signal handling. */
228
 
229
#if !defined (HAVE_POSIX_SIGNALS)
230
static int
231
rl_sigaction (sig, nh, oh)
232
     int sig;
233
     sighandler_cxt *nh, *oh;
234
{
235
  oh->sa_handler = signal (sig, nh->sa_handler);
236
  return 0;
237
}
238
#endif /* !HAVE_POSIX_SIGNALS */
239
 
240
/* Set up a readline-specific signal handler, saving the old signal
241
   information in OHANDLER.  Return the old signal handler, like
242
   signal(). */
243
static SigHandler *
244
rl_set_sighandler (sig, handler, ohandler)
245
     int sig;
246
     SigHandler *handler;
247
     sighandler_cxt *ohandler;
248
{
249
  sighandler_cxt old_handler;
250
#if defined (HAVE_POSIX_SIGNALS)
251
  struct sigaction act;
252
 
253
  act.sa_handler = handler;
254
#if defined (SIGWINCH)
255
  act.sa_flags = (sig == SIGWINCH) ? SA_RESTART : 0;
256
#else
257
  act.sa_flags = 0;
258
#endif
259
  sigemptyset (&act.sa_mask);
260
  sigemptyset (&ohandler->sa_mask);
261
  sigaction (sig, &act, &old_handler);
262
#else
263
  old_handler.sa_handler = (SigHandler *)signal (sig, handler);
264
#endif /* !HAVE_POSIX_SIGNALS */
265
 
266
  /* XXX -- assume we have memcpy */
267
  /* If rl_set_signals is called twice in a row, don't set the old handler to
268
     rl_signal_handler, because that would cause infinite recursion. */
269
  if (handler != rl_signal_handler || old_handler.sa_handler != rl_signal_handler)
270
    memcpy (ohandler, &old_handler, sizeof (sighandler_cxt));
271
 
272
  return (ohandler->sa_handler);
273
}
274
 
275
static void
276
rl_maybe_set_sighandler (sig, handler, ohandler)
277
     int sig;
278
     SigHandler *handler;
279
     sighandler_cxt *ohandler;
280
{
281
  sighandler_cxt dummy;
282
  SigHandler *oh;
283
 
284
  sigemptyset (&dummy.sa_mask);
285
  oh = rl_set_sighandler (sig, handler, ohandler);
286
  if (oh == (SigHandler *)SIG_IGN)
287
    rl_sigaction (sig, ohandler, &dummy);
288
}
289
 
290
int
291
rl_set_signals ()
292
{
293
  sighandler_cxt dummy;
294
  SigHandler *oh;
295
 
296
  if (rl_catch_signals && signals_set_flag == 0)
297
    {
298
      rl_maybe_set_sighandler (SIGINT, rl_signal_handler, &old_int);
299
      rl_maybe_set_sighandler (SIGTERM, rl_signal_handler, &old_term);
300
#if defined (SIGQUIT)
301
      rl_maybe_set_sighandler (SIGQUIT, rl_signal_handler, &old_quit);
302
#endif
303
 
304
#if defined (SIGALRM)
305
      oh = rl_set_sighandler (SIGALRM, rl_signal_handler, &old_alrm);
306
      if (oh == (SigHandler *)SIG_IGN)
307
        rl_sigaction (SIGALRM, &old_alrm, &dummy);
308
#if defined (HAVE_POSIX_SIGNALS) && defined (SA_RESTART)
309
      /* If the application using readline has already installed a signal
310
         handler with SA_RESTART, SIGALRM will cause reads to be restarted
311
         automatically, so readline should just get out of the way.  Since
312
         we tested for SIG_IGN above, we can just test for SIG_DFL here. */
313
      if (oh != (SigHandler *)SIG_DFL && (old_alrm.sa_flags & SA_RESTART))
314
        rl_sigaction (SIGALRM, &old_alrm, &dummy);
315
#endif /* HAVE_POSIX_SIGNALS */
316
#endif /* SIGALRM */
317
 
318
#if defined (SIGTSTP)
319
      rl_maybe_set_sighandler (SIGTSTP, rl_signal_handler, &old_tstp);
320
#endif /* SIGTSTP */
321
 
322
#if defined (SIGTTOU)
323
      rl_maybe_set_sighandler (SIGTTOU, rl_signal_handler, &old_ttou);
324
#endif /* SIGTTOU */
325
 
326
#if defined (SIGTTIN)
327
      rl_maybe_set_sighandler (SIGTTIN, rl_signal_handler, &old_ttin);
328
#endif /* SIGTTIN */
329
 
330
      signals_set_flag = 1;
331
    }
332
 
333
#if defined (SIGWINCH)
334
  if (rl_catch_sigwinch && sigwinch_set_flag == 0)
335
    {
336
      rl_maybe_set_sighandler (SIGWINCH, rl_sigwinch_handler, &old_winch);
337
      sigwinch_set_flag = 1;
338
    }
339
#endif /* SIGWINCH */
340
 
341
  return 0;
342
}
343
 
344
int
345
rl_clear_signals ()
346
{
347
  sighandler_cxt dummy;
348
 
349
  if (rl_catch_signals && signals_set_flag == 1)
350
    {
351
      sigemptyset (&dummy.sa_mask);
352
 
353
      rl_sigaction (SIGINT, &old_int, &dummy);
354
      rl_sigaction (SIGTERM, &old_term, &dummy);
355
#if defined (SIGQUIT)
356
      rl_sigaction (SIGQUIT, &old_quit, &dummy);
357
#endif
358
#if defined (SIGALRM)
359
      rl_sigaction (SIGALRM, &old_alrm, &dummy);
360
#endif
361
 
362
#if defined (SIGTSTP)
363
      rl_sigaction (SIGTSTP, &old_tstp, &dummy);
364
#endif /* SIGTSTP */
365
 
366
#if defined (SIGTTOU)
367
      rl_sigaction (SIGTTOU, &old_ttou, &dummy);
368
#endif /* SIGTTOU */
369
 
370
#if defined (SIGTTIN)
371
      rl_sigaction (SIGTTIN, &old_ttin, &dummy);
372
#endif /* SIGTTIN */
373
 
374
      signals_set_flag = 0;
375
    }
376
 
377
#if defined (SIGWINCH)
378
  if (rl_catch_sigwinch && sigwinch_set_flag == 1)
379
    {
380
      sigemptyset (&dummy.sa_mask);
381
      rl_sigaction (SIGWINCH, &old_winch, &dummy);
382
      sigwinch_set_flag = 0;
383
    }
384
#endif
385
 
386
  return 0;
387
}
388
 
389
/* Clean up the terminal and readline state after catching a signal, before
390
   resending it to the calling application. */
391
void
392
rl_cleanup_after_signal ()
393
{
394
  _rl_clean_up_for_exit ();
395
  if (rl_deprep_term_function)
396
    (*rl_deprep_term_function) ();
397
  rl_clear_signals ();
398
  rl_clear_pending_input ();
399
}
400
 
401
/* Reset the terminal and readline state after a signal handler returns. */
402
void
403
rl_reset_after_signal ()
404
{
405
  if (rl_prep_term_function)
406
    (*rl_prep_term_function) (_rl_meta_flag);
407
  rl_set_signals ();
408
}
409
 
410
/* Free up the readline variable line state for the current line (undo list,
411
   any partial history entry, any keyboard macros in progress, and any
412
   numeric arguments in process) after catching a signal, before calling
413
   rl_cleanup_after_signal(). */
414
void
415
rl_free_line_state ()
416
{
417
  register HIST_ENTRY *entry;
418
 
419
  rl_free_undo_list ();
420
 
421
  entry = current_history ();
422
  if (entry)
423
    entry->data = (char *)NULL;
424
 
425
  _rl_kill_kbd_macro ();
426
  rl_clear_message ();
427
  _rl_reset_argument ();
428
}
429
 
430
#endif  /* HANDLE_SIGNALS */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.