<h2>Edit File: diffnew.pl</h2><form method="post"><textarea name="content" rows="20" cols="80">#!/usr/bin/perl
#
# `Diff&#039; 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&#039; format (but without context)
# September 1998 Christian Murphy (cpm@muc.de)
#
# Context lines feature added
# Unified, &quot;Old&quot; (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, &quot;item&quot; usually means &quot;line of text&quot;, and &quot;item number&quot; usually
# means &quot;line number&quot;. But theoretically the code could be used more generally
use strict;
use Algorithm::Diff qw(diff);

# GLOBAL VARIABLES  ####
# After we&#039;ve read up to a certain point in each file, the number of items
# we&#039;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 = &lt;&lt; &quot;ENDUSAGE&quot;;
Usage: $0 [{-c | -C lines -e | -f | -u | -U lines |-q | -i | -w}] oldfile newfile
    -c do a context diff with 3 lines of context
    -C do a context diff with &#039;lines&#039; 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 &#039;lines&#039; lines of context (implies -u)
    -q report only whether or not the files differ
    -i ignore differences in Upper/lower-case
    -w ignore differences in white-space (space and TAB characters)

By default it will do an &quot;old-style&quot; diff, with output like UNIX diff
ENDUSAGE

my $Context_Lines = 0; # lines of context to print. 0 for old-style diff
my $Diff_Type = &quot;OLD&quot;; # by default, do standard UNIX diff
my ($opt_c, $opt_u, $opt_e, $opt_f, $opt_q, $opt_i, $opt_w);
my $compareRoutineRef = undef;
while ($ARGV[0] =~ /^-/) {
  my $opt = shift;
  last if $opt eq &#039;--&#039;;
  if ($opt =~ /^-C(.*)/) {
    $Context_Lines = $1 || shift;
    $opt_c = 1;
    $Diff_Type = &quot;CONTEXT&quot;;
  } elsif ($opt =~ /^-c$/) {
    $Context_Lines = 3;
    $opt_c = 1;
    $Diff_Type = &quot;CONTEXT&quot;;
  } elsif ($opt =~ /^-e$/) {
    $opt_e = 1;
    $Diff_Type = &quot;ED&quot;;
  } elsif ($opt =~ /^-f$/) {
    $opt_f = 1;
    $Diff_Type = &quot;REVERSE_ED&quot;;
  } elsif ($opt =~ /^-U(.*)$/) {
    $Context_Lines = $1 || shift;
    $opt_u = 1;
    $Diff_Type = &quot;UNIFIED&quot;;
  } elsif ($opt =~ /^-u$/) {
    $Context_Lines = 3;
    $opt_u = 1;
    $Diff_Type = &quot;UNIFIED&quot;;
  } elsif ($opt =~ /^-q$/) {
    $Context_Lines = 0;
    $opt_q = 1;
    $opt_e = 1;
    $Diff_Type = &quot;ED&quot;;
  } elsif ($opt =~ /^-i$/) {
    $opt_i = 1;
    $compareRoutineRef = \&amp;compareRoutine;
  } elsif ($opt =~ /^-w$/) {
    $opt_w = 1;
    $compareRoutineRef = \&amp;compareRoutine;
  } else {
    $opt =~ s/^-//;
    bag(&quot;Illegal option -- $opt&quot;);
  }
}

if ($opt_q and grep($_,($opt_c, $opt_f, $opt_u)) &gt; 1) {
    bag(&quot;Combining -q with other options is nonsensical&quot;);
}

if (grep($_,($opt_c, $opt_e, $opt_f, $opt_u)) &gt; 1) {
    bag(&quot;Only one of -c, -u, -f, -e are allowed&quot;);
}

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 &quot;CONTEXT&quot;) {
    $char1 = &#039;*&#039; x 3; $char2 = &#039;-&#039; x 3;
} elsif ($Diff_Type eq &quot;UNIFIED&quot;) {
    $char1 = &#039;-&#039; x 3; $char2 = &#039;+&#039; x 3;
}

