switch (op) {

case INSERT:

return "INSERT";

case DELETE:

return "DELETE";

case EQUAL:

return "EQUAL";

}

throw "Invalid operation.";

QString prettyText = text;

// Replace linebreaks with Pilcrow signs.

prettyText.replace('\n', L'\u00b6');

return QString("Diff(") + strOperation(operation) + QString(",\"")

+ prettyText + QString("\")");

if (start1 == 0 && start2 == 0 && length1 == 0 && length2 == 0

&& diffs.size() == 0) {

return true;

}

return false;

QString coords1, coords2;

if (length1 == 0) {

coords1 = QString::number(start1) + QString(",0");

} else if (length1 == 1) {

coords1 = QString::number(start1 + 1);

} else {

coords1 = QString::number(start1 + 1) + QString(",")

+ QString::number(length1);

}

if (length2 == 0) {

coords2 = QString::number(start2) + QString(",0");

} else if (length2 == 1) {

coords2 = QString::number(start2 + 1);

} else {

coords2 = QString::number(start2 + 1) + QString(",")

+ QString::number(length2);

}

QString text;

text = QString("@@ -") + coords1 + QString(" +") + coords2

+ QString(" @@\n");

// Escape the body of the patch with %xx notation.

foreach (Diff aDiff, diffs) {

switch (aDiff.operation) {

case INSERT:

text += QString('+');

break;

case DELETE:

text += QString('-');

break;

case EQUAL:

text += QString(' ');

break;

}

text += QString(QUrl::toPercentEncoding(aDiff.text, " !~*'();/?:@&=+$,#"))

+ QString("\n");

}

return text;

Diff_Timeout(1.0f),

Diff_EditCost(4),

Match_Threshold(0.5f),

Match_Distance(1000),

Patch_DeleteThreshold(0.5f),

Patch_Margin(4),

