You could probably get GNU grep (external link) to compile on Solaris if you prod it enough.

----
I wanted to explore how Perl's closures can be manipulated, and ended up creating an object system by accident.
-- Schemer

Note: All code is untested, unless otherwise stated

Alternatively there is http://www.sunfreeware.com/ where a precompiled binary may be found for the appropriate OS/Hardware version.

/J\

use strict;
use warnings;
use Tie::File;
use Getopt::Std;

our %opts;
getopt('AB',\%opts);
die "USAGE: $0 [-An] [-Bn] match file" unless @ARGV;
my ($match,$filename) = @ARGV;

my @file;
tie @file, 'Tie::File', $filename;

# i wish there was a way for grep to return indices ...
my @found;
for (0..$#file) {
   push @found, $_ if $file[$_] =~ /$match/;
}

for (@found) {
   my ($start,$end) = ($_,$_);

   $start -= $opts{A} if $opts{A};
   $end   += $opts{B} if $opts{B};
 
   $start = 0 if $start < 0;
   $end = $#file if $end > $#file;

   print $_,$/ for @file[$start..$end];
}
[download]

jeffa

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

Your code works great for simple cases, but fails for files that have matches that are close together. You end up with duplicate lines being displayed.

for example try the following:

grep.pl -A 1 -B 1 test data

with the file 'data' containing:

test 1
test 2
test 3
[download]

The results are:

test 1
test 2
test 1
test 2
test 3
test 2
test 3
[download]

Also your version will parse the entire file before printing out any results. This will be slow for large files.

Still a good base to start from though...

Cheers

Cees

You can download Perl grep from the Perl Power Tools project:

http://www.perl.com/language/ppt/src/grep/index.html

Here is a version that I based heavily on jeffa's version above.

use strict;
use warnings;
use Tie::File;
use Getopt::Std;

our %opts;
getopt('AB',\%opts);
die "USAGE: $0 [-An] [-Bn] match file" unless @ARGV;
my ($match,$filename) = @ARGV;

my @file;
tie @file, 'Tie::File', $filename, autochomp => 0;

my @prebuffer;
my $postbuffer_counter = 0;
foreach (@file) {
  if (/$match/) {
    print @prebuffer, $_;
    @prebuffer = ();
    $postbuffer_counter = $opts{A} || 0;
  } else {
    if ($postbuffer_counter-- > 0) {
      print $_
    } else {
      push @prebuffer, $_;
      shift @prebuffer if @prebuffer > $opts{B};
    }
  }
}
[download]

This prints as it finds matches and handles matches that are close together. I haven't done a whole lot of testing, so there very well may be other issues.

Comments and suggestions are welcome...

Cees

use strict;
use warnings;
use Getopt::Std;

our %opts;
getopts('A:B:n',\%opts);
die "USAGE: $0 [-n] [-An] [-Bn] pattern [file] ..." unless @ARGV;
my $pattern = shift;


my @buffer;
my @matches;

my $nextmatch;
my $prevmatch;
my $linenum;
my $shownames;
my $fname;
my $showlines = $opts{n};
my $behind = $opts{B} || 0;
my $after  = $opts{A} || 0;
my $bufsize = 1 + $behind;

if (@ARGV == 0) {
  procfile("-");
} else {
  $shownames = 1 if @ARGV > 1;
  procfile($fname) while ($fname = shift @ARGV);
}

sub procfile {
  $prevmatch = -2 - $after;
  $linenum = 0;
  $nextmatch = 0;
  my $f = shift;
  unless (open IN, "<$f") {
    warn "$0: $f: $!\n";
    return;
  }
  while (<IN>) {
    push @buffer, $_;
    my  $matched = m/$pattern/o;
    push @matches, $matched;
    $linenum++;
    $nextmatch = $linenum if $matched;
    if (@buffer >= $bufsize) {
      proconeline();
    }
  }
}

proconeline() while @buffer && ($nextmatch || $prevmatch);

sub proconeline {
  my $oldlinenum = $linenum - @buffer + 1;
  my $oldmatch   = shift @matches;
  $_ = shift @buffer;
  if ($oldmatch || $oldlinenum - $prevmatch <= $after || $nextmatch) {
    print "$fname:" if $shownames;
    print "$oldlinenum:" if $showlines;
    print;
  }
  $prevmatch = $oldlinenum if $oldmatch;
  $nextmatch = 0 if $oldlinenum == $nextmatch;
}
[download]