class Strsignal:
"""An instance of this class emulates the standard (POSIX.1-2008)
C library function strsignal(). If possible, it calls the real
C library function, using ctypes; if this is not possible, it
produces the name of the SIGxxx constant (from the signal
module) corresponding to the signal number passed in; if *that*
doesn't work either, it returns the string "signal %d" with the
%d replaced with the decimal signal number.
For testing purposes, functions that implement a single one of
the strategies above can be retrieved from the static methods
get_ctypes_strsignal, get_reversemap_strsignal, and
get_fallback_strsignal. These methods may throw arbitrary
exceptions.
"""
def __init__(self):
"""Which strategy we will use is lazily determined on the first call."""
self._strsignal = None
def __call__(self, signo):
"""External entry point."""
if self._strsignal is None:
self.lazy_init()
return self._strsignal(signo)
def lazy_init(self):
"""Pick whichever of our three strategies doesn't throw an exception
upon instantiation."""
try:
self._strsignal = self.get_ctypes_strsignal()
except:
try:
self._strsignal = self.get_reversemap_strsignal()
except:
self._strsignal = self.get_fallback_strsignal()
@staticmethod
def get_ctypes_strsignal():
"""Strategy 1: If the C library exposes strsignal(), use it."""
import signal
import ctypes
import ctypes.util
libc = ctypes.CDLL(ctypes.util.find_library("c"))
strsignal_proto = ctypes.CFUNCTYPE(ctypes.c_char_p,
ctypes.c_int)
strsignal_c = strsignal_proto(("strsignal", libc), ((1,),))
NSIG = signal.NSIG
def strsignal_ctypes_wrapper(signo):
# The behavior of the C library strsignal() is unspecified if
# called with an out-of-range argument. Range-check on entry
# _and_ NULL-check on exit.
if 0 <= signo < NSIG:
s = strsignal_c(signo)
if s:
return s.decode("utf-8")
return "Unknown signal "+str(signo)
return strsignal_ctypes_wrapper
@staticmethod
def get_reversemap_strsignal():
"""Strategy 2: return the name of the signal constant corresponding to
the value passed in."""
import signal
signames = [None] * signal.NSIG
for constant in dir(signal):
if not constant.startswith("SIG"):
continue
if constant.startswith("SIG_"):
continue
# obsolete names for signals
if constant in ('SIGIOT', 'SIGCLD', 'SIGPOLL'):
continue
signames[getattr(signal, constant)] = constant
for rt in range(signal.SIGRTMIN+1, signal.SIGRTMAX):
signames[rt] = "SIGRTMIN+"+str(rt - signal.SIGRTMIN)
for gap in range(len(signames)):
if signames[gap] is None:
signames[gap] = "SIG_"+str(gap)
NSIG = signal.NSIG
def strsignal_reversemap_wrapper(signo):
if 0 <= signo < NSIG:
return signames[signo]
else:
return "Unknown signal "+str(signo)
return strsignal_reversemap_wrapper
@staticmethod
def get_fallback_strsignal():
"""Strategy F: just return "signal N" where N is the signal
number."""
def strsignal_fallback_wrapper(signo):
return "signal "+str(signo)
return strsignal_fallback_wrapper
strsignal = Strsignal()
__all__ = ('strsignal',)
if __name__ == '__main__':
def main():
import signal
import sys
import traceback
try:
strsignal_c = Strsignal.get_ctypes_strsignal()
except Exception as e:
sys.stdout.write("Ctypes strsignal unavailable: ")
sys.stdout.write(traceback.format_exception_only(type(e), e)[0])
strsignal_c = lambda _: "--"
try:
strsignal_r = Strsignal.get_reversemap_strsignal()
except Exception as e:
sys.stdout.write("Reverse-map strsignal unavailable: ")
sys.stdout.write(traceback.format_exception_only(type(e), e)[0])
strsignal_r = lambda _: "--"
try:
strsignal_f = Strsignal.get_fallback_strsignal()
except Exception as e:
sys.stdout.write("Fallback strsignal unavailable: ")
sys.stdout.write(traceback.format_exception_only(type(e), e)[0])
strsignal_f = lambda _: "--"
try:
strsignal(1)
strsignal(0)
strsignal(-9999)
strsignal_a = strsignal
except:
sys.stdout.write("Automatic strsignal unavailable: ")
traceback.print_exc(limit=0, file=sys.stdout)
strsignal_a = lambda _: "--"
rows = [('N', 'Auto', 'Ctypes', 'Revmap', 'Fallback')]
for n in [-signal.NSIG-1, -1] + list(range(signal.NSIG + 2)):
rows.append((str(n),
strsignal_a(n),
strsignal_c(n),
strsignal_r(n),
strsignal_f(n)))
cols = zip(*rows)
col_widths = [ max(len(val) for val in col) for col in cols ]
form = ' '.join(['{{:<{0}}}'.format(width) for width in col_widths])
form += '\n'
for row in rows:
sys.stdout.write(form.format(*row))
main()
