—
—

              
#!/usr/bin/perl
HideShow 13 lines of Pod
=begin metadata
Name: diff
Description: compute 'intelligent' differences between two files
Author: Mark-Jason Dominus, mjd-perl-diff@plover.com
Author: Christian Murphy, cpm@muc.de
Author: Amir D. Karger, karger@bead.aecom.yu.edu
License: perl
=end metadata
=cut
#
# `Diff' program in Perl
# Copyright 1998 M-J. Dominus. (mjd-perl-diff@plover.com)
#
# This program is free software; you can redistribute it and/or modify it
# under the same terms as Perl itself.
#
# Altered to output in `context diff' format (but without context)
# September 1998 Christian Murphy (cpm@muc.de)
#
# Context lines feature added
# Unified, "Old" (Standard UNIX), Ed diff added September 1998
# Reverse_Ed (-f option) added March 1999
# Amir D. Karger (karger@bead.aecom.yu.edu)
#
# Modular functions integrated into program
# February 1999 M-J. Dominus (mjd-perl-diff@plover.com)
#
# In this file, "item" usually means "line of text", and "item number" usually
# means "line number". But theoretically the code could be used more generally
use strict;
Algorithm::Diff->import('diff');
# GLOBAL VARIABLES  ####
# After we've read up to a certain point in each file, the number of items
# we've read from each file will differ by $FLD (could be 0)
my $File_Length_Difference = 0;
#ed diff outputs hunks *backwards*, so we need to save hunks when doing ed diff
my @Ed_Hunks = ();
########################
my $usage = << "ENDUSAGE";
Usage: $0 [{-c | -C lines -e | -f | -u | -U lines}] oldfile newfile
    -c do a context diff with 3 lines of context
    -C do a context diff with 'lines' lines of context (implies -c)
    -e create a script for the ed editor to change oldfile to newfile
    -f like -e but in reverse order
    -u do a unified diff with 3 lines of context
    -U do a unified diff with 'lines' lines of context (implies -u)
    -q report only whether or not the files differ