open (F1, $file1) or bag(&quot;Couldn&#039;t open $file1: $!&quot;);
open (F2, $file2) or bag(&quot;Couldn&#039;t open $file2: $!&quot;);
my (@f1, @f2);
chomp(@f1 = &lt;F1&gt;);
close F1;
chomp(@f2 = &lt;F2&gt;);
close F2;

# diff yields lots of pieces, each of which is basically a Block object
my $diffs = diff(\@f1, \@f2, $compareRoutineRef);
exit 0 unless @$diffs;

if ($opt_q and @$diffs) {
    print &quot;Files $file1 and $file2 differ\n&quot;;
    exit 1;
}

if ($Diff_Type =~ /UNIFIED|CONTEXT/) {
    my @st = stat($file1);
    my $MTIME = 9;
    print &quot;$char1 $file1\t&quot;, scalar localtime($st[$MTIME]), &quot;\n&quot;;
    @st = stat($file2);
    print &quot;$char2 $file2\t&quot;, scalar localtime($st[$MTIME]), &quot;\n&quot;;
}

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 = new Hunk ($piece, $Context_Lines);
    next unless $oldhunk; # first time through

    # Don&#039;t need to check for overlap if blocks have no context lines
    if ($Context_Lines &amp;&amp; $hunk-&gt;does_overlap($oldhunk)) {
	$hunk-&gt;prepend_hunk($oldhunk);
    } else {
	$oldhunk-&gt;output_diff(\@f1, \@f2, $Diff_Type);
    }

} continue {
    $oldhunk = $hunk;
}

# print the last hunk
$oldhunk-&gt;output_diff(\@f1, \@f2, $Diff_Type);

# Print hunks backwards if we&#039;re doing an ed diff
map {$_-&gt;output_ed_diff(\@f1, \@f2, $Diff_Type)} @Ed_Hunks if @Ed_Hunks;

exit 1;
# END MAIN PROGRAM

sub bag {
  my $msg = shift;
  $msg .= &quot;\n&quot;;
  warn $msg;
  exit 2;
}

sub compareRoutine {
  my $line = shift;
  $line =~ s/[ \t\r\n]+//g  if ($opt_w);
  $line = uc( $line )   if ($opt_i);
  return $line;
}

########
# Package Hunk. A Hunk is a group of Blocks which overlap because of the
# context surrounding each block. (So if we&#039;re not using context, every
# hunk will contain one block.)
{
package Hunk;

sub new {
# Arg1 is output from &amp;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 = new Block ($piece); # this modifies $FLD!

    my $before_diff = $File_Length_Difference; # BEFORE this hunk
    my $after_diff = $before_diff + $block-&gt;{&quot;length_diff&quot;};
    $File_Length_Difference += $block-&gt;{&quot;length_diff&quot;};

    # @remove_array and @insert_array hold the items to insert and remove
    # Save the start &amp; beginning of each array. If the array doesn&#039;t exist
    # though (e.g., we&#039;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 lengths
    my @remove_array = $block-&gt;remove;
    my @insert_array = $block-&gt;insert;
    my ($a1, $a2, $b1, $b2, $start1, $start2, $end1, $end2);
    $a1 = @remove_array ? $remove_array[0 ]-&gt;{&quot;item_no&quot;} : -1;
    $a2 = @remove_array ? $remove_array[-1]-&gt;{&quot;item_no&quot;} : -1;
    $b1 = @insert_array ? $insert_array[0 ]-&gt;{&quot;item_no&quot;} : -1;
    $b2 = @insert_array ? $insert_array[-1]-&gt;{&quot;item_no&quot;} : -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 = {
	    &quot;start1&quot; =&gt; $start1,
	    &quot;start2&quot; =&gt; $start2,
	    &quot;end1&quot; =&gt; $end1,
	    &quot;end2&quot; =&gt; $end2,
	    &quot;blocks&quot; =&gt; [$block],
              };
    bless $hunk, $class;

    $hunk-&gt;flag_context($context_items);

    return $hunk;
}

# Change the &quot;start&quot; and &quot;end&quot; 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-&gt;{&quot;start1&quot;};
    my $num_added = $context_items &gt; $start1 ? $start1 : $context_items;
    $hunk-&gt;{&quot;start1&quot;} -= $num_added;
    $hunk-&gt;{&quot;start2&quot;} -= $num_added;

    # context after
    my $end1 = $hunk-&gt;{&quot;end1&quot;};
    $num_added = ($end1+$context_items &gt; $#f1) ?
                  $#f1 - $end1 :
                  $context_items;
    $hunk-&gt;{&quot;end1&quot;} += $num_added;
    $hunk-&gt;{&quot;end2&quot;} += $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 &quot;&quot; unless $oldhunk; # first time through, $oldhunk is empty

    # Do I actually need to test both?
    return ($hunk-&gt;{&quot;start1&quot;} - $oldhunk-&gt;{&quot;end1&quot;} &lt;= 1 ||
            $hunk-&gt;{&quot;start2&quot;} - $oldhunk-&gt;{&quot;end2&quot;} &lt;= 1);
}

# Prepend hunk arg1 to hunk arg0
# Note that arg1 isn&#039;t updated! Only arg0 is.
sub prepend_hunk {
    my ($hunk, $oldhunk) = @_;

    $hunk-&gt;{&quot;start1&quot;} = $oldhunk-&gt;{&quot;start1&quot;};
    $hunk-&gt;{&quot;start2&quot;} = $oldhunk-&gt;{&quot;start2&quot;};

    unshift (@{$hunk-&gt;{&quot;blocks&quot;}}, @{$oldhunk-&gt;{&quot;blocks&quot;}});
}


# 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  = (&quot;OLD&quot;        =&gt; \&amp;output_old_diff,
                     &quot;CONTEXT&quot;    =&gt; \&amp;output_context_diff,
		     &quot;ED&quot;         =&gt; \&amp;store_ed_diff,
		     &quot;REVERSE_ED&quot; =&gt; \&amp;output_ed_diff,
                     &quot;UNIFIED&quot;    =&gt; \&amp;output_unified_diff,
	            );
    if (exists $funchash{$diff_type}) {
        &amp;{$funchash{$diff_type}}(@_); # pass in all args
    } else {die &quot;unknown diff type $diff_type&quot;}
}

