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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [libiberty/] [strsignal.c] - Blame information for rev 280

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

Line No. Rev Author Line
1 24 jeremybenn
/* Extended support for using signal values.
2
   Written by Fred Fish.  fnf@cygnus.com
3
   This file is in the public domain.  */
4
 
5
#include "config.h"
6
#include "ansidecl.h"
7
#include "libiberty.h"
8
 
9
/* We need to declare sys_siglist, because even if the system provides
10
   it we can't assume that it is declared in <signal.h> (for example,
11
   SunOS provides sys_siglist, but it does not declare it in any
12
   header file).  However, we can't declare sys_siglist portably,
13
   because on some systems it is declared with const and on some
14
   systems it is declared without const.  If we were using autoconf,
15
   we could work out the right declaration.  Until, then we just
16
   ignore any declaration in the system header files, and always
17
   declare it ourselves.  With luck, this will always work.  */
18
#define sys_siglist no_such_symbol
19
#define sys_nsig sys_nsig__no_such_symbol
20
 
21
#include <stdio.h>
22
#include <signal.h>
23
 
24
/*  Routines imported from standard C runtime libraries. */
25
 
26
#ifdef HAVE_STDLIB_H
27
#include <stdlib.h>
28
#else
29
extern PTR malloc ();
30
#endif
31
 
32
#ifdef HAVE_STRING_H
33
#include <string.h>
34
#else
35
extern PTR memset ();
36
#endif
37
 
38
/* Undefine the macro we used to hide the definition of sys_siglist
39
   found in the system header files.  */
40
#undef sys_siglist
41
#undef sys_nsig
42
 
43
#ifndef NULL
44
#  define NULL (void *) 0
45
#endif
46
 
47
#ifndef MAX
48
#  define MAX(a,b) ((a) > (b) ? (a) : (b))
49
#endif
50
 
51
static void init_signal_tables (void);
52
 
53
/* Translation table for signal values.
54
 
55
   Note that this table is generally only accessed when it is used at runtime
56
   to initialize signal name and message tables that are indexed by signal
57
   value.
58
 
59
   Not all of these signals will exist on all systems.  This table is the only
60
   thing that should have to be updated as new signal numbers are introduced.
61
   It's sort of ugly, but at least its portable. */
62
 
63
struct signal_info
64
{
65
  const int value;              /* The numeric value from <signal.h> */
66
  const char *const name;       /* The equivalent symbolic value */
67
#ifndef HAVE_SYS_SIGLIST
68
  const char *const msg;        /* Short message about this value */
69
#endif
70
};
71
 
72
#ifndef HAVE_SYS_SIGLIST
73
#   define ENTRY(value, name, msg)      {value, name, msg}
74
#else
75
#   define ENTRY(value, name, msg)      {value, name}
76
#endif
77
 