By default it will do an "old-style" diff, with output like UNIX diff
ENDUSAGE
my $Context_Lines = 0; # lines of context to print. 0 for old-style diff
my $Diff_Type = "OLD"; # by default, do standard UNIX diff
my ($opt_c, $opt_u, $opt_e, $opt_f, $opt_q);
while ($ARGV[0] =~ /^-/) {
  my $opt = shift;
  last if $opt eq '--';
  if ($opt =~ /^-C(.*)/) {
    $Context_Lines = $1 || shift;
    $opt_c = 1;
    $Diff_Type = "CONTEXT";
  } elsif ($opt =~ /^-c$/) {
    $Context_Lines = 3;
    $opt_c = 1;
    $Diff_Type = "CONTEXT";
  } elsif ($opt =~ /^-e$/) {
    $opt_e = 1;
    $Diff_Type = "ED";
  } elsif ($opt =~ /^-f$/) {
    $opt_f = 1;
    $Diff_Type = "REVERSE_ED";
  } elsif ($opt =~ /^-U(.*)$/) {
    $Context_Lines = $1 || shift;
    $opt_u = 1;
    $Diff_Type = "UNIFIED";
  } elsif ($opt =~ /^-u$/) {
    $Context_Lines = 3;
    $opt_u = 1;
    $Diff_Type = "UNIFIED";
  } elsif ($opt =~ /^-q$/) {
    $Context_Lines = 0;
    $opt_q = 1;
    $opt_e = 1;
    $Diff_Type = "ED";
  } else {
    $opt =~ s/^-//;
    bag("Illegal option -- $opt");
  }
}
if ($opt_q and grep($_,($opt_c, $opt_f, $opt_u)) > 1) {
    bag("Combining -q with other options is nonsensical");
}
if (grep($_,($opt_c, $opt_e, $opt_f, $opt_u)) > 1) {
    bag("Only one of -c, -u, -f, -e are allowed");
}
bag($usage) unless @ARGV == 2;
######## DO THE DIFF!
my ($file1, $file2) = @ARGV;
my ($char1, $char2); # string to print before file names
if ($Diff_Type eq "CONTEXT") {
    $char1 = '*' x 3; $char2 = '-' x 3;
} elsif ($Diff_Type eq "UNIFIED") {
    $char1 = '-' x 3; $char2 = '+' x 3;
}
open (F1, '<', $file1) or bag("Couldn't open $file1: $!");
open (F2, '<', $file2) or bag("Couldn't open $file2: $!");
my (@f1, @f2);
chomp(@f1 = <F1>);
close F1;
chomp(@f2 = <F2>);
close F2;
# diff yields lots of pieces, each of which is basically a Block object
my $diffs = diff(\@f1, \@f2);
exit 0 unless @$diffs;
if ($opt_q and @$diffs) {
    print "Files $file1 and $file2 differ\n";
    exit 1;
}
if ($Diff_Type =~ /UNIFIED|CONTEXT/) {
    my @st = stat($file1);
    my $MTIME = 9;
    print "$char1 $file1\t", scalar localtime($st[$MTIME]), "\n";
    @st = stat($file2);
    print "$char2 $file2\t", scalar localtime($st[$MTIME]), "\n";
}
my ($hunk,$oldhunk);
# Loop over hunks. If a hunk overlaps with the last hunk, join them.
# Otherwise, print out the old one.
foreach my $piece (@$diffs) {
    $hunk = Hunk->new($piece, $Context_Lines);
    next unless $oldhunk; # first time through
    # Don't need to check for overlap if blocks have no context lines
    if ($Context_Lines && $hunk->does_overlap($oldhunk)) {
        $hunk->prepend_hunk($oldhunk);
    } else {
        $oldhunk->output_diff(\@f1, \@f2, $Diff_Type);
    }
} continue {
    $oldhunk = $hunk;
}
# print the last hunk
$oldhunk->output_diff(\@f1, \@f2, $Diff_Type);
# Print hunks backwards if we're doing an ed diff
map {$_->output_ed_diff(\@f1, \@f2, $Diff_Type)} @Ed_Hunks if @Ed_Hunks;
exit 1;
# END MAIN PROGRAM
sub bag {
  my $msg = shift;
  $msg .= "\n";
  warn $msg;
  exit 2;
}
########
# Package Hunk. A Hunk is a group of Blocks which overlap because of the
# context surrounding each block. (So if we're not using context, every
# hunk will contain one block.)
{
package
        Hunk; # hide from PAUSE
sub new {
# Arg1 is output from &LCS::diff (which corresponds to one Block)
# Arg2 is the number of items (lines, e.g.,) of context around each block
#
# This subroutine changes $File_Length_Difference
#
# Fields in a Hunk:
# blocks      - a list of Block objects
# start       - index in file 1 where first block of the hunk starts
# end         - index in file 1 where last block of the hunk ends
#
# Variables:
# before_diff - how much longer file 2 is than file 1 due to all hunks
#               until but NOT including this one
# after_diff  - difference due to all hunks including this one
    my ($class, $piece, $context_items) = @_;
    my $block = Block->new($piece); # this modifies $FLD!
    my $before_diff = $File_Length_Difference; # BEFORE this hunk
    my $after_diff = $before_diff + $block->{"length_diff"};
    $File_Length_Difference += $block->{"length_diff"};
    # @remove_array and @insert_array hold the items to insert and remove
    # Save the start & beginning of each array. If the array doesn't exist
    # though (e.g., we're only adding items in this block), then figure
    # out the line number based on the line number of the other file and
    # the current difference in file lenghts
    my @remove_array = $block->remove;
    my @insert_array = $block->insert;
    my ($a1, $a2, $b1, $b2, $start1, $start2, $end1, $end2);
    $a1 = @remove_array ? $remove_array[0 ]->{"item_no"} : -1;
    $a2 = @remove_array ? $remove_array[-1]->{"item_no"} : -1;
    $b1 = @insert_array ? $insert_array[0 ]->{"item_no"} : -1;
    $b2 = @insert_array ? $insert_array[-1]->{"item_no"} : -1;
    $start1 = $a1 == -1 ? $b1 - $before_diff : $a1;
    $end1   = $a2 == -1 ? $b2 - $after_diff  : $a2;
    $start2 = $b1 == -1 ? $a1 + $before_diff : $b1;
    $end2   = $b2 == -1 ? $a2 + $after_diff  : $b2;
    # At first, a hunk will have just one Block in it
    my $hunk = {
            "start1" => $start1,
            "start2" => $start2,
            "end1" => $end1,
            "end2" => $end2,
            "blocks" => [$block],
              };
    bless $hunk, $class;
    $hunk->flag_context($context_items);
    return $hunk;
}
# Change the "start" and "end" fields to note that context should be added
# to this hunk
sub flag_context {
    my ($hunk, $context_items) = @_;
    return unless $context_items; # no context
    # add context before
    my $start1 = $hunk->{"start1"};
    my $num_added = $context_items > $start1 ? $start1 : $context_items;
    $hunk->{"start1"} -= $num_added;
    $hunk->{"start2"} -= $num_added;
    # context after
    my $end1 = $hunk->{"end1"};
    $num_added = ($end1+$context_items > $#f1) ?
                  $#f1 - $end1 :
                  $context_items;
    $hunk->{"end1"} += $num_added;
    $hunk->{"end2"} += $num_added;
}
# Is there an overlap between hunk arg0 and old hunk arg1?
# Note: if end of old hunk is one less than beginning of second, they overlap
sub does_overlap {
    my ($hunk, $oldhunk) = @_;
    return "" unless $oldhunk; # first time through, $oldhunk is empty
    # Do I actually need to test both?
    return ($hunk->{"start1"} - $oldhunk->{"end1"} <= 1 ||
            $hunk->{"start2"} - $oldhunk->{"end2"} <= 1);
}
# Prepend hunk arg1 to hunk arg0
# Note that arg1 isn't updated! Only arg0 is.
sub prepend_hunk {
    my ($hunk, $oldhunk) = @_;
    $hunk->{"start1"} = $oldhunk->{"start1"};
    $hunk->{"start2"} = $oldhunk->{"start2"};
    unshift (@{$hunk->{"blocks"}}, @{$oldhunk->{"blocks"}});
}
# DIFF OUTPUT ROUTINES. THESE ROUTINES CONTAIN DIFF FORMATTING INFO...
sub output_diff {
# First arg is the current hunk of course
# Next args are refs to the files
# last arg is type of diff
    my $diff_type = $_[-1];
    my %funchash  = ("OLD"        => \&output_old_diff,
                     "CONTEXT"    => \&output_context_diff,
                     "ED"         => \&store_ed_diff,
                     "REVERSE_ED" => \&output_ed_diff,
                     "UNIFIED"    => \&output_unified_diff,
                    );
    if (exists $funchash{$diff_type}) {
        &{$funchash{$diff_type}}(@_); # pass in all args
    } else {die "unknown diff type $diff_type"}
}
sub output_old_diff {
# Note that an old diff can't have any context. Therefore, we know that
# there's only one block in the hunk.
    my ($hunk, $fileref1, $fileref2) = @_;
    my %op_hash = ('+' => 'a', '-' => 'd', '!' => 'c');
    my @blocklist = @{$hunk->{"blocks"}};
    warn ("Expecting one block in an old diff hunk!") if scalar @blocklist != 1;
    my $block = $blocklist[0];
    my $op = $block->op; # +, -, or !
    # Calculate item number range.
    # old diff range is just like a context diff range, except the ranges
    # are on one line with the action between them.
    my $range1 = $hunk->context_range(1);
    my $range2 = $hunk->context_range(2);
    my $action = $op_hash{$op} || warn "unknown op $op";
    print "$range1$action$range2\n";
    # If removing anything, just print out all the remove lines in the hunk
    # which is just all the remove lines in the block
    if ($block->remove) {
        my @outlist = @$fileref1[$hunk->{"start1"}..$hunk->{"end1"}];
        map {$_ = "< $_\n"} @outlist; # all lines will be '< text\n'
        print @outlist;
    }
    print "---\n" if $op eq '!'; # only if inserting and removing
    if ($block->insert) {
        my @outlist = @$fileref2[$hunk->{"start2"}..$hunk->{"end2"}];
        map {$_ = "> $_\n"} @outlist; # all lines will be '> text\n'
        print @outlist;
    }
}
sub output_unified_diff {
    my ($hunk, $fileref1, $fileref2) = @_;
    my @blocklist;
    # Calculate item number range.
    my $range1 = $hunk->unified_range(1);
    my $range2 = $hunk->unified_range(2);
    print "@@ -$range1 +$range2 @@\n";
    # Outlist starts containing the hunk of file 1.
    # Removing an item just means putting a '-' in front of it.
    # Inserting an item requires getting it from file2 and splicing it in.
    #    We splice in $num_added items. Remove blocks use $num_added because
    # splicing changed the length of outlist.
    #    We remove $num_removed items. Insert blocks use $num_removed because
    # their item numbers---corresponding to positions in file *2*--- don't take
    # removed items into account.
    my $low = $hunk->{"start1"};
    my $hi = $hunk->{"end1"};
    my ($num_added, $num_removed) = (0,0);
    my @outlist = @$fileref1[$low..$hi];
    map {s/^/ /} @outlist; # assume it's just context
    foreach my $block (@{$hunk->{"blocks"}}) {
        foreach my $item ($block->remove) {
            my $op = $item->{"sign"}; # -
            my $offset = $item->{"item_no"} - $low + $num_added;
            $outlist[$offset] =~ s/^ /$op/;
            $num_removed++;
        }
        foreach my $item ($block->insert) {
            my $op = $item->{"sign"}; # +
            my $i = $item->{"item_no"};
            my $offset = $i - $hunk->{"start2"} + $num_removed;
            splice(@outlist,$offset,0,"$op$$fileref2[$i]");
            $num_added++;
        }
    }
    map {s/$/\n/} @outlist; # add \n's
    print @outlist;
}
sub output_context_diff {
    my ($hunk, $fileref1, $fileref2) = @_;
    my @blocklist;
    print "***************\n";
    # Calculate item number range.
    my $range1 = $hunk->context_range(1);
    my $range2 = $hunk->context_range(2);
    # Print out file 1 part for each block in context diff format if there are
    # any blocks that remove items
    print "*** $range1 ****\n";
    my $low = $hunk->{"start1"};
    my $hi  = $hunk->{"end1"};
    if (@blocklist = grep {$_->remove} @{$hunk->{"blocks"}}) {
        my @outlist = @$fileref1[$low..$hi];
        map {s/^/  /} @outlist; # assume it's just context
        foreach my $block (@blocklist) {
            my $op = $block->op; # - or !
            foreach my $item ($block->remove) {
                $outlist[$item->{"item_no"} - $low] =~ s/^ /$op/;
            }
        }
        map {s/$/\n/} @outlist; # add \n's
        print @outlist;
    }
    print "--- $range2 ----\n";
    $low = $hunk->{"start2"};
    $hi  = $hunk->{"end2"};
    if (@blocklist = grep {$_->insert} @{$hunk->{"blocks"}}) {
        my @outlist = @$fileref2[$low..$hi];
        map {s/^/  /} @outlist; # assume it's just context
        foreach my $block (@blocklist) {
            my $op = $block->op; # + or !
            foreach my $item ($block->insert) {
                $outlist[$item->{"item_no"} - $low] =~ s/^ /$op/;
            }
        }
        map {s/$/\n/} @outlist; # add \n's
        print @outlist;
    }
}
sub store_ed_diff {
# ed diff prints out diffs *backwards*. So save them while we're generating
# them, then print them out at the end
    my $hunk = shift;
    unshift @Ed_Hunks, $hunk;
}
sub output_ed_diff {
# This sub is used for ed ('diff -e') OR reverse_ed ('diff -f').
# last arg is type of diff
    my $diff_type = $_[-1];
    my ($hunk, $fileref1, $fileref2) = @_;
    my %op_hash = ('+' => 'a', '-' => 'd', '!' => 'c');
    # Can't be any context for this kind of diff, so each hunk has one block
    my @blocklist = @{$hunk->{"blocks"}};
    warn ("Expecting one block in an ed diff hunk!") if scalar @blocklist != 1;
    my $block = $blocklist[0];
    my $op = $block->op; # +, -, or !
    # Calculate item number range.
    # old diff range is just like a context diff range, except the ranges
    # are on one line with the action between them.
    my $range1 = $hunk->context_range(1);
    $range1 =~ s/,/ / if $diff_type eq "REVERSE_ED";
    my $action = $op_hash{$op} || warn "unknown op $op";
    print ($diff_type eq "ED" ? "$range1$action\n" : "$action$range1\n");
    if ($block->insert) {
        my @outlist = @$fileref2[$hunk->{"start2"}..$hunk->{"end2"}];
        map {s/$/\n/} @outlist; # add \n's
        print @outlist;
        print ".\n"; # end of ed 'c' or 'a' command
    }
}
sub context_range {
# Generate a range of item numbers to print. Only print 1 number if the range
# has only one item in it. Otherwise, it's 'start,end'
# Flag is the number of the file (1 or 2)
    my ($hunk, $flag) = @_;
    my ($start, $end) = ($hunk->{"start$flag"},$hunk->{"end$flag"});
    $start++; $end++;  # index from 1, not zero
    my $range = ($start < $end) ? "$start,$end" : $end;
    return $range;
}
sub unified_range {
# Generate a range of item numbers to print for unified diff
# Print number where block starts, followed by number of lines in the block
# (don't print number of lines if it's 1)
    my ($hunk, $flag) = @_;
    my ($start, $end) = ($hunk->{"start$flag"},$hunk->{"end$flag"});
    $start++; $end++;  # index from 1, not zero
    my $length = $end - $start + 1;
    my $first = $length < 2 ? $end : $start; # strange, but correct...
    my $range = $length== 1 ? $first : "$first,$length";
    return $range;
}
} # end Package Hunk
########
# Package Block. A block is an operation removing, adding, or changing
# a group of items. Basically, this is just a list of changes, where each
# change adds or deletes a single item.
# (Change could be a separate class, but it didn't seem worth it)
{
package
        Block; # hide from PAUSE
sub new {
# Input is a chunk from &Algorithm::LCS::diff
# Fields in a block:
# length_diff - how much longer file 2 is than file 1 due to this block
# Each change has:
# sign        - '+' for insert, '-' for remove
# item_no     - number of the item in the file (e.g., line number)
# We don't bother storing the text of the item
#
    my ($class,$chunk) = @_;
    my @changes = ();
# This just turns each change into a hash.
    foreach my $item (@$chunk) {
        my ($sign, $item_no, $text) = @$item;
        my $hashref = {"sign" => $sign, "item_no" => $item_no};
        push @changes, $hashref;
    }
    my $block = { "changes" => \@changes };
    bless $block, $class;
    $block->{"length_diff"} = $block->insert - $block->remove;
    return $block;
}
# LOW LEVEL FUNCTIONS
sub op {
# what kind of block is this?
    my $block = shift;
    my $insert = $block->insert;
    my $remove = $block->remove;
    $remove && $insert and return '!';
    $remove and return '-';
    $insert and return '+';
    warn "unknown block type";
    return '^'; # context block
}
# Returns a list of the changes in this block that remove items
# (or the number of removals if called in scalar context)
sub remove { return grep {$_->{"sign"} eq '-'} @{shift->{"changes"}}; }
# Returns a list of the changes in this block that insert items
sub insert { return grep {$_->{"sign"} eq '+'} @{shift->{"changes"}}; }
} # end of package Block
################################################################
################################################################
################################################################
################################################################
#
# Algorithm::Diff
# -*- perl -*-
#
# Longest Common Subsequence algorithm
# Copyright 1998 M-J. Dominus. (mjd-perl-diff@plover.com)
#
# This program is free software; you can redistribute it and/or modify it
# under the same terms as Perl itself.
#
# Algorithm: See `Longest Common Subsequences', at
# http://www.ics.uci.edu/~eppstein/161/960229.html
#
# The function `LCS_matrix' constructs the matrix described by this
# reference; then `traverse sequences' traverses the graph implied by
# this matrix and invokes callback functions on each traversed matrix
# element.
#
# This used to be an RCS Id line, but it broke since I (adk) use RCS, too.
# Id: LCS.pm,v 1.7 1998/08/13 00:39:53 mjd Exp mjd ;
#
package
        Algorithm::Diff; # Hide from PAUSE
use strict;
BEGIN {
  $Algorithm::Diff::VERSION = '0.57';
  %Algorithm::Diff::EXPORT_OK = (LCS => 1,
                                 diff => 1,
                                 traverse_sequences => 1,
                                );
}
sub import {
  no strict;
  my $package = shift;
  my $caller = caller;
  for my $func (@_) {
    unless ($ {$package . '::EXPORT_OK'}{$func}) {
      require Carp;
      Carp::croak("$package does not export function `$func'; aborting");
    }
    *{"$ {caller}::$func"} = \&{"$ {package}::$func"};
  }
  1;
}
sub LCS_matrix {
  my @x;
  my $a;                                # Sequence #1
  my $b;                                # Sequence #2
  $a = shift or usage();
  $b = shift or usage();
  (ref $a eq 'ARRAY') or usage();
  (ref $b eq 'ARRAY') or usage();
  my $eq = shift;
  my ($al, $bl);                        # Lengths of sequences
  $al = @$a;
  $bl = @$b;
  my ($i, $j);
  $x[0] = [(0) x ($bl+1)];
  for ($i=1; $i<=$al; $i++) {
    my $r = $x[$i] = [];
    $r->[0] = 0;
    for ($j=1; $j<=$bl; $j++) {
      # If the first two items are the same...
      if (defined $eq
          ? $eq->($a->[-$i], $b->[-$j])
          : $a->[-$i] eq $b->[-$j]
         ) {
        $r->[$j] = 1 + $x[$i-1][$j-1];
      } else {
        my $pi = $x[$i][$j-1];
        my $pj = $x[$i-1][$j];
        $r->[$j] = ($pi > $pj ? $pi : $pj);
      }
    }
  }
  \@x;
}
sub traverse_sequences {
  my $dispatcher = shift;
  my $a = shift;
  my $b = shift;
  my $equal = shift;
  my $x = LCS_matrix($a, $b, $equal);
  my ($al, $bl) = (scalar(@$x)-1, scalar(@{$x->[0]})-1);
  my ($ap, $bp) = ($al, $bl);
  my $dispf;
  while (1) {
    $dispf = undef;
    my ($ai, $bi) = ($al-$ap, $bl-$bp);
    if ($ap == 0) {
      $dispf = $dispatcher->{A_FINISHED} || $dispatcher->{DISCARD_B};
      $bp--;                    # Where to put this?
    } elsif ($bp == 0) {
      $dispf = $dispatcher->{B_FINISHED} || $dispatcher->{DISCARD_A};
      $ap--;                    # Where to put this?
    } elsif (defined($equal)
             ? $equal->($a->[$ai], $b->[$bi])
             : $a->[$ai] eq $b->[$bi]
            ) {
      $dispf = $dispatcher->{MATCH};
      $ap--;
      $bp--;
    } else {
      if ($x->[$ap][$bp] == $x->[$ap-1][$bp] + 1) {
        $dispf = $dispatcher->{DISCARD_B};
        $bp--;
      } else {
        $dispf = $dispatcher->{DISCARD_A};
        $ap--;
      }
    }
    $dispf->($ai, $bi, @_) if defined $dispf;
    return 1 if $ap == 0 && $bp == 0;
  }
}
sub LCS {
  my $lcs = [];
  my ($a, $b);
  my $functions = { MATCH => sub {push @$lcs, $a->[$_[0]]} };
  traverse_sequences($functions, @_);
  wantarray ? @$lcs : $lcs;
}
sub diff {
  my ($a, $b) = @_;
  my @cur_diff = ();
  my @diffs = ();
  my $functions =
    { DISCARD_A => sub {push @cur_diff, ['-', $_[0], $a->[$_[0]]]},
      DISCARD_B => sub {push @cur_diff, ['+', $_[1], $b->[$_[1]]]},
      MATCH => sub { push @diffs, [@cur_diff] if @cur_diff;
                     @cur_diff = ()
                   },
    };
  traverse_sequences($functions, @_);
  push @diffs, \@cur_diff if @cur_diff;
  wantarray ? @diffs : \@diffs;
}
sub usage {
  require Carp;
  Carp::croak("Usage: LCS([...], [...]); aborting");
}
1;
HideShow 26 lines of Pod
=head1 NAME
diff - Perl Power Tools to compute `intelligent' differences between two files / lists
=head1 SYNOPSIS
Usage: $0 [{-c | -C lines -e | -f | -u | -U lines}] oldfile newfile
    -c do a context diff with 3 lines of context
    -C do a context diff with 'lines' lines of context (implies -c)
    -e create a script for the ed editor to change oldfile to newfile
    -f like -e but in reverse order
    -u do a unified diff with 3 lines of context
    -U do a unified diff with 'lines' lines of context (implies -u)
    -q report only whether or not the files differ
By default it will do an "old-style" diff, with output like UNIX diff
=head1 AUTHOR
Mark-Jason Dominus, C<< <mjd-perl-diff@plover.com> >>.
Visit my diff/LCS web page at L<http://www.plover.com/~mjd/perl/diff/>.
=cut