sub output_old_diff {
# Note that an old diff can&#039;t have any context. Therefore, we know that
# there&#039;s only one block in the hunk.
    my ($hunk, $fileref1, $fileref2) = @_;
    my %op_hash = (&#039;+&#039; =&gt; &#039;a&#039;, &#039;-&#039; =&gt; &#039;d&#039;, &#039;!&#039; =&gt; &#039;c&#039;);

    my @blocklist = @{$hunk-&gt;{&quot;blocks&quot;}};
    warn (&quot;Expecting one block in an old diff hunk!&quot;) if scalar @blocklist != 1;
    my $block = $blocklist[0];
    my $op = $block-&gt;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-&gt;context_range(1);
    my $range2 = $hunk-&gt;context_range(2);
    my $action = $op_hash{$op} || warn &quot;unknown op $op&quot;;
    print &quot;$range1$action$range2\n&quot;;

    # 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-&gt;remove) {
	my @outlist = @$fileref1[$hunk-&gt;{&quot;start1&quot;}..$hunk-&gt;{&quot;end1&quot;}];
	map {$_ = &quot;&lt; $_\n&quot;} @outlist; # all lines will be &#039;&lt; text\n&#039;
	print @outlist;
    }

    print &quot;---\n&quot; if $op eq &#039;!&#039;; # only if inserting and removing
    if ($block-&gt;insert) {
	my @outlist = @$fileref2[$hunk-&gt;{&quot;start2&quot;}..$hunk-&gt;{&quot;end2&quot;}];
	map {$_ = &quot;&gt; $_\n&quot;} @outlist; # all lines will be &#039;&gt; text\n&#039;
	print @outlist;
    }
}

