EOF is when you ask to read some byte(s) and you don't get an error but you get zero bytes read.

Interactively, CTRL-D flushes your input. If you've just flushed your input already (by pressing RETURN which queued up a newline then flushed the input), then flushing again with CTRL-D means that 0 bytes get flushed to the next read request (and so gets interpretted as EOF).

Most other forms of I/O don't support this abillity to flush all the way through to the reader without irreversibly closing the handle.

In other words, you're out of luck... unless you want to use a pseudo-tty...

Ok well I just ran into this post, and I think that the conversation got muddled... the Key is if you're doing a bidirectional pipe to close the Writer stream... Sorry about updating an old post, but its first Google response.

sub pushusers() {
    my $host = shift;
    my $cmd = sprintf("ssh %s@%s perl",$user,$host);
    my $pid = open2(*Reader, *Writer, $cmd);

    print Writer "die('got into perl')\n";
    close(Writer);
    my $output = <Reader>;
    print "Got from host ${host} output: ${output}";
    exit(0);
}
[download]

-Anacreo

This program is called 'consumer.pl'. I added a clue for Expect to use to find the end of the output. You can do without the ending markers, you just have to be a little more clever with Expect. This sample program is similar to yours, in that it uses multiple input streams. It writes a file for each stream.

use File::Slurp;

my $out='';
while(<>)
{
  $out .= "1:$_";
}
$out .= "end1\n";
write_file("out1.txt", $out);

$out='';
while(<>)
{
  $out .= "2:$_";
}
$out .= "end2\n";
write_file("out2.txt", $out);
[download]

use Expect;

my $proc= new Expect();
$proc->spawn("./consumer.pl");

$proc->send("hello there\n");
$proc->send("\cD");
$proc->send("this is\n");
$proc->send("\cD");

$proc->expect(1,
  [
    /end1/ => sub
    {
      exp_continue;
    }
  ],
  [
    /end2/ => sub
    {
      exp_continue;
    }
  ]
);
[download]

minor update: pushed the code around a bit

If you want to emulate that behavior (moving to the next loop or whatever in your program after user presses ^D) then you'll have to DIY. However, since your program isn't a terminal input device, you'll probably decide to do something else. :)

I have a program that wants to read two separate streams from STDIN.

In unix, a data file is also referred to as a "stream". Since your example just uses  while <>, I wonder if you're talking about a case where two files (streams) are being presented to the script via ARGV, like this:

some_script.pl  file1  file2
[download]

  In a "while (<>)" loop, "eof" or "eof(ARGV)" can be used to
  detect the end of each file, "eof()" will only detect the end
  of the last file.  Examples: ...
[download]

my $prefix = 1;

while (<>)
{
    print "$prefix: $_";
    $prefix++ if ( eof );
}
[download]

  cat file1 file2 | some_script.pl

# or something less mundane:

  grep "target string" file1 | cat - file2 | some_script.pl
[download]

(update: I should say, the only way around that is to make sure there are reliable clues in the resulting stream -- e.g.:

 echo "____STREAM_BOUNDARY____" > bndry
 grep "target string" file1 | cat - bndry file2 | script.pl
[download]

In the earlier case, where the script is given two or more file names in @ARGV, and these are read successively by the diamond operator, perl obviously knows when one file ends and the next must be opened, and "eof" is how you find out about that.

If your notion of "two streams on STDIN" is referring to something other than these cases, then I'm puzzled as to what you could be talking about.

Sorry for any confusion it might have caused, but I used the diamond operator simply for convenience. Pretend that instead of <>, I had written <STDIN>, and it might make more sense. How to read the streams wasn't the question I had, however. In fact, the reading program was out of my control anyway. I found it odd that it was able to read two separate streams interactively, and I wondered how to write them both to STDOUT. tye's response clarified that bit for me, specifically where he wrote:

flushing again with CTRL-D means that 0 bytes get flushed to the next read request (and so gets interpretted as EOF).

And toma's response explained how I can emulate the terminal's behavior from a non-interactive perl script. Thanks for taking the time to reply, though.

Update: btw, just to pass along a neat little trick, if using bash (or perhaps other shells support this, but only tested on bash) you could avoid the temporary file in your last example with something like:

    grep "target string" file1                      \
    | cat - <(echo "____STREAM_BOUNDARY____") file2 \
    | script.pl
[download]