78
static const struct signal_info signal_table[] =
79
{
80
#if defined (SIGHUP)
81
  ENTRY(SIGHUP, "SIGHUP", "Hangup"),
82
#endif
83
#if defined (SIGINT)
84
  ENTRY(SIGINT, "SIGINT", "Interrupt"),
85
#endif
86
#if defined (SIGQUIT)
87
  ENTRY(SIGQUIT, "SIGQUIT", "Quit"),
88
#endif
89
#if defined (SIGILL)
90
  ENTRY(SIGILL, "SIGILL", "Illegal instruction"),
91
#endif
92
#if defined (SIGTRAP)
93
  ENTRY(SIGTRAP, "SIGTRAP", "Trace/breakpoint trap"),
94
#endif
95
/* Put SIGIOT before SIGABRT, so that if SIGIOT==SIGABRT then SIGABRT
96
   overrides SIGIOT.  SIGABRT is in ANSI and POSIX.1, and SIGIOT isn't. */
97
#if defined (SIGIOT)
98
  ENTRY(SIGIOT, "SIGIOT", "IOT trap"),
99
#endif
100
#if defined (SIGABRT)
101
  ENTRY(SIGABRT, "SIGABRT", "Aborted"),
102
#endif
103
#if defined (SIGEMT)
104
  ENTRY(SIGEMT, "SIGEMT", "Emulation trap"),
105
#endif
106
#if defined (SIGFPE)
107
  ENTRY(SIGFPE, "SIGFPE", "Arithmetic exception"),
108
#endif
109
#if defined (SIGKILL)
110
  ENTRY(SIGKILL, "SIGKILL", "Killed"),
111
#endif
112
#if defined (SIGBUS)
113
  ENTRY(SIGBUS, "SIGBUS", "Bus error"),
114
#endif
115
#if defined (SIGSEGV)
116
  ENTRY(SIGSEGV, "SIGSEGV", "Segmentation fault"),
117
#endif
118
#if defined (SIGSYS)
119
  ENTRY(SIGSYS, "SIGSYS", "Bad system call"),
120
#endif
121
#if defined (SIGPIPE)
122
  ENTRY(SIGPIPE, "SIGPIPE", "Broken pipe"),
123
#endif
124
#if defined (SIGALRM)
125
  ENTRY(SIGALRM, "SIGALRM", "Alarm clock"),
126
#endif
127
#if defined (SIGTERM)
128
  ENTRY(SIGTERM, "SIGTERM", "Terminated"),
129
#endif
130
#if defined (SIGUSR1)
131
  ENTRY(SIGUSR1, "SIGUSR1", "User defined signal 1"),
132
#endif
133
#if defined (SIGUSR2)
134
  ENTRY(SIGUSR2, "SIGUSR2", "User defined signal 2"),
135
#endif
136
/* Put SIGCLD before SIGCHLD, so that if SIGCLD==SIGCHLD then SIGCHLD
137
   overrides SIGCLD.  SIGCHLD is in POXIX.1 */
138
#if defined (SIGCLD)
139
  ENTRY(SIGCLD, "SIGCLD", "Child status changed"),
140
#endif
141
#if defined (SIGCHLD)
142
  ENTRY(SIGCHLD, "SIGCHLD", "Child status changed"),
143
#endif
144
#if defined (SIGPWR)
145
  ENTRY(SIGPWR, "SIGPWR", "Power fail/restart"),
146
#endif
147
#if defined (SIGWINCH)
148
  ENTRY(SIGWINCH, "SIGWINCH", "Window size changed"),
149
#endif
150
#if defined (SIGURG)
151
  ENTRY(SIGURG, "SIGURG", "Urgent I/O condition"),
152
#endif
153
#if defined (SIGIO)
154
  /* "I/O pending" has also been suggested, but is misleading since the
155
     signal only happens when the process has asked for it, not everytime
156
     I/O is pending. */
157
  ENTRY(SIGIO, "SIGIO", "I/O possible"),
158
#endif
159
#if defined (SIGPOLL)
160
  ENTRY(SIGPOLL, "SIGPOLL", "Pollable event occurred"),
161
#endif
162
#if defined (SIGSTOP)
163
  ENTRY(SIGSTOP, "SIGSTOP", "Stopped (signal)"),
164
#endif
165
#if defined (SIGTSTP)
166
  ENTRY(SIGTSTP, "SIGTSTP", "Stopped (user)"),
167
#endif
168
#if defined (SIGCONT)
169
  ENTRY(SIGCONT, "SIGCONT", "Continued"),
170
#endif
171
#if defined (SIGTTIN)
172
  ENTRY(SIGTTIN, "SIGTTIN", "Stopped (tty input)"),
173
#endif
174
#if defined (SIGTTOU)
175
  ENTRY(SIGTTOU, "SIGTTOU", "Stopped (tty output)"),
176
#endif
177
#if defined (SIGVTALRM)
178
  ENTRY(SIGVTALRM, "SIGVTALRM", "Virtual timer expired"),
179
#endif
180
#if defined (SIGPROF)
181
  ENTRY(SIGPROF, "SIGPROF", "Profiling timer expired"),
182
#endif
183
#if defined (SIGXCPU)
184
  ENTRY(SIGXCPU, "SIGXCPU", "CPU time limit exceeded"),
185
#endif
186
#if defined (SIGXFSZ)
187
  ENTRY(SIGXFSZ, "SIGXFSZ", "File size limit exceeded"),
188
#endif
189
#if defined (SIGWIND)
190
  ENTRY(SIGWIND, "SIGWIND", "SIGWIND"),
191
#endif
192
#if defined (SIGPHONE)
193
  ENTRY(SIGPHONE, "SIGPHONE", "SIGPHONE"),
194
#endif
195
#if defined (SIGLOST)
196
  ENTRY(SIGLOST, "SIGLOST", "Resource lost"),
197
#endif
198
#if defined (SIGWAITING)
199
  ENTRY(SIGWAITING, "SIGWAITING", "Process's LWPs are blocked"),
200
#endif
201
#if defined (SIGLWP)
202
  ENTRY(SIGLWP, "SIGLWP", "Signal LWP"),
203
#endif
204
#if defined (SIGDANGER)
205
  ENTRY(SIGDANGER, "SIGDANGER", "Swap space dangerously low"),
206
#endif
207
#if defined (SIGGRANT)
208
  ENTRY(SIGGRANT, "SIGGRANT", "Monitor mode granted"),
209
#endif
210
#if defined (SIGRETRACT)
211
  ENTRY(SIGRETRACT, "SIGRETRACT", "Need to relinguish monitor mode"),
212
#endif
213
#if defined (SIGMSG)
214
  ENTRY(SIGMSG, "SIGMSG", "Monitor mode data available"),
215
#endif
216
#if defined (SIGSOUND)
217
  ENTRY(SIGSOUND, "SIGSOUND", "Sound completed"),
218
#endif
219
#if defined (SIGSAK)
220
  ENTRY(SIGSAK, "SIGSAK", "Secure attention"),
221
#endif
222
  ENTRY(0, NULL, NULL)
223
};
224
 
