To create your own, you have to create a reference to a subroutine and put it into the %SIG array. So, to create your own SIGINT handler, do the following:

sub my_sig_int_handler {
    print "Woo-Hoo!\n";
}

my $oldSigInt = $SIG{INT};
$SIG{INT} = \&my_sig_int_handler;
[download]

------
We are the carpenters and bricklayers of the Information Age.

Don't go borrowing trouble. For programmers, this means Worry only about what you need to implement.

Better then using the UNIX command-line kill command, is using perl's built-in kill function. For example to send the INT signal to the process ID in the $pid variable you could use:

kill INT => $pid;
# which is the same as
kill 'INT', $pid;
[download]

Note that people often do something like:

$SIG{INT} = sub { 
 # code executed on 'INT' signal here
}; # <-- that semicolon isn't optional
[download]

...using an anonymous subroutine instead of a named one.

Often if one just wants to handle a signal differently for a small section of code one can take advantage of local to temperarily set a signal handler up. For example:

{
  my $stop = 0;
  local $SIG{INT} = sub { $stop++ }; 
  while (!$stop) {
    # the loop continues until it's left with an explict
    # last, or until the process recieves SIGINT.
  }
}
# our old SIGINT handle is restored here, because we
# left the old block.
[download]

(Though you can of course manually store the current signal handler, set a new one, and reset the signal handler when you are done if you want.)

$SIG{INT}  = sub { print "You zapped me!\n"; };

print "Try to zap me with ^C, I dare you!\n";
sleep 5;

# normally warnings are not fatal
warn "This is your last warning\n";
# make warnings fatal
$SIG{__WARN__} = sub { print "Died fron the warning @_\n"; exit };
# now warnings will be fatal
warn "I warned you!";

print "You will never read this, because the last warning killed me!";
[download]

cheers

tachyon

s&&rsenoyhcatreve&&&s&n.+t&"$'$`$\"$\&"&ee&&y&srve&&d&&print