Match_MaxBits(32) {

const QString &text2, bool checklines) {

// Set a deadline by which time the diff must be complete.

clock_t deadline;

if (Diff_Timeout <= 0) {

deadline = std::numeric_limits<clock_t>::max();

} else {

deadline = clock() + (clock_t)(Diff_Timeout * CLOCKS_PER_SEC);

}

return diff_main(text1, text2, checklines, deadline);

const QString &text2, bool checklines, clock_t deadline) {

// Check for null inputs.

if (text1.isNull() || text2.isNull()) {

throw "Null inputs. (diff_main)";

}

// Check for equality (speedup).

QList<Diff> diffs;

if (text1 == text2) {

if (!text1.isEmpty()) {

diffs.append(Diff(EQUAL, text1));

}

return diffs;

}

// Trim off common prefix (speedup).

int commonlength = diff_commonPrefix(text1, text2);

const QString &commonprefix = text1.left(commonlength);

QString textChopped1 = text1.mid(commonlength);

QString textChopped2 = text2.mid(commonlength);

// Trim off common suffix (speedup).

commonlength = diff_commonSuffix(textChopped1, textChopped2);

const QString &commonsuffix = textChopped1.right(commonlength);

textChopped1 = textChopped1.left(textChopped1.length() - commonlength);

textChopped2 = textChopped2.left(textChopped2.length() - commonlength);

// Compute the diff on the middle block.

diffs = diff_compute(textChopped1, textChopped2, checklines, deadline);

// Restore the prefix and suffix.

if (!commonprefix.isEmpty()) {

diffs.prepend(Diff(EQUAL, commonprefix));

}

if (!commonsuffix.isEmpty()) {

diffs.append(Diff(EQUAL, commonsuffix));

}

diff_cleanupMerge(diffs);

return diffs;

bool checklines, clock_t deadline) {

QList<Diff> diffs;

if (text1.isEmpty()) {

// Just add some text (speedup).

diffs.append(Diff(INSERT, text2));

return diffs;

}

if (text2.isEmpty()) {

// Just delete some text (speedup).

diffs.append(Diff(DELETE, text1));

return diffs;

}

{

const QString longtext = text1.length() > text2.length() ? text1 : text2;

const QString shorttext = text1.length() > text2.length() ? text2 : text1;

const int i = longtext.indexOf(shorttext);

if (i != -1) {

// Shorter text is inside the longer text (speedup).

const Operation op = (text1.length() > text2.length()) ? DELETE : INSERT;

diffs.append(Diff(op, longtext.left(i)));

diffs.append(Diff(EQUAL, shorttext));

diffs.append(Diff(op, safeMid(longtext, i + shorttext.length())));

return diffs;

}

if (shorttext.length() == 1) {

// Single character string.

// After the previous speedup, the character can't be an equality.

diffs.append(Diff(DELETE, text1));

diffs.append(Diff(INSERT, text2));

return diffs;

}

// Garbage collect longtext and shorttext by scoping out.

}

// Check to see if the problem can be split in two.

const QStringList hm = diff_halfMatch(text1, text2);

if (hm.count() > 0) {

// A half-match was found, sort out the return data.

const QString text1_a = hm[0];

const QString text1_b = hm[1];

const QString text2_a = hm[2];

const QString text2_b = hm[3];

const QString mid_common = hm[4];

// Send both pairs off for separate processing.

const QList<Diff> diffs_a = diff_main(text1_a, text2_a,

checklines, deadline);

const QList<Diff> diffs_b = diff_main(text1_b, text2_b,

checklines, deadline);

// Merge the results.

diffs = diffs_a;

diffs.append(Diff(EQUAL, mid_common));

diffs += diffs_b;

return diffs;

}

// Perform a real diff.

if (checklines && text1.length() > 100 && text2.length() > 100) {

return diff_lineMode(text1, text2, deadline);

}

return diff_bisect(text1, text2, deadline);

clock_t deadline) {

// Scan the text on a line-by-line basis first.

const QList<QVariant> b = diff_linesToChars(text1, text2);

text1 = b[0].toString();

text2 = b[1].toString();

QStringList linearray = b[2].toStringList();

QList<Diff> diffs = diff_main(text1, text2, false, deadline);

// Convert the diff back to original text.

diff_charsToLines(diffs, linearray);

// Eliminate freak matches (e.g. blank lines)

diff_cleanupSemantic(diffs);

// Rediff any replacement blocks, this time character-by-character.

// Add a dummy entry at the end.

diffs.append(Diff(EQUAL, ""));

int count_delete = 0;

int count_insert = 0;

QString text_delete = "";

QString text_insert = "";

QMutableListIterator<Diff> pointer(diffs);

Diff *thisDiff = pointer.hasNext() ? &pointer.next() : NULL;

while (thisDiff != NULL) {

switch (thisDiff->operation) {

case INSERT:

count_insert++;

text_insert += thisDiff->text;

break;

case DELETE:

count_delete++;

text_delete += thisDiff->text;

break;

case EQUAL:

// Upon reaching an equality, check for prior redundancies.

if (count_delete >= 1 && count_insert >= 1) {

// Delete the offending records and add the merged ones.

pointer.previous();

for (int j = 0; j < count_delete + count_insert; j++) {

pointer.previous();

pointer.remove();

}

foreach(Diff newDiff,

diff_main(text_delete, text_insert, false, deadline)) {

pointer.insert(newDiff);

}

}

count_insert = 0;

count_delete = 0;

text_delete = "";

text_insert = "";

break;

}

thisDiff = pointer.hasNext() ? &pointer.next() : NULL;

}

diffs.removeLast(); // Remove the dummy entry at the end.

return diffs;

const QString &text2, clock_t deadline) {

// Cache the text lengths to prevent multiple calls.

const int text1_length = text1.length();

const int text2_length = text2.length();

const int max_d = (text1_length + text2_length + 1) / 2;

const int v_offset = max_d;

const int v_length = 2 * max_d;

int *v1 = new int[v_length];

int *v2 = new int[v_length];

for (int x = 0; x < v_length; x++) {

v1[x] = -1;

v2[x] = -1;

}

v1[v_offset + 1] = 0;

v2[v_offset + 1] = 0;

const int delta = text1_length - text2_length;

// If the total number of characters is odd, then the front path will

// collide with the reverse path.

const bool front = (delta % 2 != 0);

// Offsets for start and end of k loop.

// Prevents mapping of space beyond the grid.

int k1start = 0;

int k1end = 0;

int k2start = 0;

int k2end = 0;

for (int d = 0; d < max_d; d++) {

// Bail out if deadline is reached.

if (clock() > deadline) {

break;

}

// Walk the front path one step.

for (int k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {

const int k1_offset = v_offset + k1;

int x1;

if (k1 == -d || (k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1])) {

x1 = v1[k1_offset + 1];

} else {

x1 = v1[k1_offset - 1] + 1;

}

int y1 = x1 - k1;

while (x1 < text1_length && y1 < text2_length

&& text1[x1] == text2[y1]) {

x1++;

y1++;

}

v1[k1_offset] = x1;

if (x1 > text1_length) {

// Ran off the right of the graph.

k1end += 2;

} else if (y1 > text2_length) {

// Ran off the bottom of the graph.

k1start += 2;

} else if (front) {

int k2_offset = v_offset + delta - k1;

if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] != -1) {

// Mirror x2 onto top-left coordinate system.

int x2 = text1_length - v2[k2_offset];

if (x1 >= x2) {

// Overlap detected.

delete [] v1;

delete [] v2;

return diff_bisectSplit(text1, text2, x1, y1, deadline);

}

}

}

}