225
/* Translation table allocated and initialized at runtime.  Indexed by the
226
   signal value to find the equivalent symbolic value. */
227
 
228
static const char **signal_names;
229
static int num_signal_names = 0;
230
 
231
/* Translation table allocated and initialized at runtime, if it does not
232
   already exist in the host environment.  Indexed by the signal value to find
233
   the descriptive string.
234
 
235
   We don't export it for use in other modules because even though it has the
236
   same name, it differs from other implementations in that it is dynamically
237
   initialized rather than statically initialized. */
238
 
239
#ifndef HAVE_SYS_SIGLIST
240
 
241
static int sys_nsig;
242
static const char **sys_siglist;
243
 
244
#else
245
 
246
#ifdef NSIG
247
static int sys_nsig = NSIG;
248
#else
249
#ifdef _NSIG
250
static int sys_nsig = _NSIG;
251
#endif
252
#endif
253
extern const char * const sys_siglist[];
254
 
255
#endif
256
 
257
 
258
/*
259
 
260
NAME
261
 
262
        init_signal_tables -- initialize the name and message tables
263
 
264
SYNOPSIS
265
 
266
        static void init_signal_tables ();
267
 
268
DESCRIPTION
269
 
270
        Using the signal_table, which is initialized at compile time, generate
271
        the signal_names and the sys_siglist (if needed) tables, which are
272
        indexed at runtime by a specific signal value.
273
 
274
BUGS
275
 
276
        The initialization of the tables may fail under low memory conditions,
277
        in which case we don't do anything particularly useful, but we don't
278
        bomb either.  Who knows, it might succeed at a later point if we free
279
        some memory in the meantime.  In any case, the other routines know
280
        how to deal with lack of a table after trying to initialize it.  This
281
        may or may not be considered to be a bug, that we don't specifically
282
        warn about this particular failure mode.
283
 
284
*/
285
 
286
static void
287
init_signal_tables (void)
288
{
289
  const struct signal_info *eip;
290
  int nbytes;
291
 
292
  /* If we haven't already scanned the signal_table once to find the maximum
293
     signal value, then go find it now. */
294
 
295
  if (num_signal_names == 0)
296
    {
297
      for (eip = signal_table; eip -> name != NULL; eip++)
298
        {
299
          if (eip -> value >= num_signal_names)
300
            {
301
              num_signal_names = eip -> value + 1;
302
            }
303
        }
304
    }
305
 
306
  /* Now attempt to allocate the signal_names table, zero it out, and then
307
     initialize it from the statically initialized signal_table. */
308
 
309
  if (signal_names == NULL)
310
    {
311
      nbytes = num_signal_names * sizeof (char *);
312
      if ((signal_names = (const char **) malloc (nbytes)) != NULL)
313
        {
314
          memset (signal_names, 0, nbytes);
315
          for (eip = signal_table; eip -> name != NULL; eip++)
316
            {
317
              signal_names[eip -> value] = eip -> name;
318
            }
319
        }
320
    }
321
 
322
#ifndef HAVE_SYS_SIGLIST
323
 
324
  /* Now attempt to allocate the sys_siglist table, zero it out, and then
325
     initialize it from the statically initialized signal_table. */
326
 
327
  if (sys_siglist == NULL)
328
    {
329
      nbytes = num_signal_names * sizeof (char *);
330
      if ((sys_siglist = (const char **) malloc (nbytes)) != NULL)
331
        {
332
          memset (sys_siglist, 0, nbytes);
333
          sys_nsig = num_signal_names;
334
          for (eip = signal_table; eip -> name != NULL; eip++)
335
            {
336
              sys_siglist[eip -> value] = eip -> msg;
337
            }
338
        }
339
    }
340
 
341
#endif
342
 
343
}
344
 
