Strawberry Perl runs on Windows. Windows does not have signals. POSIX systems like Linux have signals.

Perl emulates some minor aspects of kill() on Windows, but you can't expect the emulation to be perfect.

From perlport:

kill() doesn't have the semantics of raise(), i.e. it doesn't send a signal to the identified process like it does on Unix platforms. Instead kill($sig, $pid) terminates the process identified by $pid, and makes it exit immediately with exit status $sig. As in Unix, if $sig is 0 and the specified process exists, it returns true without actually terminating it. (Win32)

kill(-9, $pid) will terminate the process specified by $pid and recursively all child processes owned by it. This is different from the Unix semantics, where the signal will be delivered to all processes in the same process group as the process specified by $pid. (Win32)

From perlwin32:

Signal handling may not behave as on Unix platforms (where it doesn't exactly "behave", either :). For instance, calling die() or exit() from signal handlers will cause an exception, since most implementations of signal() on Win32 are severely crippled. Thus, signals may work only for simple things like setting a flag variable in the handler. Using signals under this port should currently be considered unsupported.

Alexander

Thanks to everyone who has answered, and especially afoken for pointing me to a couple docs I hadn't read. Very helpful!

print pack("A25",pack("V*",map{1919242272+$_}(34481450,-49737472,6228,0,-285028276,6979,-1380265972)))

#!/usr/bin/perl

use strict;
use warnings;

$SIG{ALRM} = sub {
   print "Alarming!\n";
};

kill 'ALRM', $$;

print "Not alarming\n";
[download]

Alarming!
Not alarming
[download]

On Windows XP, ActiveState 5.10 you will get:
Process completed with exit code 14

There is a problem with "kill", not with ALRM signal.

And SIG INT works also!

#!/usr/bin/perl

use strict;
use warnings;

while (1)
{
  sleep(1);
}
__END__
Terminating on signal SIGINT(2)

Process completed with exit code 2
[download]

....This was CTRL-Break....

kill ALRM, $$ doesn't make sense to me!

The below code shows a simple example of a handler for SIGALRM.

#!/usr/bin/perl -w
use strict;
#$|=1; #see note below...

$SIG{'ALRM'} = 'timeout';

alarm(1);
while (1){sleep(1);} 

sub timeout
{
    print        "stdout: Alarming!\n";
    print STDERR "stderr: Alarming!\n";
    exit(0);
};
__END__
prints:
   Note: stderr msg comes first because "autoflush" for
   stdout wasn't turned on (stdout normally doesn't
   get "flushed" until program end). 
   $|=1; turns autoflush on.

stderr: Alarming!
stdout: Alarming!
[download]

kill ALRM, $$ doesn't make sense to me!

It means "send an ALRM signal to the process with PID $$ (which mean the current process). While it may not make much sense in production code, it's certainly useful for testing.

You may want to reread the docs for kill; unlike the shell version, the perl version requires you to have the signal as first parameter, followed by the PIDs you want to send the signal to.

When I test code with ALRM signal, I fiddle with the alarm($num) parameter and often use sleep() to cause the alarm to "trigger" during testing. There are problems with signal handling...in general, there is no way to "safely" continue executing a process after an ALRM signal because many OS functions are not re-entrant or even re-startable by any means.

Update: I strike this last sentence because it upset some folks. No offense was intended. I have no interest in obfuscated, obscure code although I do see that some folks have fun with this as an "art form".

The original question was, why doesn't this code work?

sub verse4 {
    my $boy;
    $SIG{ALRM} = sub { say "slip n slide" };
    ride( $boy ), kill (ALRM, $$) for (1 .. 3);
    sleep 1; map { $_++ } ($ice_cream, $cake);
}

sub ride { say "Whee!" };
[download]

use POSIX 'SIGALRM';
die SIGALRM ;
[download]

Unfortunately, that gives me an error:

> perl -e "use POSIX 'SIGALRM'; die SIGALRM;'
Your vendor has not defined POSIX macro SIGALRM, used at -e line 1
[download]

On another note, though, I'm curious about that. Does die SIGALRM actually raise a SIGALRM to the calling process, similar to POSIX::raise? If so, is it a POSIX thing, or can I use die SIGSTOP and so forth without useing POSIX?

print pack("A25",pack("V*",map{1919242272+$_}(34481450,-49737472,6228,0,-285028276,6979,-1380265972)))

Does die SIGALRM actually raise a SIGALRM to the calling process

No. die is a terse way of printing. It never sends a signal.

I'm guessing SIGALRM is a constant whose value is the signal number associated with SIGALRM.