"Fossies" - the Fresh Open Source Software Archive

Member "install-tl-20200916/tlpkg/tlperl/lib/sigtrap.pm" (7 Mar 2020, 8736 Bytes) of package /windows/misc/install-tl.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Perl source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 package sigtrap;
    2 
    3 =head1 NAME
    4 
    5 sigtrap - Perl pragma to enable simple signal handling
    6 
    7 =cut
    8 
    9 use Carp;
   10 
   11 $VERSION = 1.09;
   12 $Verbose ||= 0;
   13 
   14 sub import {
   15     my $pkg = shift;
   16     my $handler = \&handler_traceback;
   17     my $saw_sig = 0;
   18     my $untrapped = 0;
   19     local $_;
   20 
   21   Arg_loop:
   22     while (@_) {
   23     $_ = shift;
   24     if (/^[A-Z][A-Z0-9]*$/) {
   25         $saw_sig++;
   26         unless ($untrapped and $SIG{$_} and $SIG{$_} ne 'DEFAULT') {
   27         print "Installing handler $handler for $_\n" if $Verbose;
   28         $SIG{$_} = $handler;
   29         }
   30     }
   31     elsif ($_ eq 'normal-signals') {
   32         unshift @_, grep(exists $SIG{$_}, qw(HUP INT PIPE TERM));
   33     }
   34     elsif ($_ eq 'error-signals') {
   35         unshift @_, grep(exists $SIG{$_},
   36                  qw(ABRT BUS EMT FPE ILL QUIT SEGV SYS TRAP));
   37     }
   38     elsif ($_ eq 'old-interface-signals') {
   39         unshift @_,
   40         grep(exists $SIG{$_},
   41          qw(ABRT BUS EMT FPE ILL PIPE QUIT SEGV SYS TERM TRAP));
   42     }
   43         elsif ($_ eq 'stack-trace') {
   44         $handler = \&handler_traceback;
   45     }
   46     elsif ($_ eq 'die') {
   47         $handler = \&handler_die;
   48     }
   49     elsif ($_ eq 'handler') {
   50         @_ or croak "No argument specified after 'handler'";
   51         $handler = shift;
   52         unless (ref $handler or $handler eq 'IGNORE'
   53             or $handler eq 'DEFAULT') {
   54                 require Symbol;
   55         $handler = Symbol::qualify($handler, (caller)[0]);
   56         }
   57     }
   58     elsif ($_ eq 'untrapped') {
   59         $untrapped = 1;
   60     }
   61     elsif ($_ eq 'any') {
   62         $untrapped = 0;
   63     }
   64     elsif ($_ =~ /^\d/) {
   65         $VERSION >= $_ or croak "sigtrap.pm version $_ required,"
   66                                 . " but this is only version $VERSION";
   67     }
   68     else {
   69         croak "Unrecognized argument $_";
   70     }
   71     }
   72     unless ($saw_sig) {
   73     @_ = qw(old-interface-signals);
   74     goto Arg_loop;
   75     }
   76 }
   77 
   78 sub handler_die {
   79     croak "Caught a SIG$_[0]";
   80 }
   81 
   82 sub handler_traceback {
   83     package DB;     # To get subroutine args.
   84     my $use_print;
   85     $SIG{'ABRT'} = DEFAULT;
   86     kill 'ABRT', $$ if $panic++;
   87 
   88     # This function might be called as an unsafe signal handler, so it
   89     # tries to delay any memory allocations as long as possible.
   90     #
   91     # Unfortunately with PerlIO layers, using syswrite() here has always
   92     # been broken.
   93     #
   94     # Calling PerlIO::get_layers() here is tempting, but that does
   95     # allocations, which we're trying to avoid for this early code.
   96     if (eval { syswrite(STDERR, 'Caught a SIG', 12); 1 }) {
   97         syswrite(STDERR, $_[0], length($_[0]));
   98         syswrite(STDERR, ' at ', 4);
   99     }
  100     else {
  101         print STDERR 'Caught a SIG', $_[0], ' at ';
  102         ++$use_print;
  103     }
  104 
  105     ($pack,$file,$line) = caller;
  106     unless ($use_print) {
  107         syswrite(STDERR, $file, length($file));
  108         syswrite(STDERR, ' line ', 6);
  109         syswrite(STDERR, $line, length($line));
  110         syswrite(STDERR, "\n", 1);
  111     }
  112     else {
  113         print STDERR $file, ' line ', $line, "\n";
  114     }
  115 
  116     # we've got our basic output done, from now on we can be freer with allocations
  117     # find out whether we have any layers we need to worry about
  118     unless ($use_print) {
  119         my @layers = PerlIO::get_layers(*STDERR);
  120         for my $name (@layers) {
  121             unless ($name =~ /^(unix|perlio)$/) {
  122                 ++$use_print;
  123                 last;
  124             }
  125         }
  126     }
  127 
  128     # Now go for broke.
  129     for ($i = 1; ($p,$f,$l,$s,$h,$w,$e,$r) = caller($i); $i++) {
  130         @a = ();
  131     for (@{[@args]}) {
  132         s/([\'\\])/\\$1/g;
  133         s/([^\0]*)/'$1'/
  134           unless /^(?: -?[\d.]+ | \*[\w:]* )$/x;
  135             require 'meta_notation.pm';
  136             $_ = _meta_notation($_) if /[[:^print:]]/a;
  137         push(@a, $_);
  138     }
  139     $w = $w ? '@ = ' : '$ = ';
  140     $a = $h ? '(' . join(', ', @a) . ')' : '';
  141     $e =~ s/\n\s*\;\s*\Z// if $e;
  142     $e =~ s/[\\\']/\\$1/g if $e;
  143     if ($r) {
  144         $s = "require '$e'";
  145     } elsif (defined $r) {
  146         $s = "eval '$e'";
  147     } elsif ($s eq '(eval)') {
  148         $s = "eval {...}";
  149     }
  150     $f = "file '$f'" unless $f eq '-e';
  151     $mess = "$w$s$a called from $f line $l\n";
  152         if ($use_print) {
  153             print STDERR $mess;
  154         }
  155         else {
  156             syswrite(STDERR, $mess, length($mess));
  157         }
  158     }
  159     kill 'ABRT', $$;
  160 }
  161 
  162 1;
  163 
  164 __END__
  165 
  166 =head1 SYNOPSIS
  167 
  168     use sigtrap;
  169     use sigtrap qw(stack-trace old-interface-signals);  # equivalent
  170     use sigtrap qw(BUS SEGV PIPE ABRT);
  171     use sigtrap qw(die INT QUIT);
  172     use sigtrap qw(die normal-signals);
  173     use sigtrap qw(die untrapped normal-signals);
  174     use sigtrap qw(die untrapped normal-signals
  175             stack-trace any error-signals);
  176     use sigtrap 'handler' => \&my_handler, 'normal-signals';
  177     use sigtrap qw(handler my_handler normal-signals
  178                     stack-trace error-signals);
  179 
  180 =head1 DESCRIPTION
  181 
  182 The B<sigtrap> pragma is a simple interface to installing signal
  183 handlers.  You can have it install one of two handlers supplied by
  184 B<sigtrap> itself (one which provides a Perl stack trace and one which
  185 simply C<die()>s), or alternately you can supply your own handler for it
  186 to install.  It can be told only to install a handler for signals which
  187 are either untrapped or ignored.  It has a couple of lists of signals to
  188 trap, plus you can supply your own list of signals.
  189 
  190 The arguments passed to the C<use> statement which invokes B<sigtrap>
  191 are processed in order.  When a signal name or the name of one of
  192 B<sigtrap>'s signal lists is encountered a handler is immediately
  193 installed, when an option is encountered it affects subsequently
  194 installed handlers.
  195 
  196 =head1 OPTIONS
  197 
  198 =head2 SIGNAL HANDLERS
  199 
  200 These options affect which handler will be used for subsequently
  201 installed signals.
  202 
  203 =over 4
  204 
  205 =item B<stack-trace>
  206 
  207 The handler used for subsequently installed signals outputs a Perl stack
  208 trace to STDERR and then tries to dump core.  This is the default signal
  209 handler.
  210 
  211 =item B<die>
  212 
  213 The handler used for subsequently installed signals calls C<die>
  214 (actually C<croak>) with a message indicating which signal was caught.
  215 
  216 =item B<handler> I<your-handler>
  217 
  218 I<your-handler> will be used as the handler for subsequently installed
  219 signals.  I<your-handler> can be any value which is valid as an
  220 assignment to an element of C<%SIG>. See L<perlvar> for examples of
  221 handler functions.
  222 
  223 =back
  224 
  225 =head2 SIGNAL LISTS
  226 
  227 B<sigtrap> has a few built-in lists of signals to trap.  They are:
  228 
  229 =over 4
  230 
  231 =item B<normal-signals>
  232 
  233 These are the signals which a program might normally expect to encounter
  234 and which by default cause it to terminate.  They are HUP, INT, PIPE and
  235 TERM.
  236 
  237 =item B<error-signals>
  238 
  239 These signals usually indicate a serious problem with the Perl
  240 interpreter or with your script.  They are ABRT, BUS, EMT, FPE, ILL,
  241 QUIT, SEGV, SYS and TRAP.
  242 
  243 =item B<old-interface-signals>
  244 
  245 These are the signals which were trapped by default by the old
  246 B<sigtrap> interface, they are ABRT, BUS, EMT, FPE, ILL, PIPE, QUIT,
  247 SEGV, SYS, TERM, and TRAP.  If no signals or signals lists are passed to
  248 B<sigtrap>, this list is used.
  249 
  250 =back
  251 
  252 For each of these three lists, the collection of signals set to be
  253 trapped is checked before trapping; if your architecture does not
  254 implement a particular signal, it will not be trapped but rather
  255 silently ignored.
  256 
  257 =head2 OTHER
  258 
  259 =over 4
  260 
  261 =item B<untrapped>
  262 
  263 This token tells B<sigtrap> to install handlers only for subsequently
  264 listed signals which aren't already trapped or ignored.
  265 
  266 =item B<any>
  267 
  268 This token tells B<sigtrap> to install handlers for all subsequently
  269 listed signals.  This is the default behavior.
  270 
  271 =item I<signal>
  272 
  273 Any argument which looks like a signal name (that is,
  274 C</^[A-Z][A-Z0-9]*$/>) indicates that B<sigtrap> should install a
  275 handler for that name.
  276 
  277 =item I<number>
  278 
  279 Require that at least version I<number> of B<sigtrap> is being used.
  280 
  281 =back
  282 
  283 =head1 EXAMPLES
  284 
  285 Provide a stack trace for the old-interface-signals:
  286 
  287     use sigtrap;
  288 
  289 Ditto:
  290 
  291     use sigtrap qw(stack-trace old-interface-signals);
  292 
  293 Provide a stack trace on the 4 listed signals only:
  294 
  295     use sigtrap qw(BUS SEGV PIPE ABRT);
  296 
  297 Die on INT or QUIT:
  298 
  299     use sigtrap qw(die INT QUIT);
  300 
  301 Die on HUP, INT, PIPE or TERM:
  302 
  303     use sigtrap qw(die normal-signals);
  304 
  305 Die on HUP, INT, PIPE or TERM, except don't change the behavior for
  306 signals which are already trapped or ignored:
  307 
  308     use sigtrap qw(die untrapped normal-signals);
  309 
  310 Die on receipt one of an of the B<normal-signals> which is currently
  311 B<untrapped>, provide a stack trace on receipt of B<any> of the
  312 B<error-signals>:
  313 
  314     use sigtrap qw(die untrapped normal-signals
  315             stack-trace any error-signals);
  316 
  317 Install my_handler() as the handler for the B<normal-signals>:
  318 
  319     use sigtrap 'handler', \&my_handler, 'normal-signals';
  320 
  321 Install my_handler() as the handler for the normal-signals, provide a
  322 Perl stack trace on receipt of one of the error-signals:
  323 
  324     use sigtrap qw(handler my_handler normal-signals
  325                     stack-trace error-signals);
  326 
  327 =cut