345
 
346
/*
347
 
348
@deftypefn Extension int signo_max (void)
349
 
350
Returns the maximum signal value for which a corresponding symbolic
351
name or message is available.  Note that in the case where we use the
352
@code{sys_siglist} supplied by the system, it is possible for there to
353
be more symbolic names than messages, or vice versa.  In fact, the
354
manual page for @code{psignal(3b)} explicitly warns that one should
355
check the size of the table (@code{NSIG}) before indexing it, since
356
new signal codes may be added to the system before they are added to
357
the table.  Thus @code{NSIG} might be smaller than value implied by
358
the largest signo value defined in @code{<signal.h>}.
359
 
360
We return the maximum value that can be used to obtain a meaningful
361
symbolic name or message.
362
 
363
@end deftypefn
364
 
365
*/
366
 
367
int
368
signo_max (void)
369
{
370
  int maxsize;
371
 
372
  if (signal_names == NULL)
373
    {
374
      init_signal_tables ();
375
    }
376
  maxsize = MAX (sys_nsig, num_signal_names);
377
  return (maxsize - 1);
378
}
379
 
380
 
381
/*
382
 
383
@deftypefn Supplemental {const char *} strsignal (int @var{signo})
384
 
385
Maps an signal number to an signal message string, the contents of
386
which are implementation defined.  On systems which have the external
387
variable @code{sys_siglist}, these strings will be the same as the
388
ones used by @code{psignal()}.
389
 
390
If the supplied signal number is within the valid range of indices for
391
the @code{sys_siglist}, but no message is available for the particular
392
signal number, then returns the string @samp{Signal @var{num}}, where
393
@var{num} is the signal number.
394
 
395
If the supplied signal number is not a valid index into
396
@code{sys_siglist}, returns @code{NULL}.
397
 
398
The returned string is only guaranteed to be valid only until the next
399
call to @code{strsignal}.
400
 
401
@end deftypefn
402
 
403
*/
404
 
405
#ifndef HAVE_STRSIGNAL
406
 
407 225 jeremybenn
char *
408 24 jeremybenn
strsignal (int signo)
409
{
410 225 jeremybenn
  char *msg;
411 24 jeremybenn
  static char buf[32];
412
 
413
#ifndef HAVE_SYS_SIGLIST
414
 
415
  if (signal_names == NULL)
416
    {
417
      init_signal_tables ();
418
    }
419
 
420
#endif
421
 
422
  if ((signo < 0) || (signo >= sys_nsig))
423
    {
424
      /* Out of range, just return NULL */
425
      msg = NULL;
426
    }
427
  else if ((sys_siglist == NULL) || (sys_siglist[signo] == NULL))
428
    {
429
      /* In range, but no sys_siglist or no entry at this index. */
430
      sprintf (buf, "Signal %d", signo);
431 225 jeremybenn
      msg = buf;
432 24 jeremybenn
    }
433
  else
434
    {
435 225 jeremybenn
      /* In range, and a valid message.  Just return the message.  We
436
         can safely cast away const, since POSIX says the user must
437
         not modify the result.  */
438
      msg = (char *) sys_siglist[signo];
439 24 jeremybenn
    }
440 225 jeremybenn
 
441 24 jeremybenn
  return (msg);
442
}
443
 
444
#endif /* ! HAVE_STRSIGNAL */
445
 
