my $flag = 0;
while (<FILE>) {
    if ($flag) {
        $flag = 0;
        do_something($_);
    }
    if (/pattern/) {
        $flag = 1;
        next;
    }
}
[download]

I think it is as simple as reversing the tests and using an elsif in trammell's example to cover his "special" case...

my $flag = 0;

while( <FILE> ) {
    if ( /test/ ) {
        print;
        $flag = 1;
    }
    elsif ( $flag ) {
        print;
        $flag = 0;
    }
}
[download]

--Solo

--
You said you wanted to be around when I made a mistake; well, this could be it, sweetheart.

The short answer is that you need to use $nextLine = <INPUT> to get the next line after you match, then use last to leave the loop.

Here's something I patched together:

#!/usr/bin/perl -w

# Next After Match .. PM node 418383

my $filename = shift;

open ( INPUT, $filename ) or
  die "Unable to open $filename: $!";

my $string = shift;

my $nextLine;
while(<INPUT>) {
  if ( /$string/ ) {
    $nextLine = <INPUT>;
    last;
  }
}

close ( INPUT );

if ( defined ( $nextLine ) ) {
  print "INFO: $string found in file $filename, next line is:\n";
  print $nextLine;
} else {
  print "INFO: $string not found in file $filename.\n";
}
[download]

[foo@bar dev]$ perl -w nam.pl nam.pl print
INFO: print found in file nam.pl, next line is:
  print $nextLine;
[foo@bar dev]$ perl -w nam.pl nam.pl whoosat
INFO: whoosat not found in file nam.pl.
[download]

The one-liner approach:

$ cat input.txt
one
two
three
four
five
six
seven

$ perl -ne 'print $_ = <> and last if /five/' input.txt
six
[download]

#!/usr/bin/perl -w

use strict;

my $line;
my $pattern = "asdf";
my $flag = 0;

while($line = <>) {

    if($flag) {
        print "do something here to $line \n";
    }

    if($line =~ m/$pattern/) {
        $flag = 1;
    } else {
        $flag = 0;
    }
}

if($flag) {
    print "Oops, we don't have a line to work on but flag was set.\n";
}
[download]

while (<FILE>){
  if (/text to check for/){
    my $nextline = <FILE>;
    print $nextline;
  }
}
[download]

my question was : once a line is matched, what should I do , like increment pointer to go to next line to get that line in file ?

I think previous two posts were talking about setting flags if match is found !

The previous posts do go to the next line, the flag is set so that when you get to the next line, you know that the previous line was a match. If you get to a line, and the flag is set, then do whatever it is that you wanted to do after finding the matching line.
UPDATE-
I'm going to use tremmel's code to make sure that you understand what is going on, forgive me if I go in to too much detail, but I don't know where your level of understanding is - not trying to talk down to you, I'm a relative beginner myself.

my $flag = 0;
while (<FILE>) {   #If not at end of file process next line
    if ($flag) {   #flag is set, previous line was a match
        $flag = 0; #reset the flag
        do_something($_);  #do what you want to do after finding match
    }
    if (/pattern/) {  #if this line matches
        $flag = 1;  #set the flag so I can do something on next line
        next;  #go to next line, not required but might make more read
+able
    }
}
[download]

Basically, whenever you evaluate <FOO> in scalar context, it reads the next line from the file handle FOO and returns it, or returns undef if you're at the end of the file. A normal

while (<FOO>){
[download]

loop is short for

while (defined($_ = <FOO>)){
[download]

So all you have to do to read the next line is execute <FOO> again, either by doing so directly and using the result, or by waiting for the next iteration of the loop (which will read it for you) and then dealing with it then (the flag, then, lets you know that last time you saw what you needed). Which is preferable depends on what else you need to do with what lines in the file.

The problem with the approach you describe is that it won't work if two lines in a row match. For example, say you have a file like:

foo
bar
barbar
bell

and the pattern is /bar/. bar will match; if you read in the next line and print it out, you won't notice that barbar also matches, and so won't print out bell. You could add some code to fix this, but the flag approach handles it quite nicely.

    perl -ne 'print if $,;$, = /PATTERN/' input
[download]

Is there any advantage to using $, here besides an obscurity bonus? :)