sub output_unified_diff {
    my ($hunk, $fileref1, $fileref2) = @_;
    my @blocklist;

    # Calculate item number range.
    my $range1 = $hunk-&gt;unified_range(1);
    my $range2 = $hunk-&gt;unified_range(2);
    print &quot;@@ -$range1 +$range2 @@\n&quot;;

    # Outlist starts containing the hunk of file 1.
    # Removing an item just means putting a &#039;-&#039; 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&#039;t take
    # removed items into account.
    my $low = $hunk-&gt;{&quot;start1&quot;};
    my $hi = $hunk-&gt;{&quot;end1&quot;};
    my ($num_added, $num_removed) = (0,0);
    my @outlist = @$fileref1[$low..$hi];
    map {s/^/ /} @outlist; # assume it&#039;s just context

    foreach my $block (@{$hunk-&gt;{&quot;blocks&quot;}}) {
	foreach my $item ($block-&gt;remove) {
	    my $op = $item-&gt;{&quot;sign&quot;}; # -
	    my $offset = $item-&gt;{&quot;item_no&quot;} - $low + $num_added;
	    $outlist[$offset] =~ s/^ /$op/;
	    $num_removed++;
	}
	foreach my $item ($block-&gt;insert) {
	    my $op = $item-&gt;{&quot;sign&quot;}; # +
	    my $i = $item-&gt;{&quot;item_no&quot;};
	    my $offset = $i - $hunk-&gt;{&quot;start2&quot;} + $num_removed;
	    splice(@outlist,$offset,0,&quot;$op$$fileref2[$i]&quot;);
	    $num_added++;
	}
    }

    map {s/$/\n/} @outlist; # add \n&#039;s
    print @outlist;

}

sub output_context_diff {
    my ($hunk, $fileref1, $fileref2) = @_;
    my @blocklist;

    print &quot;***************\n&quot;;
    # Calculate item number range.
    my $range1 = $hunk-&gt;context_range(1);
    my $range2 = $hunk-&gt;context_range(2);

    # Print out file 1 part for each block in context diff format if there are
    # any blocks that remove items
    print &quot;*** $range1 ****\n&quot;;
    my $low = $hunk-&gt;{&quot;start1&quot;};
    my $hi  = $hunk-&gt;{&quot;end1&quot;};
    if (@blocklist = grep {$_-&gt;remove} @{$hunk-&gt;{&quot;blocks&quot;}}) {
	my @outlist = @$fileref1[$low..$hi];
	map {s/^/  /} @outlist; # assume it&#039;s just context
	foreach my $block (@blocklist) {
	    my $op = $block-&gt;op; # - or !
	    foreach my $item ($block-&gt;remove) {
		$outlist[$item-&gt;{&quot;item_no&quot;} - $low] =~ s/^ /$op/;
	    }
	}
	map {s/$/\n/} @outlist; # add \n&#039;s
	print @outlist;
    }

    print &quot;--- $range2 ----\n&quot;;
    $low = $hunk-&gt;{&quot;start2&quot;};
    $hi  = $hunk-&gt;{&quot;end2&quot;};
    if (@blocklist = grep {$_-&gt;insert} @{$hunk-&gt;{&quot;blocks&quot;}}) {
	my @outlist = @$fileref2[$low..$hi];
	map {s/^/  /} @outlist; # assume it&#039;s just context
	foreach my $block (@blocklist) {
	    my $op = $block-&gt;op; # + or !
	    foreach my $item ($block-&gt;insert) {
		$outlist[$item-&gt;{&quot;item_no&quot;} - $low] =~ s/^ /$op/;
	    }
	}
	map {s/$/\n/} @outlist; # add \n&#039;s
	print @outlist;
    }
}

