use File::Tail ();

{
   local *CATLOG;

   if ($opt{'c'}) {
      open CATLOG, '<', $MAILLOG
         or die("Unable to open mail log: $!\n");
   } else {
      tie *CATLOG, 'File::Tail', (name => $MAILLOG, tail => -1);
   }

   while (<CATLOG>) {
      ...while loop code here...
   }
}
[download]

use File::Tail ();
use IO::File   ();

{
   # Why doesn't File::Tail implement IO::Handle's interface?
   # "read" means something else in Perl!
   package File::MyTail;
   BEGIN { our @ISA = 'File::Tail'; }
   sub getline { my $self = shift; return $self->read(@_); }
}

{
   my $log_fh;

   if ($opt{'c'}) {
      $log_fh = IO::File->new($MAILLOG, '<')
         or die("Unable to open mail log: $!\n");
   } else {
      $log_fh = File::MyTail->new(name => $MAILLOG, tail => -1);
   }

   while (defined(my $line = $log_fh->getline())) {
      ...while loop code here...
   }
}
[download]

use File::Tail ();

{
   my $getline;

   if ($opt{'c'}) {
      open my $fh, '<', $MAILLOG
         or die("Unable to open mail log: $!\n");
      $getline = sub { return scalar <$fh>; }
   } else {
      my $fh = File::MyTail->new(name => $MAILLOG, tail => -1);
      $getline = sub { return scalar $fh->read(); }
   }

   while (defined(my $line = $getline->()) {
      ...while loop code here...
   }
}
[download]

Untested.

I like the last one. It has less overhead, and allows you to use the method of your choice to get a line from the source.

Well then, just use the tie mode of File::Tail:

if ($opt{'c'}) {
    open ( CATLOG, '<', $MAILLOG )
         or die "Can't open $MAILLOG: $!\n";
} else {
    my $ref = tie *CATLOG, "File::Tail",(
        name  => $MAILLOG,
        tail  => -1
    ) or die "Can't tie $MAILLOG: $!\n";
}
while (my $line = <CATLOG>) {
    # ...while loop code here...
}
[download]

One more thing: Always check the return value of open / close.

cheers,
--shmem

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

Use a simple iterator.

# Create an iterator...
my $reader;
if ( $opt{c} ) {
    open my $fh, '<', $MAILLOG
      or die "Can't open $MAILLOG: $!";
    $reader = sub { <$fh> }
}
else {
    my $tail = File::Tail->new( name => $MAILLOG, tail => -1 );
    $reader = sub { $tail->read };
}

# Use our iterator, however it works...
while ( my $line = $reader->() ) {
    ...
}
[download]

The whole point of subroutines is so you don't have to write stuff more than once, after all.

The reason I do not want to go with the subroutine approach is because this is part of the main body of the program. That would mean the main body just opens this loop and drops right into subroutines. My coding style (be it right or wrong), is that the main body of the program stays as the main body and a subroutine should be for a specific purpose, not to replace the main body of the program.

my $c = 0;
BLOCK:
{
print "Hi there!\n";
redo BLOCK if $c++ < 10;
}
[download]

Example implementation:

use strict;
use warnings;
use File::Tail;
my %opt = (c => 0);
my $MAILLOG = $ARGV[0];


#
# $reader will hold a reference to an anonymous subroutine that reads 
+from
# a source. Either a filehandle or a File::Tail object.
#
my $reader = undef;

if ($opt{'c'}) {
    my $fh = undef;
    open $fh, "<", $MAILLOG or die "Failed to read $MAILLOG. $!";
    # Create an anonymous subroutine that reads from the lexical $fh
    # filehandle. Once $reader goes out of scope the file will be clos
+ed
    $reader = sub { readline($fh) };
} else {
    my $log = File::Tail->new(
        name => $MAILLOG,
        tail => -1,
        interval => 1,
        max_interval => 1,
    );
    # Create an anonymous subroutine that reads from the $log
    # object. Once $reader goes out of scope the object will be
    # destroyed.
    $reader = sub { $log->read() };
}

while (defined(my $line=$reader->())) {
    print $line;
}
[download]