| package bmsi.util; |
| |
| /* $Log: not supported by cvs2svn $ |
| * Revision 1.2 2000/03/02 16:59:54 stuart |
| * add GPL |
| * |
| */ |
| |
| import java.io.*; |
| import java.util.Vector; |
| |
| import bmsi.util.Diff; |
| |
| //import com.objectspace.jgl.predicates.UnaryPredicate; |
| |
| interface UnaryPredicate { |
| boolean execute(Object obj); |
| } |
| |
| /** A simple framework for printing change lists produced by <code>Diff</code>. |
| @see bmsi.util.Diff |
| @author Stuart D. Gathman |
| Copyright (C) 2000 Business Management Systems, Inc. |
| <p> |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 1, or (at your option) |
| any later version. |
| <p> |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| <p> |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| */ |
| public class DiffPrint { |
| /** A Base class for printing edit scripts produced by Diff. |
| This class divides the change list into "hunks", and calls |
| <code>print_hunk</code> for each hunk. Various utility methods |
| are provided as well. |
| */ |
| public static abstract class Base { |
| protected Base(Object[] a, Object[] b) { |
| outfile = new PrintWriter(new OutputStreamWriter(System.out)); |
| file0 = a; |
| file1 = b; |
| } |
| |
| /** Set to ignore certain kinds of lines when printing |
| an edit script. For example, ignoring blank lines or comments. |
| */ |
| protected UnaryPredicate ignore = null; |
| |
| /** Set to the lines of the files being compared. |
| */ |
| protected Object[] file0, file1; |
| |
| /** Divide SCRIPT into pieces by calling HUNKFUN and |
| print each piece with PRINTFUN. |
| Both functions take one arg, an edit script. |
| |
| PRINTFUN takes a subscript which belongs together (with a null |
| link at the end) and prints it. */ |
| public void print_script(Diff.change script) { |
| Diff.change next = script; |
| |
| while (next != null) { |
| Diff.change t, end; |
| |
| /* Find a set of changes that belong together. */ |
| t = next; |
| end = hunkfun(next); |
| |
| /* Disconnect them from the rest of the changes, |
| making them a hunk, and remember the rest for next iteration. */ |
| next = end.link; |
| end.link = null; |
| //if (DEBUG) |
| // debug_script(t); |
| |
| /* Print this hunk. */ |
| print_hunk(t); |
| |
| /* Reconnect the script so it will all be freed properly. */ |
| end.link = next; |
| } |
| outfile.flush(); |
| } |
| |
| /** Called with the tail of the script |
| and returns the last link that belongs together with the start |
| of the tail. */ |
| |
| protected Diff.change hunkfun(Diff.change hunk) { |
| return hunk; |
| } |
| |
| protected int first0, last0, first1, last1, deletes, inserts; |
| protected PrintWriter outfile; |
| |
| /** Look at a hunk of edit script and report the range of lines in each file |
| that it applies to. HUNK is the start of the hunk, which is a chain |
| of `struct change'. The first and last line numbers of file 0 are stored |
| in *FIRST0 and *LAST0, and likewise for file 1 in *FIRST1 and *LAST1. |
| Note that these are internal line numbers that count from 0. |
| |
| If no lines from file 0 are deleted, then FIRST0 is LAST0+1. |
| |
| Also set *DELETES nonzero if any lines of file 0 are deleted |
| and set *INSERTS nonzero if any lines of file 1 are inserted. |
| If only ignorable lines are inserted or deleted, both are |
| set to 0. */ |
| |
| protected void analyze_hunk(Diff.change hunk) { |
| int f0, l0 = 0, f1, l1 = 0, show_from = 0, show_to = 0; |
| int i; |
| Diff.change next; |
| boolean nontrivial = (ignore == null); |
| |
| show_from = show_to = 0; |
| |
| f0 = hunk.line0; |
| f1 = hunk.line1; |
| |
| for (next = hunk; next != null; next = next.link) { |
| l0 = next.line0 + next.deleted - 1; |
| l1 = next.line1 + next.inserted - 1; |
| show_from += next.deleted; |
| show_to += next.inserted; |
| for (i = next.line0; i <= l0 && !nontrivial; i++) |
| if (!ignore.execute(file0[i])) |
| nontrivial = true; |
| for (i = next.line1; i <= l1 && !nontrivial; i++) |
| if (!ignore.execute(file1[i])) |
| nontrivial = true; |
| } |
| |
| first0 = f0; |
| last0 = l0; |
| first1 = f1; |
| last1 = l1; |
| |
| /* If all inserted or deleted lines are ignorable, |
| tell the caller to ignore this hunk. */ |
| |
| if (!nontrivial) |
| show_from = show_to = 0; |
| |
| deletes = show_from; |
| inserts = show_to; |
| } |
| |
| protected abstract void print_hunk(Diff.change hunk); |
| |
| protected void print_1_line(String pre, Object linbuf) { |
| outfile.println(pre + linbuf.toString()); |
| } |
| |
| /** Print a pair of line numbers with SEPCHAR, translated for file FILE. |
| If the two numbers are identical, print just one number. |
| |
| Args A and B are internal line numbers. |
| We print the translated (real) line numbers. */ |
| |
| protected void print_number_range(char sepchar, int a, int b) { |
| /* Note: we can have B < A in the case of a range of no lines. |
| In this case, we should print the line number before the range, |
| which is B. */ |
| if (++b > ++a) |
| outfile.print("" + a + sepchar + b); |
| else |
| outfile.print(b); |
| } |
| |
| public static char change_letter(int inserts, int deletes) { |
| if (inserts == 0) |
| return 'd'; |
| else if (deletes == 0) |
| return 'a'; |
| else |
| return 'c'; |
| } |
| } |
| |
| /** Print a change list in the standard diff format. |
| */ |
| public static class NormalPrint extends Base { |
| |
| public NormalPrint(Object[] a, Object[] b) { |
| super(a, b); |
| } |
| |
| /** Print a hunk of a normal diff. |
| This is a contiguous portion of a complete edit script, |
| describing changes in consecutive lines. */ |
| |
| protected void print_hunk(Diff.change hunk) { |
| |
| /* Determine range of line numbers involved in each file. */ |
| analyze_hunk(hunk); |
| if (deletes == 0 && inserts == 0) |
| return; |
| |
| /* Print out the line number header for this hunk */ |
| print_number_range(',', first0, last0); |
| outfile.print(change_letter(inserts, deletes)); |
| print_number_range(',', first1, last1); |
| outfile.println(); |
| |
| /* Print the lines that the first file has. */ |
| if (deletes != 0) |
| for (int i = first0; i <= last0; i++) |
| print_1_line("< ", file0[i]); |
| |
| if (inserts != 0 && deletes != 0) |
| outfile.println("---"); |
| |
| /* Print the lines that the second file has. */ |
| if (inserts != 0) |
| for (int i = first1; i <= last1; i++) |
| print_1_line("> ", file1[i]); |
| } |
| } |
| |
| /** Prints an edit script in a format suitable for input to <code>ed</code>. |
| The edit script must be generated with the reverse option to |
| be useful as actual <code>ed</code> input. |
| */ |
| public static class EdPrint extends Base { |
| |
| public EdPrint(Object[] a, Object[] b) { |
| super(a, b); |
| } |
| |
| /** Print a hunk of an ed diff */ |
| protected void print_hunk(Diff.change hunk) { |
| |
| /* Determine range of line numbers involved in each file. */ |
| analyze_hunk(hunk); |
| if (deletes == 0 && inserts == 0) |
| return; |
| |
| /* Print out the line number header for this hunk */ |
| print_number_range(',', first0, last0); |
| outfile.println(change_letter(inserts, deletes)); |
| |
| /* Print new/changed lines from second file, if needed */ |
| if (inserts != 0) { |
| boolean inserting = true; |
| for (int i = first1; i <= last1; i++) { |
| /* Resume the insert, if we stopped. */ |
| if (!inserting) |
| outfile.println(i - first1 + first0 + "a"); |
| inserting = true; |
| |
| /* If the file's line is just a dot, it would confuse `ed'. |
| So output it with a double dot, and set the flag LEADING_DOT |
| so that we will output another ed-command later |
| to change the double dot into a single dot. */ |
| |
| if (".".equals(file1[i])) { |
| outfile.println(".."); |
| outfile.println("."); |
| /* Now change that double dot to the desired single dot. */ |
| outfile.println(i - first1 + first0 + 1 + "s/^\\.\\././"); |
| inserting = false; |
| } else |
| /* Line is not `.', so output it unmodified. */ |
| print_1_line("", file1[i]); |
| } |
| |
| /* End insert mode, if we are still in it. */ |
| if (inserting) |
| outfile.println("."); |
| } |
| } |
| } |
| |
| /** Read a text file into an array of String. This provides basic diff |
| functionality. A more advanced diff utility will use specialized |
| objects to represent the text lines, with options to, for example, |
| convert sequences of whitespace to a single space for comparison |
| purposes. |
| */ |
| public static String[] slurp(String file) throws IOException { |
| BufferedReader rdr = new BufferedReader(new FileReader(file)); |
| Vector s = new Vector(); |
| for (; ;) { |
| String line = rdr.readLine(); |
| if (line == null) break; |
| s.addElement(line); |
| } |
| String[] a = new String[s.size()]; |
| s.copyInto(a); |
| return a; |
| } |
| |
| public static void main(String[] argv) throws IOException { |
| String[] a = slurp(argv[argv.length - 2]); |
| String[] b = slurp(argv[argv.length - 1]); |
| Diff d = new Diff(a, b); |
| boolean edstyle = "-e".equals(argv[0]); |
| Diff.change script = d.diff_2(edstyle); |
| if (script == null) |
| System.err.println("No differences"); |
| else { |
| Base p; |
| if (edstyle) |
| p = new EdPrint(a, b); |
| else |
| p = new NormalPrint(a, b); |
| p.print_script(script); |
| } |
| } |
| |
| } |
