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