One thought I had while considering this question was that you could open a tied filehandle, tied to a class that hides the intricacies of allowing you to "unshift" data. The tied FH would read from STDIN, but would provide an OO interface on the side that allows you to do some funky things like $obj->push_fh($);.

Here is a very simple implementation of this strategy. I wouldn't consider it complete, as it doesn't implement all of the required tied filehandle methods. But it does implement those necessary for the purpose of this example, and the result is executable code that seems to work fine in simple situations. Filling in the blanks to complete the rest of the required tied filehandle methods remains to be completed if you want to fully implement the solution. In particular, you'll need an EOF, PRINT, and GETC method, if I'm not mistaken. :)

use strict;
use warnings;

package PushableFH;

use strict;
use warnings;

sub TIEHANDLE {
    my $class = shift;
    my $rfh = shift;
    my $obj = {};
    $obj->{FH} = $rfh;
    $obj->{PUSHED} = [];
    bless $obj, $class;
}

sub READLINE {
    my $self = shift;
    my $fh = $self->{FH};
    return ( @{$self->{PUSHED}} > 0 ) ? pop @{$self->{PUSHED}} : <$fh>
+;
}

sub push_fh {
    my $self = shift;
    push @{$self->{PUSHED}}, @_;
}

package main;

use strict;
use warnings;
use vars qw/*FILEHANDLE/;

my $fhobj = tie *FILEHANDLE, "PushableFH", \*DATA;

my $line = <FILEHANDLE>;    # Read the first line from the filehandle.
print $line;

$fhobj->push_fh("Hello world!\n");  # Push something onto the FH.

$line = <FILEHANDLE>;  # Read what was just pushed.
print $line;

$line = <FILEHANDLE>;  # Read the next physical line from FH.
print $line;

__DATA__
This is the first line.
This is the second line.
[download]

You'll find that the output is:

This is the first line.
Hello world!
This is the second line.

So, as you can see, you now have a filehandle that reads from (in this case) DATA, but that allows you to push data back onto it for later use.

Enjoy!

package Tie::Input::Insertable;

sub PRINT {
  my $self = shift;
  $self->{buffer} = join '', @_, $self->{buffer};
}

sub TIEHANDLE {
  my ($class, $fh) = @_;
  bless {fh => $fh, buffer => ""}, $class;
}

sub READLINE {
  my $self = shift;
  return undef if $self->{eof};
  while (-1 == index($self->{buffer}, $/)) {
    my $fh = $self->{fh};
    my $data = <$fh>;
    if (length($data)) {
      $self->{buffer} .= $data;
    }
    else {
      $self->{eof} = 1;
      return delete $self->{buffer};
    }
  }
  my $pos = index($self->{buffer}, $/) + length($/);
  return substr($self->{buffer}, 0, $pos, "");
}

sub EOF {
  my $self = shift;
  $self->{eof} ||= not length($self->{buffer}) or $self->{fh}->eof();
}

1;
[download]

use Tie::Input::Insertable;
tie *FOO, 'TIE::Input::Insertable', *STDIN;

while (<FOO>) {
  print FOO "Hello, world\n" if /foo/;
  print $_;
}
[download]

To tie directly STDIN you can hold the original STDIN in other GLOB, soo this will work:

  *ORIGINAL_STDIN = \*STDIN ;
    
  tie *STDIN, 'Tie::Input::Insertable', *ORIGINAL_STDIN;
  
  print "> " ;
  while (<STDIN>) {
    print STDIN "Hello, world\n" if /foo/;
    print "\n# $_\n" ;
    print "> " ;
  }
[download]

And by the way, nice work in the TIEHANDLE. ;-P

Graciliano M. P.
"Creativity is the expression of the liberty".

Better to bring in the extra text from a new source,

while (<STDIN>) {
    $_ = "hi test text" if some_condition;
    # etc
}
[download]

Update: One way to slip in an extra STDIN is to localize the handle:

while (<STDIN>) {
    do {
        local $_ = $_;
        open local(*STDIN), @other_args or die $!;
        # do stuff
    } if some_condition;
    # more stuff
}
[download]

The interpreter is here: http://yoyo.monash.edu.my/~chwanren/uploader/assignment1.txt. If I did that, wouldn't I be throwing away whatever is read from STDIN? I mean if $_ is originally 'push' and I substitute it with $_ = "hi test test", then 'push' will be ignored right? Thanks for the help :)

Yeah I'm sorry about that. Had to take it down. Don't want to get plagiarised.

Anyway to the other replies, the reason I want to unshift to STDIN is because when my forth interpreter reads the "call" function, I want to unshift the commands stored in the variable onto STDIN. I'll elaborate. When curly braces are encountered, everything in it until the closing brace is added to a string. This string is then stored into a variable declared earlier. Like:

pop3 { pop pop pop } store
the string "pop pop pop" is stored into pop3 (via hash tables)

then, when i do pop3 call, I want to unshift "pop pop pop" onto STDIN to be read.

I've already implemented this differently by reading it everything from STDIN until EOF into a list, then handling each element of the list as though it is read from STDIN. Thus, I can unshift "pop pop pop" onto the list.

Is there any other way to do this more elegantly?

# old STDIN: 1 2 3
while (<STDIN>) {
   if (some condition) unshift "hi test test" to STDIN
   # new STDIN hi test test 1 2 3 
}
[download]

Second: why go to the trouble of doing deep magic with the file handle? That is, why wouldn't the following approach, which yields the same basic result, do just as well (with a lot less code and complexity)?

while (<STDIN>) {
    if (some condition) $_ = "hi test test " . $_;
    # ...
}
[download]

If it's more complicated then that, maybe you should be looking at a two-stage process, where the first stage is a simple text filter, adding prefixes to lines where needed, etc; the filter's output is piped to the second stage, whose logic is now much simpler, because the stream is appropriate to its task -- two simple scripts are often better than one complicated script. If you want to keep it really simple for the command-line user, you could set up the second script to handle its input like this:

# supposing that @ARGV contains file name(s) to be filtered and proces
+sed:

open( INP, "my_filter_script.pl @ARGV |" ) or die "can't filter: $!";

while (<INP>) {
    # prefixes and other source code filtering are already done
    # ...
}
[download]

my @f;
while ( $_ = scalar @f ? shift @f : <STDIN> ) {
  chomp;
  unshift(@f,"hi test test") if condition;
}
[download]

my @f;
{
  redo if $_ = shift @f || <STDIN>;
}
[download]