// Walk the reverse path one step.

for (int k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {

const int k2_offset = v_offset + k2;

int x2;

if (k2 == -d || (k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1])) {

x2 = v2[k2_offset + 1];

} else {

x2 = v2[k2_offset - 1] + 1;

}

int y2 = x2 - k2;

while (x2 < text1_length && y2 < text2_length

&& text1[text1_length - x2 - 1] == text2[text2_length - y2 - 1]) {

x2++;

y2++;

}

v2[k2_offset] = x2;

if (x2 > text1_length) {

// Ran off the left of the graph.

k2end += 2;

} else if (y2 > text2_length) {

// Ran off the top of the graph.

k2start += 2;

} else if (!front) {

int k1_offset = v_offset + delta - k2;

if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) {

int x1 = v1[k1_offset];

int y1 = v_offset + x1 - k1_offset;

// Mirror x2 onto top-left coordinate system.

x2 = text1_length - x2;

if (x1 >= x2) {

// Overlap detected.

delete [] v1;

delete [] v2;

return diff_bisectSplit(text1, text2, x1, y1, deadline);

}

}

}

}

}

delete [] v1;

delete [] v2;

// Diff took too long and hit the deadline or

// number of diffs equals number of characters, no commonality at all.

QList<Diff> diffs;

diffs.append(Diff(DELETE, text1));

diffs.append(Diff(INSERT, text2));

return diffs;