446
/*
447
 
448
@deftypefn Extension {const char*} strsigno (int @var{signo})
449
 
450
Given an signal number, returns a pointer to a string containing the
451
symbolic name of that signal number, as found in @code{<signal.h>}.
452
 
453
If the supplied signal number is within the valid range of indices for
454
symbolic names, but no name is available for the particular signal
455
number, then returns the string @samp{Signal @var{num}}, where
456
@var{num} is the signal number.
457
 
458
If the supplied signal number is not within the range of valid
459
indices, then returns @code{NULL}.
460
 
461
The contents of the location pointed to are only guaranteed to be
462
valid until the next call to @code{strsigno}.
463
 
464
@end deftypefn
465
 
466
*/
467
 
468
const char *
469
strsigno (int signo)
470
{
471
  const char *name;
472
  static char buf[32];
473
 
474
  if (signal_names == NULL)
475
    {
476
      init_signal_tables ();
477
    }
478
 
479
  if ((signo < 0) || (signo >= num_signal_names))
480
    {
481
      /* Out of range, just return NULL */
482
      name = NULL;
483
    }
484
  else if ((signal_names == NULL) || (signal_names[signo] == NULL))
485
    {
486
      /* In range, but no signal_names or no entry at this index. */
487
      sprintf (buf, "Signal %d", signo);
488
      name = (const char *) buf;
489
    }
490
  else
491
    {
492
      /* In range, and a valid name.  Just return the name. */
493
      name = signal_names[signo];
494
    }
495
 
496
  return (name);
497
}
498
 
499
 
500
/*
501
 
502
@deftypefn Extension int strtosigno (const char *@var{name})
503
 
504
Given the symbolic name of a signal, map it to a signal number.  If no
505
translation is found, returns 0.
506
 
507
@end deftypefn
508
 
509
*/
510
 
511
int
512
strtosigno (const char *name)
513
{
514
  int signo = 0;
515
 
516
  if (name != NULL)
517
    {
518
      if (signal_names == NULL)
519
        {
520
          init_signal_tables ();
521
        }
522
      for (signo = 0; signo < num_signal_names; signo++)
523
        {
524
          if ((signal_names[signo] != NULL) &&
525
              (strcmp (name, signal_names[signo]) == 0))
526
            {
527
              break;
528
            }
529
        }
530
      if (signo == num_signal_names)
531
        {
532
          signo = 0;
533
        }
534
    }
535
  return (signo);
536
}
537
 
538
 
539
/*
540
 
541
@deftypefn Supplemental void psignal (int @var{signo}, char *@var{message})
542
 
543
Print @var{message} to the standard error, followed by a colon,
544
followed by the description of the signal specified by @var{signo},
545
followed by a newline.
546
 
547
@end deftypefn
548
 
549
*/
550
 
551
#ifndef HAVE_PSIGNAL
552
 
553
void
554
psignal (int signo, char *message)
555
{
556
  if (signal_names == NULL)
557
    {
558
      init_signal_tables ();
559
    }
560
  if ((signo <= 0) || (signo >= sys_nsig))
561
    {
562
      fprintf (stderr, "%s: unknown signal\n", message);
563
    }
564
  else
565
    {
566
      fprintf (stderr, "%s: %s\n", message, sys_siglist[signo]);
567
    }
568
}
569
 
570
#endif  /* ! HAVE_PSIGNAL */
571
 
572
 
573
/* A simple little main that does nothing but print all the signal translations
574
   if MAIN is defined and this file is compiled and linked. */
575
 
576
#ifdef MAIN
577
 
578
#include <stdio.h>
579
 
580
int
581
main (void)
582
{
583
  int signo;
584
  int maxsigno;
585
  const char *name;
586
  const char *msg;
587
 
588
  maxsigno = signo_max ();
589
  printf ("%d entries in names table.\n", num_signal_names);
590
  printf ("%d entries in messages table.\n", sys_nsig);
591
  printf ("%d is max useful index.\n", maxsigno);
592
 
593
  /* Keep printing values until we get to the end of *both* tables, not
594
     *either* table.  Note that knowing the maximum useful index does *not*
595
     relieve us of the responsibility of testing the return pointer for
596
     NULL. */
597
 
598
  for (signo = 0; signo <= maxsigno; signo++)
599
    {
600
      name = strsigno (signo);
601
      name = (name == NULL) ? "<NULL>" : name;
602
      msg = strsignal (signo);
603
      msg = (msg == NULL) ? "<NULL>" : msg;
604
      printf ("%-4d%-18s%s\n", signo, name, msg);
605
    }
606
 
607
  return 0;
608
}
609
 
610
#endif

powered by: WebSVN 2.1.0

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