sdcc/support/sdbinutils/libiberty/strsignal.c

   1 /* 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 char *
 408 strsignal (int signo)
 409 {
 410   char *msg;
 411   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       msg = buf;
 432     }
 433   else
 434     {
 435       /* 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     }
 440
 441   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