The special variable '$.' is convenient when you want a quick way to detect the line number of the currently read file. But it can get a little confusing when you're dealing with multiple input files. In such cases, it might be advisable to take advantage of the added control and comfort of an object-oriented interface to filehandles such as that provided by IO::File.

IO::File inherits from IO::Handle and IO::Seekable. And one of the methods of IO::Handle is: input_line_number(), which happens to be an object-encapsulated substitute for '$.', but benefitting from all the scoping that applies to object instances.

A usage example:

use strict;
use warnings;
use IO::File;

{
    my $fh = IO::File->new( '< filename.txt' );
    if( defined $fh ) {
        while( my $line = <$fh> ) {
            print $fh->input_line_number(), 
                  ":\t",
                  $line;
        }
    }
}   # As $fh falls out of scope it is closed automatically.
[download]

It seems that input_line_number() is probably somewhat of a misnomer. Given that the input record separator needn't be '\n', the method would probably be better named input_record_number(), but that's just water under the bridge. :)

Thanks for the suggestion, though I solved my actual problem per the response below (localizing $. wherever my module performed a seek() or used <>).

Instead of using IO::File as you propose, since open()'ed files are automatically IO::Handles, you can just "use IO::Handle;" to provide the input_line_number method (note the continue):

use strict;
use warnings;
use IO::Handle;

while (<>) {
    my $lineno = ARGV->input_line_number;
    # print a status message every 100 lines
    warn "Processing $ARGV line $lineno\n" unless $lineno % 100;
    # do some processing stuff
} continue {
    close ARGV if ARGV->eof; # else input_line_number won't reset per-
+file
}
[download]

(Update:) s/eof/ARGV->eof/ in the code example. (else a poorly written function, like my original seeky() would let the eof refer to the wrong file)

local $. in the <DATA>-block has no usage. What will perl do? it will copy the current value of $. to a temp variable, and reset it after the block.

It is not this block that it is messing up the results of $., it is the seeky-sub. What you could do is add a local $. in sub seeky, then you get the results you expect.

Since this means that at the start of the block it will copy $. to another variable, seek will set $. to another alias, and at the end of the block the value of $. is restored (by using the copy it made).

Update: another solution with which you would get the same result is to create a new block in your code, and localising $. in there. Something like:

while (<DATA>) {
    chomp;
    my $line = $.;
    warn "Pre match: Line $. == $line\n";
    next if /match/;
    {
      local $.;
      seeky();
    }
    warn "Postmatch: Line $. != $line\n";
}
[download]

You're quite right. And even though I understood what was going wrong, my interpretation of localization was backwards in this case. I was thinking that I was trying to make $.'s behavior local to the <DATA>-block, when I should have been attempting to localize seek()'s effects on $. to seeky().

(It didn't help matters that my original problem was significantly more complicated. I tried to fix it by localizing $. wherever I had a "local $_;" in a module, but forgot to search for seek()s.)

FWIW, I would add the "local $.;" statement to seeky itself, analagous to adding "local $_;" in subroutines.

Thanks for the response, Animator.