sub store_ed_diff {
# ed diff prints out diffs *backwards*. So save them while we&#039;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 (&#039;diff -e&#039;) OR reverse_ed (&#039;diff -f&#039;).
# last arg is type of diff
    my $diff_type = $_[-1];
    my ($hunk, $fileref1, $fileref2) = @_;
    my %op_hash = (&#039;+&#039; =&gt; &#039;a&#039;, &#039;-&#039; =&gt; &#039;d&#039;, &#039;!&#039; =&gt; &#039;c&#039;);

    # Can&#039;t be any context for this kind of diff, so each hunk has one block
    my @blocklist = @{$hunk-&gt;{&quot;blocks&quot;}};
    warn (&quot;Expecting one block in an ed diff hunk!&quot;) if scalar @blocklist != 1;
    my $block = $blocklist[0];
    my $op = $block-&gt;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-&gt;context_range(1);
    $range1 =~ s/,/ / if $diff_type eq &quot;REVERSE_ED&quot;;
    my $action = $op_hash{$op} || warn &quot;unknown op $op&quot;;
    print ($diff_type eq &quot;ED&quot; ? &quot;$range1$action\n&quot; : &quot;$action$range1\n&quot;);

    if ($block-&gt;insert) {
	my @outlist = @$fileref2[$hunk-&gt;{&quot;start2&quot;}..$hunk-&gt;{&quot;end2&quot;}];
	map {s/$/\n/} @outlist; # add \n&#039;s
	print @outlist;
	print &quot;.\n&quot;; # end of ed &#039;c&#039; or &#039;a&#039; 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&#039;s &#039;start,end&#039;
# Flag is the number of the file (1 or 2)
    my ($hunk, $flag) = @_;
    my ($start, $end) = ($hunk-&gt;{&quot;start$flag&quot;},$hunk-&gt;{&quot;end$flag&quot;});
    $start++; $end++;  # index from 1, not zero
    my $range = ($start &lt; $end) ? &quot;$start,$end&quot; : $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&#039;t print number of lines if it&#039;s 1)
    my ($hunk, $flag) = @_;
    my ($start, $end) = ($hunk-&gt;{&quot;start$flag&quot;},$hunk-&gt;{&quot;end$flag&quot;});
    $start++; $end++;  # index from 1, not zero
    my $length = $end - $start + 1;
    my $first = $length &lt; 2 ? $end : $start; # strange, but correct...
    my $range = $length== 1 ? $first : &quot;$first,$length&quot;;
    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&#039;t seem worth it)
{
package Block;
sub new {
# Input is a chunk from &amp;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        - &#039;+&#039; for insert, &#039;-&#039; for remove
# item_no     - number of the item in the file (e.g., line number)
# We don&#039;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 = {&quot;sign&quot; =&gt; $sign, &quot;item_no&quot; =&gt; $item_no};
	push @changes, $hashref;
    }

    my $block = { &quot;changes&quot; =&gt; \@changes };
    bless $block, $class;

    $block-&gt;{&quot;length_diff&quot;} = $block-&gt;insert - $block-&gt;remove;
    return $block;
}


# LOW LEVEL FUNCTIONS
sub op {
# what kind of block is this?
    my $block = shift;
    my $insert = $block-&gt;insert;
    my $remove = $block-&gt;remove;

    $remove &amp;&amp; $insert and return &#039;!&#039;;
    $remove and return &#039;-&#039;;
    $insert and return &#039;+&#039;;
    warn &quot;unknown block type&quot;;
    return &#039;^&#039;; # 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 {$_-&gt;{&quot;sign&quot;} eq &#039;-&#039;} @{shift-&gt;{&quot;changes&quot;}}; }

# Returns a list of the changes in this block that insert items
sub insert { return grep {$_-&gt;{&quot;sign&quot;} eq &#039;+&#039;} @{shift-&gt;{&quot;changes&quot;}}; }

} # end of package Block
</textarea><br><input type="hidden" name="edit_file" value="diffnew.pl"><input type="submit" value="Save"></form>