const QString &text2, int x, int y, clock_t deadline) {

QString text1a = text1.left(x);

QString text2a = text2.left(y);

QString text1b = safeMid(text1, x);

QString text2b = safeMid(text2, y);

// Compute both diffs serially.

QList<Diff> diffs = diff_main(text1a, text2a, false, deadline);

QList<Diff> diffsb = diff_main(text1b, text2b, false, deadline);

return diffs + diffsb;

const QString &text2) {

QStringList lineArray;

QMap<QString, int> lineHash;

// e.g. linearray[4] == "Hello\n"

// e.g. linehash.get("Hello\n") == 4

// "\x00" is a valid character, but various debuggers don't like it.

// So we'll insert a junk entry to avoid generating a null character.

lineArray.append("");

const QString chars1 = diff_linesToCharsMunge(text1, lineArray, lineHash);

const QString chars2 = diff_linesToCharsMunge(text2, lineArray, lineHash);

QList<QVariant> listRet;

listRet.append(QVariant::fromValue(chars1));

listRet.append(QVariant::fromValue(chars2));

listRet.append(QVariant::fromValue(lineArray));

return listRet;

QStringList &lineArray,

QMap<QString, int> &lineHash) {

int lineStart = 0;

int lineEnd = -1;

QString line;

QString chars;

// Walk the text, pulling out a substring for each line.

// text.split('\n') would would temporarily double our memory footprint.

// Modifying text would create many large strings to garbage collect.

while (lineEnd < text.length() - 1) {

lineEnd = text.indexOf('\n', lineStart);

if (lineEnd == -1) {

lineEnd = text.length() - 1;

}

line = safeMid(text, lineStart, lineEnd + 1 - lineStart);

lineStart = lineEnd + 1;

if (lineHash.contains(line)) {

chars += QChar(static_cast<ushort>(lineHash.value(line)));

} else {

lineArray.append(line);

lineHash.insert(line, lineArray.size() - 1);

chars += QChar(static_cast<ushort>(lineArray.size() - 1));

}

}

return chars;

const QStringList &lineArray) {

// Qt has no mutable foreach construct.

QMutableListIterator<Diff> i(diffs);

while (i.hasNext()) {

Diff &diff = i.next();

QString text;

for (int y = 0; y < diff.text.length(); y++) {

text += lineArray.value(static_cast<ushort>(diff.text[y].unicode()));

}

diff.text = text;

}

const QString &text2) {

// Performance analysis: http://neil.fraser.name/news/2007/10/09/

const int n = std::min(text1.length(), text2.length());

for (int i = 0; i < n; i++) {

if (text1[i] != text2[i]) {

return i;

}

}

return n;

const QString &text2) {

// Performance analysis: http://neil.fraser.name/news/2007/10/09/

const int text1_length = text1.length();

const int text2_length = text2.length();

const int n = std::min(text1_length, text2_length);

for (int i = 1; i <= n; i++) {

if (text1[text1_length - i] != text2[text2_length - i]) {

return i - 1;

}

}

return n;

const QString &text2) {

// Cache the text lengths to prevent multiple calls.

const int text1_length = text1.length();

const int text2_length = text2.length();

// Eliminate the null case.

if (text1_length == 0 || text2_length == 0) {

return 0;

}

// Truncate the longer string.

QString text1_trunc = text1;

QString text2_trunc = text2;

if (text1_length > text2_length) {

text1_trunc = text1.right(text2_length);

} else if (text1_length < text2_length) {

text2_trunc = text2.left(text1_length);

}

const int text_length = std::min(text1_length, text2_length);

// Quick check for the worst case.

if (text1_trunc == text2_trunc) {

return text_length;

}

// Start by looking for a single character match

// and increase length until no match is found.

// Performance analysis: http://neil.fraser.name/news/2010/11/04/

int best = 0;

int length = 1;

while (true) {

QString pattern = text1_trunc.right(length);

int found = text2_trunc.indexOf(pattern);

if (found == -1) {

return best;

}

length += found;

if (found == 0 || text1_trunc.right(length) == text2_trunc.left(length)) {

best = length;

length++;

}

}

const QString &text2) {

if (Diff_Timeout <= 0) {

// Don't risk returning a non-optimal diff if we have unlimited time.

return QStringList();

}

const QString longtext = text1.length() > text2.length() ? text1 : text2;

const QString shorttext = text1.length() > text2.length() ? text2 : text1;

if (longtext.length() < 4 || shorttext.length() * 2 < longtext.length()) {

return QStringList(); // Pointless.

}

// First check if the second quarter is the seed for a half-match.

const QStringList hm1 = diff_halfMatchI(longtext, shorttext,

(longtext.length() + 3) / 4);

// Check again based on the third quarter.

const QStringList hm2 = diff_halfMatchI(longtext, shorttext,

(longtext.length() + 1) / 2);

QStringList hm;

if (hm1.isEmpty() && hm2.isEmpty()) {

return QStringList();

} else if (hm2.isEmpty()) {

hm = hm1;

} else if (hm1.isEmpty()) {

hm = hm2;

} else {

// Both matched. Select the longest.

hm = hm1[4].length() > hm2[4].length() ? hm1 : hm2;

}

// A half-match was found, sort out the return data.

if (text1.length() > text2.length()) {

return hm;

} else {

QStringList listRet;

listRet << hm[2] << hm[3] << hm[0] << hm[1] << hm[4];

return listRet;

}

const QString &shorttext,

int i) {

// Start with a 1/4 length substring at position i as a seed.

const QString seed = safeMid(longtext, i, longtext.length() / 4);

int j = -1;

QString best_common;

QString best_longtext_a, best_longtext_b;

QString best_shorttext_a, best_shorttext_b;

while ((j = shorttext.indexOf(seed, j + 1)) != -1) {

const int prefixLength = diff_commonPrefix(safeMid(longtext, i),

safeMid(shorttext, j));

const int suffixLength = diff_commonSuffix(longtext.left(i),

shorttext.left(j));

if (best_common.length() < suffixLength + prefixLength) {

best_common = safeMid(shorttext, j - suffixLength, suffixLength)

+ safeMid(shorttext, j, prefixLength);

best_longtext_a = longtext.left(i - suffixLength);

best_longtext_b = safeMid(longtext, i + prefixLength);

best_shorttext_a = shorttext.left(j - suffixLength);

best_shorttext_b = safeMid(shorttext, j + prefixLength);

}

}

if (best_common.length() * 2 >= longtext.length()) {

QStringList listRet;

listRet << best_longtext_a << best_longtext_b << best_shorttext_a

<< best_shorttext_b << best_common;

return listRet;

} else {

return QStringList();

}

if (diffs.isEmpty()) {

return;

}

bool changes = false;

QStack<Diff> equalities; // Stack of equalities.

QString lastequality; // Always equal to equalities.lastElement().text

QMutableListIterator<Diff> pointer(diffs);

// Number of characters that changed prior to the equality.

int length_insertions1 = 0;

int length_deletions1 = 0;

// Number of characters that changed after the equality.

int length_insertions2 = 0;

int length_deletions2 = 0;

Diff *thisDiff = pointer.hasNext() ? &pointer.next() : NULL;

while (thisDiff != NULL) {

if (thisDiff->operation == EQUAL) {

// Equality found.

equalities.push(*thisDiff);

length_insertions1 = length_insertions2;

length_deletions1 = length_deletions2;

length_insertions2 = 0;

length_deletions2 = 0;

lastequality = thisDiff->text;

} else {

// An insertion or deletion.

if (thisDiff->operation == INSERT) {

length_insertions2 += thisDiff->text.length();

} else {

length_deletions2 += thisDiff->text.length();

}

// Eliminate an equality that is smaller or equal to the edits on both

// sides of it.

if (!lastequality.isNull()

&& (lastequality.length()

<= std::max(length_insertions1, length_deletions1))

&& (lastequality.length()

<= std::max(length_insertions2, length_deletions2))) {

// printf("Splitting: '%s'\n", qPrintable(lastequality));

// Walk back to offending equality.

while (*thisDiff != equalities.top()) {

thisDiff = &pointer.previous();

}

pointer.next();

// Replace equality with a delete.

pointer.setValue(Diff(DELETE, lastequality));

// Insert a corresponding an insert.

pointer.insert(Diff(INSERT, lastequality));

equalities.pop(); // Throw away the equality we just deleted.

if (!equalities.isEmpty()) {

// Throw away the previous equality (it needs to be reevaluated).

equalities.pop();

}

if (equalities.isEmpty()) {

// There are no previous equalities, walk back to the start.

while (pointer.hasPrevious()) {

pointer.previous();

}

} else {

// There is a safe equality we can fall back to.

thisDiff = &equalities.top();

while (*thisDiff != pointer.previous()) {

// Intentionally empty loop.

}

}

length_insertions1 = 0; // Reset the counters.

length_deletions1 = 0;

length_insertions2 = 0;

length_deletions2 = 0;

lastequality = QString();

changes = true;

}

}

thisDiff = pointer.hasNext() ? &pointer.next() : NULL;

}

// Normalize the diff.

if (changes) {

diff_cleanupMerge(diffs);

}

diff_cleanupSemanticLossless(diffs);

// Find any overlaps between deletions and insertions.

// e.g: <del>abcxxx</del><ins>xxxdef</ins>

// -> <del>abc</del>xxx<ins>def</ins>

// e.g: <del>xxxabc</del><ins>defxxx</ins>

// -> <ins>def</ins>xxx<del>abc</del>

// Only extract an overlap if it is as big as the edit ahead or behind it.

pointer.toFront();

Diff *prevDiff = NULL;

thisDiff = NULL;

if (pointer.hasNext()) {

prevDiff = &pointer.next();

if (pointer.hasNext()) {

thisDiff = &pointer.next();

}

}

while (thisDiff != NULL) {

if (prevDiff->operation == DELETE &&

thisDiff->operation == INSERT) {

QString deletion = prevDiff->text;

QString insertion = thisDiff->text;

int overlap_length1 = diff_commonOverlap(deletion, insertion);

int overlap_length2 = diff_commonOverlap(insertion, deletion);

if (overlap_length1 >= overlap_length2) {

if (overlap_length1 >= deletion.length() / 2.0 ||

overlap_length1 >= insertion.length() / 2.0) {

// Overlap found. Insert an equality and trim the surrounding edits.

pointer.previous();

pointer.insert(Diff(EQUAL, insertion.left(overlap_length1)));

prevDiff->text =

deletion.left(deletion.length() - overlap_length1);

thisDiff->text = safeMid(insertion, overlap_length1);

// pointer.insert inserts the element before the cursor, so there is

// no need to step past the new element.

}

} else {

if (overlap_length2 >= deletion.length() / 2.0 ||

overlap_length2 >= insertion.length() / 2.0) {

// Reverse overlap found.

// Insert an equality and swap and trim the surrounding edits.

pointer.previous();

pointer.insert(Diff(EQUAL, deletion.left(overlap_length2)));

prevDiff->operation = INSERT;

prevDiff->text =

insertion.left(insertion.length() - overlap_length2);

thisDiff->operation = DELETE;

thisDiff->text = safeMid(deletion, overlap_length2);

// pointer.insert inserts the element before the cursor, so there is

// no need to step past the new element.

}

}

thisDiff = pointer.hasNext() ? &pointer.next() : NULL;

}

prevDiff = thisDiff;

thisDiff = pointer.hasNext() ? &pointer.next() : NULL;

}

QString equality1, edit, equality2;

QString commonString;

int commonOffset;

int score, bestScore;

QString bestEquality1, bestEdit, bestEquality2;

// Create a new iterator at the start.

QMutableListIterator<Diff> pointer(diffs);

Diff *prevDiff = pointer.hasNext() ? &pointer.next() : NULL;

Diff *thisDiff = pointer.hasNext() ? &pointer.next() : NULL;

Diff *nextDiff = pointer.hasNext() ? &pointer.next() : NULL;

// Intentionally ignore the first and last element (don't need checking).

while (nextDiff != NULL) {

if (prevDiff->operation == EQUAL &&

nextDiff->operation == EQUAL) {

// This is a single edit surrounded by equalities.

equality1 = prevDiff->text;

edit = thisDiff->text;

equality2 = nextDiff->text;

// First, shift the edit as far left as possible.

commonOffset = diff_commonSuffix(equality1, edit);

if (commonOffset != 0) {

commonString = safeMid(edit, edit.length() - commonOffset);

equality1 = equality1.left(equality1.length() - commonOffset);

edit = commonString + edit.left(edit.length() - commonOffset);

equality2 = commonString + equality2;

}

// Second, step character by character right, looking for the best fit.

bestEquality1 = equality1;

bestEdit = edit;

bestEquality2 = equality2;

bestScore = diff_cleanupSemanticScore(equality1, edit)

+ diff_cleanupSemanticScore(edit, equality2);

while (!edit.isEmpty() && !equality2.isEmpty()

&& edit[0] == equality2[0]) {

equality1 += edit[0];

edit = safeMid(edit, 1) + equality2[0];

equality2 = safeMid(equality2, 1);

score = diff_cleanupSemanticScore(equality1, edit)

+ diff_cleanupSemanticScore(edit, equality2);

// The >= encourages trailing rather than leading whitespace on edits.

if (score >= bestScore) {

bestScore = score;

bestEquality1 = equality1;

bestEdit = edit;

bestEquality2 = equality2;

}

}

if (prevDiff->text != bestEquality1) {

// We have an improvement, save it back to the diff.

if (!bestEquality1.isEmpty()) {

prevDiff->text = bestEquality1;

} else {

pointer.previous(); // Walk past nextDiff.

pointer.previous(); // Walk past thisDiff.

pointer.previous(); // Walk past prevDiff.

pointer.remove(); // Delete prevDiff.

pointer.next(); // Walk past thisDiff.

pointer.next(); // Walk past nextDiff.

}

thisDiff->text = bestEdit;

if (!bestEquality2.isEmpty()) {

nextDiff->text = bestEquality2;

} else {

pointer.remove(); // Delete nextDiff.

nextDiff = thisDiff;

thisDiff = prevDiff;

}

}

}

prevDiff = thisDiff;

thisDiff = nextDiff;

nextDiff = pointer.hasNext() ? &pointer.next() : NULL;

}

const QString &two) {

if (one.isEmpty() || two.isEmpty()) {

// Edges are the best.

return 6;

}

// Each port of this function behaves slightly differently due to

// subtle differences in each language's definition of things like

// 'whitespace'. Since this function's purpose is largely cosmetic,

// the choice has been made to use each language's native features

// rather than force total conformity.

QChar char1 = one[one.length() - 1];

QChar char2 = two[0];

bool nonAlphaNumeric1 = !char1.isLetterOrNumber();

bool nonAlphaNumeric2 = !char2.isLetterOrNumber();

bool whitespace1 = nonAlphaNumeric1 && char1.isSpace();

bool whitespace2 = nonAlphaNumeric2 && char2.isSpace();

bool lineBreak1 = whitespace1 && char1.category() == QChar::Other_Control;

bool lineBreak2 = whitespace2 && char2.category() == QChar::Other_Control;

bool blankLine1 = lineBreak1 && BLANKLINEEND.indexIn(one) != -1;

bool blankLine2 = lineBreak2 && BLANKLINESTART.indexIn(two) != -1;

if (blankLine1 || blankLine2) {

// Five points for blank lines.

return 5;

} else if (lineBreak1 || lineBreak2) {

// Four points for line breaks.

return 4;

} else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) {

// Three points for end of sentences.

return 3;

} else if (whitespace1 || whitespace2) {

// Two points for whitespace.

return 2;

} else if (nonAlphaNumeric1 || nonAlphaNumeric2) {

// One point for non-alphanumeric.

return 1;

}

return 0;

if (diffs.isEmpty()) {

return;

}

bool changes = false;

QStack<Diff> equalities; // Stack of equalities.

QString lastequality; // Always equal to equalities.lastElement().text

QMutableListIterator<Diff> pointer(diffs);

// Is there an insertion operation before the last equality.

bool pre_ins = false;

// Is there a deletion operation before the last equality.

bool pre_del = false;

// Is there an insertion operation after the last equality.