To get unsafe signal handling in Perl, you just need to set the environment variable PERL_SIGNALS to the value "unsafe" before you call Perl. Unsafe signal handling is important when you have long-running opcodes that might block the handling of a signal. A perfect example of such an opcode is calling out to a C library. Think a long-running database handler. If you are using safe signals, that query cannot be interrupted. Your problem doesn't "smell" like an unsafe signals issue, but now you know how to do it if you want to experiment.

All I wanted to do was this, and be able to type ctrl-D to signify that I was done:

my @lines = <STDIN>;
[download]

(Somebody let me know if I missed the obvious boat here; I couldn't find the way to do this.)

I read somewhere that Ctrl-D is Ctrl-Z on Windows, but I cannot confirm that. Maybe this is the reason that it did not work for you?

Ctrl-Z works as you suggest in the code above, but it must be the first character on a line and must be followed by a newline (although other characters may intervene between the Ctrl-Z and the newline). A Ctrl-Z that is not the first character on a line shows up as a teeny, right-pointing arrow.

perl -wMstrict -le
"my $lines = do {
   local $/ = qq(\cD);
   my $in = <STDIN>;
   chomp $in;
   $in
   };
 print $lines
"
qwert
asdf
zx^D
qwert
asdf
zx
[download]

C:\@Work\Perl\monks\zemane>perl -wMstrict -le
"my $lines = do {
   local $/ = qq(\cD);
   my $in = <STDIN>;
   chomp $in;
   $in
   };
 print $lines
"
the cow
jumped over
the moo^Dn whoops!
the cow
jumped over
the moo
[download]

Your ctrl-D technique of course works on UNIX but windows often does not follow UNIX. I cannot think of any reason why windows should follow UNIX on this point. A quick search reveals many people with the same issue.

What problem are you trying to solve? Could you treat a certain string of characters as terminating the input?

#!/usr/bin/perl
use warnings;
use strict;

my @lines;
{
    $SIG{INT} = 'IGNORE';
    @lines = <STDIN>;
}
print "You entered: " . join("", @lines)
[download]

Right... but now ctrl-C is ignored for the entire life of the script. And, if the signal handler is reset back to default later in the script, it doesn't keep the script from dying as a result of the ctrl-C.

#!perl

use strict;
use Win32::API;
use Win32::API::Callback;

use constant CTRL_C_EVENT        => 0;
use constant CTRL_BREAK_EVENT    => 1;
use constant CTRL_CLOSE_EVENT    => 2;
use constant CTRL_LOGOFF_EVENT   => 5;
use constant CTRL_SHUTDOWN_EVENT => 6;

######################################################################
+#
# BOOL WINAPI HandlerRoutine( __in  DWORD dwCtrlType );
my $cbfn = Win32::API::Callback->new( sub { my $type = shift; return 0
+; }, 'L', 'L' );

######################################################################
+#
# BOOL WINAPI SetConsoleCtrlHandler( __in_opt  PHANDLER_ROUTINE Handle
+rRoutine, __in BOOL Add);
my $fn1 = new Win32::API('kernel32', 'SetConsoleCtrlHandler', 'KL', 'L
+');
die "Can't get function handle" unless ($fn1);

# The following line of code complains that PHANDLER_ROUTINE is an unk
+nown type.  Boo.  Hiss.
#my $fn = new Win32::API('kernel32', 'BOOL SetConsoleCtrlHandler(PHAND
+LER_ROUTINE HandlerRoutine, BOOL Add)');
#die "Can't get function handle" unless ($fn);

my $fn2 = new Win32::API('kernel32', 'SetConsoleCtrlHandler', 'LL', 'L
+');
die "Can't get function handle" unless ($fn2);


######################################################################
+#
# BOOL WINAPI GenerateConsoleCtrlEvent(DWORD dwCtrlEvent, DWORD dwProc
+essGroupId);
my $fn3 = new Win32::API('kernel32', 'BOOL GenerateConsoleCtrlEvent(DW
+ORD dwCtrlEvent, DWORD dwProcessGroupId)');
die "Can't get function handle" unless ($fn3);


print "Registering the callback function...\n";
die "Bad function call return value"
   unless $fn1->Call($cbfn, 1);

# Generate a CTRL-C event that can be captured
print "Generating a CTRL-C event...\n";
$fn3->Call(CTRL_C_EVENT, 0);

print "Resetting the callback handler...\n";
my $return = $fn2->Call(0, 0); 

print "Done!\n";
[download]

#!perl -w
use strict;

print "Enter CTRL-C to end input\n";
my $lines = get_lines();

print "Enter CTRL-C to exit\n";
while ( 1 )
{
   local($") = ', ';
   print "You entered: @$lines\n";
   sleep(1);
}

sub get_lines
{
   use threads;
   local($SIG{INT}) = 'IGNORE';
   $lines = threads->create( sub{ my @rv = <STDIN>; chomp @rv; return 
+\@rv } )->join();
}
[download]

#!perl -w
use strict;

print "Enter CTRL-C to end input\n";
$SIG{INT} = 'IGNORE';
my @rv = <STDIN>; 
eval q/$SIG{INT} = 'DEFAULT'/;
chomp @rv;
print "Enter CTRL-C to exit\n";
while ( 1 )
{
   local($") = ', ';
   print "You entered: @rv\n";
   sleep(1);
}
[download]