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

Subversion Repositories or1k

[/] [or1k/] [branches/] [oc/] [gdb-5.0/] [libiberty/] [strsignal.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom
/* 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 "ansidecl.h"
6
#include "libiberty.h"
7
 
8
#include "config.h"
9
 
10
/* We need to declare sys_siglist, because even if the system provides
11
   it we can't assume that it is declared in <signal.h> (for example,
12
   SunOS provides sys_siglist, but it does not declare it in any
13
   header file).  fHowever, we can't declare sys_siglist portably,
14
   because on some systems it is declared with const and on some
15
   systems it is declared without const.  If we were using autoconf,
16
   we could work out the right declaration.  Until, then we just
17
   ignore any declaration in the system header files, and always
18
   declare it ourselves.  With luck, this will always work.  */
19
#define sys_siglist no_such_symbol
20
 
21
#include <stdio.h>
22
#include <signal.h>
23
 
24
/*  Routines imported from standard C runtime libraries. */
25
 
26
#ifdef __STDC__
27
#include <stddef.h>
28
extern void *malloc (size_t size);                              /* 4.10.3.3 */
29
extern void *memset (void *s, int c, size_t n);                 /* 4.11.6.1 */
30
#else   /* !__STDC__ */
31
extern char *malloc ();         /* Standard memory allocater */
32
extern char *memset ();
33
#endif  /* __STDC__ */
34
 
35
/* Undefine the macro we used to hide the definition of sys_siglist
36
   found in the system header files.  */
37
#undef sys_siglist
38
 
39
#ifndef NULL
40
#  ifdef __STDC__
41
#    define NULL (void *) 0
42
#  else
43
#    define NULL 0
44
#  endif
45
#endif
46
 
47
#ifndef MAX
48
#  define MAX(a,b) ((a) > (b) ? (a) : (b))
49
#endif
50
 
51
static void init_signal_tables PARAMS ((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
  int value;            /* The numeric value from <signal.h> */
66
  const char *name;     /* The equivalent symbolic value */
67
#ifndef HAVE_SYS_SIGLIST
68
  const char *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 ()
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
NAME
349
 
350
        signo_max -- return the max signo value
351
 
352
SYNOPSIS
353
 
354
        int signo_max ();
355
 
356
DESCRIPTION
357
 
358
        Returns the maximum signo value for which a corresponding symbolic
359
        name or message is available.  Note that in the case where
360
        we use the sys_siglist supplied by the system, it is possible for
361
        there to be more symbolic names than messages, or vice versa.
362
        In fact, the manual page for psignal(3b) explicitly warns that one
363
        should check the size of the table (NSIG) before indexing it,
364
        since new signal codes may be added to the system before they are
365
        added to the table.  Thus NSIG might be smaller than value
366
        implied by the largest signo value defined in <signal.h>.
367
 
368
        We return the maximum value that can be used to obtain a meaningful
369
        symbolic name or message.
370
 
371
*/
372
 
373
int
374
signo_max ()
375
{
376
  int maxsize;
377
 
378
  if (signal_names == NULL)
379
    {
380
      init_signal_tables ();
381
    }
382
  maxsize = MAX (sys_nsig, num_signal_names);
383
  return (maxsize - 1);
384
}
385
 
386
 
387
/*
388
 
389
NAME
390
 
391
        strsignal -- map a signal number to a signal message string
392
 
393
SYNOPSIS
394
 
395
        const char *strsignal (int signo)
396
 
397
DESCRIPTION
398
 
399
        Maps an signal number to an signal message string, the contents of
400
        which are implementation defined.  On systems which have the external
401
        variable sys_siglist, these strings will be the same as the ones used
402
        by psignal().
403
 
404
        If the supplied signal number is within the valid range of indices
405
        for the sys_siglist, but no message is available for the particular
406
        signal number, then returns the string "Signal NUM", where NUM is the
407
        signal number.
408
 
409
        If the supplied signal number is not a valid index into sys_siglist,
410
        returns NULL.
411
 
412
        The returned string is only guaranteed to be valid only until the
413
        next call to strsignal.
414
 
415
*/
416
 
417
#ifndef HAVE_STRSIGNAL
418
 
419
const char *
420
strsignal (signo)
421
  int signo;
422
{
423
  const char *msg;
424
  static char buf[32];
425
 
426
#ifndef HAVE_SYS_SIGLIST
427
 
428
  if (signal_names == NULL)
429
    {
430
      init_signal_tables ();
431
    }
432
 
433
#endif
434
 
435
  if ((signo < 0) || (signo >= sys_nsig))
436
    {
437
      /* Out of range, just return NULL */
438
      msg = NULL;
439
    }
440
  else if ((sys_siglist == NULL) || (sys_siglist[signo] == NULL))
441
    {
442
      /* In range, but no sys_siglist or no entry at this index. */
443
      sprintf (buf, "Signal %d", signo);
444
      msg = (const char *) buf;
445
    }
446
  else
447
    {
448
      /* In range, and a valid message.  Just return the message. */
449
      msg = (const char *) sys_siglist[signo];
450
    }
451
 
452
  return (msg);
453
}
454
 
455
#endif /* ! HAVE_STRSIGNAL */
456
 
457
/*
458
 
459
NAME
460
 
461
        strsigno -- map an signal number to a symbolic name string
462
 
463
SYNOPSIS
464
 
465
        const char *strsigno (int signo)
466
 
467
DESCRIPTION
468
 
469
        Given an signal number, returns a pointer to a string containing
470
        the symbolic name of that signal number, as found in <signal.h>.
471
 
472
        If the supplied signal number is within the valid range of indices
473
        for symbolic names, but no name is available for the particular
474
        signal number, then returns the string "Signal NUM", where NUM is
475
        the signal number.
476
 
477
        If the supplied signal number is not within the range of valid
478
        indices, then returns NULL.
479
 
480
BUGS
481
 
482
        The contents of the location pointed to are only guaranteed to be
483
        valid until the next call to strsigno.
484
 
485
*/
486
 
487
const char *
488
strsigno (signo)
489
  int signo;
490
{
491
  const char *name;
492
  static char buf[32];
493
 
494
  if (signal_names == NULL)
495
    {
496
      init_signal_tables ();
497
    }
498
 
499
  if ((signo < 0) || (signo >= num_signal_names))
500
    {
501
      /* Out of range, just return NULL */
502
      name = NULL;
503
    }
504
  else if ((signal_names == NULL) || (signal_names[signo] == NULL))
505
    {
506
      /* In range, but no signal_names or no entry at this index. */
507
      sprintf (buf, "Signal %d", signo);
508
      name = (const char *) buf;
509
    }
510
  else
511
    {
512
      /* In range, and a valid name.  Just return the name. */
513
      name = signal_names[signo];
514
    }
515
 
516
  return (name);
517
}
518
 
519
 
520
/*
521
 
522
NAME
523
 
524
        strtosigno -- map a symbolic signal name to a numeric value
525
 
526
SYNOPSIS
527
 
528
        int strtosigno (char *name)
529
 
530
DESCRIPTION
531
 
532
        Given the symbolic name of a signal, map it to a signal number.
533
        If no translation is found, returns 0.
534
 
535
*/
536
 
537
int
538
strtosigno (name)
539
     const char *name;
540
{
541
  int signo = 0;
542
 
543
  if (name != NULL)
544
    {
545
      if (signal_names == NULL)
546
        {
547
          init_signal_tables ();
548
        }
549
      for (signo = 0; signo < num_signal_names; signo++)
550
        {
551
          if ((signal_names[signo] != NULL) &&
552
              (strcmp (name, signal_names[signo]) == 0))
553
            {
554
              break;
555
            }
556
        }
557
      if (signo == num_signal_names)
558
        {
559
          signo = 0;
560
        }
561
    }
562
  return (signo);
563
}
564
 
565
 
566
/*
567
 
568
NAME
569
 
570
        psignal -- print message about signal to stderr
571
 
572
SYNOPSIS
573
 
574
        void psignal (unsigned signo, char *message);
575
 
576
DESCRIPTION
577
 
578
        Print to the standard error the message, followed by a colon,
579
        followed by the description of the signal specified by signo,
580
        followed by a newline.
581
*/
582
 
583
#ifndef HAVE_PSIGNAL
584
 
585
void
586
psignal (signo, message)
587
  unsigned signo;
588
  char *message;
589
{
590
  if (signal_names == NULL)
591
    {
592
      init_signal_tables ();
593
    }
594
  if ((signo <= 0) || (signo >= sys_nsig))
595
    {
596
      fprintf (stderr, "%s: unknown signal\n", message);
597
    }
598
  else
599
    {
600
      fprintf (stderr, "%s: %s\n", message, sys_siglist[signo]);
601
    }
602
}
603
 
604
#endif  /* ! HAVE_PSIGNAL */
605
 
606
 
607
/* A simple little main that does nothing but print all the signal translations
608
   if MAIN is defined and this file is compiled and linked. */
609
 
610
#ifdef MAIN
611
 
612
#include <stdio.h>
613
 
614
int
615
main ()
616
{
617
  int signo;
618
  int maxsigno;
619
  const char *name;
620
  const char *msg;
621
 
622
  maxsigno = signo_max ();
623
  printf ("%d entries in names table.\n", num_signal_names);
624
  printf ("%d entries in messages table.\n", sys_nsig);
625
  printf ("%d is max useful index.\n", maxsigno);
626
 
627
  /* Keep printing values until we get to the end of *both* tables, not
628
     *either* table.  Note that knowing the maximum useful index does *not*
629
     relieve us of the responsibility of testing the return pointer for
630
     NULL. */
631
 
632
  for (signo = 0; signo <= maxsigno; signo++)
633
    {
634
      name = strsigno (signo);
635
      name = (name == NULL) ? "<NULL>" : name;
636
      msg = strsignal (signo);
637
      msg = (msg == NULL) ? "<NULL>" : msg;
638
      printf ("%-4d%-18s%s\n", signo, name, msg);
639
    }
640
 
641
  return 0;
642
}
643
 
644
#endif

powered by: WebSVN 2.1.0

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